211-socket网络编程(UDP)

心已赠人 2022-11-05 08:48 208阅读 0赞

TCP 提供的是面向连接的、可靠的、字节流服务。  
UDP 提供的是无连接、不可靠的、数据报服务。

## 我们先回顾一下TCP ##

在 Linux 系统上，一个 TCP 端口不能被同时打开多次（两次及以上）。当一个 TCP 连接处于 TIME\_WAIT 状态时，我们将无法立即使用该连接占用着的端口来建立一个新连接。如果确实需要强制进程立即使用处于 TIME\_WAIT 状态的连接所占用的端口，可以通过setsockopt（）方法设置 socket 选项 SO\_REUSEADDR 来完成。  
**TCP在收发数据，要建立链接，通过三次握手建立链接进行通讯，四次挥手断开连接。**

**流式服务特点**  
TCP 字节流的特点，发送端执行的写操作次数和接收端执行的读操作次数之间没有任何数量关系，应用程序对数据的发送和接收是没有边界限制的。如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]  
**TCP的可靠性**：**应答确认，超时重传机制**。我们本端给对方发送数据，对方收到后会给我们本端应答。我们send发送数据，对方收到会回复一个ACK确认信息。如果对方没有收到，我们本端会重发，我们之前发送的数据包确实丢了，对方收不到数据，不会给我们本端回复，等到一段时间，对方还是没有回复确认，说明这个数据包丢了，我们本端重发，对方收到数据，给我们回复确认。  
**还有一种情况**，我们发送的数据对方收到了，对方进行确认回复，但是确认的数据包丢了，我们本端一直没有收到回复，认为这个数据包丢了，依然回重发，导致对方收到2份数据，但是我们不用担心，从传输层来讲，TCP协议，每个数据包都有自己的序号，如果2个数据包的序列号相同，我们认为是同一个数据包，会丢弃一个。  
**网络中**，我们发送的数据包不一定都是一条固定的路，有的路拥塞，它可能会选择走其他的路，有可能造成先发送的数据后到达了。也就是乱序了。也没有关系。**因为有序列号，TCP有乱序重排，丢弃重复报文的能力。**

## 应答确认与超时重传 ##

TCP 发送的报文段是交给 IP 层传送的。但 IP 层只能提供尽最大努力的服务，也就是说，TCP 下面的网络所提供的是不可靠的传输。因此，TCP 必须采用适当的措施才能使两个运输层之间的通信变得可靠。TCP 的可靠传输是通过使用应答确认和超时重传来完成。  
**下图是通过 netstat 命令抓包看到的信息：**  
![在这里插入图片描述][20210305233058338.png_pic_center]  
下图是无差错时，数据交互的流程：发送端发送数据 m1 给接收端，接收端收到数据后会给发送端一个确认信息，以表明数据已经被成功收到。在发送方未收到确认信息前，M1应继续被保留，直到确认信息到达才能丢弃。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]

## TCP还有滑动窗口（进行流量控制） ##

我们可以一次性发很多数据，对方一起确认。  
**TCP 协议是利用滑动窗口实现流量控制的。** 一般来说，我们总是希望数据传输得更快一些，不会一次只发一个字节。但是如果发送方把数据发得过快，接受方就可能来不及接收，这就会造成数据的丢失。所谓流量控制就是让发送方的发送速率不要太快，要让接收方来的及接收。  
**在 TCP 的报头中有一个字段叫做接收通告窗口，这个字段由接收端填充，是接收端告诉发送端自己还有多少缓冲区可以接收数据**。于是发送端就可以根据这个接收端的处理能力来发送数据，而不会导致接收端处理不过来。所以发送端就会有一个发送窗口，这个发送窗口的大小是由接收端填充的接收通告窗口的大小决定的，并且窗口的位置会随着发送端数据的发送和接收到接收端对数据的确认而不断的向右滑动，将之称为滑动窗口。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]  
**最多只允许一次性把窗口里的东西发出去。** 后面的数据不能再发。窗口执行流量控制。开的大，流的大。大小可变，根据实际情况。  
**这些都是来支撑其可靠性**。

## 拥塞控制 ##

在计算机网络中的链路容量（即带宽）、交换结点中的缓存和处理机等，都是网络的资源。在某段时间，若对网络中某一资源的需求超过了该资源所能提供的可用部分，网络的性能就要变坏。这种情况就叫做拥塞。所谓拥塞控制就是防止过多的数据注入到网络中，这样可以使网络中的路由器或链路不致过载。拥塞控制是一个全局性的过程，涉及到所有主机，所有路由器，以及与降低网络传输性能有关的所有因素。  
几种拥塞控制的方法：  
◼ 慢开始  
◼ 拥塞避免  
◼ 快速重传  
◼ 快速恢复  
慢开始、拥塞避免、快速恢复示意图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]

## UDP 编程流程 ##

**不可靠，只是尽最大能力帮你去传输。但是效率高。**

UDP发出的数据包不经过确认，可以继续发送。发送成功与否都不管，尽最大能力去发送，丢包也不负责。  
**有自己的使用特点：适合于 做视频（实时性）适合于即使丢包了，处理也比较便宜。**  
**适合于摄像头** 以恒定速率发，对方以恒定速率收，丢包了继续发，可以实时。  
但是如果是TCP，如果丢包，会重发，时间花销大了，不能实时。不适合做摄像头和视频。

**UDP 提供的是无连接、不可靠的、数据报服务。编程流程如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]  
服务端和客户端没有严格的区别

## UDP 服务端客户端编程示例代码： ##

**udpser.c**  
![在这里插入图片描述][ce7afda820e143c0a881efa313a85f9b.png]

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    #include <assert.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    int main()
    {
        
    	int sockfd = socket(AF_INET,SOCK_DGRAM,0);//相当于手机
    	assert( sockfd != -1 );
    
    	struct sockaddr_in saddr,caddr;
    	memset(&saddr,0,sizeof(saddr));//要清0，因为有占位的
    	saddr.sin_family = AF_INET;
    	saddr.sin_port = htons(6000);
    	saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    	int res = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    	assert( res != -1 );//命名套接字，注册手机号
    
    	while( 1 )//循环接收数据
    	{
        
    		int len = sizeof(caddr);
    		char buff[128] = {
        0};
    		recvfrom(sockfd,buff,127,0,(struct sockaddr*)&caddr,&len);
    		printf("ip:%s,port:%d,buff=%s\n",inet_ntoa(caddr.sin_addr), ntohs(caddr.sin_port),buff );
    
    		sendto(sockfd,"ok",2,0,(struct sockaddr*)&caddr,sizeof(caddr));
    		//因为是无连接，所以每次发送都要确定目标地址
    	}
    	close(sockfd);
    }

**udpser.c在Linux上的显示：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]  
**运行后，阻塞在recvfrom()**

**udpcli.c**

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <string.h>
    #include <assert.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    
    int main()
    {
        
    	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    	assert( sockfd != -1 );
    
    	struct sockaddr_in saddr;
    	memset(&saddr,0,sizeof(saddr));
    	saddr.sin_family = AF_INET;
    	saddr.sin_port = htons(6000);
    	saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    	while( 1 )
    	{
        
    		char buff[128] = {
        0};
    		printf("input:\n");
    
    		fgets(buff,128,stdin);
    
    		if ( strncmp(buff,"end",3) == 0 )
    		{
        
    			break;
    		}
    
    		sendto(sockfd,buff,strlen(buff),0,(struct sockaddr*)&saddr,sizeof(saddr));
    		memset(buff,0,128);
    
    		int len = sizeof(saddr);
    		recvfrom(sockfd,buff,127,0,(struct sockaddr*)&saddr,&len);
    
    		printf("buff=%s\n",buff);
    	}
    
    	close(sockfd);
    }

**udpcli.c在Linux的显示**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]

## 将服务器端和客户端一起运行起来 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]  
**我们得知，UDP，多个客户端可以和服务器一起链接通讯。recvfrom并不是只等第一个或者第二个客户端，而是谁给它发，它就收谁的。**  
**可以同时处理多个客户端** 看recvfrom得到谁的地址，端口。彼此之间没有建立连接。

**客户端保持运行中，我们把服务器端关闭，然后再把服务器端重新运行起来**  
这时候客户端发送数据，服务器端是可以收到的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]  
**因为UDP本来就没有建立连接。如果服务器端关了，客户端send就失败了。** 数据包丢了就丢了，不管。  
**不管关闭哪一端，对方端都不知道这件事情，彼此无关系，无影响。**

**我们再来做一点改动。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]  
让服务器端recfrom一次只收一个字符。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]  
**UDP的特点**：我给你发一个数据包，你去收这个数据包，你recvfrom，你把这个数据包拆开，你读取1个字符，后面的不读，直接就丢掉了。你每执行一次recvfrom，每次都打开一个数据包。我们得把一个数据包的数据一次性收取完。

UDP 数据报服务特点：发送端应用程序每执行一次写操作，UDP 模块就将其封装成一个 UDP 数据报发送。接收端必须及时针对每一个 UDP 数据报执行读操作，否则就会丢包。并且，如果用户没有指定足够的应用程序缓冲区来读取 UDP 数据，则 UDP 数据将被截断。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 17]  
**第一次sendto，发送到第一个UDP数据报。第二次sendto，发送到第二个UDP数据报，两者不会合并的。**

**每次sendto都要指定地址。两次去sendto可能地址一样也可能地址不一样。所以两种情况，UDP都得去支持，所以每个sendto都有一个自己的数据包。**

**接收端也一样，发送端每执行一次sendto，接收端就有专门的一次recvfrom去接收，拆相应的那一个数据包。**

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/8326a968f8b54babab950b681931d0ef.png
[20210305233058338.png_pic_center]: /images/20221023/17096f5146dc4b3ba816ca828ea1a1e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221023/afb67a7c189048fcbc1de7add96c052b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221023/897da8761ab5459ea3f3c7b930bfc42b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221023/ee50fbc955a34734affae0e84f707313.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221023/7efadc6af19d4cfd9404df91e1339eb0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221023/dcb66ce860e5444fa9a519e7509d307d.png
[ce7afda820e143c0a881efa313a85f9b.png]: /images/20221023/914b4bf25db44457bfbd7a35b9e154a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221023/808946aac02641979b0681c12c2b4672.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221023/319edb1babab497987a0cb4ec28d3747.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221023/ae84b75a7c35466dad927c4e84c1521c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221023/c6b846a191a84b308028f70dbdcd0aa9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221023/5b23e27a58e64833884a159133639204.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221023/f676687bdf0d4c27aa8144710ca7f134.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221023/9456d1f59b0a480b9d818646cac3338d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221023/0e4188c8b5d54407be197aedbd93d1c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221023/0b6d860a20714c55954440388388bdd0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221023/7ae4712d85c046b9827e782c1a51f937.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221023/6b6e132e5653422d9f695e1d00f69e4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221023/d8a0e613df2644919a68d74fb82f4543.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221023/1517fc19426d4dd4a4b7394ebf9bbf36.png