int main(void)
{
    int n, fd1[2], fd2[2];
    pid_t pid;
    char line[MAXLINE];

    // 创建信号,用于接受SIGPIPE信号,用自定义sig_pipe()函数进行处理.
    if (signal(SIGPIPE, sig_pipe) == SIG_ERR) {
        err_sys("signal error");
    }

    // 创建两个管道
    if (pipe(fd1) < 0 || pipe(fd2) < 0) {
        err_sys("pipe error");
    }

    // 创建子进程
    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {           // 父进程
        close(fd1[0]);
        close(fd2[1]);

        while (fgets(line, MAXLINE, stdin) != NULL) {   // 从标准输入读取数据写入到fd1管道
            n = strlen(line);
            if (write(fd1[1], line, n) != n) {
                err_sys("write error to pipe");
            }
            if ((n = read(fd2[0], line, MAXLINE)) < 0) {    // 从fd2管道读取结果
                err_sys("read error from pipe");
            }
            if (n == 0) {
                err_msg("child closed pipe");
                break;
            }
            line[n] = 0;
            if (fputs(line, stdout) == EOF) {
                err_sys("fputs error");
            }
        }

        if (ferror(stdin)) {
            err_sys("fgets error on stdin");
        }
        exit(0);
    } else {                // 子进程
        close(fd1[1]);
        close(fd2[0]);

        if (fd1[0] != STDIN_FILENO) {
            if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO) {
                err_sys("dup2 error to stdin");
            }
            close(fd1[0]);
        }

        if (fd2[1] != STDOUT_FILENO) {
            if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO) {
                err_sys("dup2 error to stdout");
            }
            close(fd2[1]);
        }

        if (execl("./add2", "add2", (char *)0) < 0) {   // 执行过滤程序
            err_sys("execl error");
        }
    }
    exit(0);
}

void
Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    if (bind(fd, sa, salen) < 0)
        err_sys("bind error");
}

void
Getsockname(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
    if (getsockname(fd, sa, salenptr) < 0)
        err_sys("getsockname error");
}

void
Send(int fd, const void *ptr, size_t nbytes, int flags)
{
    if (send(fd, ptr, nbytes, flags) != (ssize_t)nbytes)
        err_sys("send error");
}

void
Shutdown(int fd, int how)
{
    if (shutdown(fd, how) < 0)
        err_sys("shutdown error");
}

struct ifi_info * 
get_ifi_info(int family, int doaliases) 
{ 
	struct ifi_info *ifi, *ifihead, **ifipnext; 
	int sockfd, len, lastlen, flags, myflags, idx = 0, hlen = 0; 
	char *ptr, *buf, lastname[IFNAMSIZ], *cptr, *haddr, *sdlname; 
	struct ifconf ifc; 
	struct ifreq *ifr, ifrcopy; 
	struct sockaddr_in *sinptr; 
	struct sockaddr_in6 *sin6ptr; 
	int bufsz;
	
	sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 
 
	lastlen = 0;
	if (ioctl(sockfd, SIOCGIFIFNUM, &bufsz) > 0) {
		len = bufsz;
	} else {
		len = 100 * sizeof(struct ifreq); /* initial buffer size guess */
	}

	for ( ; ; ) { 
		buf = Malloc(len); 
		ifc.ifc_len = len; 
		ifc.ifc_buf = buf; 
		if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) { 
			if (errno != EINVAL || lastlen != 0) 
				err_sys("ioctl error"); 
		} else { 
			if (ifc.ifc_len == lastlen) 
				break; /* success, len has not changed */ 
			lastlen = ifc.ifc_len; 
		} 
		len += 10 * sizeof(struct ifreq); /* increment */ 
		free(buf); 
	} 
	ifihead = NULL; 
	ifipnext = &ifihead; 
	lastname[0] = 0; 
	sdlname = NULL; 
/* end get_ifi_info1 */ 
 
/* include get_ifi_info2 */ 
	for (ptr = buf; ptr < buf + ifc.ifc_len; ) { 
		ifr = (struct ifreq *) ptr; 
 
#ifdef HAVE_SOCKADDR_SA_LEN 
		len = max(sizeof(struct sockaddr), ifr->ifr_addr.sa_len); 
#else 
		switch (ifr->ifr_addr.sa_family) { 
#ifdef IPV6 
		case AF_INET6: 
			len = sizeof(struct sockaddr_in6); 
			break; 
#endif 
		case AF_INET: 
		default: 
			len = sizeof(struct sockaddr); 
			break; 
		} 
#endif /* HAVE_SOCKADDR_SA_LEN */ 
		ptr += sizeof(ifr->ifr_name) + len; /* for next one in buffer */ 
 
#ifdef HAVE_SOCKADDR_DL_STRUCT 
		/* assumes that AF_LINK precedes AF_INET or AF_INET6 */ 
		if (ifr->ifr_addr.sa_family == AF_LINK) { 
			struct sockaddr_dl *sdl = (struct sockaddr_dl *)&ifr->ifr_addr; 
			sdlname = ifr->ifr_name; 
			idx = sdl->sdl_index; 
			haddr = sdl->sdl_data + sdl->sdl_nlen; 
			hlen = sdl->sdl_alen; 
		} 
#endif 
 
		if (ifr->ifr_addr.sa_family != family) 
			continue; /* ignore if not desired address family */ 
 
		myflags = 0; 
		if ( (cptr = strchr(ifr->ifr_name, ':')) != NULL) 
			*cptr = 0; /* replace colon with null */ 
		if (strncmp(lastname, ifr->ifr_name, IFNAMSIZ) == 0) { 
			if (doaliases == 0) 
				continue; /* already processed this interface */ 
			myflags = IFI_ALIAS; 
		} 
		memcpy(lastname, ifr->ifr_name, IFNAMSIZ); 
 
		ifrcopy = *ifr; 
		Ioctl(sockfd, SIOCGIFFLAGS, &ifrcopy); 
		flags = ifrcopy.ifr_flags; 
		if ((flags & IFF_UP) == 0) 
			continue; /* ignore if interface not up */ 
/* end get_ifi_info2 */ 
 
/* include get_ifi_info3 */ 
		ifi = Calloc(1, sizeof(struct ifi_info)); 
		*ifipnext = ifi; /* prev points to this new one */ 
		ifipnext = &ifi->ifi_next; /* pointer to next one goes here */ 
 
		ifi->ifi_flags = flags; /* IFF_xxx values */ 
//.........这里部分代码省略.........

void
Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    if ( connect( fd, sa, salen) < 0)
        err_sys( "connect error");
}

int
main ( int argc, char *argv[] )
{
   struct stat struct_stat;
   pthread_t pid;
   pthread_attr_t attr;
   int i, num_sources;
   uid_t gmetad_uid;
   mode_t rrd_umask;
   char * gmetad_username;
   struct passwd *pw;
   char hostname[HOSTNAMESZ];
   gmetad_config_t *c = &gmetad_config;
   apr_interval_time_t sleep_time;
   apr_time_t last_metadata;
   double random_sleep_factor;
   unsigned int rand_seed;

   /* Ignore SIGPIPE */
   signal( SIGPIPE, SIG_IGN );

   if (cmdline_parser(argc, argv, &args_info) != 0)
      err_quit("command-line parser error");

   num_sources = number_of_datasources( args_info.conf_arg );
   if(!num_sources)
      {
         err_quit("%s doesn't have any data sources specified", args_info.conf_arg);
      }

   memset(&root, 0, sizeof(root));
   root.id = ROOT_NODE;

   /* Get the real number of data sources later */
   sources = hash_create( num_sources + 10 );
   if (! sources )
      {
         err_quit("Unable to create sources hash\n");
      }

   root.authority = hash_create( num_sources + 10 );
   if (!root.authority)
      {
         err_quit("Unable to create root authority (our grids and clusters) hash\n");
      }

   root.metric_summary = hash_create (DEFAULT_METRICSIZE);
   if (!root.metric_summary)
      {
         err_quit("Unable to create root summary hash");
      }

   parse_config_file ( args_info.conf_arg );
    /* If given, use command line directives over config file ones. */
   if (args_info.debug_given)
      {
         c->debug_level = args_info.debug_arg;
      }
   debug_level = c->debug_level;
   set_debug_msg_level(debug_level);

   /* Setup our default authority pointer if the conf file hasnt yet.
    * Done in the style of hash node strings. */
   if (!root.stringslen)
      {
         gethostname(hostname, HOSTNAMESZ);
         root.authority_ptr = 0;
         sprintf(root.strings, "http://%s/ganglia/", hostname);
         root.stringslen += strlen(root.strings) + 1;
      }

   rand_seed = apr_time_now() * (int)pthread_self();
   for(i = 0; i < root.stringslen; rand_seed = rand_seed * root.strings[i++]);

   /* Debug level 1 is error output only, and no daemonizing. */
   if (!debug_level)
      {
         rrd_umask = c->umask;
         daemon_init (argv[0], 0, rrd_umask);
      }

   if (args_info.pid_file_given)
     {
       update_pidfile (args_info.pid_file_arg);
     }

   /* The rrd_rootdir must be writable by the gmetad process */
   if( c->should_setuid )
      {
         if(! (pw = getpwnam(c->setuid_username)))
            {
               err_sys("Getpwnam error");
            }
         gmetad_uid = pw->pw_uid;
         gmetad_username = c->setuid_username;
      }
   else
      {
         gmetad_uid = getuid();
         if(! (pw = getpwuid(gmetad_uid)))
//.........这里部分代码省略.........

int main(int argc, char **argv)
{
    int i, maxi, listenfd, connfd, sockfd;
	int nready;
	ssize_t n;
	char buf[MAXLINE];
	socklen_t clilen;
	struct pollfd client[OPEN_MAX];
	struct sockaddr_in cliaddr, servaddr;

	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	Bind(listenfd, (SA *)&servaddr, sizeof(servaddr));

	Listen(listenfd, LISTENQ);

	client[0].fd = listenfd;
	client[0].events = POLLIN;
	for (i = 1; i < OPEN_MAX; i++)
		client[1].fd = -1;
	maxi = 0;

	for ( ; ; )
	{
		nready = Poll(client, maxi + 1, INFTIM);

		if (client[0].revents & POLLIN)   /* new client connection */
		{
            clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (SA *)&cliaddr, &clilen);

			for (i = 1; i < OPEN_MAX; i++)
				if (client[i].fd < 0)
				{
					client[i].fd = connfd;   /* save descriptor */
					break;
				}

			if (i == OPEN_MAX)
                err_quit("too many clients");
            
			client[i].events = POLLIN;
			if (i > maxi)
				maxi = i;   /* max index in client[] array */

			if (--nready <= 0)
				continue;   /* no more readable descriptors */
		}

		for (i = 1; i <= maxi; i++)   /* check all clients for data */
		{
            if ((sockfd = client[i].fd) < 0)
				continue;

			if (client[i].revents & (POLLIN | POLLERR))
			{
				if ((n = read(sockfd, buf, MAXLINE)) < 0)
				{
					if (errno == ECONNRESET)   /* connection reset by client */
					{
                        Close(sockfd);
						client[i].fd = -1;
					}
					else
						err_sys("read error");
				}
				else if (n == 0)   /* connection closed by client */
				{
					Close(sockfd);
					client[i].fd = -1;
				}
				else
				    Writen(sockfd, buf, n);

				if (--nready <= 0)   /* no more readable descriptors */
					break;
			}
		}
	}
}

int
main(void)
{
	int fd1[2], fd2[2];
	pid_t pid;
	char line[MAXLINE];
	FILE *infp, *outfp;

	if (signal(SIGPIPE, sig_pipe) == SIG_ERR)
		err_sys("signal error");

	if (pipe(fd1) < 0 || pipe(fd2) < 0)
		err_sys("pipe error");

	if ((pid = fork()) < 0) {
		err_sys("fork error");
	} else if (pid > 0) {	/* parent */
		close(fd1[IN]),	close(fd2[OUT]);

		if (((infp = fdopen(fd2[IN], "r")) == NULL) ||
		    ((outfp = fdopen(fd1[OUT], "w")) == NULL))  
			err_sys("fdopen error");
		
		if ((setvbuf(infp, NULL, _IOLBF, 0) != 0) ||
		    (setvbuf(outfp, NULL, _IOLBF, 0) != 0))
			err_sys("setvbuf error");
				
		while (fgets(line, MAXLINE, stdin) != NULL) {
			if (fputs(line, outfp) == EOF)
				err_sys("fputs error");
			if (fgets(line, MAXLINE, infp) == NULL) {
				if (ferror(infp) != 0)
					err_sys("fgets error");
				else
					err_msg("child closed pipe");
			}
			if (fputs(line, stdout) == EOF)
				err_sys("fputs error");
		}
		Fclose(infp);
		Fclose(outfp);
		if (ferror(stdin))
			err_sys("fgets error on stdin");
		exit(0);
	} else {		/* child */
		close(fd1[OUT]);
		close(fd2[IN]);
		if (fd1[IN] != STDIN_FILENO) {
			if (dup2(fd1[IN], STDIN_FILENO) != STDIN_FILENO)
				err_sys("dup2 error to stdin");
			close(fd1[IN]);
		}

		if (fd2[OUT] != STDOUT_FILENO) {
			if (dup2(fd2[OUT], STDOUT_FILENO) != STDOUT_FILENO)
				err_sys("dup2 error to stdout");
			close(fd2[OUT]);
		}
		if (execl("./add2", "add2", (char *)0))
			err_sys("execl error");
	}
	exit(0);
}

static int 
init_fpga_task(void)
{
  int j, i;
  int ans;
  static int firsttime = TRUE;
  
 

  //enter code
    /* get home path */
    homePath= getenv ("HOME");
  
 
     //////////////////////////////////////////////////////////////////////////
    // Create a MMAP
    //////////////////////////////////////////////////////////////////////////
#ifdef WIN32
	/*// Create a 4K memory-mapped file (MMF)
	hFile = CreateFile((LPCTSTR) "input.dat", 
		GENERIC_WRITE | GENERIC_READ, 
		FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 
		OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	
	if(hFile == INVALID_HANDLE_VALUE) 
	{
		// Failed to create file 
		return 1;
	}

	map = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 1024, "MMAPShmem");
	g_fpga2robot = (char *) MapViewOfFile (map, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0); 
	*/
#else



 printf("buffer_size: %d\n\n", statbuf.st_size);
	
	int fd_i;
    char* fgpa2robot_FilePath;
    fgpa2robot_FilePath = strncat(homePath, "/prog/masterUser/src/fpga2robot.dat", 100);  //max number of characers to be concatinated :100
    if((fd_i = open(fgpa2robot_FilePath, O_RDWR)) == -1)
	{
        printf("Couldn't open 'fpga2robot.dat'\n");
   	}
   	g_fpga2robot = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd_i, 0);
    
    if (g_fpga2robot == MAP_FAILED) {
        close(fd_i);
        perror("Error mmapping the file");
        exit(EXIT_FAILURE);
    }
    
    int fd_o;
    if((fd_o = open("/home/eric/prog/masterUser/src/robot2fpga.dat", O_RDWR)) == -1)
    {
        printf("Couldn't open 'robot2fpga.dat'\n");
    }
    lseek(fd_o, 0, SEEK_SET);
    g_robot2fpga = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd_o, 0);
    
    if (g_robot2fpga == MAP_FAILED) {
        close(fd_o);
        perror("Error mmapping the file");
        exit(EXIT_FAILURE);
    }
#endif

    if(g_fpga2robot != NULL)
    {	
        printf("Wrapper has created a MMAP for file 'fpga2robot.dat'\n");
    }

    if(g_robot2fpga != NULL)
    {   
        printf("Wrapper has created a MMAP for file 'robot2fpga.dat'\n");
    }
    
    /* find size of input file */
    if (fstat (fd_i, &statbuf) < 0)
        err_sys ("fstat error");

	system("/home/eric/prog/masterUser/src/py/py_mmap.py &");
  //end code



  
  

  if (firsttime){
    firsttime = FALSE;
    freq = 0.1; // frequency
    amp  = 0.5; // amplitude
  }

  // prepare going to the default posture
  bzero((char *)&(target[1]),N_DOFS*sizeof(target[1]));
  for (i=1; i<=N_DOFS; i++)
//.........这里部分代码省略.........

int main(int argc, char argv**)
{
	socklen_t len;
	int n, listenfd, connfd, char_in, count = 0;
	struct sockaddr_in  servaddr, cliaddr;
	char buff[40], wbuff[MAXLINE], rbuff[MAXLINE], cmd[16], path1[64]=".", path[64], vers[16];

	FILE * hFile;

	if(argc != 2)
	{
		err_quit("usage: a.out <Port>");
	}

	listenfd = Socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.sin_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(atoi(argv[1]));

	Bind(listenfd, (SA*) &servaddr, sizeof(servaddr));

	Listen(listenfd, LISTENQ);

	for( ; ; )
	{
		len = sizeof(cliaddr);

		connfd  = Accept(listenfd, (SA*) &cliaddr, &len);
		printf("\nConnection from %s, port %d\n", Inet_ntop(AF_INET, &cliaddr.sin_addr, buff, sizeof(buff)) ntohs(cliaddr.sin_port));

		while((n = read(connfd, rbuff, MAXLINE)) > 0)
		{
			rbuff[n] = 0;

			if(fputs(rbuff, stdout) == 0)
			{
				err_sys("fputs error");
			}

			if(strstr(rbuff,"\r\n\r\n") > 0)
			{
				break;
			}
		}

		if(n < 0)
		{
			err_sys("read error");
		}

		sscanf(rbuff, "%s %s %s", cmd, path, vers);
		strcat(path1, path);
		if(strcmp(path1, "./") == 0)
		{
			strcpy(path1, "./index.html");
		}

		hFile = fopen(path1, "r");
		if(hFile == NULL)
		{
			hFIle = fopen("error.html", "r");
		}

		strcpy(wbuff,"");

		while((char_in = fgetc(hFile)) != EOF)
		{
			wbuff(count) = char_in;
			count++;
		}

		wbuff(count) = 0;

		Write(connfd, wbuff, strlen(wbuff));

		count = 0;
		fclose(hFile);
		strcpy(path1,".");

		Close(connfd);
	}
}

int main(int argc, char const *argv[])
{
	char line[MAXLINE];
	FILE *fpout, *fpin;

	if((fpout = popen("./kbfilter", "w")) == NULL)
			err_sys("popen error");
	//if((fpin = popen("./kbfilter", "r")) == NULL)
	//		err_sys("popen error");

	struct termios termios_struct;

  tcgetattr(STDIN_FILENO, &orig_termios_struct);
  tcgetattr(STDIN_FILENO, &termios_struct);
  // could be done like this also:
  // termios_struct = orig_termios_struct;

  termios_struct.c_lflag &= (~ICANON) & (~ECHO);
  termios_struct.c_cc[VTIME] = 0;
  termios_struct.c_cc[VMIN] = 1;
  tcsetattr(STDIN_FILENO, TCSANOW, &termios_struct);
  sleep(1);

  char c[2];
  //while((c = getchar()) != EOF)
  while((c[0] = getc(stdin)) != EOF)
	{   
		c[1] = 0;    
		//printf("%s\n", c);
		if(fputs(c,fpout) == EOF)
		{ 
  		tcsetattr(STDIN_FILENO, TCSANOW, &orig_termios_struct);
			err_sys("fputs error to pipe");
		}
	}
  tcsetattr(STDIN_FILENO, TCSANOW, &orig_termios_struct);
	if (ferror(fpout))
		//||ferror(fpin))
		err_sys("fputs error to pipe");
  if(pclose(fpout) == -1)
		err_sys("pclose fpout error");
  //if(pclose(fpin) == -1)
	//	err_sys("pclose fpin error");
/*
	if((fpin = popen("./kbfilter", "r")) == NULL)
			err_sys("popen error");
	for(;;)
	{
		//fputs("prompt> ", stdout);
		//fflush(stdout);
		if(fgets(line, MAXLINE, fpin) == NULL) // read from pipe
			break;
		if(fputs(line, stdout) == EOF)
			err_sys("fputs error to pipe");
	}
	if(pclose(fpin) == -1)
		err_sys("pclose error");

//	tcsetattr(STDIN_FILENO, TCSANOW, &orig_termios_struct);
*/
	putchar('\n');
	exit(0);
}

//.........这里部分代码省略.........
                int close_fd_errout = 1;
                
                if (i + 1 < cmdc) {
                    // If there's next command
                    Pipe(in_out_pipe);
                    fd_out = in_out_pipe[1];
                    fd_errout = in_out_pipe[1];
                } else {
                    // This is last one
                    fd_out = sockfd;
                    fd_errout = sockfd;
                    
                    int minus = 0;
                    
                    for (int q = 0; q < argc; q++) {
                        if (strcmp(argv[q], ">") == 0) {
                            fd_out = open(argv[q + 1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
                            argv[q] = '\0';
                            argc = q;
                            break;
                        } else if (argv[q][0] == '|' && argv[q][1] != '!') {
                            int dest_pipe = parse_number(&argv[q][1]) + line;
                            printf("dest_pipe std = %d\n", dest_pipe);
                            if (pipes[dest_pipe][1] == -1)
                                Pipe(pipes[dest_pipe]);
                            fd_out = pipes[dest_pipe][1];
                            close_fd_out = 0;
                            
                            argv[q] = '\0';
                            minus++;
                        } else if (argv[q][0] == '!' && argv[q][1] != '|') {

                            int dest_pipe = parse_number(&argv[q][1]) + line;
                            printf("dest_pipe err = %d\n", dest_pipe);
                            
                            if (pipes[dest_pipe][1] == -1)
                                Pipe(pipes[dest_pipe]);
                            fd_errout = pipes[dest_pipe][1];
                            close_fd_errout = 0;

                            argv[q] = '\0';
                            minus++;
                        } else if (
                                   (argv[q][0] == '!' && argv[q][1] == '|') ||
                                   (argv[q][0] == '|' && argv[q][1] == '!')) {

                            int dest_pipe = atoi(&argv[q][2]) + line;
                            printf("dest_pipe std+err = %d\n", dest_pipe);
                            
                            if (pipes[dest_pipe][1] == -1)
                                Pipe(pipes[dest_pipe]);

                            fd_out = pipes[dest_pipe][1];
                            fd_errout = pipes[dest_pipe][1];
                            
                            
                            argv[q] = '\0';
                            minus++;
                        }
                    }
                    argc -= minus;
                }
                
                printf("pipe[0]=%d\n", in_out_pipe[0]);
                printf("pipe[1]=%d\n", in_out_pipe[1]);
                
                char exit_code = fork_process(argv, fd_in, fd_out, fd_errout, sockfd);
                
                if (close_fd_out && fd_out != sockfd && fd_out != -1)
                    Close(fd_out);
                if (close_fd_errout && fd_errout != fd_out && fd_errout != sockfd && fd_errout != -1)
                    Close(fd_errout);

                if (exit_code == ERR_CMD_NOT_FOUND) {
                    dprintf(sockfd, "Unknown command: [%s].\n", argv[0]);
                    unknown_command = 1;
                    break;
                } else {
                    if (fd_in != -1)
                        Close(fd_in);
                    fd_in = in_out_pipe[0];
                }
                
            }

            showSymbol(sockfd);

            if (!unknown_command)
                line++;
        }
    }
    if (n < 0 && errno == EINTR) {
        pos += n;
        goto again;
    }
    else if (n < 0) {
        err_sys("str_echo: read error");
    }

}

void err_setout(int fd)
{
	if (dup2(fd, STDERR_FILENO) == -1)
		err_sys("liberr redirect stderr");
	_err_tty = isatty(STDERR_FILENO);
}

int main (int argc, char **argv) {
  int    listenfd, connfd, n;
  struct sockaddr_in servaddr, clientaddr;
  
  //char   buf[MAXDATASIZE];
  char   recvline[MAXLINE + 1];
  
  //time_t ticks;
  char   error[MAXLINE + 1];
  
  //para obter o endereço do socket
  socklen_t addrlen = sizeof(clientaddr);

  //valor temporario para o id dos processos filhos
  pid_t child_pid;

  if (argc != 3) { //caso o usuário não tenha fornecido um IP e a porta para conexão
    strcpy(error,"uso: ");
    strcat(error,argv[0]);
    strcat(error," <Porta> <listen Backlog value");
    perror(error);
    exit(1);
  }

  //Inicializa o socket
  listenfd = Socket(AF_INET, SOCK_STREAM, 0);
  //Preenche informacoes relativas ao socket do servidor
  Servaddr(&servaddr, argv[1]);
  //Associa socket com um ip e uma porta
  Bind(listenfd, &servaddr);
  //Diz para o socket ouvir conexoes
  Listen(listenfd, atoi(argv[2]));
  //Registra funcao de handler
  Signal(SIGCHLD, sig_child);
  
  //Prepara arquivo de log

  time_t now;
  char timeString[256];
  FILE *log;
  
  while (1){
    //Retarda a remoção dos sockets da fila de conexões completas
    sleep(10);
    //Aceita uma conexao e atribui a um socket
    if ((connfd = Accept(listenfd, &clientaddr, &addrlen)) < 0){
      if (errno = EINTR){
	continue;
      }
      else{
	err_sys("accept error");
      }
    }

    //Registra conexao
    
    time(&now);
    strftime (timeString, 256, "%Y-%m-%d %H:%M:%S", localtime(&now));

    log = fopen("log.txt","a");
    if (log == NULL){
      printf ("Failed to log entry.\n");
    }
    else{
      fprintf(log,"[%s] %s:%u conectou-se\n",
	      timeString,
	      inet_ntoa(clientaddr.sin_addr),
	      ntohs(clientaddr.sin_port));
    }
    fclose(log);


    // Cria subprocesso que lidara com essa conexao
    
    if ((child_pid = fork()) == 0) { //Processo filho
      //Fecha socket para ouvir novas conexoes
      close(listenfd);
      //Imprime o endereço do socket local
      getsockname(connfd,(struct sockaddr *)&servaddr, &addrlen);
      printf("Endereço local: %s:%u \n",inet_ntoa(servaddr.sin_addr), ntohs(servaddr.sin_port));
     
      //Imprime o endereço do socket remoto
      printf("Endereço do cliente: %s:%u \n",
	     inet_ntoa(clientaddr.sin_addr),
	     ntohs(clientaddr.sin_port));
      
      while(1) {
        //Executa comandos enviados pelo cliente
	n = read(connfd, recvline, MAXLINE);

	if (n == 0){
	  // socket disconnected
	  break;
	}

	if (strcmp(recvline,"bye\n") == 0){
	  break;
	}
	else {
	  char outputbuffer[MAXLINE + 1];
//.........这里部分代码省略.........

void
Fclose(FILE *fp)
{
	if (fclose(fp) != 0)
		err_sys("fclose error");
}

int recv_v6(int seq, struct timeval *tv)
{
    int     hlen2, icmp6len, ret;
    ssize_t n;
    socklen_t len;
    struct ip6_hdr *hip6;
    struct icmp6_hdr *icmp6;
    struct udphdr *udp;

    gotalarm = 0;
    alarm(3);
    for ( ; ; ) {
        if (gotalarm)
            return -3;              /* alarm expired */

        len = pr->salen;
        n = recvfrom(recvfd, recvbuf, sizeof(recvbuf), 0, pr->sarecv, &len);
        if (n < 0) {
            /* 
             * EINTR indicates an interrupted system call (maybe by our SIGALRM).
             * Linux doesn't interrupt recvfrom() so we set a socket timeout option
             * (in traceloop() function). If recvfrom() times out, it returns
             * EAGAIN == EWOULDBLOCK
             */
            if (errno == EINTR || errno == EAGAIN)
                continue;
            else
                err_sys("recvfrom() error");
        }

        icmp6 = (struct icmp6_hdr *) recvbuf;       /* ICMP header */
        if ((icmp6len = n) < 8)
            continue;                               /* not enough to look at ICMP header */

        if (icmp6->icmp6_type == ICMP6_TIME_EXCEEDED &&
                icmp6->icmp6_code == ICMP6_TIME_EXCEED_TRANSIT) {
            if (icmp6len < 8 + sizeof(struct ip6_hdr) + 4)
                continue;                           /* not enough data to look at inner header */

            hip6 = (struct ip6_hdr *) (recvbuf + 8);        /* skip over ICMP header to get to inner IPv6 */
            hlen2 = sizeof(struct ip6_hdr);                 
            udp = (struct udphdr *) (recvbuf + 8 + hlen2);  /* skip over IPv6 header and inner IPv6 to get to inner UDP */
            if (hip6->ip6_nxt == IPPROTO_UDP &&
                    udp->source == htons(sport) &&                            /* BSD: udp->uh_sport */
                    udp->dest == htons(dport + seq)) {                        /* BSD: udp->uh_dport */
                ret = -2;                           /* we hit an intermediate router */
                break;
            }

        } else if (icmp6->icmp6_type == ICMP6_DST_UNREACH) {
            if (icmp6len < 8 + sizeof(struct ip6_hdr) + 4)
                continue;                           /* not enough data to look at inner header */

            hip6 = (struct ip6_hdr *) (recvbuf + 8);        /* skip over ICMP header to get to inner IPv6 */
            hlen2 = sizeof(struct ip6_hdr);                 
            udp = (struct udphdr *) (recvbuf + 8 + hlen2);  /* skip over IPv6 header and inner IPv6 to get to inner UDP */
            if (hip6->ip6_nxt == IPPROTO_UDP &&
                    udp->source == htons(sport) &&                              /* BSD: udp->uh_sport */
                    udp->dest == htons(dport + seq)) {                          /* BSD: udp->uh_dport */
                if (icmp6->icmp6_code == ICMP6_DST_UNREACH_NOPORT)
                    ret = -1;                           /* have reached destination */
                else
                    ret = icmp6->icmp6_code;            /* 0, 1, 2, ... */
                break;
            }

        } else if (verbose) {
            printf(" (from %s: type = %d, code = %d)\n",
                    sock_ntop_host(pr->sarecv, pr->salen),
                    icmp6->icmp6_type, icmp6->icmp6_code);
        }

        /* Some other ICMP error, recvfrom() again */
    }

    alarm(0);                               /* don't leave alarm running */
    gettimeofday(tv, NULL);                 /* get time of packet arrival */
    return ret;
}

void Dup2(int fd1, int fd2)
{
	if (dup2(fd1, fd2) == -1)
		err_sys("dup2 error");
}

int main(int argc,char *argv[])
{
	int	listenfd,acceptfd,maxfd,client[MAXSIZE],nread,i,imax;
	char	recvmsg[MAXLINE];
	struct sockaddr sa;
	socklen_t	salen;
	fd_set	rset,rsetsave;

	for(i=0;i<MAXSIZE;i++)
		client[i] = -1;
	listenfd = acceptfd = -1;
	imax = 0;

	if(argc == 2)
		listenfd = Tcp_listen(NULL,argv[1],&salen);
	else if(argc == 3)
		listenfd = Tcp_listen(argv[1],argv[2],&salen);
	else
		err_quit("usage : server02 [<host>] <serv>");

	maxfd = listenfd;
	FD_ZERO(&rsetsave);
	
	FD_SET(listenfd,&rsetsave);
	while(1){
		rset = rsetsave;
		if((nread = select(maxfd+1,&rset,NULL,NULL,NULL)) < 0)
			err_quit("select error");

		if(FD_ISSET(listenfd,&rset)) {
			if((acceptfd = accept(listenfd,&sa,&salen)) < 0) {
				if((errno == EINTR))
					continue;
				else
					err_sys("server02 error in accept!");
			}else {
				for(i=0;i<MAXSIZE;i++){
					if(client[i] < 0){
						client[i] = acceptfd;
						break;
					}
				}

				if(i == MAXSIZE)
					err_quit("reach max client!please wait\n");
				FD_SET(acceptfd,&rsetsave);
				if(acceptfd > maxfd)
					maxfd = acceptfd;
				if(i > imax)
					imax = i;
				if(--nread <= 0)
					continue;
			}
		}

		for(i=0;i<=imax;i++){
			if(client[i] < 0)
				continue;
			if(FD_ISSET(client[i],&rset)) {
				if((Readline(client[i],recvmsg,MAXLINE)) == 0){
					Close(client[i]);
					FD_CLR(client[i],&rsetsave);
					client[i] = -1;
					printf("has disconnect with one socket!\n");
				}else {
					Writen(client[i],recvmsg,strlen(recvmsg));
				}

				if(--nread <= 0)
					continue;
			}
		}
	}
}