linux中的TCP TCP多客户端echo服务器

问题描述 投票：0回答：2

我目前正在使用fork，thread，multiplexing 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 ......无论如何），我都有一个共同的困难。

问题是：在上面的源代码中，消息的长度（“hello，world”是12.因此预期在服务器的第一个readn（）中读取12。

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

当有很多客户时，为什么会出现这个问题？我想知道它是否与一次发送TCP数据包并将其分为两次相同。

下面是针对上述问题情况的tcpdump捕获。

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

tcpdump

c linux sockets tcp
2个回答
2
投票

在客户端，您有关于如何发送消息长度的多个问题。从这里开始：

  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()来读取它。未能考虑短读取和写入的可能性是一个重大缺陷，尤其是在诸如您的协议之类的协议中，其消息边界不容易与数据区分开。未经注意的短读或写将导致客户端和服务器不同步，无法轻松恢复。

0
投票

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

if (listen(listenFD, 256) < 0) {
  perror("listen() error\n");
  exit(0);
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.