服务器后台TCP连接存活问题

0. 背景

　　公司的服务器后台部署在某一个地方，接入的是用户的APP，而该地方的网络信号较差，导致了服务器后台在运行一段时间后用户无法接入，那边的同事反馈使用netstat查看系统，存在较多的TCP连接。

1. 问题分析

　　首先在公司内部测试服务器上部署，使用LoadRunner做压力测试，能正常运行，然后那边的同事反馈该地方信号较差。考虑到接入的问题，有可能接入进程的FD资源耗尽，导致accept失败。推论的依据是对于TCP连接来说，如果客户端那边由于一些异常情况导致断网而未能向服务器发起FIN关闭消息，服务端这边若没有设置存活检测的话，该连接会存在（存活时间暂未测）。

2. 实验测试

　　这里简单地写了一个服务端的程序，主要功能是回应，即接受一个报文（格式：2Byte报文长度+报文内容），然后原封不动将报文内容发回客户端。

 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/epoll.h>
 #include <unistd.h>
 #include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
 #include <arpa/inet.h>

 int g_epfd;

 int InitServer( unsigned short port )
 {
     int nServerFd = socket( AF_INET, SOCK_STREAM,  );

     struct sockaddr_in addr;
     memset( &addr, , sizeof(addr) );

     addr.sin_family = AF_INET;
     addr.sin_port = htons( port );
     addr.sin_addr.s_addr = ;

     if ( bind( nServerFd, (struct sockaddr *)&addr, sizeof(addr) ) < )
     {
         printf("bind error\n");
         exit(-);
     }

     if ( listen( nServerFd,  ) <  )
     {
         printf("listen error\n");
         exit(-);
     }

     return nServerFd;
 }

 int AddFd( int epfd, int nFd , int nOneShot)
 {
     struct epoll_event event;
     memset( &event, , sizeof( event) );

     event.data.fd = nFd;
     event.events |= EPOLLIN | EPOLLRDHUP | EPOLLET;

     if ( nOneShot ) event.events |= EPOLLONESHOT;

     return epoll_ctl( epfd, EPOLL_CTL_ADD, nFd, &event );
 }

 int ResetOneShot( int epfd, int nFd )
 {
     struct epoll_event event;
     memset( &event, , sizeof(event) );

     event.data.fd = nFd;
     event.events |= EPOLLIN | EPOLLRDHUP | EPOLLONESHOT;

     return epoll_ctl( epfd, EPOLL_CTL_MOD, nFd, &event);
 }

 void * ReadFromClient( void * arg )
 {
     int nClientFd = (int)arg;
     unsigned char buf[];
     const int nBufSize = sizeof( buf );
     int nRead;
     int nTotal;
     int nDataLen;

     printf("ReadFromClient Enter\n");

     if ( (nRead = read( nClientFd, buf,  )) !=  )
     {
         printf("Read Data Len error\n");
         pthread_exit(NULL);
     }

     nDataLen = *(unsigned short *)buf;
     printf("nDataLen [%d]\n", nDataLen);
     nDataLen = buf[]* + buf[];
     printf("nDataLen [%d]\n", nDataLen);

     nRead = ;
     nTotal = ;
     while(  )
     {
         nRead = read( nClientFd, buf + nRead, nBufSize );
         if ( nRead <  )
         {
             printf("Read Data error\n");
             pthread_exit( NULL );
         }
         nTotal += nRead;
         if ( nTotal >= nDataLen )
         {
             break;
         }
     }
     printf("nTotal [%d]\n", nTotal);

     sleep();

     int nWrite = write( nClientFd, buf, nTotal );
     printf("nWrite[%d]\n", nWrite);

     printf("Not Write ResetOneShot [%d]\n", ResetOneShot(g_epfd, nClientFd));

     return NULL;
 }

 int main(int argc, char const *argv[])
 {
     int i;
     int nClientFd;
     pthread_t tid;
     struct epoll_event events[];

     int nServerFd = InitServer(  );
     if ( nServerFd <  )
     {
         perror( "nServerFd" );
         exit(-);
     }

     int epfd = epoll_create(  );

     g_epfd = epfd;

     int nReadyNums;

     if ( AddFd( epfd, nServerFd,  ) <  )
     {
         printf("AddFd error\n");
         exit(-);
     }

     while(  )
     {
          nReadyNums = epoll_wait( epfd, events, , -1 );

          if ( nReadyNums <  )
          {
              printf("epoll_wait error\n");
              exit(-);
          }

          for ( i = ; i <  nReadyNums; ++i)
          {
              if ( events[i].data.fd == nServerFd )
              {
                  nClientFd = accept( nServerFd, NULL, NULL );

                  AddFd( epfd, nClientFd,  );

              }else if ( events[i].events & EPOLLIN )
              {
                 // Can be implemented by threadpool
                  //Read data from client
                 pthread_create( &tid, NULL, ReadFromClient, (void *)(events[i].data.fd) );

              }else if ( events[i].events & EPOLLRDHUP )
              {
                  //Close By Peer
                 printf("Close By Peer\n");
                 close( events[i].data.fd );
              }else
              {
                 printf("Some thing happened\n");
              }

          }
     }

     return ;
 }

测试内容：

注：客户端IP: 192.168.10.108  服务器IP&Port: 192.168.10.110:7777

a. 客户端发送一个报文至服务端，然后断网。（这里对程序做了点改动，这次实验注释了write响应，防止write影响测试，后面一个实验会使用write）。

　　　客户端断网后，使用netstat查看网络连接状态发送客户端与服务端还处于established状态，如图所示。

a. 实验结果

　　服务端没有检测到客户端断网，依然处于连接状态。

b. 客户端发送一个报文至服务端，然后断网，关闭客户端，再重复一次。

　　这次试验测试重新联网，程序再次建立Socket连接是否会导致之前的连接被检测到。

b. 实验结论：

　　重新联网，程序再次建立Socket连接之前的连接不会被检测到。

c. 客户端发送一个报文至服务端，然后断网。（这次实验使用了write响应，查看write后的结果）。

　　这里查看到Write居然成功了，成功了....。

c. 实验结论：

　　这次使用write不会检测对端是否已经断了。

3. 解决方案

　　临时：使用TCP的选项SO_KEEPALIVE检测客户端是否已异常掉了（setsockopt）。

　　后续改进：使用心跳包来检测长连接存活问题。

注：SO_KEEPALIVE明天再补充，回家了，只有一台笔记本直接装了Ubuntu，没装虚拟机，伤不起。

4. 补充

　　如果什么不对的或者建议直接说，多讨论讨论比较好。