CLOSE_WAIT状态分析

先给出如下C程序.在此代码中,我们故意屏蔽了发送端的close socket函数.运行后我们会发现发送端有大量的CLOSE_WAIT状态的连接,此时接收端是大量的FIN_WAIT_2状态的连接.

main.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <netinet/tcp.h>
#include <netinet/in.h>

int socket_connect(const char *remoteip, int remoteport){
int socketfd = -1;
unsigned long uladdr = 0;
struct sockaddr_in sa = {0};

int bReuseaddr = 1;
socklen_t optlen = sizeof(bReuseaddr);
/*
int keepAlive = 1;
int keepIdle = 1;
int keepInterval = 1;
int keepCount = 2;
*/
socketfd = socket(AF_INET, SOCK_STREAM, 0);
if(socketfd < 0){
printf("Error: create socket error/n");
return -1;
}
/*
if(setsockopt(socketfd, SOL_SOCKET, SO_KEEPALIVE, &keepAlive, sizeof(keepAlive)) < 0) {
printf("Error: set socket [%d] opt keep alive error/n", socketfd);
return -1;
}
if(setsockopt(socketfd, SOL_TCP, TCP_KEEPIDLE, &keepIdle, sizeof(keepIdle)) < 0) {
printf("Error: set socket [%d] opt keep idle error/n", socketfd);
return -1;
}
if(setsockopt(socketfd, SOL_TCP, TCP_KEEPINTVL, &keepInterval, sizeof(keepInterval)) < 0) {
printf("Error: set socket [%d] opt keep alive error/n", socketfd);
return -1;
}
if(setsockopt(socketfd, SOL_TCP, TCP_KEEPCNT, &keepCount, sizeof(keepCount)) < 0) {
printf("Error: set socket [%d] opt keep alive error/n", socketfd);
return -1;
}
*/

uladdr = inet_addr(remoteip);
memset(&sa,0,sizeof(sa));
sa.sin_family=AF_INET;
sa.sin_port=htons(remoteport);
sa.sin_addr.s_addr=uladdr;

if( connect(socketfd, (struct sockaddr *)&sa, sizeof(struct sockaddr)) < 0) {
printf("Error: connect exception/n");
return -1;
}
return socketfd;
}

int socket_listen(int port, int listen_queue_size){
int ret = 0;
int s = 0;
struct sockaddr_in addr;

int bReuseaddr = 1;
socklen_t optlen = sizeof(bReuseaddr);

s = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if(s < 0) {
return -1;
}
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = htonl(INADDR_ANY);

ret = bind(s,(struct sockaddr *)&addr, sizeof(struct sockaddr_in));
if(ret < 0) {
printf("Info: bind port %d failed/n",port);
return -1;
}
ret = listen(s, listen_queue_size);
if(ret < 0){
return -1;
}
return s;
}

int socket_accept(int listen_socket,char* remoteip){
int len = 0;
struct sockaddr_in remote_addr;
int s = -1;
len = sizeof(struct sockaddr_in);
memset((char *)&remote_addr, 0, len);
s = accept(listen_socket, (struct sockaddr *)&remote_addr, (socklen_t *)&len);
if(s <= 0){
printf("accept ret = %d/n",errno);
return -1;
}
return s;
}

int main(int argc, char* argv[]){
int sender = 0;
int ret = 0;
int listen_sock = 0;
if(argc !=2){
printf("usage: ./test 1/n");
return -1;
}
sender = atoi(argv[1]);
if(sender){
while(1){
printf("new round connect/n");
sleep(4);
ret = socket_connect("10.224.55.145",8765);
if(ret < 0){
printf("socket connect failed/n");
return -1;
}else{
printf("socket connect success, sock = %d/n",ret);
// close(ret);
}
}
}else{
listen_sock = socket_listen(8765,100);
if(listen_sock < 0){
printf("socket listen failed/n");
return -1;
}else{
while(1){
printf("before accept socket/n");
ret = socket_accept(listen_sock,NULL);
if(ret < 0){
printf("socket accept failed/n");
return -1;
}else{
printf("socket accept success, sock = %d/n",ret);
close(ret);
}
}
}
}
return 0;
}

上面程序相当于接收端主动断掉当前连接,那么双方关闭此TCP连接需要的四次挥手如下:

SERVER --- FIN --- CLINET

CLINET --- ACK --- SERVER

CLINET --- FIN --- SERVER

SERVER --- ACK --- CLINET

接受端关闭连接,步骤I,II没问题.由于发送端没有关闭连接,所以步骤III不会继续执行.此时,发送端等待自己关闭连接,而接收端等待发送断发送FIN报文.所以,此时,发送端处于CLOSE_WAIT状态,接收端处于FIN_WAIT_2状态.

同理,发送端主动关闭连接,而屏蔽接收端的close socket函数.则发送端会有大量FIN_WAIT_2状态的连接,而接收端会有大量的CLOSE_WAIT状态的连接.当然,造成这种问题也可能是在关闭连接前要处理大量事情.

如何解决此问题?通过设置SO_KEEPALIVE选项能保证此连接会在2个小时后被检测到有问题,此选项一般用于对端以一种非优雅的方式断开的情况.如果我们不能接受如此之长的等待时间,可以通过设置TCP_KEEPIDLE,TCP_KEEPINTVL,TCP_KEEPCNT三个选项来缩短这个时间,从而使CLOSE_WAIT状态的连接尽快释放,而不会越来越多. 如程序socket_connect函数中屏蔽代码实现的.

TCP_KEEPIDL:开始首次KeepAlive探测前的TCP空闭时间.

TCP_KEEPINTVL:两次KeepAlive探测间的时间间隔.

TCP_KEEPCNT:判定断开前的KeepAlive探测次数.

注意:这些属性都必须在客户端(发送端)设置.如果在服务器端(接收端)accepte后设置,只能释放接收端未能释放的连接.