TCP/IP 网络编程（二）---套接字类型与协议设置

协议（Protocol）

简单来说，协议就是为了完成数据交换而定好的约定。

如果相隔很远的两人想展开对话，必须先决定对话方式。如果一方使用电话，那么另一方也只能使用电话，而不是书信。可以说电话就是两人对话的协议。协议是对话中使用的通信规则，把上述概念拓展到计算机领域可整理为“计算机间对话必备通信规则”。

由套接字的创建函数引出相关概念

#include <sys/socket.h>
int socket(int domain, int type, int protocol);

• domain ：套接字中使用的协议族（Protocol Family）信息。
• type ：套接字数据传输类型信息。
• protocol ：计算机间通信中使用的协议信息。

（一）协议族（Protocol Family）

套接字通信中的协议有一些分类，通过 socket 函数的第一个参数传递套接字中使用的协议分类信息。

协议族可分为如下几类：

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

（二）套接字类型（Type）

套接字类型指的是套接字的数据传输方式，通过 socket 函数的第二个参数传递。

已经通过第一个参数传递了协议族信息，为什么还要决定数据传输方式？因为协议族中也存在多种数据传输方式。

下面介绍两种具有代表性的数据传输方式。

（1）面向连接的套接字（SOCK_STREANM）

向 socket 函数的第二个参数传递 SOCK_STREAM ，将创建面向连接的套接字。面向连接的套接字具有如下特点：

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

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

向 socket 函数的第二个参数传递 SOCK_DGRAM ，将创建面向消息的套接字。面向消息的套接字具有如下特点：

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

（三）协议的最终选择

socket 函数的第三个参数决定最终采用的协议。它允许在同一个协议族和套接字类型下选择不同的协议。

为什么需要第三个参数？

前两个参数通常足以创建所需套接字，所以大部分情况下可以向第三个参数传递0，表示选择默认协议，除非同一协议族中存在多个数据传输方式相同的协议，第三个参数允许你细化选择具体的协议。下面给出几个例子：

① “IPv4 协议族中面向连接的套接字”，这种套接字也被称为 TCP 套接字。

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

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

上面两句代码等效，因为在大多数实现中， SOCK_STREAM 默认使用 TCP 协议。

② “IPv4 协议族中面向消息的套接字”，这种套接字也被称为 UDP 套接字。

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

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

上面两句代码等效，因为在大多数实现中， SOCK_DGRAM 默认使用 UDP 协议。

TCP 套接字示例

（一）Linux 平台

服务器端（tcp_server.c）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.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);
	}
	
        
	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]));
	
	if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1)
		error_handling("bind() error"); 
	
	if(listen(serv_sock, 5)==-1)
		error_handling("listen() error");
	
	clnt_addr_size=sizeof(clnt_addr);  
	clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size);
	if(clnt_sock==-1)
		error_handling("accept() error");  
	
	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);
}

客户端（tcp_client.c）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.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);
	}
	
	// 创建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]));
		
	if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 
		error_handling("connect() error!");

	// 反复调用read函数，每次读取一个字节
	while(read_len=read(sock, &message[idx++], 1))
	{
		if(read_len==-1)
			error_handling("read() error!");
		
		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);
}

运行结果

服务器端发送了13字节的数据，客户端调用13次 read 函数进行读取。

（二）Windows 平台

服务器端（tcp_server_win.c）

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
	WSADATA	wsaData;
	SOCKET hServSock, hClntSock;		
	SOCKADDR_IN servAddr, clntAddr;		

	int szClntAddr;
	char message[]="Hello World!";

	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(&servAddr, 0, sizeof(servAddr));
	servAddr.sin_family=AF_INET;
	servAddr.sin_addr.s_addr=htonl(INADDR_ANY);
	servAddr.sin_port=htons(atoi(argv[1]));
	
	if(bind(hServSock, (SOCKADDR*) &servAddr, sizeof(servAddr))==SOCKET_ERROR)
		ErrorHandling("bind() error");  
	
	if(listen(hServSock, 5)==SOCKET_ERROR)
		ErrorHandling("listen() error");

	szClntAddr=sizeof(clntAddr);    	
	hClntSock=accept(hServSock, (SOCKADDR*)&clntAddr,&szClntAddr);
	if(hClntSock==INVALID_SOCKET)
		ErrorHandling("accept() error");  
	
	send(hClntSock, message, sizeof(message), 0);
	closesocket(hClntSock);
	closesocket(hServSock);
	WSACleanup();
	return 0;
}

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

客户端（tcp-client_win.c）

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hSocket;
	SOCKADDR_IN servAddr;

	char message[30];
	int strLen=0;
	int idx=0, readLen=0;

	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("hSocket() error");
	
	memset(&servAddr, 0, sizeof(servAddr));
	servAddr.sin_family=AF_INET;
	servAddr.sin_addr.s_addr=inet_addr(argv[1]);
	servAddr.sin_port=htons(atoi(argv[2]));
	
	if(connect(hSocket, (SOCKADDR*)&servAddr, sizeof(servAddr))==SOCKET_ERROR)
		ErrorHandling("connect() error!");
 
	while(readLen=recv(hSocket, &message[idx++], 1, 0))
	{
		if(readLen==-1)
			ErrorHandling("read() error!");
		
		strLen+=readLen;
	}

	printf("Message from server: %s \n", message);  
	printf("Function read call count: %d \n", strLen);

	closesocket(hSocket);
	WSACleanup();
	return 0;
}

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

运行结果

同 Linux 端。