服务端主动关闭，客户端继续写，会发生什么？

本文主要是介绍服务端主动关闭，客户端继续写，会发生什么？，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

四次挥手

下图显示了一次典型的TCP四次挥手的过程，以及主动关闭方和被动关闭方的状态变化。在图中是客户端主动断开了连接，这里只是举个例子，服务端一样可以主动断开连接。

为什么是四次挥手，因为如果只进行了1、2次。由于TCP是全双工的，可以处于Half-Close状态，此时就是处于Half-Close状态，客户端到服务器的通道已经关闭，服务器到客户端的通道还没关闭，所以需要第三次和第四次来完全关闭连接。

谁主动关闭

客户端主动关闭

如果客户端主动关闭连接，那就是正常的关闭了。首先客户端发起关闭连接的请求，服务端收到后，先发送ACK给客户端表示已收到关闭请求，然后客户端到服务端的连接就可以关闭了。此时服务端不会立刻关闭连接，服务端会将还没发完的数据发送到客户端。
此时客户端只是不能向服务端发送数据，但是可以接受数据，这就是TCP的半关闭。此时客户端处于FIN_WAIT2，服务端处于CLOSE_WAIT(如果服务端不关闭连接，将会一直处于该状态，如果连接很多，这将会浪费大量的socket资源)。
服务端在发送完数据后再向客户端发起关闭连接的请求，客户端收到后确认关闭，此时TCP全双工连接就关闭了。

服务端主动关闭

如果是服务端主动发起关闭，此时四次挥手的顺序会颠倒。那么此时客户端再向服务端发送数据时，根据TCP协议的规定，认为它是一个异常终止连接，客户端将会收到一个RST复位响应(而不是ACK响应)，如果客户端再次向服务端发送数据，系统将会发送一个SIGPIPE信号给客户端进程，告诉客户端进程该连接已关闭，不要再写了。系统给SIGPIPE信号的默认处理是直接终止收到该信号的进程，所以此时客户端进程会被极不情愿地终止。
如果不希望客户端进程被终止，可以自定义一个该信号处理的函数，通过调用函数signal(SIGPIPE, handler)实现对信号的处理，其中handler就是可以自定义的函数。
所以说当服务端主动关闭，客户端继续写两次将会导致客户端进程被终止(服务端并不能接收)，客户端不能向服务器写入数据。

其中输出(this is in client SigpipeRun...)是我自定义的一个SIGPIPE处理函数中的输出，表示该进程已收到SIGPIPE信号了，不能向服务端写数据啦。
此时可以观察到TCP全双工连接已经关闭了，但是客户端进程并没有被关闭，因为自定义了信号处理函数。

测试程序(linux下)

服务端

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

// socket(int domain, int type, int protocol);
//int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
// int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int StartUp(char* ip,char* port)
{
     //listen_sock
    int sock=socket(AF_INET,SOCK_STREAM,0);
         if(sock < 0){
                 perror("socket...");
                 exit(-1);
         }
         struct sockaddr_in sockaddr;
         sockaddr.sin_family=AF_INET;
         sockaddr.sin_port=htons(atoi(port));   //16 bit port
         //sockaddr.sin_addr.s_addr=inet_addr(ip);
         inet_aton(ip,&sockaddr.sin_addr);
         if(bind(sock,(struct sockaddr*)&sockaddr,sizeof(sockaddr))<0){
                perror("bind..\n");
                exit(-2);
         }
         struct sockaddr_in addrtmp;
         socklen_t Len;
         getsockname(sock,(struct sockaddr*)&addrtmp,&Len);
         printf("com:%d\n",ntohs(addrtmp.sin_port));

         if(listen(sock,5)<0){
                perror("listen...\n");
                exit(-3);
         }

         return sock;
}

//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int main(int argc,char* argv[])
{
        if(argc!=3){
                printf("Usg: %s [ip] [port]\n",argv[0]);
                return 3;
        }
        printf("hello servet..\n");
        int id=fork();
        if(id==0){
                printf("this is child...%d\n",getpid());
                printf("debug 1\n");
                int listen_sock=StartUp(argv[1],argv[2]);
                struct sockaddr_in addr;
                socklen_t Len=0;
                while(1){
                        int fd=accept(listen_sock,(struct sockaddr*)&addr,&Len);
                        printf("It's %s address send message\n",\
                                        inet_ntoa(addr.sin_addr));
                        if(fd < 0){
                                perror("accept...\n");
                                return 2;
                        }
                        else if(fd==0){
                                printf("client is quit...\n");
                        }
                        char buf[1024];
                        while(1){
                                ssize_t _s=read(fd,buf,sizeof(buf));
                                if(_s==0){
                                        printf("client is quit..\n");
                                        break;
                                }
                                else if(_s<0){
                                        perror("read...");
                                        exit(1);
                                }
                                buf[_s-1]='\0';
                                printf("client #");
                                fflush(stdout);
                                printf("%s\n",buf);
                        }
                }
        }
        else{
                //father proc
                wait(NULL);
        }

        return 0;
}
复制代码

客户端

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <signal.h>

//int socket(int domain, int type, int protocol);
//int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
void SigpipeRun(int signo)
{
        printf("this is in client SigpipeRun..,signo:%d\n",signo);
        sleep(2);
}

int main(int argc,char* argv[])
{
        signal(SIGPIPE,SigpipeRun);
        if(argc!=3){
                printf("Usegs: %s [ip] [port]",argv[1]);
                return 3;
        }
        printf("Hello client\n");
        int sock=socket(AF_INET,SOCK_STREAM,0);
        if(sock<0){
                perror("socket..");
                exit(1);
        }
        struct sockaddr_in addr;
        addr.sin_family=AF_INET;
        addr.sin_port=htons(atoi(argv[2]));
        addr.sin_addr.s_addr=inet_addr(argv[1]);
        if(connect(sock,(struct sockaddr*)&addr,sizeof(addr))<0){
                perror("connect...");
                return 2;
        }
        printf("connect success...\n");
        char buf[1024];
        while(1){
                ssize_t _s=read(0,buf,1024);
                if(_s<0){
                        perror("read...\n");
                        exit(1);
                }
                buf[_s-1]='\0';
                printf("client #");
                fflush(stdout);
                printf("%s\n",buf);
                write(sock,buf,_s);
        }
        close(sock);
        return 0;
}
复制代码

这篇关于服务端主动关闭，客户端继续写，会发生什么？的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！