网络编程——TCP原理

参考

1. 《TCP/IP网络编程》 尹圣雨

TCP原理

TCP套接字中的I/O缓冲

TCP套接字的数据收发无边界，例如，客户端可以缓慢地分批接收服务器端一次性传输的数据

实际上，write函数调用后并非立即传输数据，read函数调用后也并非马上接收数据。更准确地，write函数调用瞬间，数据将移至输出缓冲，在适当的时候（不管是分别传送还是一次性传送）传向对方的输入缓冲；read函数调用瞬间，从输入缓冲读取数据

这些I/O缓冲特性如下：

1. I/O缓冲在每个TCP套接字中单独存在
2. I/O缓冲在创建套接字时自动生成
3. 即使关闭套接字也会继续传递输出缓冲中遗留的数据
4. 关闭套接字将丢失输入缓冲中的数据

从write函数返回的时间点

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

与对方套接字的连接（三次握手）

TCP套接字从创建到消失所经过程分为如下三步：

1. 与对方套接字建立连接
2. 与对方套接字进行数据交换
3. 断开与对方套接字的连接

TCP在于对方套接字建立连接的过程中会经过3次对话，因此，该过程又称Three-way handshaking（三次握手）

套接字是以全双工（Full-duplex）方式工作的。因此，收发数据前需要做一些准备

（1）首先，请求连接的主机A箱主机B传递如下信息：

[SYN] SEQ: 1000, ACK:-

该消息中SEQ为1000，ACK为空，而SEQ为1000的含义为：传递的数据包序号为1000，如果接收无误，请通知我向您传递1001号数据包

这是首次请求连接时使用的消息，又称SYN（Synchronization），表示收发数据前传输的同步消息

（2）接下来主机B向A传递如下消息：

[SYN+ACK] SEQ: 2000, ACK: 1001

此时SEQ为2000，ACK为1001，而SEQ为2000的含义为：传递的数据包序号为2000，如果接收无误，请通知我向您传递2001号数据包

而ACK 1001的含义为：刚才传输的SEQ为1000的数据包接收无误，现在请传递SEQ为1001的数据包

对主机A首次传输的数据包的确认消息（ACK 1001）和为主机B传输数据做准备的同步消息（SEQ 2000）捆绑发送，因此，此种类型的消息又称SYN+ACK

收发数据前向数据包分配序号，并向对方通报此序号，这是为防止数据丢失所做的准备。通过向数据包分配序号并确认，可以在数据丢失时马上查看并重传丢失的数据包。因此，TCP可以保证可靠的传输

（3）最后，主机A向主机B传输的消息：

[ACK] SEQ: 1001, ACK: 2001

此时该数据包传递的消息为，已正确收到传输的SEQ为2000的数据包，现在可以传输SEQ为2001的数据包

至此，主机A和主机B确认了彼此均就绪

与对方主机的数据交换

假设主机A向主机B传递100字节

（1）首先，主机A通过1个数据包发送100个字节的数据，数据包的SEQ为1200

（2）主机B为了确认这一点，向主机A发送ACK 1301消息

此时的ACK号为1301而非1201，原因在于ACK号的增量为传输的数据字节数。假设每次ACK号不加传输的字节数，这样虽然可以确认数据包的传输，但无法明确100字节全部正确传递还是丢失了一部分。因此按如下公式传递ACK消息：

ACK号 = SEQ号 + 传递的字节数 + 1

最后加1是为了告知对方下次要传递的SEQ号

断开与套接字的连接（四次握手）

先由套接字A向套接字B传递断开连接的消息，套接字B发出确认收到的消息，然后向套接字A传递可以断开连接的消息，套接字A同样发出确认消息

（1）首先，请求断开连接的主机A箱主机B传递如下信息：

[FIN] SEQ: 5000, ACK: -

FIN表示表示断开连接

（2）然后，主机B向A传递确认消息：

[ACK] SEQ: 7500, ACK: 5001

（3）接下来，主机B向主机A发送一次FIN消息：

[FIN] SEQ: 7501, ACK: 5001

这次传递ACK 5001是因为接收ACK消息后未接收数据而重传的

（4）最后，主机A向主机B确认消息：

[ACK] SEQ: 5001, ACK: 7502

基于Windows实现计算器服务器端/客户端

客户端实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>
#include <WS2tcpip.h>

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

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hSocket;
	char opmsg[BUF_SIZE];
	int result, opndCnt, i;
	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!");
	}

	hSocket = socket(PF_INET, SOCK_STREAM, 0);
	if (hSocket == INVALID_SOCKET)
	{
		ErrorHandling("socket() error");
	}

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

	if (connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
	{
		ErrorHandling("connect() error!");
	}
	else
	{
		puts("Connected.......");
	}

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

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

	printf("Operation result: %d \n", result);
	closesocket(hSocket);
	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 1024
#define OPSZ 4
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hServSock, hClntSock;
	char opinfo[BUF_SIZE];
	int result, opndCnt, i;
	int recvCnt, recvLen;
	SOCKADDR_IN servAdr, clntAdr;
	int clntAdrSize;
	if (argc != 2)
	{
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}

	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
	{
		ErrorHandling("WSAStartup() error!");
	}

	hServSock = socket(PF_INET, SOCK_STREAM, 0);
	if (hServSock == INVALID_SOCKET)
	{
		ErrorHandling("socket() error");
	}

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

	if (bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
	{
		ErrorHandling("bind() error");
	}
	if (listen(hServSock, 5) == SOCKET_ERROR)
	{
		ErrorHandling("listen() error");
	}
	clntAdrSize = sizeof(clntAdr);

	for (i = 0; i < 5; i++)
	{
		opndCnt = 0;
		hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize);
		recv(hClntSock, &opndCnt, 1, 0);

		recvLen = 0;
		while (opndCnt * OPSZ + 1 > recvLen)
		{
			recvCnt = recv(hClntSock, &opinfo[recvLen], BUF_SIZE - 1, 0);
			recvLen += recvCnt;
		}
		result = calculate(opndCnt, (int*)opinfo, opinfo[recvLen - 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;
		}
	}
	return result;
}

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