开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> TCP/IP网络编程：P5-＞基于TCP的服务器端/客户端(下) -> 正文阅读

[系统运维]TCP/IP网络编程：P5-＞基于TCP的服务器端/客户端(下)

本系列文章为《TCP/IP网络编程----尹圣雨》学习笔记，前面的系列文章链接如下
TCP/IP网络编程：P1-＞理解网络编程和套接字
 TCP/IP网络编程：P2-＞套接字类型与协议设置
 TCP/IP网络编程：P3-＞地址族与数据序列
 TCP/IP网络编程：P4-＞基于TCP的服务器端/客户端(上)

前言

前面一章通过回声服务示例讲解了TCP服务器端/客户端的实现方法。但这仅是从编程角度的学习，我们尚未详细讨论TCP的工作原理。因此，本章将详细讲解TCP中必要的理论知识，还将给出第4章客户端问题的解决方案。

一、回声客户端的完美实现

1.1 回声服务器端没有问题，只有回声客户端有问题？

问题不在服务器端，而在客户端。

先回顾回声服务器端的I/O相关代码

while((str_len = read(clnt_sock, message, BUF_SIZE)) != 0)				
    write(clnt_sock, message, str_len);

再回顾回声客户端的I/O相关代码

write(sock, message, strlen(message));
str_len = read(sock, message, BUF_SIZE - 1);

二者都在循环调用read或write函数。实际上之前的回声客户端将100%接受自己传输的数据，只不过接收数据时的单位有些问题。扩展客户端代码回顾范围，下面是echo_client.c中要扩展回顾的代码：

while(1)
{
	fputs("Input message(Q to quit): ", stdout);
    fgets(message, BUF_SIZE, stdin);
    ...
    write(sock, message, strlen(message));
    str_len = read(sock, message, BUF_SIZE - 1)
    message[str_len] = 0;
    printf("Message from server: %s", message);
}

思考

回声客户端传输的是字符串，而且是通过调用write函数一次性发送的。之后还调用一次read函数，期待着接收自己传输的字符串。这就是问题所在。
问题： 既然回声客户端会收到所有字符串数据，是否只需多等一会儿？过一段时间后再调用read函数是否可以一次性读取所有字符串数据？
答：的确，过一段时间后即可接收，但需要等多久？要等10分钟吗？这不符合常理，理想的客户端应在收到字符串数据时立即读取并输出。

1.2 回声客户端问题解决方法

解决方案： 因为可以提前确定接收数据的大小，所以解决办法很简单。若之前传输了20字节长的字符串，则在接收时循环调用read函数读取20个字节即可。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#define BUF_SIZE 1024
void error_handling(char * message);

int main(int argc, char * argv[])
{
	int sock;
	char message[BUF_SIZE];
	int str_len, recv_len, recv_cnt;
	struct sockaddr_in serv_adr;

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

	sock = socket(PF_INET, SOCK_STREAM, 0);
	if(sock == -1)
		error_handling("socket() error");

	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]));

	if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
		error_handling("connect() error!");
	else
		puts("Connected.......");
	
	while(1)
	{
		fputs("Input message(Q to quit): ", stdout);
		fgets(message, BUF_SIZE, stdin);
		if(!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
			break;

		//新的实现代码
		str_len = write(sock, message, strlen(message));
		recv_len = 0;
		while(recv_len < str_len)
		{
			recv_cnt = read(sock, &message[recv_len], BUF_SIZE - 1);	// 并不是读BUF_SIZE - 1，而是读输入的数据到结束符。
			if(recv_len == -1)
				error_handling("read() error!");
			recv_len += recv_cnt;
		}
		message[recv_len] = 0;
		//结束
		
		printf("Message from server: %s", message);
	}
	close(sock);
	return 0;
}

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

1.3 如果问题不在于回声客户端：定义应用层协议

背景

----回声客户端可以提前知道接收的数据长度，但我们应该意识到，更多情况下这不太可能。既然如此，若无法预知接收数据长度时应如何收发数据？此时需要的就是应用层协议的定义。之前的回声服务器端/客户端中定义了如下协议：收到Q就立即终止连接。
----同样，收发数据过程中也需要定好规则(协议)以表示数据的边界，或提前告知收发数据的大小。服务器端/客户端实现过程中逐步定义的这些规则集合就是应用层协议。可以看出，应用层协议并不是高深莫测的存在，只不过是为特定程序的实现而制定的规则。

案例：实现加减乘

案例描述： 编写程序以体验应用层协议的定义过程。该程序中，服务器端从客户端获得多个数字和运算符信息。服务器端收到数字后对其进行加减乘运算，然后把结果传回客户端。例如：
----向服务器端传递3、5、9的同时请求加法运算，则客户端收到3+5+9的运算结果；
----若请求做乘法运算，则客户端收到3×5×9的运算结果；
----向服务器端传递4、3、2的同时要求做减法，则客户端将收到4-3-2的运算结果，即第一个参数成为被减数。

服务器端代码

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

#define BUF_SIZE 1024
#define OPSZ 4
void error_handling(char* message);
int calculate(int opnum, int opnds[], char oprator);

int main(int argc, char* argv[])
{
    int serv_sock, clnt_sock;
    char opinfo[BUF_SIZE];
    int result, opnd_cnt, i;
    int recv_cnt, recv_len;
    struct sockaddr_in serv_adr, clnt_adr;
    socklen_t clnt_adr_sz;

    if(argc != 2){
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if(serv_sock == -1) 
        error_handling("socket() error");

    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]));

    if(bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    if(listen(serv_sock, 5) == -1)
        error_handling("listen() error");
    
    clnt_adr_sz = sizeof(clnt_adr);

    for(int i = 0; i < 5; i++)
    {
        opnd_cnt = 0;
        clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
        read(clnt_sock, &opnd_cnt, 1); //接受待计算数字个数

        recv_len = 0;
        //接受待计算数字
        while((opnd_cnt*OPSZ+1)>recv_len)
        {
            recv_cnt = read(clnt_sock, &opinfo[recv_len], BUF_SIZE-1);
            recv_len += recv_cnt;
        }
        result = calculate(opnd_cnt, (int*)opinfo, opinfo[recv_len -1]);
        write(clnt_sock, (char*)&result, sizeof(result)); //向客户端传入结果
        close(clnt_sock);
    }
    close(serv_sock);
    return 0;
}

int calculate(int opnum, int opnds[], char op)
{
    int result = opnds[0], i;
    switch (op)
    {
    case '+':
        for(i = 1; i < opnum; i++) result+=opnds[i];
        break;
    case '-':
        for(i = 1; i < opnum; i++) result-=opnds[i];
        break;
    case '*':
        for(i = 1; i < opnum; i++) result*=opnds[i];
        break;
    default:
        break;
    }
    return result;
}

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

首先执行gcc op_server.c -o opserver编译源文件，然后执行./opserver 9190等待客户端消息的来临。
在这里插入图片描述

客户端代码

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

#define BUF_SIZE 1024
#define RLT_SIZE 4
#define OPSZ 4
void error_handling(char* message);

int main(int argc, char* argv[])
{
    int sock;
    char opmsg[BUF_SIZE];
    int result, opnd_cnt, i;
    struct sockaddr_in serv_adr;
    if(argc != 3)
    {
        printf("Usage : %s >IP> <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_STREAM, 0);
    if(sock == -1) error_handling("socket() error");

    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]));

    if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("connect() error!");
    else
        puts("Connected.........");
    
    fputs("Operand count: ", stdout);
    scanf("%d", &opnd_cnt);
    opmsg[0] = (char)opnd_cnt;

    for(i=0;i<opnd_cnt;i++)
    {
        printf("Operand %d: ", i+1);
        scanf("%d", (int*)&opmsg[i*OPSZ+1]);
    }
    fgetc(stdin);
    fputs("Operayot: ", stdout);
    scanf("%c", &opmsg[opnd_cnt*OPSZ+1]);
    write(sock, opmsg, opnd_cnt*OPSZ+2);
    read(sock, &result, RLT_SIZE);

    printf("Operation result: %d \n", result);
    close(sock);
    return 0;
}

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

首先执行gcc op_client.c -o opclient编译源文件，然后执行./opclient 127.0.0.1 9190。输入操作数的数量、数字、操作符。最后从服务器端返回正确的结果。
在这里插入图片描述

二、TCP原理

2.1 TCP套接字中的I/O缓冲

问题引出

TCP套接字的数据收发无边界。服务器端即使调用1次write函数传输40字节的数据，客户端也有可能通过4次read函数调用每次读取10字节。但此处也有一些疑问，服务器端一次性传输了40字节，而客户端居然可以缓慢地分批接收。客户端接收10字节后，剩下的30字节再何处等候呢？是不是像飞机为等待着陆而在空中盘旋一样，剩下30字节也在网络中徘徊并等待接收呢？

I/O缓冲

实际上，write函数调用后并非立即传输数据，read函数调用后，也并非马上接收数据。更准确地说，write函数调用瞬间，数据将移至输出缓存。read函数调用瞬间，从输入缓冲读取数据。

如图上所示，调用wirte函数时，数据将移到输出缓冲，在适当的时候(不管是分别传送还是一次性传送)传向对方的输入缓冲。这时对方将调用read函数从输入缓冲读取数据。这些I/O缓冲特性可整理如下：
①I/O缓冲在每个TCP套接字中单独存在。
②I/O缓冲在创建套接字时自动生成。
③即使关闭套接字也会继续传递输出缓冲中遗留的数据。
④关闭套接字将丢失输入缓冲中的数据。

流量控制

问题： 客户端输入缓冲为50字节，而服务器端传输了100字节。这种情况会引发什么事情？
结论： 不会发生超过输入缓冲大小的数据传输，因为TCP会控制数据流。TCP中有滑动窗口协议(Sliding Window)协议，用对话方式呈现如下。
----套接字A：“你好，最多可以向我传递50字节。”
----套接字B：“OK！”
----套接字A：“我腾出了20字节的空间，最多可以收70字节。”
----套接字B：“OK！”
数据收发也是如此，因此TCP中不回因为缓冲溢出而丢失数据。

从write函数返回的时间点

write函数和Windows 的send函数并不会在完成向对方主机的数据传输时返回，而是在数据移到输出缓冲时。但 TCP会保证对输出缓冲数据的传输，所以说write函数在数据传输完成时返回。

2.2 TCP内部工作原理1：与对方套接字的连接

三次握手

TCP套接字从创建到消失所经过程分成如下3步：
①与对方套接字建立连接
②与对方套接字进行数据交换。
③断开与对方套接字的连接。
与对方套接字建立连接的过程中，套接字之间的对话如下：
①[Shake 1]套接字A：“你好，套接字B。我这儿有数据要传给你，建立连接吧。”
②[Shake 2]套接字B：“好的，我这边已就绪。”
③[Shake 3]套接字A：“谢谢你受理我的请求。”
TCP在实际通信过程中也会经过3次对话过程，因此，该过程又称“三次握手”(Three-way handshaking)。

连接过程中实际交换的信息格式

①第一次握手
套接字是以全双工(Full-duplex)方式工作的。也就是说，它可以双向传递数据。因此，收发数据前需要做一些准备。首先，请求连接的主机A向主机B传递如下信息：
[SYN] SEQ: 1000, ACK：-
该消息中SEQ为1000，ACK为空，而SEQ为1000的含义如下：
----现传递的数据包序号为1000，如果接收无误，请通知我向您传递1001号数据包。
这是首次请求连接时使用的消息，又称SYN。SYN是Synchronization的简写，表示收发数据前传输的同步消息。
②第二次握手
接下来主机B向A传递如下消息：
[SYN+ACK] SEQ: 2000, ACK: 1001
此时SEQ为2000，ACK为1001，而SEQ为2000的含义如下：
----现传递的数据包序号为2000，如果接受无误，请通知我向您传递2001号数据包。
而ACK1001的含义如下：
----刚才传输的SEQ为1000的数据包接收无误，现在传递SEQ为1001的数据包。
对主机A首次传输的数据包的确认消息(ACK1001)和为主机B传输数据做准备的同步消息(SEQ2000)捆绑发送，因此，此种类型的消息又称SYN+ACK。
③第三次握手
收发数据前向数据包分配序号，并向对方通报此序号，这都是防止丢失所做的准备。通过向数据包分配序号并确认，可以在数据丢失时马上查看并重传丢失的数据包。因此TCP可以保证可靠的数据传输。最后主机A向主机B传输的消息如下：
[ACK] SEQ: 1001, ACK: 2001
之前也讨论过，TCP连接过程中发送数据包时需分配序号。在之前的序号1000的基础上加1，也就是分配1001。此时该数据包传递如下消息：
----已正确收到传输的SEQ为2000的数据包，现在可以传输SEQ为2001的数据包。
这样就传输了添加ACK 2001的ACK消息。至此，主机A和主机B确认了彼此均就绪。

2.3 TCP内部工作原理2：与对方主机的数据交换

通过第一步三次握手过程完成了数据交换准备，下面就正式开始收发数据，其默认方式如下图所示：

----上图给出了主机A分2次(分2个数据包)向主机B传递200字节的过程。首先，主机A通过1个数据包发送100个字节的数据，数据包的SEQ为1200。主机B为了确认这一点，向主机A发送ACK1301消息。
----此时的ACK号为1301而非1201,原因在于ACK号的增量为传输的数据字节数。假设每次ACK号不加传输的字节数，这样虽然可以确认数据包的传输，但无法明确100字节全都正确传递还是丢失了一部分，比如只传递了80字节。因此按如下公式传递ACK消息：
ACK号 = SEQ号 + 传递的字节数 + 1
----与三次握手协议相同，最后加1是为了告知对方下次要传递的SEQ号。
下面分析传输过程中数据包丢失的情况：

上图表示通过SEQ 1301数据包向主机B传递100字节数据。但中间发生了错误，主机B未收到。经过一段时间后，主机A仍未收到对于SEQ 1301的ACK确认，因此试着重传该数据包。为了完成数据包重传，TCP套接字启动计时器以等待ACK应答。若相应计时器发生超时，则重传。

2.4 TCP内部工作原理3：断开与套接字的连接

TCP套接字的结束过程也非常优雅。如果对方还有数据需要传输时直接断掉连接会出问题，所以断开连接时需要双方协商。断开连接时对话如下：

套接字A：“我希望断开连接。”
套接字B：“哦，是吗？请稍后。”
套接字B：“我也准备就绪，可以断开连接。”
套接字A：“好的，谢谢合作。”

先由套接字A向套接字B传递断开连接的消息，套接字B发出确认收到的消息，然后向套接字A传递可以断开连接的消息，套接字A同样发出确认消息，如下图所示。
在这里插入图片描述
----上图数据包内的FIN表示断开连接。也就是说，双方各发送1次FIN消息后断开连接。此过程经历4个阶段，因此又称四次挥手(Four-way handshaking)。
----上图中向主机A传递了两次ACK 5001，也许这会让各位感到困惑。其实，第二次FIN数据包中的ACK 5001只是因为接收ACK消息后未接收数据而重传的。

三、基于Windows的实现

服务器端代码

#pragma comment(lib,"ws2_32.lib")
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>

#define BUF_SIZE 1024
#define OPSZ 4
void error_handling(char* message);
int calculate(int opnum, int opnds[], char oprator);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hServSock, hClntSock;
	char opinfo[BUF_SIZE];

	int result, opnd_cnt, i;
	int recv_cnt, recv_len;
	SOCKADDR_IN serv_adr, clnt_adr;
	int clnt_adr_sz;

	if (argc != 2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}

	if(WSAStartup(MAKEWORD(2,2),&wsaData)!=0)
		error_handling("WSAStartup() error!");

	hServSock = socket(PF_INET, SOCK_STREAM, 0);
	if (hServSock == INVALID_SOCKET)
		error_handling("socket() error");

	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]));

	if (bind(hServSock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == SOCKET_ERROR)
		error_handling("bind() error");
	if (listen(hServSock, 5) == SOCKET_ERROR)
		error_handling("listen() error");
	clnt_adr_sz = sizeof(clnt_adr);

	for (int i = 0; i < 5; i++)
	{
		opnd_cnt = 0;
		hClntSock = accept(hServSock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
		recv(hClntSock, &opnd_cnt, 1, 0); //接受待计算数字个数

		recv_len = 0;
		//接受待计算数字
		while ((opnd_cnt*OPSZ + 1) > recv_len)
		{
			recv_cnt = recv(hClntSock, &opinfo[recv_len], BUF_SIZE - 1, 0);
			recv_len += recv_cnt;
		}
		result = calculate(opnd_cnt, (int*)opinfo, opinfo[recv_len - 1]);
		send(hClntSock, (char*)&result, sizeof(result), 0); //向客户端传入结果
		closesocket(hClntSock);
	}
	closesocket(hServSock);
	WSACleanup();
	return 0;
}

int calculate(int opnum, int opnds[], char op)
{
	int result = opnds[0], i;
	switch (op)
	{
	case '+':
		for (i = 1; i < opnum; i++) result += opnds[i];
		break;
	case '-':
		for (i = 1; i < opnum; i++) result -= opnds[i];
		break;
	case '*':
		for (i = 1; i < opnum; i++) result *= opnds[i];
		break;
	default:
		break;
	}
	return result;
}

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

运行，等待客户端消息到来。
在这里插入图片描述

客户端代码

#pragma comment(lib,"ws2_32.lib")
#pragma warning(disable:4996)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>

#define BUF_SIZE 1024
#define RLT_SIZE 4
#define OPSZ 4
void error_handling(const char* message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hSocket;
	char opmsg[BUF_SIZE];
	char result;
	int opnd_cnt, i;
	SOCKADDR_IN serv_adr;
	if (argc != 3)
	{
		printf("Usage : %s >IP> <port>\n", argv[0]);
		exit(1);
	}

	if(WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
		error_handling("WSAStartup() error!");

	hSocket = socket(PF_INET, SOCK_STREAM, 0);
	if (hSocket == INVALID_SOCKET) 
		error_handling("socket() error");

	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]));

	if (connect(hSocket, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
		error_handling("connect() error!");
	else
		puts("Connected.........");

	fputs("Operand count: ", stdout);
	scanf("%d", &opnd_cnt);
	opmsg[0] = (char)opnd_cnt;

	for (i = 0; i < opnd_cnt; i++)
	{
		printf("Operand %d: ", i + 1);
		scanf("%d", (int*)&opmsg[i*OPSZ + 1]);
	}
	fgetc(stdin);
	fputs("Operayot: ", stdout);
	scanf("%c", &opmsg[opnd_cnt*OPSZ + 1]);
	send(hSocket, opmsg, opnd_cnt*OPSZ + 2, 0);
	recv(hSocket, &result, RLT_SIZE, 0);

	printf("Operation result: %d \n", result);
	closesocket(hSocket);
	WSACleanup();
	return 0;
}

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