c语言中的linux TCP多客户端回显服务器

Question

我目前正在研究使用fork、线程、多路复用IO等的TCP多客户端回显服务器和客户端。 下面是使用 fork() 的简单服务器和客户端。

server_fork.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>

#include <arpa/inet.h>

static const int BUFSIZE = 1024;

int readn(int fd, char *buf, short n);

int main(void)
{
  int cnt = 0;
  int listenFD, connectFD;
  struct sockaddr_in listenSocket, connectSocket;
  char buffer [BUFSIZE];

  if ((listenFD = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
    perror("socket() error\n");
    exit(0);
  }

  if (setsockopt(listenFD, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof(int)) < 0) {
    perror("sockopt error\n");
    exit(0);
  }

  memset(&listenSocket, 0, sizeof(listenSocket));
  listenSocket.sin_family = AF_INET;
  listenSocket.sin_addr.s_addr = inet_addr("0.0.0.0");
  listenSocket.sin_port = htons(7777);

  if (bind(listenFD, (struct sockaddr *)&listenSocket, sizeof(listenSocket)) < 0) {
    perror("bind() error\n");
    exit(0);
  }

  if (listen(listenFD, 1) < 0) {
    perror("listen() error\n");
    exit(0);
  }

  signal(SIGCHLD, SIG_IGN);

  int connectSocketLen;
  short readLen;
  pid_t pid;

  while (1) {
    connectSocketLen = sizeof(connectSocket);
    if ((connectFD = accept(listenFD, (struct sockaddr *)&connectSocket,
            &connectSocketLen)) < 0) {
      perror("accept() error\n");
      exit(0);
    }

    pid = fork();
    cnt++;
    if (pid == 0) {
      close(listenFD);

      while (1) {
        memset(buffer, 0, BUFSIZE);
        if (readn(connectFD, buffer, 2) == 0) {
          break;
        }
        readLen = (*(short *)&buffer);
        if(readLen != 12)
          printf("[%d] : %d\n", cnt, readLen);
        if (readn(connectFD, buffer, readLen) == 0) {
          break;
        }
        buffer[readLen] = 0;
        int n;
        if ((n = write(connectFD, buffer, readLen)) <= 0) {
          perror("!!");
        }
        sleep(0);
      }
      close(connectFD);
      exit(0);
    }

    else if (pid > 0) {
      close(connectFD);
    }

    else {
      perror("fork() error\n");
      exit(0);
    }
  }
  close(listenFD);

  return 0;
}

int readn(int fd, char *buf, short n)
{
  short sp = 0, readed;
  while (n) {
    readed = read(fd, buf + sp, n);
    if (readed <= 0) {
      return 0;
    }
    n -= readed;
    sp += readed;
  }
  return 1;
}

client.c

#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>

static const int bufSize = 1024;

int main(int argc,char *argv[])
{
  signal(SIGCHLD, SIG_IGN);
  fork();
  fork();
  fork();
  fork();
  fork();
  fork();
  fork();
  fork();
  //fork();
  //fork();

  char length[2], recvBuf[bufSize];
  char buf[]="hello, world\0";
  short len = strlen(buf);
  sprintf(length,"%c",len);
  int client_sockfd, size, i, n, state;

  uint64_t delta_us = 0;

  struct sockaddr_in server_addr;
  struct timespec start, end;

  client_sockfd = socket(PF_INET, SOCK_STREAM, 0);
  memset(&server_addr, 0, sizeof server_addr);
  server_addr.sin_family = AF_INET;
  server_addr.sin_port = htons(7777);

  inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr.s_addr);

  state = connect(client_sockfd, (struct sockaddr *)&server_addr, 
      sizeof server_addr);

  if (state < 0) {
    perror("connect err");
    exit(1);
  }

  for (i=0;i<10;i++) {
    clock_gettime(CLOCK_MONOTONIC_RAW, &start);

    n = write(client_sockfd, length, sizeof length);
    if (n<=0) {
      perror("write err");
      exit(1);
    }
    n = write(client_sockfd, buf, *((short *)&length));
    if (n<=0) {
      perror("write err");
      exit(1);
    }

    n = read(client_sockfd, recvBuf, *((short *)&length));
    if (n<=0) {
      perror("read err");
      exit(1);
    }

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    delta_us += (end.tv_sec - start.tv_sec) * 1000000 +
      (end.tv_nsec - start.tv_nsec)/1000;
    printf("%lu\n", delta_us);
    sleep(1);

  }
  return 0;
}

1. 客户端首先传输2字节表示的消息长度。
2. 然后客户端在 buf 中向服务器发送“hello, world”消息。
3. 服务器先通过readn()读取2个字节，再读取消息。

但在所有情况下（分叉、线程、多路复用 IO……等等），我都有一个共同的困难。

问题是：在上面的源码中，message("hello, world"的长度是12。所以在服务器的第一个readn()中预计会读到12。

实际上，当客户端数量较少时（客户端上的分叉数量为 7 或更少），它可以正常工作。 但是，如果客户端数量增加，readLen 的值在某些连接上将为 25960。 25960 是用十六进制表示“他”的值。

为什么当有很多客户端时会出现这个问题？ 不知道是不是和一次发一个TCP包分两次是一样的。

下面是上述问题情况的tcpdump抓包。

很抱歉，我无法立即上传图片。

tcpdump

Answer 1

在客户端，您在如何发送消息长度方面存在多个问题。从这里开始：

  char length[2], recvBuf[bufSize];
  char buf[]="hello, world\0";
  short len = strlen(buf);
  sprintf(length,"%c",len);

您的sprintf 格式承诺第三个参数的类型为char（提升为int），并指示它将相应的字符 输出到字符串中。实际上，参数是short（升级为int），这种不匹配会产生未定义的行为。

在实践中，整个sprintf 调用可能相当于这样：

length[0] = (char)(int)len;
length[1] = '\0';

如果char 是有符号类型，则它具有实现定义的特征，但无论如何，它无法捕获大于unsigned char 可以表示的最大值的长度。

客户继续这样做：

    n = write(client_sockfd, length, sizeof length);

这本身并没有错，但它确实无法适应短写的可能性。此外，服务器不会以与准备方式一致的方式解释这部分消息：

        if (readn(connectFD, buffer, 2) == 0) {
          break;
        }
        readLen = (*(short *)&buffer);

事实证明，如果服务器使用 short 类型的 16 位小端表示（受我已经描述的可表示消息长度的限制）和执行字符集，那么这种组合可能会起作用与客户端兼容，但对于一般网络软件来说，这些假设并不安全。

在某种程度上，您似乎遗漏了关于 read() 和 write() 和 char 指针的重要一点：char * 可用于读取任何类型的对象的表示，因此您不会需要将您的数据移动到char 数组中才能发送或接收。

总的来说，这将是一种更合适的方法：

// Client:
uint16_t len = strlen(buf);                // risk: buf may be too long
uint16_t len_n = htons(len);
int n = writen(client_sockfd, &len_n, 2);  // a write() analog of readn()
// ... handle possible error ...

---

// Sever:
uint16_t len_n;
int n = readn(connectFD, &len_n, 2);
// ... possible handle error ...
uint16_t readLen = ntohs(len_n);

请注意，无需将长度复制到单独的char 数组中即可发送，也无需将其接收到char 数组中。另一方面，还要注意在双方使用指定大小的数据类型（uint16_t），并使用htons() 和ntohs() 来确保客户端和服务器解释数据的字节同样的方法。此外，请注意使用readn() 的写模拟来发送数据，否则可能会发送不完整。

同样，客户端和服务器都应该使用（假设的）writen() 函数来发送消息的文本，并且就像服务器一样，客户端应该使用readn() 来读取它。未能考虑短读和写的可能性是一个重大缺陷，尤其是在像您这样的协议中，其消息边界不易与数据区分开来。不注意的短时间读取或写入将导致您的客户端和服务器不同步，并且没有简单的方法可以恢复。

Answer 2

除了@JohnBollinger 已经注意到的问题之外，当您的所有分叉客户端进程尝试同时连接时，您只在 server.c 中使用 1 的侦听窗口。它在我的测试中造成了大量的connect : conn reset by peer 错误。我必须在我的 FreeBSD 上使用大于 64 的窗口（在 256 处没有错误）来摆脱它们：

if (listen(listenFD, 256) < 0) {
  perror("listen() error\n");
  exit(0);
}