为什么wireshark抓到了client的请求包，但是server不回ACK

dyqiu

大家好，发现一个很奇怪的问题，经过多次试验和网上搜索都没有找到答案，想让大家帮忙分析一下。
为了简化问题，我写了两个简单程序，Server和Client，Client根据输入参数建立指定数量的连接到Server，然后定时发送一个字节的指令到Server，Server接收指令后不做任何事情。
发现以下情况：
        1. Client建立1个连接到Server，每个连接每隔50ms发送一次指令，运行十几个小时没有发现问题。
        2. Client建立1个连接到Server，每隔约15ms发送一个字节的指令，大概运行一两个小时后就出现问题。
        3. Cleint建立4个或以上的连接，每个连接每隔50ms发送一个字节的指令，有时一两分钟，有时二三十分钟会出现问题，随着连接的数量增加，出现问题的频率也增加。
出现问题后的现象是：在Server端用wireshark能抓到Client发送的指令，但是Server没有回ACK，200ms后Client重传此包，Server这时才回复正常。检查此时收到的包的内容与之前正常情况下数据包的内容没有什么区别。但是运行netstat -s可以看到bad segments received的数量会增加一个。
环境：在Fedora10,CentOS6.3上都试过，换过多台机器，试过两台机网线直连，试过Server和Client运行在同一台机器上。都会出现上述现象。
请各位大佬们帮忙分析一下有什么可能的原因，谢谢。

myworkstation

回复 1# dyqiu


   设置一下socket选项 启用TCP_NODELAY（这会禁用Nagle)并禁用TCP_CORK（如果本来就没有设置它就不用设了）。你的问题应该是数量太小导致TCP阻塞控制中Nagle算法引起的。

dyqiu

回复 2# myworkstation


    谢谢，Server和Client的NODELAY选项都已经设置了的。
   Server端已经抓到了Client发的数据包，所以应该不是Client的延迟发包导致。
   那会不会是因为Server端延迟ACK导致的呢，我在Server端增加定时50ms发送一个字节到Client的处理，发现在等待的200ms里面Server发送了4个包到Client，但是没有对之前Client的包进行确认，所以应该也不是延迟ACK导致的。
   下面的抓包的记录，其中第一行就是出问题的包172.16.129.3(client)发送到172.16.129.138(server)的包，最后一行是client重传的包：

   

dyqiu

Server端的代码

1. typedef struct client_t
   
2. {
   
3.         int             sock;
   
4.         int             frameNO;
   
5.         struct timeval  lastKeepAlive;
   
6.         struct timeval  lasttime;
   
7. }Client;
   
8. 
   
9. int                     g_listenSock    = 0;
   
10. list<Client*>           g_clientList;
    
11. 
    
12. void SetFds(fd_set* set)
    
13. {
    
14.         FD_ZERO(set);
    
15.         if(g_listenSock > 0)
    
16.         {
    
17.                 FD_SET(g_listenSock, set);
    
18.         }
    
19. 
    
20.         for(list<Client*>::iterator it = g_clientList.begin(); it != g_clientList.end(); it++)
    
21.         {
    
22.                 Client* cl      = *it;
    
23.                 if(cl->sock > 0)
    
24.                 {
    
25.                         FD_SET(cl->sock, set);
    
26.                 }
    
27.         }
    
28. }
    
29. 
    
30. void SetSockOpt(int sock)
    
31. {
    
32.         Network::SetNonBlock(sock);
    
33.         Network::SetKeepLive(sock, 6, 3, 2);
    
34.         Network::SetNonDelay(sock);
    
35. }
    
36. 
    
37. bool ProceessClientCmd(Client* cl)
    
38. {
    
39.         unsigned char msgType   = 0;
    
40.         int ret = Network::Readn(cl->sock, &msgType, 1);
    
41.         if(ret != 1)
    
42.         {
    
43.                 printf("recv failed, sock = %d\n", cl->sock);
    
44.                 return false;
    
45.         }
    
46. 
    
47.         printf("sock = %d, recv request, seq = %d, frame %d\n", cl->sock, msgType, ++cl->frameNO);
    
48. 
    
49.         struct timeval  now;
    
50.         gettimeofday(&now, NULL);
    
51.         if(cl->lasttime.tv_sec  == 0)
    
52.         {
    
53.                 cl->lasttime    = now;
    
54.         }
    
55.         else
    
56.         {
    
57.                 long diff       = (now.tv_sec - cl->lasttime.tv_sec)* 1000000 + now.tv_usec - cl->lasttime.tv_usec;
    
58.                 printf("sock = %d, now is %ld:%06d, wait %ld us\n", cl->sock, now.tv_sec, now.tv_usec, diff);
    
59.                 if(diff > 200000)
    
60.                 {
    
61.                         usleep(500000);
    
62.                         _exit(0);
    
63.                         sleep(900000);  // stop
    
64.                 }
    
65.                 cl->lasttime    = now;
    
66.         }
    
67. 
    
68.         return true;
    
69. }
    
70. 
    
71. int main(int argc, char** argv)
    
72. {
    
73.         if(argc < 2)
    
74.         {
    
75.                 return 0;
    
76.         }
    
77. 
    
78.         g_listenSock    = Network::MakeInetServer(atoi(argv[1]));
    
79.         if(g_listenSock < 0)
    
80.         {
    
81.                 printf("start listen failed\n");
    
82.                 return -1;
    
83.         }
    
84. 
    
85.         while(1)
    
86.         {
    
87.                 fd_set  rfds;
    
88.                 SetFds(&rfds);
    
89. 
    
90.                 struct timeval  tv      = {2, 0};
    
91.                 int ret = select(FD_SETSIZE, &rfds, NULL, NULL, &tv);
    
92.                 if(ret > 0)
    
93.                 {
    
94.                         if(FD_ISSET(g_listenSock, &rfds))
    
95.                         {
    
96.                                 int sock        = Network::MakeAccept(g_listenSock);
    
97.                                 if(sock > 0)
    
98.                                 {
    
99.                                         Client* cl      = new Client;
    
100.                                         cl->frameNO     = 0;
     
101.                                         cl->sock        = sock;
     
102.                                                                                
     
103.                                         SetSockOpt(sock);
     
104.                                        
     
105.                                                                                 gettimeofday(&(cl->lastKeepAlive), NULL);
     
106.                                         cl->lasttime.tv_sec     = 0;
     
107.                                         g_clientList.push_back(cl);
     
108.                                         printf("new client, sock = %d\n", sock);
     
109.                                 }
     
110.                                 else
     
111.                                 {
     
112.                                         printf("make accpet failed\n");
     
113.                                 }
     
114.                         }
     
115. 
     
116.                         for(list<Client*>::iterator it = g_clientList.begin(); it != g_clientList.end(); it++)
     
117.                         {
     
118.                                 Client* cl      = *it;
     
119.                                 if(FD_ISSET(cl->sock, &rfds))
     
120.                                 {
     
121.                                         if(!ProceessClientCmd(cl))
     
122.                                         {
     
123.                                                 Network::Close(cl->sock);
     
124.                                                 cl->sock = -1;
     
125.                                         }
     
126.                                 }
     
127.                         }
     
128. 
     
129.                         for(list<Client*>::iterator it = g_clientList.begin(); it != g_clientList.end();)
     
130.                         {
     
131.                                 Client* cl      = *it;
     
132.                                 if(cl->sock < 0)
     
133.                                 {
     
134.                                         delete *it;
     
135.                                         it = g_clientList.erase(it);
     
136.                                 }
     
137.                                 else
     
138.                                 {
     
139.                                         it++;
     
140.                                 }
     
141.                         }
     
142.                 }
     
143.         }
     
144. }

复制代码

dyqiu

网络读写函数

1. ssize_t Network::Recvn(int fd, void* vptr, ssize_t n)
   
2. {
   
3.         ssize_t  nleft;
   
4.         ssize_t  nread;
   
5.         char        *ptr;
   
6.         fd_set  fds;
   
7.         struct  timeval tv;
   
8. 
   
9.         ptr     = reinterpret_cast<char*>(vptr);
   
10.         nleft   = n;
    
11.         while(nleft > 0)
    
12.         {
    
13. #ifdef __linux__
    
14.                 nread = read(fd,ptr,nleft);
    
15. #elif _WIN32
    
16.                 nread = recv(fd,ptr,nleft,0);
    
17. #else
    
18.                 nread = read(fd,ptr,nleft);
    
19. #endif
    
20. 
    
21. #ifdef __linux__
    
22.                 if(nread < 0 )
    
23. #elif _WIN32
    
24.                 if(nread == SOCKET_ERROR )
    
25. #else
    
26.                 if(nread < 0 )
    
27. #endif
    
28.                 {
    
29. #ifdef __linux__
    
30.                         if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR)
    
31.                         {
    
32.                                 return RET_ERROR;
    
33.                         }
    
34. #elif _WIN32
    
35.                         int err = GetLastError();
    
36.                         if(err != WSAEWOULDBLOCK)
    
37.                         {
    
38.                                 return RET_ERROR;
    
39.                         }
    
40. #else
    
41.                         if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR)
    
42.                         {
    
43.                                 return RET_ERROR;
    
44.                         }
    
45. #endif
    
46. 
    
47.                         FD_ZERO(&fds);
    
48.                         FD_SET(fd, &fds);
    
49.                         tv.tv_sec  = 5;
    
50.                         tv.tv_usec = 0;
    
51.                         int nselect = Select(fd+ 1, &fds, NULL, NULL, &tv);
    
52.                         if(nselect <= 0)
    
53.                         {
    
54.                                 return RET_ERROR;
    
55.                         }
    
56.                 }
    
57.                 else if (nread == 0)
    
58.                 {
    
59.                         return RET_ERROR;
    
60.                 }
    
61.                 else
    
62.                 {
    
63.                         nleft -= nread;
    
64.                         ptr          += nread;
    
65.                 }
    
66.         }
    
67.         return (n - nleft);
    
68. }
    
69. 
    
70. 
    
71. ssize_t        Network::Sendn(int fd, const void* vptr, ssize_t n)
    
72. {
    
73.         ssize_t     nleft;
    
74.         ssize_t     nwritten;
    
75.         const char *ptr;
    
76. 
    
77.         fd_set fds;
    
78.         struct timeval tv;
    
79. 
    
80.         ptr     = reinterpret_cast<const char*>(vptr);
    
81.         nleft   = n;
    
82. 
    
83.         while(nleft > 0)
    
84.         {
    
85. #ifdef __linux__
    
86.                 nwritten = write(fd,ptr,nleft);
    
87. #elif _WIN32
    
88.                 {
    
89.                         nwritten = send(fd,ptr,nleft,0);
    
90.                 }
    
91. #else
    
92.                 nwritten = write(fd,ptr,nleft);
    
93. #endif
    
94. 
    
95. #ifdef __linux__
    
96.                 if(nwritten < 0 )
    
97. #elif _WIN32
    
98.                 if(nwritten == SOCKET_ERROR )
    
99. #else
    
100.                 if(nwritten < 0 )
     
101. #endif
     
102.                 {
     
103. #ifdef __linux__
     
104.                         if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR)
     
105.                         {
     
106.                                 return RET_ERROR;
     
107.                         }
     
108. #elif _WIN32
     
109.                         int err = GetLastError();
     
110.                         if(err != WSAEWOULDBLOCK)
     
111.                         {
     
112.                                 return RET_ERROR;
     
113.                         }
     
114. #else
     
115.                         if (errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR)
     
116.                         {
     
117.                                 return RET_ERROR;
     
118.                         }
     
119. #endif
     
120. 
     
121.                         FD_ZERO(&fds);
     
122.                         FD_SET(fd, &fds);
     
123.                         tv.tv_sec  = 5;
     
124.                         tv.tv_usec = 0;
     
125.                        
     
126.                         int nselect = Select(fd + 1,NULL,&fds,NULL,&tv);
     
127.                         if(nselect <= 0)
     
128.                         {
     
129.                                 return RET_ERROR;
     
130.                         }
     
131.                 }
     
132.                 else if(nwritten == 0)
     
133.                 {
     
134.                         return RET_ERROR;
     
135.                 }
     
136.                 else
     
137.                 {
     
138.                         nleft   -= nwritten;
     
139.                         ptr     += nwritten;
     
140.                 }
     
141.         }
     
142.         return (n-nleft);
     
143. }

复制代码

dyqiu

下图是相邻两个客户端的请求包，左边是正常的，右边是错误的，没看出来哪里不正常

myworkstation

回复 3# dyqiu


    看你的记录，我怀疑和这行代码相关“Network::SetKeepLive(sock, 6, 3, 2);”,虽然我不知道里面干了什么，但我想它肯定修改了KEEPALIVE的默认行为，默认是两个小时，这个代码是不是把TCP_KEEPIDLE给改了。

dyqiu

SetKeepLive的代码如下。我刚才试过，把这行代码注释掉，问题仍然存在。

1. int Network::SetKeepLive(int sockfd,int idle,int intvl,int cnt)
   
2. {
   
3.         int opt = 1;
   
4.         if (setsockopt(sockfd,SOL_SOCKET,SO_KEEPALIVE,reinterpret_cast<char*>(&opt),sizeof(opt)) < 0)
   
5.         {
   
6.                 return RET_ERROR;
   
7.         }
   
8. 
   
9. #ifdef __linux__
   
10.         if (setsockopt(sockfd,IPPROTO_TCP,TCP_KEEPIDLE, &idle, sizeof(idle)) < 0 ||
    
11.             setsockopt(sockfd,IPPROTO_TCP,TCP_KEEPINTVL,&intvl,sizeof(intvl))< 0 ||
    
12.             setsockopt(sockfd,IPPROTO_TCP,TCP_KEEPCNT,  &cnt,  sizeof(cnt)) < 0)
    
13.         {
    
14.                 return RET_ERROR;
    
15.         }
    
16. #elif _WIN32
    
17.         unsigned long dw;
    
18.         tcp_keepalive live,liveout;
    
19. 
    
20.         live.onoff                                =        1;
    
21.         live.keepalivetime                = idle * 1000;       
    
22.         live.keepaliveinterval        = intvl * 1000;
    
23. 
    
24.         if(WSAIoctl(sockfd,SIO_KEEPALIVE_VALS,&live,sizeof(live),&liveout,sizeof(liveout),&dw,NULL,NULL) < 0)
    
25.         {
    
26.                 return RET_ERROR;
    
27.         }
    
28. #else
    
29.         if (setsockopt(sockfd,IPPROTO_TCP,TCP_KEEPIDLE, &idle, sizeof(idle)) < 0 ||
    
30.             setsockopt(sockfd,IPPROTO_TCP,TCP_KEEPINTVL,&intvl,sizeof(intvl))< 0 ||
    
31.             setsockopt(sockfd,IPPROTO_TCP,TCP_KEEPCNT,  &cnt,  sizeof(cnt)) < 0)
    
32.         {
    
33.                 return RET_ERROR;
    
34.         }
    
35. #endif
    
36. 
    
37.         return RET_SUCCESS;
    
38. }

复制代码

myworkstation

回复 8# dyqiu


    客户端和服务器都注释掉这个功能了吗？

dyqiu

是，都注释了的