【tcp 四次挥手之close和shutdown】

已于 2022-03-25 22:31:29 修改
阅读量1.3k 收藏 4
点赞数 1
文章标签： nginx linux 运维
于 2022-03-25 22:27:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37674060/article/details/123740790
版权

【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的流程图
在这里插入图片描述

不爱学习的王小小
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
网络-TCP关闭连接（close、shutdown）
qq_61084129的博客
03-01 987
在TCP协议中，关闭连接的过程可以通过shutdown函数和close函数来实现。
tcp连接出现close_wait状态？_tcp_close_
09-30
tcp连接出现close_wait状态？
TCP协议为啥会有三次挥手（close、shutdown）
最新发布
zize_snail的博客
06-11 864
TCP协议三次挥手的原因
高性能网络编程4--TCP连接的关闭
iteye_10227的博客
10-26 1767
TCP连接的关闭有两个方法close和shutdown，这篇文章将尽量精简的说明它们分别做了些什么。 为方便阅读，我们可以带着以下5个问题来阅读本文： 1、当socket被多进程或者多线程共享时，关闭连接时有何区别？ 2、关连接时，若连接上有来自对端的还未处理的消息，会怎么处理？ 3、关连接时，若连接上有本进程待发送却未来得及发送出的消息，又会怎么处理？ 4、so_linger这个功能的用处在哪？...
close和shutdown函数的区别
月饼大叔的博客
07-21 9498
参考：https://blog.csdn.net/lgp88/article/details/7176509 《UNIX网络编程》 close()函数： close一个套接字的默认行为是把套接字标记为已关闭，然后立即返回到调用进程，该套接字描述符不能再由调用进程使用，然而TCP将尝试发送已经排队等待发送到对端的任何数据，发送完毕后发生的是正常的TCP连接终止序列。 在多进程并发服务器中，父...
连接url后关闭连接_【网络编程】TCP连接的关闭
weixin_39824033的博客
12-23 400
TCP连接的关闭有两个方法close和shutdown，这篇文章将尽量精简的说明它们分别做了些什么。为方便阅读，我们可以带着以下5个问题来阅读本文：1、当socket被多进程或者多线程共享时，关闭连接时有何区别？2、关连接时，若连接上有来自对端的还未处理的消息，会怎么处理？3、关连接时，若连接上有本进程待发送却未来得及发送出的消息，又会怎么处理？4、so_linger这个功能的用处在哪？...
关于close与shutdown的区别
狂客队长
03-16 4942
终止网络连接的通常方法是调用close函数。不过close有两个限制，却可以使用shutdown来避免。 1  close把描述字的引用计数减1，仅在该计数变为0的时候才关闭套接口。而使用shutdown可以不管引用计数的值是多少就激发TCP的正常连接终止序列，也即是发送FIN节。 2  close终止数据传送的两个方向：读和写。而有的时候只是想关闭读或写，那么此时就使用shutdown函数进
TCP四次挥手 可以变成三次吗708 - 726
05-15
TCP 四次挥手是 TCP 协议栈中的一种关闭连接的机制，通常来说，TCP 四次挥手需要四个步骤来完成，但是在某些情况下，TCP 四次挥手可以变成三次挥手。本文将详细介绍 TCP 四次挥手的过程、为什么需要四次挥手，以及在...
10如何提升TCP四次挥手的性能？1
08-03
本节主要探讨如何优化TCP四次挥手的性能，并分析其背后的原理。 首先，我们了解TCP关闭连接的两种主要函数：`close`和`shutdown`。`close`函数会立即将连接标记为孤儿连接，意味着两个方向的数据传输都将停止，而`...
tcp三次握手与四次握手及SOCKE函数对应
04-15
接下来是“TCP四次挥手”来断开连接，因为TCP连接是全双工的，所以每个方向上的关闭都需要独立进行： 1. 第一次挥手：主动关闭方发送一个FIN（结束）标志的数据段，表示不再发送数据，但可以接收数据。 2. 第二次...
tcp.rar_LINUX TCP _tcp
09-19
5. **四次挥手**：当通信结束后，双方通过四次挥手释放连接。FIN（结束）和ACK（确认）交互确保数据传输完毕，并关闭连接。 6. **流量控制**：TCP通过滑动窗口机制进行流量控制，避免发送方过快发送数据导致接收方...
Linux上TCP的Shutdown和Close
03-04
本文介绍了Linux上TCP的Shutdown和Close操作。
tcp.rar_TCP框架下载
09-20
在TCP连接中，有三个重要的概念：三次握手（Three-way Handshake）和四次挥手（Four-way Close）。三次握手是建立连接的过程，它确保了双方都有能力并愿意进行通信。四次挥手则是断开连接，确保双方都已经接收到对方...
tcp 连接关闭详解
cschengvdn的专栏
03-28 3601
注：tcp关闭连接不区分客户端和服务端，哪一端口可以主动发起关闭连接请求。所以为了描述方便，描述中的“主动方”表示主动发起关闭连接一方，“被动方”表示被动关闭连接一方。 1. tcp关闭连接状态转换   上图是tcp连接主动关闭端的状态转换图： （1）应用层调用close函数发起关闭连接请求 （2）发送FIN到对端，关闭写通道，自己进入FIN_WA
shutdown与close (TCP关闭)
JaweG
10-20 744
终止数据传输的两个方向
终止TCP连接时close()和shutdown()的区别
hexiecs的技术专栏
10-29 3084
shutdown可以指定在某个方向上终止连接，通过指定标志：SHUT_RD, SHUT_WR, SHUT_RDWR。比如指定SHUT_WR后可以继续读数据，但不能写入了。而close是两个方向上终止连接。 close会将描述符的引用计数减一，如果引用计数变为0就关闭描述符，发送FIN。而shutdown不管引用计数，直接发送FIN终止连接。所以在多线程下操作同一个socket描述符下，一个线程调用s
Linux上TCP的shutdown/close
weixin_30487201的博客
02-03 215
Linux上TCP的shutdown/closeLinux的版本是kernel-2.6.21：1.只要TCP栈的读缓冲里还有未读取(read)数据,则调用close时会直接向对端发送RST.2.shutdown与socket描述符没有关系,即使调用shutdown(fd, SHUT_RDWR)也不会关闭fd,最终还需close(fd).3.可以认为shutdown(fd, SHUT_RD)...
网络编程Socket之TCP之close/shutdown详解（续）
小T是我
07-23 2442
接着上一篇网络编程Socket之TCP之close/shutdown详解
shutdown 与 close 函数 的区别
09-03 1680
http://blog.csdn.net/jnu_simba/article/details/9068059 假设server和client 已经建立了连接，server调用了close, 发送FIN 段给client（其实不一定会发送FIN段，后面再说），此时server不能再通过socket发送和接收数据，此时client调用read，如果接收到FIN 段会返回0，但client此时还是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值