基于TCP的服务器端/客户端(2) 三次握手/四次挥手

分手后的思念是犯贱 2022-05-24 23:07 220阅读 0赞

## 回声客户端的完美实现 ##

### 回声客户端问题解决办法 ###

为了确保read函数能读取完所有write函数发送的数据，可以通过在接受时用一个变量记录接受的数据量是否和发送的数据相同（或者大于发送量）

改进后的客户端代码：

/* 回声客户端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
    
    void error_handling(char *message)
    {
    	fputs(message,stderr);
    	fputc('\n',stderr);
    	exit(1);
    }
    
    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"))		// 输入q/Q退出
    			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);
    			if (recv_cnt == -1)
    				error_handling("read() error!");
    			recv_len += recv_cnt;
    		}
    		message[str_len] = 0;
    		printf("Message from server: %s",message);
    	}
    
    	close(sock);
    	return 0;
    }

54-59行利用循环条件石读取的数据大于等于发送的数据。

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

应用层协议不是高深莫测的存在，只不过是为特定程序的实现而制定的规则。

例如程序中：收到Q就立即终止连接

服务端/客户端实现过程中逐步定义的这些规则集合就是应用层协议。

### 计算器服务器端/客户端示例 ###

编写程序前设计了如下应用层协议：

![70][]

这种程度的协议相当于实现了一半程序，说明了应用层协议设计在网络编程中的重要性。

客户端：

/* 计算器客户端 */
    #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)
    {
    	fputs(message,stderr);
    	fputc('\n',stderr);
    	exit(1);
    }
    
    int main(int argc,char *argv[])
    {
    	int sock;
    	char message[BUF_SIZE];
    	int len,str_len;
    	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.........");
    	
    	scanf("%d",&len);
    	for (int i=0; i < len; i++ ) {
    		printf("读入第%d个数据:",i+1);
    		scanf("%d",(int*)&message[i];
    	}
    	
    	fgetc(stdin);				//读取运算符之前先用fgetc函数删除缓冲区中的字符\n
    	printf("读取operator:");
    	scanf("%c",&message[len]);
    
    	write(sock,message,strlen(message));
    	int result = 0;
    	read(sock,&result,len);
    	printf("The result is %d",result);
    	
    	close(sock);
    	return 0;
    }

服务器端：

/* 计算服务器端 */
    #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)
    {
    	fputs(message,stderr);
    	fputc('\n',stderr);
    	exit(1);
    }
    
    int main(int argc,char *argv[])
    {
    	int serv_sock, clnt_sock;
    	char message[BUF_SIZE];
    	int str_len, i;
    
    	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 (i = 0; i < 5; i++)				//迭代5次
    	{
    		clnt_sock = accept(serv_sock,(struct sockaddr*)&clnt_adr,&clnt_adr_sz);
    		if (clnt_sock == -1)
    			error_handling("accept() error!");
    		else 
    			printf("Connected client %d\n",i+1);
    
    		str_len = read(clnt_sock,message,BUF_SIZE);
    		int result = 0;
    		char op = message[str_len - 1]; 
    		for (int a = 0; a < str_len-1 ; ++a)
    		{
    			switch(op) {
    				case '+':	result += message[a];	break;
    				case '-':	result -= message[a];	break;
    				case '*':	result *= message[a];	break;
    				case '/':	result /= message[a];	break;
    				default :	printf("operator is wrong!\n");
    			}
    		}
    		printf("计算结果是:%d\n",result);
    		write(clnt_sock,(char*)&result,1);
    		close(clnt_sock);
    	}
    	close(serv_sock);
    	return 0;
    }

##     ##

## TCP原理 ##

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

write函数调用后并非立即传输数据，read函数调用后也并非马上接收数据。

write函数调用瞬间，数据将移至输出缓冲；

read函数调用瞬间，从输入缓冲读取数据。

![70 1][]

缓冲特性：

![70 2][]

补充\*：

位码即tcp标志位,有6种表示:

SYN(synchronous建立连接)

ACK(acknowledgement 表示响应、确认)

PSH(push表示有DATA数据传输)

FIN(finish关闭连接)

RST(reset表示连接重置)

URG(urgent紧急指针字段值有效)

###     ###

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

TCP在实际通信过程中会经过三次对话过程。该过程成为三次握手。

接下来给出连接过程中实际交换的信息格式：

![70 3][]

套接字是以全双工方式工作的。可以双向传递数据。

收发数据前需要做一些准备。

#### 三次握手Three-way Handshake ####

一个虚拟连接的建立是通过三次握手来实现的

1. (B) –> \[SYN\] –> (A)

假如服务器A和客户机B通讯. 当A要和B通信时，B首先向A发一个SYN (Synchronize) 标记的包，告诉A请求建立连接.

注意: 一个 SYN包就是仅SYN标记设为1的TCP包(参见TCP包头Resources). 认识到这点很重要，只有当A收到B发来的SYN包，才可建立连接，除此之外别无他法。因此，如果你的防火墙丢弃所有的发往外网接口的SYN包，那么你将不能让外部任何主机主动建立连接。

2. (B) <– \[SYN/ACK\] <–(A)

接着，A收到后会发一个对SYN包的确认包(SYN/ACK)回去，表示对第一个SYN包的确认，并继续握手操作.

注意: SYN/ACK包是仅SYN 和 ACK 标记为1的包.

3. (B) –> \[ACK\] –> (A)

B收到SYN/ACK 包,B发一个确认包(ACK)，通知A连接已建立。至此，三次握手完成，一个TCP连接完成

Note: ACK包就是仅ACK 标记设为1的TCP包.

需要注意的是当三此握手完成、连接建立以后，TCP连接的每个包都会设置ACK位

握手阶段：  
序号 方向 seq ack  
1　 　 A->B 10000 0  
2 B->A 20000 10000+1=10001  
3 A->B 10001 20000+1=20001  
解释：  
1：A向B发起连接请求，以一个随机数初始化A的seq,这里假设为10000，此时ACK＝0

2：B收到A的连接请求后，也以一个随机数初始化B的seq，这里假设为20000，意思是：你的请求我已收到，我这方的数据流就从这个数开始。B的ACK是A的seq加1，即10000＋1＝10001

3：A收到B的回复后，它的seq是它的上个请求的seq加1，即10000＋1＝10001，意思也是：你的回复我收到了，我这方的数据流就从这个数开始。A此时的ACK是B的seq加1，即20000+1=20001

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

通过三次握手过程完成了连接。下面正式开始收发数据。

![70 4][]

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

\-主机B确认这一点，向主机A发送ACK1301消息 （ACK号 -> SEQ号 + 传递的字节数 + 1）最后加1为了告知对方下次要传 递的SEQ号。

\-.......

与三次握手协议相同，最后加1是为了告知对方下次要传递的SEQ号。下面分析传输过程中数据包消失的情况：

![70 5][]

SEQ1301包向主机B传递100字节数据，但中间发生了错误，主机B未收到。经过一段时间后，主机A仍为收到对于SEQ1301的ACK确认。因此试着重传该数据包。

为了完成数据包重传，TCP套接字启动计时器以等待ACK应答。若计时器超时则重传。

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

#### 四次挥手Four-way handshaking  ####

![70 6][]

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

数据包中的FIN表示断开连接。双方各发送一次FIN消息后断开连接。

这个过程称为四次挥手。

全过程配图：

![70 7][]

[70]: /images/20220525/128517225ab64a8b930a77aea553b65a.png
[70 1]: /images/20220525/27e128c0956f41848e843614ed154638.png
[70 2]: /images/20220525/efe0a5291c024204b4fbaddcd82e38dc.png
[70 3]: /images/20220525/67f388eb05874ffa825be7fac17e7971.png
[70 4]: /images/20220525/b6fd3a8f021c4a0c885294b597de76d5.png
[70 5]: /images/20220525/76db326afbd94a2287797c97e7c6ce1c.png
[70 6]: /images/20220525/ffb3133428c5467bbdd10920a5222644.png
[70 7]: /images/20220525/095ced47dde94b4487fc1ba4e634cb07.png