套接字协议及其数据传输特性

1.创建套接字（socket 函数）

#include <sys/socket.h>

int socket(int domain, int type, int protocol);

// 成功时返回文件描述符，失败时返回-1
// domain：套接字中使用的协议族（Protocol Family）信息
// type：套接字数据传输类型信息
// protocol：计算机间通信中使用的协议信息

为了完全理解 socket 函数，本文将着重展开讨论 socket 函数的参数及其含义。

2.协议（Protocol）

如果相隔很远的两人想展开对话，必须先决定对话方式。如果一方使用电话，那么另一方也只能使用电话，而不是书信。可以说，电话就是两人对话的协议。

协议是对话中使用的通信规则，把上述概念拓展到计算机领域可整理为“计算机间对话必备通信规则”。简言之，协议就是为了完成数据交换而定好的约定。

3.协议族（Protocol Family）

通过 socket 函数的第一个参数传递套接字中使用的协议分类信息，此协议分类信息称为协议族，头文件 sys/socket.h 中声明的协议族如下表所示。

名称	协议族
PF_INET	IPv4互联网协议族
PF_INET6	IPv6互联网协议族
PF_LOCAL	本地通信的UNIX协议族
PF_PACKET	底层套接字的协议族
PF_IPX	IPX Novell协议族

下面将着重讲解上表中 PF_INET 对应的 IPv4 互联网协议族，其他协议族并不常用或尚未普及。

另外，套接字中实际采用的最终协议信息是通过 socket 函数的第三个参数传递的。在指定的协议族范围内通过第一个参数决定第三个参数。

4.套接字类型（Type）

套接字类型指的是套接字的数据传输方式，通过 socket 函数的第二个参数传递，只有这样才能决定创建的套接字的数据传输方式。

问：已通过第一个参数传递了协议族信息，为什么还要决定数据传输方式？

答：问题就在于，决定了协议族并不能同时决定数据传输方式，换言之，socket 函数第一个参数 PF_INET 协议族中也存在多种数据传输方式。

4.1 面向连接的套接字（SOCK_STREAM）

如果向 socket 函数的第二个参数传递 SOCK_STREAM，将创建面向连接的套接字，其数据传输方式特点如下：

• 传输过程中数据不会消失
• 按序传输数据
• 传输的数据不存在数据边界（Boundary）

下图中 $2$ 位工人通过 $1$ 条传送带传递物品，这与面向连接的数据传输方式类似。

• 图中通过独立的传送带传输数据（糖果），只要传送带本身没有问题，就能保证数据不丢失。
• 较晚传递的数据不会先到达，因为传送带保证了数据的按序传递。
• “100个糖果是分批传递的，但接收者凑齐100个后才装袋”，这句话说明的确不存在数据边界。这种情形适用于之前说过的write和read函数，“传输数据的计算机通过3次调用write函数传递了100字节的数据，但接收数据的计算机仅通过1次read函数调用就接收了全部100个字节”。

收发数据的套接字内部有缓冲（buffer），简言之就是字节数组。通过套接字传输的数据将保存到该数组。因此，收到数据并不意味着马上调用 read 函数。只要不超过数组容量，则有可能在数据填充满缓冲后通过 $1$ 次 read 函数调用读取全部，也有可能分成多次 read 函数调用进行读取。也就是说，在面向连接的套接字中，read 函数和 write 函数的调用次数并无太大意义。所以说面向连接的套接字不存在数据边界。

还有一点需要说明，上图中传输和接收端各有 $1$ 名工人，这说明面向连接的套接字还有如下特点：套接字连接必须一一对应，面向连接的套接字只能与另外一个同样特性的套接字连接。

用一句话概括面向连接的套接字如下：可靠的、按序传递的、基于字节的面向连接的数据传输方式的套接字。

套接字缓冲已满是否意味着数据丢失

为了接收数据，套接字内部有一个由字节数组构成的缓冲。如果这个缓冲被接收的数据填满会发生什么事情？之后传递的数据是否会丢失？

首先调用 read 函数从缓冲读取部分数据，因此，缓冲并不总是满的。但如果 read 函数读取速度比接收数据的速度慢，则缓冲有可能被填满。此时套接字无法再接收数据，但即使这样也不会发生数据丢失，因为传输端套接字将停止传输。也就是说，面向连接的套接字会根据接收端的状态传输数据，如果传输出错还会提供重传服务。因此，面向连接的套接字除特殊情况外不会发生数据丢失。

4.2 面向消息的套接字（SOCK_DGRAM）

如果向 socket 函数的第二个参数传递 SOCK_DGRAM，则将创建面向消息的套接字，其数据传输方式特点如下：

• 强调快速传输而非传输顺序
• 传输的数据可能丢失也可能损毁
• 传输的数据有数据边界
• 限制每次传输的数据大小

下图展示的是高速移动的摩托车快递，这与面向消息的数据传输方式类似。

• 用摩托车发往同一目的地的 $2$ 件包裹无需保证顺序，只要以最快速度交给客户即可。
• 这种方式存在损坏或丢失的风险。
• 如果用 $2$ 辆摩托车分别发送 $2$ 件包裹，则接收者也需要分 $2$ 次接收，这种特性就是“传输的数据具有数据边界”。
• 包裹大小有一定限制。因此，若要传递大量包裹，则需分批发送。

面向消息的套接字比面向连接的套接字具有更快的传输速度，但无法避免数据丢失或损毁。另外，每次传输的数据大小具有一定限制，并存在数据边界。存在数据边界意味着接收数据的次数应和传输次数相同。

面向消息的套接字特性总结如下：不可靠的、不按序传递的、以数据的高速传输为目的的套接字。另外，面向消息的套接字不存在连接的概念。

5.协议的最终选择

下面讲解 socket 函数的第三个参数，该参数决定最终采用的协议。

问：前面已经通过 socket 函数的前两个参数传递了协议族信息和套接字数据传输方式，这些信息还不足以决定采用的协议吗？为什么还需要传递第 $3$ 个参数呢？

答：正如各位所想，传递前两个参数即可创建所需套接字。所以大部分情况下可以向第三个参数传递 $0$，除非遇到以下这种情况：“同一协议族中存在多个数据传输方式相同的协议”。数据传输方式相同，但协议不同，此时需要通过第三个参数具体指定协议信息。

5.1 创建 IPv4 协议族中面向连接的套接字

参数 PF_INET 指的是 IPv4 网络协议族，SOCK_STREAM 指的是面向连接的数据传输方式，满足这 $2$ 个条件的协议只有 IPPROTO_TCP，因此，可以如下调用 socket 函数创建套接字，这种套接字称为TCP套接字。

int tcp_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

5.2 创建 IPv4 协议族中面向消息的套接字

参数 PF_INET 指的是 IPv4 网络协议族，SOCK_DGRAM 指的是面向消息的数据传输方式，满足这 $2$ 个条件的协议只有 IPPROTO_UDP，因此，可以如下调用 socket 函数创建套接字，这种套接字称为UDP套接字。

int udp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

6.验证TCP套接字传输的数据不存在数据边界

6.1 服务器端程序

服务器端 tcp_server.c 与 hello_server.c 完全相同，如下所示。

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

void error_handling(char *message);

int main(int argc, char *argv[])
{
    
    
	int serv_sock;
	int clnt_sock;

	struct sockaddr_in serv_addr;
	struct sockaddr_in clnt_addr;
	socklen_t clnt_addr_size;

	char message[] = "Hello World!";
	
	if (argc != 2)
	{
    
    
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	
	// 调用socket函数创建套接字
	serv_sock = socket(PF_INET, SOCK_STREAM, 0);
	
	if (serv_sock == -1)
	{
    
    
		error_handling("socket() error");
	}
	
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port = htons(atoi(argv[1]));
	
	// 调用bind函数分配IP地址和端口号
	if (bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1)
	{
    
    
		error_handling("bind() error");
	}

	// 调用listen函数将套接字转为可接收连接状态
	if (listen(serv_sock, 5) == -1)
	{
    
    
		error_handling("listen() error");
	}
	
	clnt_addr_size = sizeof(clnt_addr);
	
	// 调用accept函数受理连接请求
	// 如果在没有连接请求的情况下调用该函数，则不会返回，直到有连接请求为止
	clnt_sock = accept(serv_sock, (struct sockaddr*) &clnt_addr, &clnt_addr_size);
	
	if (clnt_sock == -1)
	{
    
    
		error_handling("accept() error");
	}

	// write函数用于传输数据，若程序经过第56行代码执行到本行，则说明已经有了连接请求
	write(clnt_sock, message, sizeof(message));

	close(clnt_sock);
	close(serv_sock);
	
	return 0;
}

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

6.2 客户端程序

客户端 tcp_client.c 在 hello_client.c 的基础上更改了 read 函数的调用方式，为了验证TCP套接字传输的数据不存在数据边界，需要让 write 函数的调用次数不同于 read 函数的调用次数。因此，在客户端中分多次调用 read 函数以接收服务器端发送的全部数据。

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

void error_handling(char *message);

int main(int argc, char* argv[])
{
    
    
	int sock;
	struct sockaddr_in serv_addr;
	char message[30];
	int str_len = 0;
	int idx = 0, read_len = 0;
	
	if (argc != 3)
	{
    
    
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	// 创建套接字，但此时套接字并不马上分为服务器端和客户端
	// 如果紧接着调用bind、listen函数，将成为服务器端套接字；如果调用connect函数，将成为客户端套接字
	// 若前两个参数传递PF_INET、SOCK_STREAM，则可以省略第三个参数IPPROTO_TCP
	sock = socket(PF_INET, SOCK_STREAM, 0);

	if (sock == -1)
	{
    
    
		error_handling("socket() error");
	}

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

	// 调用connect函数向服务器端发送连接请求
	if (connect(sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) == -1)
	{
    
    
		error_handling("connect() error!");
	}

	// while循环中反复调用read函数，每次读取1个字节。如果read函数返回0，则循环条件为假，跳出while循环
	while (read_len = read(sock, &message[idx++], 1))
	{
    
    
		if (read_len == -1)
		{
    
    
			error_handling("read() error!");
		}

		// 执行该语句时，变量read_len的值始终为1，因为第46行每次读取1个字节
		// 跳出while循环后，str_len中存有读取的总字节数
		str_len += read_len;
	}

	printf("Message from server: %s\n", message);

	printf("Function read call count: %d\n", str_len);

	close(sock);

	return 0;
}

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

首先编译运行服务器端程序：

gcc tcp_server.c -o tserver
./tserver 9190

正常情况下服务器端程序将停留在此状态，因为服务器端调用的 accept 函数还未返回。

接下来编译运行客户端程序：

gcc tcp_client.c -o tclient
./tclient 127.0.0.1 9190

客户端输出结果：

Message from server: Hello World!
Function read call count: 13

完成消息传输后，服务器端和客户端都停止运行。

从运行结果可以看出，服务器端发送了 $13$ 字节的数据，客户端调用 $13$ 次 read 函数进行读取。