【tcp 四次挥手之close和shutdown】
因为 这两个函数比较具有迷惑性,这篇文章结合抓包说一下这两个函数的具体作用。
定义
先看看unxi网路变成中的具体定义
close()函数:
close一个套接字的默认行为是把套接字标记为已关闭,然后立即返回到调用进程,该套接字描述符不能再由调用进程使用,然而TCP将尝试发送已经排队等待发送到对端的任何数据,发送完毕后发生的是正常的TCP连接终止序列。
在多进程并发服务器中,父子进程共享着套接字,套接字描述符引用计数记录着共享着的进程个数,当父进程或某一子进程close掉套接字时,描述符引用技术会相应的减一,当引用计数仍大于0时,这个close调用就不会引发TCP的四路握手断连过程。
shutdown()函数:
int shutdown(int sockfd,int how)
该函数行为依赖how的值。
1.SHUT_RD:值为0,关闭连接的读这一半,套接字中不再有数据接收,且套接字接收缓冲区中的现有数据全都被丢弃,该套接字描述符不能再被进程调用,对端发送的数据会被确认,然后丢弃。
2.SHUT_WR:值为1,关闭连接的写这一半。这称为半关闭,当前在套接字发送缓冲区数据被发送,然后连接终止序列。不论套接字描述符引用技术是否等于0,写半部都会被关闭。
3.SHUT_RDWR:值为2,连接的读和写都关闭。相当于先调用SHUT_RD,再调用SHUT_WR。
close与shutdown的区别:
①:close函数函数会关闭套接字,如果由其他进程共享着这个套接字,那么它仍然是打开的,这个连接仍然可以用来读和写。
②:shutdown会切断进程共享的套接字的所有连接,不管引用计数是否为0,由第二个参数选择断连的方式。
close
服务端是正常的epoll如下
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/types.h>
#define MAXEVENTS 100
// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd);
// 初始化服务端的监听端口。
int initserver(int port);
int main(int argc,char *argv[])
{
if (argc != 2)
{
printf("usage:./tcpepoll port\n"); return -1;
}
// 初始化服务端用于监听的socket。
int listensock = initserver(atoi(argv[1]));
printf("listensock=%d\n",listensock);
if (listensock < 0)
{
printf("initserver() failed.\n"); return -1;
}
int epollfd;
char buffer[1024];
memset(buffer,0,sizeof(buffer));
// 创建一个描述符
epollfd = epoll_create(1);
// 添加监听描述符事件
struct epoll_event ev;
ev.data.fd = listensock;
ev.events = EPOLLIN;
epoll_ctl(epollfd,EPOLL_CTL_ADD,listensock,&ev);
while (1)
{
struct epoll_event events[MAXEVENTS]; // 存放有事件发生的结构数组。
// 等待监视的socket有事件发生。
int infds = epoll_wait(epollfd,events,MAXEVENTS,-1);
// printf("epoll_wait infds=%d\n",infds);
// 返回失败。
if (infds < 0)
{
printf("epoll_wait() failed.\n"); perror("epoll_wait()"); break;
}
// 超时。
if (infds == 0)
{
printf("epoll_wait() timeout.\n"); continue;
}
// 遍历有事件发生的结构数组。
for (int ii=0;ii<infds;ii++)
{
if ((events[ii].data.fd == listensock) &&(events[ii].events & EPOLLIN))
{
// 如果发生事件的是listensock,表示有新的客户端连上来。
struct sockaddr_in client;
socklen_t len = sizeof(client);
int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
if (clientsock < 0)
{
printf("accept() failed.\n"); continue;
}
// 把新的客户端添加到epoll中。
memset(&ev,0,sizeof(struct epoll_event));
ev.data.fd = clientsock;
ev.events = EPOLLIN;
epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);
printf ("client(socket=%d) connected ok.\n",clientsock);
continue;
}
else if (events[ii].events & EPOLLIN)
{
// 客户端有数据过来或客户端的socket连接被断开。
char buffer[1024];
memset(buffer,0,sizeof(buffer));
// 读取客户端的数据。
ssize_t isize=read(events[ii].data.fd,buffer,sizeof(buffer));
if(read == EAGAIN)
// 发生了错误或socket被对方关闭。
if (isize <=0)
{
printf("client(eventfd=%d) disconnected.\n",events[ii].data.fd);
// 把已断开的客户端从epoll中删除。
memset(&ev,0,sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = events[ii].data.fd;
epoll_ctl(epollfd,EPOLL_CTL_DEL,events[ii].data.fd,&ev);
close(events[ii].data.fd);
continue;
}
printf("recv(eventfd=%d,size=%d):%s\n",events[ii].data.fd,isize,buffer);
// 把收到的报文发回给客户端。
write(events[ii].data.fd,buffer,strlen(buffer));
}
}
}
close(epollfd);
return 0;
}
// 初始化服务端的监听端口。
int initserver(int port)
{
int sock = socket(AF_INET,SOCK_STREAM,0);
if (sock < 0)
{
printf("socket() failed.\n"); return -1;
}
// Linux如下
int opt = 1; unsigned int len = sizeof(opt);
//设置可重用
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
//设置长连接
setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);
struct sockaddr_in servaddr;
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);
if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
{
printf("bind() failed.\n"); close(sock); return -1;
}
if (listen(sock,5) != 0 )
{
printf("listen() failed.\n"); close(sock); return -1;
}
return sock;
}
// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd)
{
if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1) return -1;
return 0;
}
客户端 如下
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
int main(int argc, char const *argv[])
{
//创建客户端的socket
int sockfd;
if( (sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1 )
{
perror("socket");
return -1;
}
struct hostent *h;
if ( (h = gethostbyname("127.0.0.1")) == 0 ){
printf("gethostbyname fail\n");
close(sockfd);
return -1;
}
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5051);
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
if (connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) !=0)
{
perror("connect");
close(sockfd);
return -1;
}
close(sockfd);
return 0;
}
服务端是比较经典的epoll服务端代码,然后客户端就是三次握手以后释放close进行释放链接。
先看看客户端的四次挥手的流程图:
抓包
然后在linux下抓包下后,结合wireshark去看,如图:
因为1-3是tcp三次握手的过程,这个已经说过,然后看一下4-6.
FIN
可以看到这次sequence Number 后四位是1243,Ack Num是2806是对上一个信息的确认,然后主要看Flag是 Fin 和ACK,是客户端主动断开链接并发出Fin信号
Fin&ACK
这个是服务端把ACK 和 FIn 信号在一个包里面一起发了,然后看一下Ack Num 后四位是1244,比上面的seq Num 多一位。然后seq Num 后四位是2806
Ack
这个其实就比较简单了,就是对上面包的回应看Ack num 后四位是2807,是2806上面加一。
可能有人疑问为什么是三次,而不是四次挥手中的四次,是因为中间有两步合并,就是 Fin&Ack。
shutdown
这个和close 功能类似,我们结合抓包看一下。
这里我们把服务端关闭socket那边continue掉,如下代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <sys/types.h>
#define MAXEVENTS 100
// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd);
// 初始化服务端的监听端口。
int initserver(int port);
int main(int argc,char *argv[])
{
if (argc != 2)
{
printf("usage:./tcpepoll port\n"); return -1;
}
// 初始化服务端用于监听的socket。
int listensock = initserver(atoi(argv[1]));
printf("listensock=%d\n",listensock);
if (listensock < 0)
{
printf("initserver() failed.\n"); return -1;
}
int epollfd;
char buffer[1024];
memset(buffer,0,sizeof(buffer));
// 创建一个描述符
epollfd = epoll_create(1);
// 添加监听描述符事件
struct epoll_event ev;
ev.data.fd = listensock;
ev.events = EPOLLIN;
epoll_ctl(epollfd,EPOLL_CTL_ADD,listensock,&ev);
while (1)
{
struct epoll_event events[MAXEVENTS]; // 存放有事件发生的结构数组。
// 等待监视的socket有事件发生。
int infds = epoll_wait(epollfd,events,MAXEVENTS,-1);
// printf("epoll_wait infds=%d\n",infds);
// 返回失败。
if (infds < 0)
{
printf("epoll_wait() failed.\n"); perror("epoll_wait()"); break;
}
// 超时。
if (infds == 0)
{
printf("epoll_wait() timeout.\n"); continue;
}
// 遍历有事件发生的结构数组。
for (int ii=0;ii<infds;ii++)
{
if ((events[ii].data.fd == listensock) &&(events[ii].events & EPOLLIN))
{
// 如果发生事件的是listensock,表示有新的客户端连上来。
struct sockaddr_in client;
socklen_t len = sizeof(client);
int clientsock = accept(listensock,(struct sockaddr*)&client,&len);
if (clientsock < 0)
{
printf("accept() failed.\n"); continue;
}
// 把新的客户端添加到epoll中。
memset(&ev,0,sizeof(struct epoll_event));
ev.data.fd = clientsock;
ev.events = EPOLLIN;
epoll_ctl(epollfd,EPOLL_CTL_ADD,clientsock,&ev);
printf ("client(socket=%d) connected ok.\n",clientsock);
continue;
}
else if (events[ii].events & EPOLLIN)
{
// 客户端有数据过来或客户端的socket连接被断开。
char buffer[1024];
memset(buffer,0,sizeof(buffer));
// 读取客户端的数据。
ssize_t isize=read(events[ii].data.fd,buffer,sizeof(buffer));
// 发生了错误或socket被对方关闭。
if (isize <=0)
{
printf("client(eventfd=%d) disconnected.\n",events[ii].data.fd);
//服务端不关闭连接
continue;
// 把已断开的客户端从epoll中删除。
memset(&ev,0,sizeof(struct epoll_event));
ev.events = EPOLLIN;
ev.data.fd = events[ii].data.fd;
epoll_ctl(epollfd,EPOLL_CTL_DEL,events[ii].data.fd,&ev);
close(events[ii].data.fd);
continue;
}
printf("recv(eventfd=%d,size=%d):%s\n",events[ii].data.fd,isize,buffer);
// 把收到的报文发回给客户端。
write(events[ii].data.fd,buffer,strlen(buffer));
}
}
}
close(epollfd);
return 0;
}
// 初始化服务端的监听端口。
int initserver(int port)
{
int sock = socket(AF_INET,SOCK_STREAM,0);
if (sock < 0)
{
printf("socket() failed.\n"); return -1;
}
// Linux如下
int opt = 1; unsigned int len = sizeof(opt);
//设置可重用
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,len);
//设置长连接
setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,&opt,len);
struct sockaddr_in servaddr;
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);
if (bind(sock,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0 )
{
printf("bind() failed.\n"); close(sock); return -1;
}
if (listen(sock,5) != 0 )
{
printf("listen() failed.\n"); close(sock); return -1;
}
return sock;
}
// 把socket设置为非阻塞的方式。
int setnonblocking(int sockfd)
{
if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1) return -1;
return 0;
}
关闭读
shutdown(sockfd,0);
关闭当前socket的读后直接返回
这个是关闭当前socket的读后直接返回
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
int main(int argc, char const *argv[])
{
//创建客户端的socket
int sockfd;
if( (sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1 )
{
perror("socket");
return -1;
}
struct hostent *h;
if ( (h = gethostbyname("127.0.0.1")) == 0 ){
printf("gethostbyname fail\n");
close(sockfd);
return -1;
}
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5051);
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
if (connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) !=0)
{
perror("connect");
close(sockfd);
return -1;
}
shutdown(sockfd,0);
return;
return 0;
}
然后看一下抓包
还是一样前三个可以忽略,然后看4和5也是比较显而易见,是关闭了客户端到服务端流。
关闭当前socket的读继续写数据
先看一下client的代码
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <signal.h>
void exit1(int singal){
printf("收到信号 singal:%d\n",singal);
return;
}
int main(int argc, char const *argv[])
{
signal(SIGPIPE,exit1);
//创建客户端的socket
int sockfd;
if( (sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1 )
{
perror("socket");
return -1;
}
struct hostent *h;
if ( (h = gethostbyname("127.0.0.1")) == 0 ){
printf("gethostbyname fail\n");
close(sockfd);
return -1;
}
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5051);
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
if (connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) !=0)
{
perror("connect");
close(sockfd);
return -1;
}
shutdown(sockfd,0);
// return;
char buffer[1024];
int ii =0;
for(ii=0;ii<3;ii++){
int iret;
memset(buffer,0,sizeof(buffer));
sprintf(buffer,"this is %d ,ii: %03d",ii+1,ii+1);
if( (iret=send(sockfd,buffer,strlen(buffer),0)) <=0 ){
printf("send err\n");
break;
}
printf("iret=%d 发送:%s\n",iret,buffer);
memset(buffer,0,sizeof(buffer));
if( (iret = recv(sockfd,buffer,sizeof(buffer),0)) <=0 ){
printf("iret=%d recv error\n",iret);
// break;
continue;
}
printf("iret=%d recv:%s\n",iret,buffer);
sleep(1);
}
close(sockfd);
return 0;
}
看一下client的结果
前两次看其实都是正常无法recv,但是第三次的时候,收到了一次服务端发的消息,查了很多资料,说shutdown 关闭读不一定可靠,可能就是原因。
然后看一下抓包的显示
前12都是正常的查收,然后第13是因为在close 套接字的时候,缓冲区有未读的消息的时候会直接给对端发送 RST,借用一位大佬的图很直观,参考下图:
关闭写
shutdown(sockfd,1);
关闭当前写之后直接返回
这个和关闭读的效果是一样的。都是发送反向Fin包
关闭当前写之后继续写
先看client代码
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <signal.h>
void exit1(int singal){
printf("收到信号 singal:%d\n",singal);
return;
}
int main(int argc, char const *argv[])
{
signal(SIGPIPE,exit1);
//创建客户端的socket
int sockfd;
if( (sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1 )
{
perror("socket");
return -1;
}
struct hostent *h;
if ( (h = gethostbyname("127.0.0.1")) == 0 ){
printf("gethostbyname fail\n");
close(sockfd);
return -1;
}
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5051);
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
if (connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) !=0)
{
perror("connect");
close(sockfd);
return -1;
}
shutdown(sockfd,1);
//return;
char buffer[1024];
int ii =0;
for(ii=0;ii<3;ii++){
int iret;
memset(buffer,0,sizeof(buffer));
sprintf(buffer,"this is %d ,ii: %03d",ii+1,ii+1);
if( (iret=send(sockfd,buffer,strlen(buffer),0)) <=0 ){
printf("send err\n");
break;
}
printf("iret=%d 发送:%s\n",iret,buffer);
memset(buffer,0,sizeof(buffer));
if( (iret = recv(sockfd,buffer,sizeof(buffer),0)) <=0 ){
printf("iret=%d recv error\n",iret);
// break;
continue;
}
printf("iret=%d recv:%s\n",iret,buffer);
sleep(1);
}
return 0;
}
然后需要注意的是一上来监听了信号
signal(SIGPIPE,exit1);SIGPIPE这个是当socket关闭了写之后,仍然写会导致系统向当前进程发送SIGPIPE信号,并且导致系统终止。
然后看一下打点。
结合上面也是比较好理解的,就是客户端向服务端单向发送Fin包,并且收到了回复。
到这里差不多了,这里可以看到关闭当前写之后继续写下面的client的代码,最后面没有close方法,如果加上close会发生什么,感兴趣的读者可以自己试试。
关闭读写
shutdown(sockfd,2);
从抓包结果看下来,效果和关闭写是类似的,读者可以自己试试。
最后附加一张shutdown的流程图