TCP/IP 网络编程（六）---优雅地断开套接字连接

咸蛋超人515
231 阅读5分钟

基于 TCP 的半关闭

之前调用的 close 或 closesocket 函数是单方面断开连接的。

（一）单方面断开连接带来的问题

Linux 的 close 函数和 Windows 的 closesocket 函数意味着完全断开连接。完全断开不仅指无法传输数据，而且也不能接收数据。

image.png

上图中，主机 A 发送完最后的数据后，调用 close 函数断开连接，之后主机 A 无法再接收主机 B 传输的数据。最终，由主机 B 传输的，主机 A 必须接收的数据被销毁。

为了解决这样的问题，“只关闭一部分数据交换中使用的流”（Half-close）的方法应运而生。断开一部分的连接是指，可以传输数据但无法接收，或可以接收数据但无法传输。

（二）套接字和流（Stream）

一旦两台主机建立了套接字连接，每个主机就会拥有单独的输入流和输出流：

image.png

Linux 的 close 函数和 Windows 的 closesocket 将同时断开这两个流。

（三）针对优雅断开的 shutdown 函数

shutdown 函数用于关闭一个流，所以是半关闭的函数。

#include <sys/socket.h>
// 成功时返回0，失败时返回-1
int shutdown(int sock, int howto);

  • sock：需要断开的套接字文件描述符。

  • howto：断开方式。

    • SHUT_RD：断开输入流。套接字无法接收数据。即使输入缓冲收到的数据也会抹去，而且无法调用输入相关函数。
    • SHUT_WR：断开输出流。无法传输数据。如果输出缓冲还留有未传输的数据，则将传递至目标主机。
    • SHUT_RDWR：同时断开 I/O 流。

（四）为什么需要半关闭

  • 明确结束写入：半关闭允许一方明确表示已经不再发送数据，但仍然希望接收数据。这样对方就知道它的写入数据已经结束，但仍可以继续读取数据直到接收方的写入也完成。

  • 流控制：在某些协议中，如TCP，半关闭帮助管理数据流和控制数据传输的状态。它有助于维护数据流的稳定性和顺序，特别是在长时间运行的连接中。

  • 异常处理：半关闭可以帮助处理网络异常或错误情况，例如，当一端发生错误并需要结束写入，但仍希望继续接收来自另一端的数据。

（五）基于半关闭的文件传输程序

（1）Linux 平台服务器端代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sd, clnt_sd;
	FILE * fp;
	char buf[BUF_SIZE];
	int read_cnt;
	
	struct sockaddr_in serv_adr, clnt_adr;
	socklen_t clnt_adr_sz;
	
	if(argc!=2) {
		printf("Usage: %s <port>\n", argv[0]);
		exit(1);
	}
	
	fp=fopen("file_server.c", "rb"); 
	serv_sd=socket(PF_INET, SOCK_STREAM, 0);   
	
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_adr.sin_port=htons(atoi(argv[1]));
	
	bind(serv_sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
	listen(serv_sd, 5);
	
	clnt_adr_sz=sizeof(clnt_adr);    
	clnt_sd=accept(serv_sd, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
	
	while(1)
	{
		read_cnt=fread((void*)buf, 1, BUF_SIZE, fp);
		if(read_cnt<BUF_SIZE)
		{
			write(clnt_sd, buf, read_cnt);
			break;
		}
		write(clnt_sd, buf, BUF_SIZE);
	}
	
	// 发送文件后针对输出流进行半关闭，这样就向客户端传输了EOF，而客户端也知道文件传输已经完成
	shutdown(clnt_sd, SHUT_WR);	

	// 只关闭了输出流，依然可以通过输入流接收数据
	read(clnt_sd, buf, BUF_SIZE);
	printf("Message from client: %s \n", buf);
	
	fclose(fp);
	close(clnt_sd); close(serv_sd);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

（2）Linux 平台客户端代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sd;
	FILE *fp;
	
	char buf[BUF_SIZE];
	int read_cnt;
	struct sockaddr_in serv_adr;
	if(argc!=3) {
		printf("Usage: %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	fp=fopen("receive.dat", "wb");
	sd=socket(PF_INET, SOCK_STREAM, 0);   

	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_adr.sin_port=htons(atoi(argv[2]));

	connect(sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
	
	while((read_cnt=read(sd, buf, BUF_SIZE ))!=0)
		fwrite((void*)buf, 1, read_cnt, fp);
	
	puts("Received file data");

	// 向服务器端发送表示感谢的消息。若服务器未关闭输入流，则可接收此消息
	write(sd, "Thank you", 10);
	fclose(fp);
	close(sd);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

（3）运行结果

image.png

（4）基于 Windows 的实现

Windows 平台的 shutdown 函数
#include <winsock2.h>
// 成功时返回0，失败时返回 SOCKET_ERROR
int shutdown(SOCKET sock, int howto);

  • sock：需要断开的套接字文件描述符。

  • howto：断开方式。

    • SD_RECEIVE：断开输入流。
    • SD_SEND：断开输出流。
    • SD_BOTH：同时断开 I/O 流。
服务器端代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 30
void ErrorHandling(char *message);

int main(int argc, char *argv[])
{
	WSADATA wsaData;
	SOCKET hServSock, hClntSock;
	FILE * fp;
	char buf[BUF_SIZE];
	int readCnt;
	
	SOCKADDR_IN servAdr, clntAdr;
	int clntAdrSz;

	if(argc!=2) {
		printf("Usage: %s <port>\n", argv[0]);
		exit(1);
	}
	if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0)
		ErrorHandling("WSAStartup() error!"); 
	
	fp=fopen("file_server_win.c", "rb"); 
	hServSock=socket(PF_INET, SOCK_STREAM, 0);   
	
	memset(&servAdr, 0, sizeof(servAdr));
	servAdr.sin_family=AF_INET;
	servAdr.sin_addr.s_addr=htonl(INADDR_ANY);
	servAdr.sin_port=htons(atoi(argv[1]));
	
	bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr));
	listen(hServSock, 5);
	
	clntAdrSz=sizeof(clntAdr);    
	hClntSock=accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSz);
	
	while(1)
	{
		readCnt=fread((void*)buf, 1, BUF_SIZE, fp);
		if(readCnt<BUF_SIZE)
		{
			send(hClntSock, (char*)&buf, readCnt, 0);
			break;
		}
		send(hClntSock, (char*)&buf, BUF_SIZE, 0);
	}
	
	shutdown(hClntSock, SD_SEND);	
	recv(hClntSock, (char*)buf, BUF_SIZE, 0);
	printf("Message from client: %s \n", buf);
	
	fclose(fp);
	closesocket(hClntSock); closesocket(hServSock);
	WSACleanup();
	return 0;
}

void ErrorHandling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}
客户端代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 30
void ErrorHandling(char *message);

int main(int argc, char *argv[])
{
	WSADATA wsaData;
	SOCKET hSocket;
	FILE *fp;
	
	char buf[BUF_SIZE];
	int readCnt;
	SOCKADDR_IN servAdr;

	if(argc!=3) {
		printf("Usage: %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0)
		ErrorHandling("WSAStartup() error!"); 

	fp=fopen("receive.dat", "wb");
	hSocket=socket(PF_INET, SOCK_STREAM, 0);   

	memset(&servAdr, 0, sizeof(servAdr));
	servAdr.sin_family=AF_INET;
	servAdr.sin_addr.s_addr=inet_addr(argv[1]);
	servAdr.sin_port=htons(atoi(argv[2]));

	connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr));
	
	while((readCnt=recv(hSocket, buf, BUF_SIZE, 0))!=0)
		fwrite((void*)buf, 1, readCnt, fp);
	
	puts("Received file data");
	send(hSocket, "Thank you", 10, 0);
	fclose(fp);
	closesocket(hSocket);
	WSACleanup();
	return 0;
}

void ErrorHandling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

问答

（一）解释 TCP 中“流”的概念。UDP 中能否形成流？

TCP 的“流”概念：

  • 连续性：数据作为一个字节流传输。
  • 顺序性：确保数据按发送顺序到达。
  • 流量控制：根据接收方缓冲区状态调整发送速率。
  • 拥塞控制：动态调整发送速率以减少网络负载。

UDP 中是否有流：

  • 无流概念：UDP 是无连接的，不保证数据顺序、可靠性或流的连续性。
  • 数据报模式：每个数据报独立处理，应用层可以将数据分段并在接收端重新组合这些数据，模拟流的行为，但 UDP 本身不支持。
avatar
文章
阅读
粉丝