Пример #1
0
int main(void) {
	pid_t	pid, mypid;

	if((pid = fork()) < 0)
		err_sys("fork error");
	else if(pid > 0) {	// parent
		mypid = getpid();
		TELL_WAIT();

		printf("%d: WAIT_CHILD()\n", mypid);
		WAIT_CHILD();
		printf("%d: wake up\n", mypid);

		sleep(2);
		printf("%d: TELL_CHILD()\n", mypid);
		TELL_CHILD(pid);
	} else {			// child
		mypid = getpid();
		TELL_WAIT();

		sleep(2);
		printf("%d: TELL_PARENT()\n", mypid);
		TELL_PARENT(getppid());

		printf("%d: WAIT_PARENT()\n", mypid);
		WAIT_PARENT();

		printf("%d: wake up\n", mypid);
	}

	return 0;
}
Пример #2
0
int main(void)
{
    int fd;
    pid_t pid;

    if ((fd = creat("templock", FILE_MODE)) < 0)
        err_sys("creat error");

    if (write(fd, "ab", 2) != 2)
        err_sys("write error");

    TELL_WAIT();

    if ((pid = fork()) < 0){
        err_sys("fork error");
    }else if(pid == 0){/*child*/
        lockabyte("child", fd, 0);

        TELL_PARENT(getppid());
        WAIT_PARENT();

        lockabyte("child", fd, 1);
    }else{
        lockabyte("parent", fd, 1);
        TELL_CHILD(pid);
        WAIT_CHILD();
        lockabyte("parent", fd, 0);
    }

    exit(0);
}
Пример #3
0
int main(int argc, char *argv[])
{
	pid_t pid;
	TELL_WAIT();
	pid = Fork();
	if (pid == 0)
	{	
		while ( n < 1000)
		{
			WAIT_PARENT();
			printf(" c%d ", n);
			n += 2;
			TELL_PARENT(getppid());
			//sleep(1);
		}
		
	}
	else if(pid > 0)
	{
		while (n < 1000)
		{
			
			printf(" p%d ", n);
			n += 2;
			TELL_CHILD(pid);
		//	sleep(1);
			WAIT_CHILD();
			
		}
		
	}
	printf("Hello, world\n");
	
	return 0;
}
Пример #4
0
int main(int argc, char *argv[])
{
	int		fd;
	pid_t	pid;

	/*Create a file and write two bytes to it*/
	fd = Open("templock", O_RDWR | O_CREAT | O_TRUNC, FILE_MODE) ;

	if(write(fd, "ab", 2) != 2)
		err_sys("write error");

	TELL_WAIT();
	pid = Fork();

	if(pid == 0)
	{
		lockabyte("child", fd, 0);
		TELL_PARENT(getppid());
		WAIT_PARENT();
		lockabyte("child", fd, 1);
	}else 
	{
		lockabyte("parent", fd, 1);
		TELL_CHILD(pid);
		WAIT_CHILD();
		lockabyte("parent", fd, 0);
	}
	return 0;
}
Пример #5
0
/* gcc apue.h apue_err.c figure-14.5.c figure-10.24.c figure-14.7.c */
int
main(void)
{
    int     fd;
    pid_t   pid;

    /*
     * Create a file and write two bytes to it.
     */
    if ((fd = creat("templock", FILE_MODE)) < 0)
        err_sys("creat error");
    if (write(fd, "ab", 2) != 2)
        err_sys("write error");

    TELL_WAIT();        /* figure-10.24.c */
    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid == 0) {  /* child */
        lockabyte("child", fd, 0);
        TELL_PARENT(getppid());
        WAIT_PARENT();
        lockabyte("child", fd, 1);
    } else {                /* parent */ 
        lockabyte("parent", fd, 1);
        TELL_CHILD(pid);
        WAIT_CHILD();
        lockabyte("parent", fd, 0);
    }
    exit(0);
}
Пример #6
0
/* increment counter in shared memory segment; mmap /dev/zero version */ 
int main(void)
{
	int fd, i, counter;
	pid_t pid;
	void *area;

	if ((fd = open("/dev/zero", O_RDWR)) < 0)
		err_sys("open error");
	if ((area = mmap(0, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
			 fd, 0)) == MAP_FAILED)
		err_sys("mmap error");
	close(fd);		/* can close /dev/zero now that it is mapped */

	TELL_WAIT();

	if ((pid = Fork()) > 0) { /* parent */
		for (i = 0; i < NLOOPS; i += 2) {
			if ((counter = update((long *)area)) != i)
				err_quit("parent: expected %d, got %d", i, counter);
			TELL_CHILD(pid);
			WAIT_CHILD();
		}
	} else {		/* child */
		for (i = 1; i < NLOOPS + 1; i += 2) {
			WAIT_PARENT();
			if ((counter = update((long *)area)) != i)
				err_quit("child: expected %d, got %d", i, counter);
			TELL_PARENT();
		}
	}
	exit(0);
}
Пример #7
0
int main(int argc, char* argv[])
{
	int fd;
	pid_t pid;

	if((fd = creat("templock", FILEMODE)) < 0)
		printf("creat error");
	if(write(fd, "ab", 2) != 2)
		printf("write error");

	TELL_WAIT();
	if((pid = fork()) < 0)
		printf("fork error");
	else if(pid == 0)
	{
		lockabyte("child:", fd, 0);
		TELL_PARENT(getpid());
		WAIT_PARENT();
		lockabyte("child:", fd, 1);
	}
	else
	{
		lockabyte("parent:", fd, 1);
		TELL_CHILD(pid);
		WAIT_CHILD();
		lockabyte("parent:", fd, 0);
	}
	exit(0);
}
Пример #8
0
Файл: a.c Проект: klion26/APUE
int main(void)
{
    pid_t pid;
    FILE *fp;
    int fd;
    int i = 0;
    char *child = "in child\n";
    char *parent = "in parent\n";

    if ((fp = fopen("tmp", "a")) == NULL) {
        perror("fopen error");
        exit(1);
    }

    fd = fileno(fp);
    /* if (write(fd, pi, 1) != 1) { */
    /*     perror("write error"); */
    /*     exit(1); */
    /* } */
    fprintf(fp, "%d\n", i);
    fflush(fp);

    TELL_WAIT();
    if ((pid = fork()) < 0) { /* pid = fork()要用括号括起来 */
        perror("fork error");
        exit(1);
    } else if (pid == 0) {
        while (i < 100) {
            WAIT_PARENT();
            /* if (write(fd, pi, 1) != 1) { */
            /*     perror("write error"); */
            /*     exit(1); */
            /* } */
            i += 2;
            fprintf(fp, "%d\t", i);
            fflush(fp);

            write(fd, child, strlen(child));   
            TELL_PARENT(getppid());
        }
    } else {
        i++;
        while (i < 100) {
            /* if (write(fd, pi, 1) != 1) { */
            /*     perror("write error"); */
            /*     exit(1); */
            /* } */
            
            fprintf(fp, "%d\t", i);
            fflush(fp);
            i += 2;
            write(fd, parent, strlen(parent));
            TELL_CHILD(pid);
            WAIT_CHILD();
        }
    }

    return 0;
}
Пример #9
0
int
main(int argc, char *argv[])
{
	int				fd;
	pid_t			pid;
	char			buf[5];
	struct stat		statbuf;

	if (argc != 2) {
		fprintf(stderr, "usage: %s filename\n", argv[0]);
		exit(1);
	}
	if ((fd = open(argv[1], O_RDWR | O_CREAT | O_TRUNC, FILE_MODE)) < 0)
		err_sys("open error");
	if (write(fd, "abcdef", 6) != 6)
		err_sys("write error");

	/* turn on set-group-ID and turn off group-execute */
	if (fstat(fd, &statbuf) < 0)
		err_sys("fstat error");
	if (fchmod(fd, (statbuf.st_mode & ~S_IXGRP) | S_ISGID) < 0)
		err_sys("fchmod error");

	TELL_WAIT();

	if ((pid = fork()) < 0) {
		err_sys("fork error");
	} else if (pid > 0) {	/* parent */
		/* write lock entire file */
		if (write_lock(fd, 0, SEEK_SET, 0) < 0)
			err_sys("write_lock error");

		TELL_CHILD(pid);

		if (waitpid(pid, NULL, 0) < 0)
			err_sys("waitpid error");
	} else {				/* child */
		WAIT_PARENT();		/* wait for parent to set lock */

		set_fl(fd, O_NONBLOCK);

		/* first let's see what error we get if region is locked */
		if (read_lock(fd, 0, SEEK_SET, 0) != -1)	/* no wait */
			err_sys("child: read_lock succeeded");
		printf("read_lock of already-locked region returns %d\n",
		  errno);

		/* now try to read the mandatory locked file */
		if (lseek(fd, 0, SEEK_SET) == -1)
			err_sys("lseek error");
		if (read(fd, buf, 2) < 0)
			err_ret("read failed (mandatory locking works)");
		else
			printf("read OK (no mandatory locking), buf = %2.2s\n",
			  buf);
	}
	exit(0);
}
Пример #10
0
void init (void)
{
	TELL_WAIT ();
	file = fopen (FILE_NAME, "w+");
	if (file == NULL) {
		err_quit ("open file failed\n");
	}
	fprintf (file, "%d", 0);
	fflush (file);
}
Пример #11
0
int main(int argc,char ** argv)
{                     
    int                 fd;    
    pid_t               pid;   
    char                buf[5];
    struct stat         statbuf;                             
                           
    if(argc!=2)       
    {                 
        fprintf(stderr,"usage:%s filename \n",argv[0]);      
        exit(1);      
    }                 
    if((fd=open(argv[1],O_RDWR|O_CREAT|O_TRUNC,FILE_MODE))<0)
        err_sys("open error"); 
    if(write(fd,"abcdef",6)<0) 
        err_sys("write error");
                   
    if(fstat(fd,&statbuf)<0)   
        err_sys("fstat error");
    if(fchmod(fd,(statbuf.st_mode & ~S_IXGRP)|S_ISGID)<0)
        err_sys("fchmod error");
    TELL_WAIT();



    if((pid=fork())<0)
        err_sys("fork error");
    else if(pid>0)
    {
        if(write_lock(fd,0,SEEK_SET,0)<0)
            err_sys("write_lock error");
        TELL_CHILD(pid);
        if(waitpid(pid,NULL,0)<0)
            err_sys("waitpid error");
    }
    else 
    {
        WAIT_PARENT();
        set_fl(fd,O_NONBLOCK);

        if(read_lock(fd,0,SEEK_SET,0)!=-1)
            err_sys("child read_lock successed ");
        printf("read_lock of arleady-locked region return %d \n",errno);
        if(lseek(fd,0,SEEK_SET)==-1)
            err_sys("lseek error");
        if(read(fd,buf,2)<0)
            err_ret("read failed (mandatory locking works )");
        else 
            printf("read OK(no mandatory locking ,buf=%2.2s\n)",buf);
        exit(0);

    }
} 
Пример #12
0
int main(int argc,char *argv[]){
    pid_t pid;
    //set up for TELL** and WAIT**
    TELL_WAIT();
    if((pid=fork())<0){
        perror("fork error:");
        return -1;
    }else if(pid>0){
        WAIT_CHILD();
        charatatime("output from parent\n");
    }else{
        charatatime("output from child\n");
        TELL_PARENT(pid);
    }
    return 0;
}
Пример #13
0
int main() {
	pid_t pid;

	TELL_WAIT();

	if ((pid = fork()) < 0) {
		err_sys("fork error");
	} else if (pid == 0) {
		WAIT_PARENT();		/* parent goes first */
		charatatime("output from child\n");
	} else {
		charatatime("output from parent\n");
		TELL_CHILD(pid);
	}
	exit(0);
}
int main()
{
    int fd = open(path, O_CREAT|O_TRUNC|O_RDWR, 0644);
    write(fd, "0", 1);
    char inbuf[20];
    char outbuf[20];
    int num;
    TELL_WAIT();
    pid_t pid;
    pid = fork();
    if(pid<0) {
        perror("fork error");
        return 1;
    } else if(pid == 0) { //child
        for(int i=0;i<10;++i) {
            lseek(fd, 0, SEEK_SET);
            ssize_t len = read(fd, inbuf, 20);
            if(len<0) break;
            inbuf[len] = 0;
            fprintf(stderr, "CHILD read %s\n",inbuf);//debug
            sscanf(inbuf,"%d",&num);
            ++num;
            lseek(fd, 0, SEEK_SET);
            sprintf(outbuf, "%d", num);
            write(fd, outbuf, strlen(outbuf));
            fprintf(stderr, "CHILD write %s\n",outbuf);//debug
            TELL_PARENT(getppid());
            WAIT_PARENT();
        }
    } else { //parent
        for(int i=0;i<10;++i) {
            WAIT_CHILD();
            lseek(fd, 0, SEEK_SET);
            ssize_t len = read(fd, inbuf, 20);
            if(len<0) break;
            inbuf[len] = 0;
            fprintf(stderr, "PARENT read %s\n",inbuf);//debug
            sscanf(inbuf,"%d",&num);
            ++num;
            lseek(fd, 0, SEEK_SET);
            sprintf(outbuf, "%d", num);
            write(fd, outbuf, strlen(outbuf));
            fprintf(stderr, "PARENT write %s\n",outbuf);//debug
            TELL_CHILD(pid);
        }
    }
}
Пример #15
0
int main(void){
	pid_t pid;
	TELL_WAIT();
	if((pid=fork())<0){
		err_sys("fork error");
	}else if(pid==0){/*child*/
		WAIT_PARENT();/*parent goes next*/
		char_at_a_time("output from child\n");
		/*TELL_PARENT(getppid());*//*child goes first*/
	}else{/*parent*/
		/*sleep(2);*/
		/*WAIT_CHILD();*//*parent goes first*/
		char_at_a_time("output from parent\n");
		TELL_CHILD(pid);/*child goest next*/
	}
	exit(0);
}
Пример #16
0
int main(int argc,char *argv[])
{
	pid_t pid;
	TELL_WAIT();

	if ((pid = fork()) < 0){
		perror("fork");
	}else if (pid == 0){
		TELL_PARENT(getppid());
		WAIT_PARENT();
		chara("output from child\n");
	}else{
		chara("output from parent\n");
		TELL_CHILD(pid);
	}
	exit(0);
}
Пример #17
0
int main(void)
{
    pid_t pid;

    TELL_WAIT();

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid == 0) {
        charactatime("output from child\n");
        TELL_PARENT(getppid());      /* child goes first  */
    } else {
        WAIT_CHILD();
        charactatime("output from parent\n");
    }
    exit(0);
}
Пример #18
0
int main(int argc, char const *argv[])
{
    pid_t pid;

    TELL_WAIT();

    if ((pid = fork()) < 0) {
        fprintf(stderr, "fork error\n");
        exit(1);
    } else if (pid == 0) {
        charatatime("output from child\n");
        TELL_PARENT(getppid());
    } else {
        WAIT_CHILD();        /* child goes first */
        charatatime("output from parent\n");
    }
    return 0;
}
Пример #19
0
int main()
{
	int fid;
	pid_t pid;
	if((fid = open("number.txt", O_WRONLY|O_CREAT|O_TRUNC))<0)
		err_sys("create file error...\n");
	
	sprintf(str,"%d",number);
	write(fid,str,strlen(str));
	close(fid);
	
	TELL_WAIT();
	
	if((pid = fork())<0)
		err_sys("fork error");
	else if(pid==0)
	{
		while((getNumber("number.txt")+1)<1000)
		{
			WAIT_PARENT();
			number  = getNumber("number.txt");
			setNumber("number.txt",number+1);
			printf("Pid = %d,Number = %d\n",getpid(),number+1);
			TELL_PARENT(getppid());
		}
	}
	else
	{
		while((getNumber("number.txt")+1)<1000)
		{
			number  = getNumber("number.txt");
			setNumber("number.txt",number+1);
			printf("Pid = %d,Number = %d\n",getpid(),number+1);
			TELL_CHILD(pid);
			WAIT_CHILD();
		}
		
		
	}
	
	
	close(fid);
	return 0;
}
Пример #20
0
int main(void) {
	pid_t	pid;

	TELL_WAIT();

	if((pid = fork()) < 0)
		err_sys("fork error");
	else if (pid == 0) {
		WAIT_PARENT();		/* parent goes first */
		charactatime("output from child\n");
		TELL_PARENT(getppid());
	}
	else {
		charactatime("output from parent\n");
		TELL_CHILD(pid);
		WAIT_CHILD();
	}

	return 0;
}
int main(void)
{
	pid_t pid;

	TELL_WAIT();

	if ((pid = fork()) < 0)
		err_sys("fork error");
	else if (pid == 0)
	{
		WAIT_PARENT();
		charatatime("child 12345678901234567890123456\n");
	}
	else
	{
		charatatime("parent abcdefghigklmnopqrstuvwxyz\n");
		TELL_CHILD(pid);
	}
	exit(0);
}
Пример #22
0
/* parent goes first program */
int main()
{
	pid_t pid;
	
	TELL_WAIT();
	
	pid = fork();
	if(pid < 0) {
		printf("fork error\n");
	}
	else if(pid == 0) {
		WAIT_PARENT();
		do_task("child task\n");
	}
	else {
		do_task("parent task\n");
		TELL_CHILD(pid);
	}
	
	return 0;
}
Пример #23
0
int main(int argc, char *argv[])
{
	char line[MAXLINE];
	int n;
	pid_t pid;
	int fd;

	if (argc != 2)
		err_sys("usage: a.out <pathname>");
	if ((fd = open(argv[1], O_RDWR)) < 0)
		err_sys("open %s file failed", argv[1]);

	memset(line, '\0', MAXLINE);
	TELL_WAIT();
	pid = fork();
	switch (pid) {
		case -1://error
			err_sys("fork error");
		case 0://child
			WAIT_PARENT();
			lseek(fd, SEEK_SET, 0);
			if ((n = read(fd, line, MAXLINE)) < 0)
				err_sys("read error form %s", argv[1]);
			printf("read %d bytes:", n);
			fflush(stdout);
			write(STDOUT_FILENO, line, n);
			TELL_PARENT(getppid());
			break;
		default://parent
			sleep(2);
			n = write(fd, "hello child\n", 13);
			printf("write %d bytes\n", n);
			fflush(stdout);
			TELL_CHILD(pid);
			WAIT_CHILD();
			break;
	}
	close(fd);
	exit(0);
}
Пример #24
0
void main()
{
    FILE *file;
    int pid;
    void (*tell)(pid_t);
    void (*wait)(void);

    TELL_WAIT();

    if((file = fopen("file.txt", "w")) == NULL)
    {
        err_sys("oh crap, unable to open file");
    }

    fprintf(file, "PARENT initializes the counter to 0\n");
    fflush(file);

    if ((pid = fork()) < 0)
    {
        err_sys("unable to fork");
    }

    if (PARENT)
    {
        tell = TELL_CHILD;
        wait = WAIT_CHILD;
    }
    else
    {
        tell = TELL_PARENT;
        wait = WAIT_PARENT;
    }

    increment_file(file, pid, tell, wait);

    if (PARENT)
        fclose(file);

}
Пример #25
0
int test_record_lock()
{
	int ret;
	int fd;
	pid_t pid;
	char *name;

	name = tmpnam(NULL);
	if((fd = creat(name, FILE_MODE)) < 0) {
		err_sys("create");
	}

	if (write(fd, "ab", 2) != 2)
		err_sys("write");

	TELL_WAIT();
	if ((pid = fork()) < 0)
		err_sys("fork");
	else if (pid == 0) {
		lockbyte("child", fd, 0);
		TELL_PARENT(getpid());
		WAIT_PARENT();
		lockbyte("child", fd, 1);
		sleep(2);
		exit(0);
	} else {
		lockbyte("parent", fd, 1);
		TELL_CHILD(getpid());
		WAIT_CHILD();
		lockbyte("parent", fd, 0);

		close(fd);
		sleep(1);
		unlink(name);
	}

	return 0;
}
Пример #26
0
int main(int argc, char const *argv[])
{
	pid_t pid;
	int fd;

	TELL_WAIT();

	if((fd = open("luo.txt", O_RDWR)) < 0) {
		printf("open file error\n");
	}

	int data = 0;
	if(write(fd, &data, sizeof(data)) == -1) {
		printf("write file error\n");
	}
	//fsync(fd);

	/*if((pid = fork()) < 0) {
		printf("fork error\n");
	}
	else if(pid == 0) {
		//while(1){
			WAIT_PARENT();
			int d1 = 0;
			lseek(fd, 0, SEEK_SET);
			if(read(fd, &d1, sizeof(d1)) == -1) {
				printf("read error\n");
			}
			printf("%d process read %d\n", getpid(), d1);
			++d1;
			if(write(fd, &d1, sizeof(d1)) == -1)
				printf("write error\n");
			fsync(fd);
			printf("%d process increase to %d\n", getpid(), d1);
			TELL_PARENT(getppid());
		//}
	}
	else {
		//while(1){
			int d2 = 0, read_cnt = 0;
			lseek(fd, 0, SEEK_SET);
			if((read_cnt = read(fd, &d2, sizeof(d2))) == -1) {
				printf("read error\n");
			}
			else if(read_cnt != sizeof(d2)) {
				printf("read error\n");
			}
			printf("%d process read %d\n", getpid(), d2);
			++d2;
			if(write(fd, &d2, sizeof(d2)) == -1)
				printf("write error\n");
			fsync(fd);
			printf("%d process increase to %d\n", getpid(), d2);
			TELL_CHILD(pid);
			WAIT_CHILD();
		//}
	}*/
	if(read(fd, &data, sizeof(data)) == -1)
		printf("read error\n");
	printf("%d\n", data);
	++data;
	write(fd, &data, sizeof(data));
	read(fd, &data, sizeof(data));
	printf("%d\n", data);

	close(fd);
	
	return 0;
}
Пример #27
0
int servopen(char* host, char* port)
{
    int fd, newfd, i, on, pid;
    const char* protocol;
    struct in_addr inaddr;
    struct servent* sp;

    protocol = udp ? "udp" : "tcp";

    /* Initialize the socket address structure */
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;

    /* Caller normally wildcards the local Internet address, meaning
           a connection will be accepted on any connected interface.
           We only allow an IP address for the "host", not a name. */
    if (host == NULL)
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY); /* wildcard */
    else {
        if (inet_aton(host, &inaddr) == 0)
            err_quit("invalid host name for server: %s", host);
        servaddr.sin_addr = inaddr;
    }

    /* See if "port" is a service name or number */
    if ((i = atoi(port)) == 0) {
        if ((sp = getservbyname(port, protocol)) == NULL)
            err_ret("getservbyname() error for: %s/%s", port, protocol);

        servaddr.sin_port = sp->s_port;
    } else
        servaddr.sin_port = htons(i);

    if ((fd = socket(AF_INET, udp ? SOCK_DGRAM : SOCK_STREAM, 0)) < 0)
        err_sys("socket() error");

    if (reuseaddr) {
        on = 1;
        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
            err_sys("setsockopt of SO_REUSEADDR error");
    }

#ifdef SO_REUSEPORT
    if (reuseport) {
        on = 1;
        if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0)
            err_sys("setsockopt of SO_REUSEPORT error");
    }
#endif

    /* Bind our well-known port so the client can connect to us. */
    if (bind(fd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        err_sys("can't bind local address");

    join_mcast(fd, &servaddr);

    if (udp) {
        buffers(fd);

        if (foreignip[0] != 0) { /* connect to foreignip/port# */
            bzero(&cliaddr, sizeof(cliaddr));
            if (inet_aton(foreignip, &cliaddr.sin_addr) == 0)
                err_quit("invalid IP address: %s", foreignip);
            cliaddr.sin_family = AF_INET;
            cliaddr.sin_port = htons(foreignport);
            /* connect() for datagram socket doesn't appear to allow
                   wildcarding of either IP address or port number */

            if (connect(fd, (struct sockaddr*)&cliaddr, sizeof(cliaddr)) < 0)
                err_sys("connect() error");
        }

        sockopts(fd, 1);

        return (fd); /* nothing else to do */
    }

    buffers(fd);     /* may set receive buffer size; must do here to get
                               correct window advertised on SYN */
    sockopts(fd, 0); /* only set some socket options for fd */

    listen(fd, listenq);

    if (pauselisten)
        sleep_us(pauselisten * 1000); /* lets connection queue build up */

    if (dofork) TELL_WAIT(); /* initialize synchronization primitives */

    for (;;) {
        i = sizeof(cliaddr);
        if ((newfd = accept(fd, (struct sockaddr*)&cliaddr, &i)) < 0)
            err_sys("accept() error");

        if (dofork) {
            if ((pid = fork()) < 0) err_sys("fork error");

            if (pid > 0) {
                close(newfd); /* parent closes connected socket */
                WAIT_CHILD(); /* wait for child to output to terminal */
                continue;     /* and back to for(;;) for another accept() */
            } else {
                close(fd); /* child closes listening socket */
            }
        }

        /* child (or iterative server) continues here */
        if (verbose) {
            /* Call getsockname() to find local address bound to socket:
                   local internet address is now determined (if multihomed). */
            i = sizeof(servaddr);
            if (getsockname(newfd, (struct sockaddr*)&servaddr, &i) < 0)
                err_sys("getsockname() error");

            /* Can't do one fprintf() since inet_ntoa() stores
                           the result in a static location. */
            fprintf(stderr, "connection on %s.%d ",
                    INET_NTOA(servaddr.sin_addr), ntohs(servaddr.sin_port));
            fprintf(stderr, "from %s.%d\n", INET_NTOA(cliaddr.sin_addr),
                    ntohs(cliaddr.sin_port));
        }

        buffers(newfd);     /* setsockopt() again, in case it didn't propagate
                                   from listening socket to connected socket */
        sockopts(newfd, 1); /* can set all socket options for this socket */

        if (dofork)
            TELL_PARENT(getppid()); /* tell parent we're done with terminal */

        return (newfd);
    }
}
Пример #28
0
/** 
 * main()
 * 
 * This program comprises two processes.  First, the "brain" which
 * communicates with a supervisor-client.  The brain receives
 * high-level control commands from the supervisor-client and then
 * conveys any resulting sensor data back.  The second process is the
 * "nerves"; this process translates high-level commands into
 * low-level iRobot SCI commands, executes them on the iRobot, and
 * then obtains any resulting sensor data.
 * 
 */
int main(int argc, char* argv[])
{

  /* Create a message queue using O_CREAT so that if the queue doesn't
   * already exist, it will be created.  When using mq_open with
   * O_CREAT, one must supply four arguments.  The first "name"
   * argument must begin with a slash.  The third "mode" argument is
   * derived from the symbolic constants is <sys/stat.h>.
   */
   mqd_t mqd_cmd = mq_open("/q_cmd", 
		    O_RDWR | O_CREAT , 
		    S_IRWXU | S_IRWXG | S_IRWXO, 
		    NULL);

   mqd_t mqd_sns = mq_open("/q_sns", 
		    O_RDWR | O_CREAT, 
		    S_IRWXU | S_IRWXG | S_IRWXO, 
		    NULL);
 
  printf("The message queue id is: %d\n", mqd_cmd);

  /* Determine the size of messages for this message queue
   */
  struct mq_attr a;
  mq_getattr(mqd_cmd,&a);  

  printf("The default message size is: %d\n", a.mq_msgsize);
   
   if( mqd_cmd == -1)
    {
      perror("mq_open():");
      return -1;
    }


   if( mqd_sns == -1)
    {
      perror("mq_open():");
      return -1;
    }

  

  int check = 0;
  char addresses[3][13];
  if ((check = checkArgName(argc, argv, addresses)) == -1)
    {
      printf("Not correct name entered. Exiting.\n");
      exit(0);
    }
  int i, counter, serverID, clientSock, numBytes;
  pid_t pid, pid2;

  // Arrays to hold most recent command sent by the
  // supervisor-client and the most recent command sent to the iRobot.
  char commandFromSupervisor[MAXDATASIZE] = {'\0'};
  char commandToRobot[MAXDATASIZE] = {'\0'};

  // An array to hold sensor data sent to the supervisor-client and
  // obtained from the iRobot.
  char sensDataToSupervisor[MAXDATASIZE] = {'\0'};
  char sensDataFromRobot[MAXDATASIZE] = {'\0'};
  char emptyDataToSupervisor[MAXDATASIZE] = "0000000000 ";
  char rawTimeString[12] = {'\0'};

  // An array to hold the timestamp.
  char currTime[100];


  // Create pipe to communicate between parent and child
  int fd[2];
  if(pipe(fd) < 0)
    perror("pipe error");

  //------------------------------------------------------------------------
  // Added Code to implement client
  //------------------------------------------------------------------------
  int sockfd, numbytes;  
  //buffer to store sensor information
  char sensorBuf[MAXDATASIZE];
  char msgBuf[MAXDATASIZE];
  struct addrinfo hints, *servinfo, *p;
  int rv;
  char s[INET6_ADDRSTRLEN];
  //array to hold the command sent
  char cmd[1];
  //initialize the input to NULL char
  char input = '\0';
  //------------------------------------------------------------------------
  // End of added section
  //------------------------------------------------------------------------ 

  // Create a socket-based server
  if((serverID = createServer()) == -1)
    {
      perror("createServer()");
      return -1;
    }

  printf("brainstem: waiting for connections...\n");


  // Establish a client-connection for the socket-based server
  if((clientSock = establishConnection(serverID)) == -1)
    {
      perror("establishConnection(serverID)");
      return -1;
    }
  

  // Set up signal-based communication between the child 
  // (brain) and parent (nervous system) to avoid possible
  // race conditions.
  TELL_WAIT();



  // Fork a child process.  This process will handle the "brain"
  // activities: communicating sensor data to the client
  // and receiving control commands from the client.
  if(( pid = fork()) < 0)
    {
      perror("fork error");

    }



  //------------------------------------------------------------------------
  // Code for parent (nerves)
  //------------------------------------------------------------------------
  else if (pid > 0)
    {

      // Close the client socket since this parent won't be using it.
      close(clientSock);

      //TELL_CHILD(pid);

      // Open the serial port to the robot.  If this is unsuccessful,
      // there is no point in continuing.
      if(openPort() == 0)
	{
	  printf("Port failed to open \n");
	  exit(-1);
	}

      // Initialize the robot, prepare it to receive commands.  Wait
      // for a second to give this some time to take effect.
      initialize();
      sleep(1);


#ifdef TARGET_WEBBY
      // Initialize the compass device.
      initializeCompass();

      // This is temporary until turn() works.
      // Turn Left 10 degrees
      turn(TURN_LEFT, 10);
#endif 


      // Turn on the LED to indicate the robot is ready and listening.
      // It's a nice sanity check.
      setLED(RED, PLAY_ON, ADVANCE_ON);

      //------------------------------------------------------------------------
      // Added Code to implement client
      //------------------------------------------------------------------------
      if(check == 1)
	{
#ifdef DEBUG
	  printf("%s %d \n", __FILE__, __LINE__);
#endif
      
	  memset(&hints, 0, sizeof hints);
	  hints.ai_family = AF_UNSPEC;
	  hints.ai_socktype = SOCK_STREAM;
    
	  if ((rv = getaddrinfo(addresses[1], PORT, &hints, &servinfo)) != 0) 
	    {
	      fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
	      return 1;
	    }
    
	  // loop through all the results and connect to the first we can
	  for(p = servinfo; p != NULL; p = p->ai_next) 
	    {
	      if ((sockfd = socket(p->ai_family, p->ai_socktype,
				   p->ai_protocol)) == -1) {
		perror("client: socket");
		continue;
	      }
      
	      if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
		close(sockfd);
		perror("client: connect");
		continue;
	      }
      
	      break;
	    }
    
	  if (p == NULL) 
	    {
	      fprintf(stderr, "client: failed to connect\n");
	      return 2;
	    }
    
	  inet_ntop(p->ai_family, get_in_addr((struct sockaddr *)p->ai_addr),
		    s, sizeof s);
	  printf("client: connecting to %s\n", s);
    
	  freeaddrinfo(servinfo); // all done with this structure
    
	  //if the client does not recieve anything from server then exit
	  if ((numbytes = recv(sockfd, msgBuf, MAXDATASIZE-1, 0)) == -1) 
	    {
	      perror("recv");
	      exit(1);
	    }
	}

      //------------------------------------------------------------------------
      // End of added section
      //------------------------------------------------------------------------

      while(commandToRobot[0] != ssQuit)
	{
	  commandToRobot[0] = 'z';
	  // Wait until a valid command is received.
	  while(commandToRobot[0] == 'z')
	    {
          commandToRobot[0] = readFromMessageQueueAndExecute(mqd_cmd);
	      
	    }

	  printf("commandToRobot: %d\n", commandToRobot[0]);
	  //------------------------------------------------------------------------
	  // Added Code to implement client
	  //------------------------------------------------------------------------
	  if(check == 1)
	    {
	      if(send(sockfd, &commandToRobot[0], 1, 0) == -1)
		perror("send");
	      printf("      the command code sent was: %d\n", commandToRobot[0]);
	    }
	  //------------------------------------------------------------------------
	  // End of added section
	  //------------------------------------------------------------------------

	  receiveGroupOneSensorData(sensDataFromRobot);

	  // check if any of the sensor data indicates a 
	  // sensor has been activated.  If so, react be
	  // driving backwards briefly and then stopping.
	  
	  int sensData = 0;

	  // Check sensor data first to stop ramming into wall.
	  sensData = checkSensorData(sensDataFromRobot);

#ifdef DEBUG
	  printf("%s %d \n", __FILE__, __LINE__);
#endif
	  // Wait until child has sent previous sensor data.
	  //WAIT_CHILD();

#ifdef DEBUG

	  printf("%s %d \n", __FILE__, __LINE__);
	  printf("%d \n", sensData);
#endif

	  if(sensData)
	    {
#ifdef DEBUG
	      printf("%s %d \n", __FILE__, __LINE__);	     	      
#endif
	      // Drive backwards and then stop.
	      driveBackwardsUntil(EIGHTH_SECOND, MED);
	      STOP_MACRO;	      

	      // Convey sensorData back to the child.
	      writeSensorDataToMessageQueue(sensDataFromRobot, mqd_sns, getTime(), getRawTime());

	    }  
	  // Done writing sensor data, tell child to proceed reading sensor data.
	  TELL_CHILD(pid);
	  
	  // Reset the array; fill it again in the next loop.
	  for(i = 0; i <= 6; i++)
	    {
	      sensDataFromRobot[i]= FALSE;
	    }
	}


      if (closePort() == -1)
	{
	  perror("Port failed to close \n");
	  exit(-1);
	}
      send(sockfd, &input, 1, 0);
      close(sockfd);
      kill(0, SIGTERM);
      mq_close(mqd_cmd);

      exit(0);
    }

  //------------------------------------------------------------------------
  // Code for child (brain)
  //------------------------------------------------------------------------
  else
    {
      // Child process doesn't need the listener.
      close(serverID);

      // Initially tell the parent to proceed and write sensor data.
      //TELL_PARENT(getppid());

      // Send the client the initial connection message.
      if(send(clientSock, MSG, sizeof(MSG), 0) == -1)
	perror("send");

      // At the request of the supervisor implementation team, The
      // brain follows a strict alternation of 'receive control
      // command' then 'send sensor data'.  If the control command
      // sent by the supervisor-client is 'turn left' and the iRobot
      // happens to bump into something, then the subsequent message
      // to the supervisor-client will indicate which bumper was activated.  
      // Similarly, if the control command sent by the supervisor is
      // 'turn left' and the iRobot experiences no sensory input, the
      // subsequent message to the supervisor will indicate that no sensors
      // were activated.

      // As long as the quit command 'q' has not been sent by the
      // supervisor-client, receive a control command and send the
      // subsequent sensor data.
      while(commandFromSupervisor[0] != ssQuit)
	{
	  // Wait to receive command from supervisor-client; read the command
	  // into cmdBuf.
	  if ((numBytes = recv(clientSock, commandFromSupervisor, MAXDATASIZE-1, 0)) == -1)
	    {
	      perror("recv");
	      return -1;
	    }
	  // Write the read command into shared memory so that the
	  // parent (nerves) may read and execute it.
	  //writeCommandToSharedMemory(commandFromSupervisor, cmdArea,mqd_cmd);
      writeCommandToMessageQueue(commandFromSupervisor,mqd_cmd);

	  // Wait until parent has written sensor data.
	  WAIT_PARENT();

#ifdef DEBUG
	  printf("%s %d \n", __FILE__, __LINE__);
#endif

	  // If there is sensor data available, send it to the
	  // supervisor-client.
	  if(readSensorDataFromMessageQueue(sensDataToSupervisor, mqd_sns))
	    {
	      printf("\nsensDataToSupervisor: %s \n", sensDataToSupervisor);
	      if(send(clientSock, sensDataToSupervisor, strlen(sensDataToSupervisor)-1 , 0) == -1)
		perror("send");
	    }
	  
	  // Otherwise, assume no sensor was activated.  Send an empty
	  // sensor message to the supervisor-client.
	  else
	    {
	      itoa(getRawTime(), rawTimeString);
	      
	      // Construct an empty sensor data message and send it to
	      // the supervisor-client.
	      strncat(emptyDataToSupervisor, rawTimeString, MAXDATASIZE-SIZE_OF_EMPTY_DATA);
	      strncat(emptyDataToSupervisor, " ", 1);
	      strncat(emptyDataToSupervisor, getTime(), MAXDATASIZE-SIZE_OF_EMPTY_DATA);
	      printf("\nemptySensDataToSupervisor: %s \n", emptyDataToSupervisor);
	      if(send(clientSock, emptyDataToSupervisor, MAXDATASIZE-1, 0) == -1)
		perror("send");

	      emptyDataToSupervisor[SIZE_OF_EMPTY_DATA] = '\0';
	    }

	  // Done reading sensor data, allow parent to write more sensor data.
	  TELL_PARENT(getppid());
	}
	

      // All done.  Clean up the toys and go home.
      printf("Closing socket and terminating processes.\nHave a nice day!\n");
      kill(pid, SIGTERM);
      close(clientSock);
      mq_close(mqd_cmd);

      exit(0);
    }
  // Added following code to implement communication between roomba's
 
  
	  
}
Пример #29
0
int main(int argc, char *argv[])
{
    int fd;
    pid_t pid;
    void *addr = NULL;

    fd = open("/dev/zero", O_RDWR);
    if (fd < 0)
    {
        perror("open failure: ");
        return EXIT_FAILURE;
    }
    
    addr = mmap(NULL, sizeof(int), PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_SHARED, fd, 0);
    if (addr == NULL)
    {
        perror("mmap failure: ");
        return EXIT_FAILURE;
    }

    close(fd); // mmap success and close fd

    TELL_WAIT();

    if ((pid = fork()) < 0)
    {
        perror("fork failure: ");
        return EXIT_FAILURE;
    }
    else if (pid == 0)
    {
        int i = 0;
        pid = getpid();

        for (i = 0; i < 1000; i+=2)
        {
            if (update((int *)addr) != i)
            {
                fprintf(stderr, "child process sync failure, i = %d\n", i);
                return EXIT_FAILURE;
            }

            printf("child start ##############\n");
            TELL_PARENT(pid);
            WAIT_PARENT();
        }
    }
    else
    {
        int i = 0;
        pid = getpid();

        for (i = 1; i < 1000; i+=2)
        {
            WAIT_CHILD();
            printf("parent start   @@@@@@@@@@@@@@\n");

            if (update((int *)addr) != i)
            {
                fprintf(stderr, "parent process sync failure, i = %d\n", i);
                return EXIT_FAILURE;
            }

            TELL_CHILD(pid);
        }
    }

    munmap(addr, sizeof(int));

    return EXIT_SUCCESS;
}