理解tcp顺序释放操作和tcp的半关闭

最新推荐文章于 2023-11-08 09:18:16 发布
最新推荐文章于 2023-11-08 09:18:16 发布
阅读量1.1k 收藏
点赞数
文章标签： tcp socket 服务器 null buffer stream
Shutdown的调用
       在关闭socket的时候，可以有两种方式closesocket和shutdown，这两个函数的区别在什么地方呢？
#include <sys/socket.h>             /*UNIX*/
#include<winsock.h>               /*Windows*/
         int shutdown(int s, int how)           /*UNIX*/
int shutdown(SOCKET s, int how)    /*Windows*/
 
how
操作
数字
POSIX
Winsock
0
SHUT_RD
SD_RECEIVE
关闭连接接收方
1
SHUT_WR
SD_SEND
关闭连接的发送方
2
SHUT_RDWR
SD_BOTH
关闭双方
                                         Shutdown参数how值介绍
说明 :
1.       shutdown根本没有关闭 socket,任何与socket关联的资源直到调用closesocket才释放。
2.       TCP连接的 socket是全双工的，也就是说它可以发送和接收数据，但是一个方向上的数据流动和另一个方向上的数据流动是不相关的，shutdown函数的功能也就是体现在这里，它通过设置how选择关闭哪条数据通道(发送通道和接收通道)，如果关闭了发送通道，那么这个socket其实还可以通过接收通道接受数据.
3.       当通过以 how=1的方式调用shutdown，就可以保证对方收到一个EOF，而不管其他的进程是否已经打开了套接字，而调用close或closesocket就不能保证，因为直到套接字的引用计数减为0时才会发送FIN消息给对方，也就是说，直到所有的进程都关闭了套接字。
例子说明
 客户端(192.168.1.122): 客户端连接上服务器后向服务器发送两条数据(数据发送间隔为2秒)，等待两秒后立即调用shutdown关闭发送数据通道或者closesocket，然后客户端在一个while循环中等待接受服务器发送回来的数据.
 服务器(192.168.1.112): 接受到客户端发送的数据后，休眠4秒后，把得到的数据发送会客户端
 
1.       shutdown关闭发送数据通道后，通过抓包程序获取的tcp处理过程。
  
                Shutdown关闭socket时，tcp的状态处理过程.
对上面的处理过程进行分析:
l         前面的三条记录是tcp的三次握手.
l         第四条记录就是客户端第一次向服务器发送数据
l         第五条记录是服务器的确认信息
l         第六条记录就是客户端间隔2秒后第二次向服务器发送数据
l         第七条记录时服务器的确认信息
l         第八条记录是在等待2秒后，调用了shutdown,客户端向服务器发送了FIN标志
l         第九条记录时服务器的确认信息
l         第十条记录是服务器接收到客户端的一条记录后休眠4秒，发回给客户端
l         第十一条记录是客户端的确认
l         第十二条记录是服务器接受到客户端的第二条数据后休眠4秒，发回给客户端
l         第十三条记录是客户端的确认
l         第十四条记录是服务器发送完tcp对列中的数据后，向客户端发送FIN标志
l         第十五条记录时客户端对FIN标志的确认
 
2.       closesocket关闭socket，通过抓包程序获取的tcp处理过程
Closesocket关闭socket时,tcp的状态处理过程
 
 
对上面的处理过程进行分析:
l         前面的三条记录是tcp的三次握手.
l         第四条记录就是客户端第一次向服务器发送数据
l         第五条记录是服务器的确认信息
l         第六条记录就是客户端间隔2秒后第二次向服务器发送数据
l         第七条记录时服务器的确认信息
l         第八条记录是在等待2秒后，调用了shutdown,客户端向服务器发送了FIN标志
l         第九条记录时服务器的确认信息
l         第十条记录是服务器接收到客户端的一条记录后休眠4秒，发回给客户端
l         第十一条记录是由于客户端已经通过closesocket关闭了连接，连接已经不存在，因此客户端向服务器发送了RST标志
总结
       为了保证在连接撤销之前，保证双方都能接收到对等方的所有数据，在调用closesocket之前，先调用shutdown关闭发送数据通道.
例子代码
客户端代码:
 
#define WIN32_LEAN_AND_MEAN
#include <stdlib.h>
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <io.h>
#include<stdlib.h>
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<winsock2.h>
#include<windows.h>
#include <Ws2tcpip.h>
#include <process.h>
#include <ws2tcpip.h>
#include <winbase.h>
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"Kernel32.lib")
 
#define PORTNUM         4500         
#define HOSTNAME        "localhost"                               
int main()         
{
 TCHAR szError[100];                 // Error message string
 SOCKET ServerSock = INVALID_SOCKET;
 SOCKADDR_IN destination_sin;       
 PHOSTENT phostent = NULL;          
                                     
 WSADATA WSAData;                   
                                      
 // Initialize Winsocket.
 if (WSAStartup (MAKEWORD(1,1), &WSAData) != 0)
 {
    wsprintf (szError, TEXT("WSAStartup failed. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    return FALSE;
 }
 if ((ServerSock = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
 {
    wsprintf (szError, TEXT("Allocating socket failed. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    return FALSE;
 }
 destination_sin.sin_family = AF_INET;
 if ((phostent = gethostbyname (HOSTNAME)) == NULL)
 {
    wsprintf (szError, TEXT("Unable to get the host name. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    closesocket (ServerSock);
    return FALSE;
 }
 memcpy ((char FAR *)&(destination_sin.sin_addr), phostent->h_addr, phostent->h_length);
 destination_sin.sin_port = htons (PORTNUM);
 
 if (connect (ServerSock,
               (PSOCKADDR) &destination_sin,
               sizeof (destination_sin)) == SOCKET_ERROR)
 {
       DWORD dw = GetLastError();
    closesocket (ServerSock);
    return FALSE;
 }
 
 send(ServerSock,"ABCDEFG", 7, 0);     //第一次发送数据
 Sleep(2000);
 send(ServerSock,"1234567", 7, 0);     //第二次发送数据
 Sleep(2000);
 shutdown (ServerSock, 0x01);          //关闭发送方的连接或者调用closesocket(ServerSock);
 char buffer[100] = {""};
 while(1)
 {
        int rc = recv(ServerSock,buffer,99,0);
        if(rc < 0)
        {
               fprintf(stderr,"recv error,error code: %d/n",GetLastError());
               fflush(stderr);
               break;
        }
        else if( rc == 0)
        {
               fprintf(stderr,"server disconnected/n");
               fflush(stderr);
               break;
        }
        else
        {
               fputs(buffer,stdout);
               fputs("/n",stdout);
               fflush(stdout);
        }
 }
 closesocket (ServerSock);
 WSACleanup ();
 return TRUE;
}
 
服务器端代码:
 
#define WIN32_LEAN_AND_MEAN
#include <stdlib.h>
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <io.h>
#include<stdlib.h>
#include<iostream.h>
#include<conio.h>
#include<stdio.h>
#include<winsock2.h>
#include<windows.h>
#include <Ws2tcpip.h>
#include <process.h>
#include <ws2tcpip.h>
#include <winbase.h>
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"Kernel32.lib")
 
#define PORTNUM               4500    // Port number 
#define MAX_PENDING_CONNECTS 4       // Maximum length of the queue
int main()          
{       
 
 char szServerA[100] = {0};                // ASCII string
 TCHAR szError[100] = {0};                 // Error message string
 
 SOCKET WinSocket = INVALID_SOCKET, // Window socket
         ClientSock = INVALID_SOCKET; // Socket for communicating
                                      // between the server and client
 SOCKADDR_IN local_sin,              // Local socket address
              accept_sin;             // Receives the address of the
                                      // connecting entity
 int accept_sin_len;                 // Length of accept_sin
 
 WSADATA WSAData;                    // Contains details of the Winsock
                                      // implementation
 
 // Initialize Winsock.
 if (WSAStartup (MAKEWORD(1,1), &WSAData) != 0)
 {
    wsprintf (szError, TEXT("WSAStartup failed. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    return FALSE;
 }
 
 // Create a TCP/IP socket, WinSocket.
 if ((WinSocket = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
 {
    wsprintf (szError, TEXT("Allocating socket failed. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    return FALSE;
 }
 
 // Fill out the local socket's address information.
 local_sin.sin_family = AF_INET;
 local_sin.sin_port = htons (PORTNUM); 
 local_sin.sin_addr.s_addr = htonl (INADDR_ANY);
 // Associate the local address with WinSocket.
 if (bind (WinSocket,
            (struct sockaddr *) &local_sin,
            sizeof (local_sin)) == SOCKET_ERROR)
 {
    wsprintf (szError, TEXT("Binding socket failed. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    closesocket (WinSocket);
    return FALSE;
 }
 
 // Establish a socket to listen for incoming connections.
 if (listen (WinSocket, MAX_PENDING_CONNECTS) == SOCKET_ERROR)
 {
    wsprintf (szError,
              TEXT("Listening to the client failed. Error: %d"),
              WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
    closesocket (WinSocket);
    return FALSE;
 }
 accept_sin_len = sizeof (accept_sin);
 // Accept an incoming connection attempt on WinSocket.
 ClientSock = accept (WinSocket,
                       (struct sockaddr *) &accept_sin,
                       (int *) &accept_sin_len);
 
 if (ClientSock == INVALID_SOCKET)
 {
    wsprintf (szError, TEXT("Accepting connection with client failed.")
              TEXT(" Error: %d"), WSAGetLastError ());
    MessageBox (NULL, szError, TEXT("Error"), MB_OK);
       closesocket (WinSocket);
    return FALSE;
 }
 char RecvBuf[100] = {""};
 int lReadCount = 100;
 while(1)
 {
              int size = sizeof(RecvBuf);
              int nRes = recv(ClientSock,RecvBuf,lReadCount,0);
              if(nRes == 0)
              {
                     fprintf(stderr,"client disconnected /n");
                     break;
              }
              else if( nRes < 0)
              {
                     fprintf(stderr,"recv failed");
                     break;
              }
              printf("Recv: data: %s datalen: %d /r/n",RecvBuf,nRes);
      
              Sleep(4000);
             
              nRes = send(ClientSock,RecvBuf,nRes,0);
              if(nRes <= 0)
              {
                     fprintf(stderr,"send failed,error code: %d/r/n",errno);
              }
              memset(RecvBuf,NULL,lReadCount);
 }
 
 
 // Close ClientSock.
 closesocket (ClientSock);
 WSACleanup ();
 return TRUE;
}
 

NowDoIT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
TCP_简单的TCP服务和客户端操作类_
09-30
TCP服务器和客户端C++类，提供简单的TCP通讯功能
C# 解决Socket/TCPServer监听端口释放失败的问题
阿修罗汉果茶的博客
01-11 4582
关闭数据流，关闭Client连接，设置背景线程。
TCP连接全过程
weixin_49461415的博客
09-12 5898
服务器收到客户端的报文后向客户端发送ACK和SYN报文，此时服务器的状态变为SYN_RCVD。以上两种原因就是 TCP 连接为什么需要三次握手的主要原因，当然 TCP 连接还可以四次握手，甚至是五次握手，也能实现 TCP 连接的稳定性，但三次握手是最节省资源的连接方式，因此 TCP 连接应该为三次握手。为的是确认服务器端是否收到客户端发出的ACK确认报文,当客户端发出最后的ACK确认报文时,并不能确定服务器端能够收到该段报文.所以客户端在发送完 ACK 确认报文之后，会设置一个时长为 2MSL 的计时器。
nginx报：upstream prematurely closed connection while reading upstream异常 返回ERR_CONTENT_LENGTH_MISMATCH
凌飞安
03-22 7276
nginx报：upstream prematurely closed connection while reading upstream异常异常描述问题原因解决方案 异常描述 在一个愉快的周末即将结束的时候，客服告诉我系统出现异常了，查询返回数据失败。 前端看了一下，请求返回错误： ERR_CONTENT_LENGTH_MISMATCH。 后台nginx查询日记，发现错误日记： 13966#0: *725 upstream prematurely closed connection while read
解决upstream prematurely closed connection while reading response header from upstream
NaNa
07-30 3万+
问题 ：访问一个接口时，出现502 Bad Gateway 分析： 1.报错显示和nginx有关，所以查看nginx的错误日志error.log 2.发现报upstream prematurely closed connection while reading response header from upstream在从上游读取响应头时，上游过早关闭连接 这里猜测上游应该指的是服务器，因为后端架构是 nginx+gunicron 3.....
基于Nodejs的Tcp封包和解包的理解
10-18
主要介绍了基于Nodejs的Tcp封包和解包的理解，详细的介绍了tcp的分包与拆包并实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
理解TCP
01-27
TCP通过检验和、序列号、确认应答、重发控制、连接管理以及窗口控制等机制实现可靠性传输。 在TCP中，当发送端的数据到达接收主机时，接收端主机会返回一个已收到消息的通知。这个消息叫做确认应答（ACK（Positive ...
如何理解TCP是面向字节流的协议
05-15
如何理解TCP是面向字节流的协议
tcp全连接和半连接问题查询步骤
02-01
有socket连接不稳定经常出现连接不上或者没有反应的问题如何查询
解决Nginx错误：Upstream prematurely closed connection while reading response header from upstream
最新发布
Fly的博客
11-08 5313
【nginx error log】 /var/log/nginx/error.log: 级别:error 类型: [other] 次数: 1 错误信息(只取第一条): upstream prematurely closed connection while reading response header from upstream, client: 50.30.156.24 server: xx requests: "GET x HTTP/1.1" upstream: "x。
pycharm远程报错“EOF while reading packet”
ergudai的博客
07-08 2782
pycharm远程报错“EOF while reading packet”
PhPStorm实现php远程开发
guchenglu的博客
01-04 2562
在实际开发中，我们可能遇到如下问题： 如何保证多个开发者的开发环境一致 某些仅支持Linux 的扩展如何在Windows上使用（而Linux下开发又十分不便利） 在单个开发者需要安装扩展后，保证其他开发者无需安装即可使用 为了解决以上问题，今天将解释如何使用Nignx 的泛域名解析和PhpStorm 解决以上问题。 首先，我们利用PhpStorm 实现远程开发： ①.在Phpstorm...
半连接、半打开、半关闭
kanguolaikanguolaik的专栏
09-17 9453
一、半连接 1.1 定义       发生在TCP3次握手中。       如果A向B发起TCP请求，B也按照正常情况进行响应了，但是A不进行第3次握手，这就是半连接。 1.2 半连接攻击      半连接，会造成B分配的内存资源就一直这么耗着，直到资源耗尽。 二、半打开（Half-Open） 2.1 定义       如果一方已经关闭或异常终止连接，而另一方却不知道。 我
Linux下 nginx日志报错 upstream prematurely closed connection while reading upstream
yanliu_的博客
10-13 5142
最近使用 net core 做了个文件上传，postman测试无返回，去查了nginx日志文件后发现这个报错： 2020/10/13 10:01:53 [error] 22370#0: *48611 upstream prematurely closed connection while reading upstream, client: ****, server: superlcc.cn, request: "POST /api/product/****HTTP/1.1", upstream: "h
TCP释放连接（四次挥手）
wangxuelei036的博客
06-05 1万+
天下没有不散的宴席，TCP同样如此，参与TCP连接的两个进程中的任何一个都能终止该连接。TCP连接释放的过程通常称为四次握手或者四次挥手 （1）客户端打算关闭连接时，向其TCP发送一个连接释放报文段，并停止发送数据，主动关闭TCP连接，该报文段的FIN标志位被置为1，seq=u,它等于前面已传送的数据的最后一个字节的序号加1（FIN报文段即使不携带数据，也要消耗一个序号）。TCP时全双工的，即可以想象为一跳TCP连接上有两条数据通路。发送FIN报文时，发送FIN的一端不能再发送数据，即关闭了其中一跳数据
TCP 详解
热门推荐
如故的博客
06-20 27万+
上回说到 UDP 协议, 与之对应的便是 TCP 协议 TCP协议 TCP协议全称: 传输控制协议, 顾名思义, 就是要对数据的传输进行一定的控制. 先来看看它的报头 我们来分析分析每部分的含义和作用 源端口号/目的端口号: 表示数据从哪个进程来, 到哪个进程去. 32位序号: 4位首部长度: 表示该tcp报头有多少个4字节(32个bit) 6位保留: 顾名思义, 先保留着, 以...
TCP/IP——TCP连接的建立与终止、TCP超时、TCP状态变迁、TCP复位
weixin_44233369的博客
02-24 2589
一、概述 TCP是一个面向连接的协议。无论哪一方想另一方发送数据之前，都必须现在双方之间建立一条连接。这种两端间连接的建立与无连接协议如UDP不同。一端使用UDP想另一端发送数据报时，无需任何预先的握手。 二、TCP连接的建立和终止的时间 发起连接（报文段1）的一方是主动打开，接受连接（报文段2）的一方是被动打开。 其中，双方的序号（ack）的初始值（ISN）都是根据自身主机的时钟随机生成的，这...
EOF while reading packet
power_kaikaige的博客
12-04 1390
用pycahrm往服务器上传文件，突然不能上传了，并提示“EOF while reading packet”，解决方案
python tcp server 关闭和释放资源
03-25
当 Python TCP Server 关闭时，需要执行以下步骤以释放相关资源： 1. 关闭服务器套接字。 2. 循环关闭所有已连接的客户端套接字。 3. 关闭已连接的客户端的网络流对象。 4. 释放服务器和客户端套接字的文件描述符。 5. 释放网络流对象内存。 以下是一个 Python TCP Server 关闭和释放资源的例子： ```python import socket # 创建 TCP 服务器套接字 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 绑定服务器地址和端口 server_address = ('127.0.0.1', 8080) server_socket.bind(server_address) # 开始监听连接 server_socket.listen(5) print('Python TCP Server 已启动') # 循环处理客户端请求 while True: # 接受客户端连接 client_socket, client_address = server_socket.accept() print('客户端连接成功：', client_address) # 处理客户端请求 # 关闭客户端套接字和网络流对象 client_socket.shutdown(socket.SHUT_RDWR) client_socket.close() # 关闭服务器套接字 server_socket.shutdown(socket.SHUT_RDWR) server_socket.close() ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值