C 的作用域，但代理不知道。因此，当我们最终发送数据时，代理无法正确处理数据，连接中断。 因为正常的实现在其中一个数据包到达时将连接放在列表的顶部，并在需要删除条目时选择队列中的最后一个连接，所以通过网络定期发送数据包是一种很好的方法，可以始终处于极性位置，并

的作用域，但代理不知道。因此，当我们最终发送数据时，代理无法正确处理数据，连接中断。 因为正常的实现在其中一个数据包到达时将连接放在列表的顶部，并在需要删除条目时选择队列中的最后一个连接，所以通过网络定期发送数据包是一种很好的方法，可以始终处于极性位置，并且删除风险很小。"

---

结束语：

哪些教程？C是区分大小写的，所以

fork

不是

fork

不是

fork

。您的命名非常混乱。而且，这绝不是一个最小的、可验证的示例。正确格式化和缩进您的代码！这乱七八糟的代码是不可读的。还要更具体一点，并提供一个“我真的很累”“然后睡一觉，明天复习今天的代码，理解它，思考它的作用。做自己的审阅者。

fork（）

是一个众所周知的系统函数。1） 不要创建与系统函数同名的函数。2） 不要仅用大写字母来分隔名称，因为这会使代码的读者感到非常困惑。这对OP毫无帮助。@alk，OP询问如何保持连接/套接字打开。SO_KEEPALIVE正是在多个“消息”之间保持套接字打开的方法。在“正常”情况下，只有当发送方或接收方明确关闭或关闭TCP套接字连接时，才关闭TCP套接字连接，无论数据是否通过它发送。

void *socket_handler_thread(void *x_void_ptr)
{
  int sockfd, new_fd;  // listen on sock_fd, new connection on new_fd
  struct addrinfo hints, *servinfo, *p;
  struct sockaddr_storage their_addr; // connector's address information
  socklen_t sin_size;
  struct sigaction sa;
  int yes = 1;
  char s[INET6_ADDRSTRLEN];
  int rv;

  memset(&hints, 0, sizeof hints);
  hints.ai_family = AF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_flags = AI_PASSIVE; // use my IP

  if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0)
  {
    fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));

  }

// loop through all the results and bind 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("server: socket");
      continue;
    }

    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
    {
      perror("setsockopt");
      exit(1);
    }

    if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1)
    {
      close(sockfd);
      perror("server: bind");
      continue;
    }

    break;
  }

  freeaddrinfo(servinfo); // all done with this structure

  if (p == NULL)
  {
    fprintf(stderr, "server: failed to bind\n");
    exit(1);
  }

  if (listen(sockfd, BACKLOG) == -1)
  {
    perror("listen");
    exit(1);
  }

  sa.sa_handler = sigchld_handler; // reap all dead processes
  sigemptyset(&sa.sa_mask);
  sa.sa_flags = SA_RESTART;
  if (sigaction(SIGCHLD, &sa, NULL) == -1)
  {
    perror("sigaction");
    exit(1);
  }

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

  int socket_fd, result;
  fd_set readset;
  struct timeval tv;
  /* Wait up to five seconds. */
  tv.tv_sec = 0;
  tv.tv_usec = 100000;

  while (1)
  {  // main accept() loop
    sin_size = sizeof their_addr;
    new_fd = accept(sockfd, (struct sockaddr *) &their_addr, &sin_size);

    if (new_fd == -1)
    {
      perror("accept");
      continue;
    }

    inet_ntop(their_addr.ss_family,
        get_in_addr((struct sockaddr *) &their_addr), s, sizeof s);
    printf("server: got connection from %s\n", s);

    do
    {

      FD_ZERO(&readset);
      FD_SET(new_fd, &readset);
      result = select(new_fd + 1, &readset, NULL, NULL, &tv);
      printf("Stuck result = %i  ::: new_fd = %i \n\r", result, new_fd);
    } while (result == -1 && errno == EINTR);

    if (result > 0)
    {
      if (FD_ISSET(new_fd, &readset))
      {
        if (!fork())
        { // this is the child process

          printf("WORKED!");

          Fork(sockfd, new_fd);

        }
        //close(new_fd);  // parent doesn't need this
      }

      result = recv(socket_fd, some_buffer, some_length, 0);
      if (result == 0)
      {
        /* This means the other side closed the socket */
        //close(socket_fd);
      }
      else
      {
        /* I leave this part to your own implementation */
      }

    }
    else if (result < 0)
    {
      printf("Connection closed!");
      /* An error ocurred, just print it to stdout */
    }
  }

}

void Fork(int sockfd, int new_fd)
{
  int n;
  char buffer[256];
  bzero(buffer, 256);

  close(sockfd); // child doesn't need the listener
  if (send(new_fd, "Hello, world!", 13, 0) == -1)
  {
    perror("send");
  }

  n = read(new_fd, buffer, 255);
  if (n > 0)
  {
    printf("NOW-> %i  ::: %s", n, buffer);
  }

  close(new_fd);
  exit(0);
}

#include <sys/socket.h>

int setsockopt(int socket, int level, int option_name,
    const void *option_value, socklen_t option_len);

SO_KEEPALIVE
Keeps connections active by enabling the periodic transmission of messages, if this is supported by the protocol. 
This option takes an int value.

Return Value

Upon successful completion, setsockopt() shall return 0. Otherwise, -1 shall be returned and errno set to indicate the error. 

int on = 1;
if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)) < 0)
{ // then setsockopt failed
    perror( "setsockopt failed for SO_KEEPALIVE" );
    exit( EXIT_FAILURE );
}