Glory-D

本篇文章简单描述了UDP传输协议的工作原理及特点。

理解UDP

UDP和TCP一样同属于TCP/IP协议栈的第二层,即传输层。

UDP套接字的特点

UDP的工作方式类似于传统的信件邮寄过程。寄信前应先在信封上填好寄信人和收信人的地址,之后贴上邮票放进邮筒即可。当然信件邮寄过程可能会发生丢失,我们也无法随时知晓对方是否已收到信件。也就是说信件是一种不可靠的传输方式,同样的,UDP所提供的也是一种不可靠的数据传输方式(以信件类比UDP只是通信形式上一致性,之前也以电话通信的方式类比了TCP的通信方式,而实际上从通信速度上来讲UDP通常是要快于TCP的;每次交换的数据量越大,TCP的传输速率就越接近于UDP)。因此,如果仅考虑可靠性,TCP显然由于UDP;但UDP在通信结构上较TCP更为简洁,通常性能也要优于TCP。

区分TCP和UDP最重要的标志是流控制,流控制赋予了TCP可靠性的特点,也说TCP的生命在于流控制。

UDP内部工作原理

与TCP不同,UDP不会进行流控制,其在数据通信中的作用如下图所示。可以看出,IP的作用就是让离开主机B的UDP数据包准确传递到主机A,而UDP则是把UDP包最终交给主机A的某一UDP套接字。UDP最重要的作用就是根据端口号将传输到主机的数据包交付给最终的UDP套接字。

 数据包传输过程UDP和IP的作用

UDP的高效使用

TCP用于对可靠性要求较高的场景,比如要传输一个重要文件或是压缩包,这种情况往往丢失一个数据包就会引起严重的问题;而对于多媒体数据来说,丢失一部分数据包并没有太大问题,因为实时性更为重要,速度就成为了重要考虑因素。TCP慢于UDP主要在于以下两点:

  • 收发数据前后进行的连接及清理过程
  • 收发数据过程中为保证可靠性而添加的流控制

因此,如果收发的数据量小但需要频繁的连接时,UDP比TCP更为高效。

基于UDP的服务器端/客户端

和TCP不同,UDP服务器端/客户端并不需要在连接状态下交换数据,UDP的通信只有创建套接字和数据交换的过程。TCP套接字是一对一的关系,且服务器端还需要一个额外的TCP套接字用于监听连接请求;而UDP通信中,无论服务器端还是客户端都只需要一个套接字即可,且可以实现一对多的通信关系。下图展示了一个UDP套接字与两台主机进行数据交换的过程。

 UDP套接字通信模型

基于UDP的数据I/O函数

TCP套接字建立连接之后,数据传输过程便无需额外添加地址信息,因为TCP套接字会保持与对端的连接状态;而UDP则没有这种连接状态,因此每次数据交换过程都需要添加目标地址信息。下面是UDP套接字数据传输函数,与TCP传输函数最大的区别在于,该函数需要额外添加传递目标的地址信息。

#include <sys/socket.h>

ssize_t sendto(int sock, void *buff, size_t nbytes, int flags, struct sockaddr *to, socklen_t addrlen);
    -> 成功时返回传输的字节数,失败时返回-1

由于UDP数据的发送端并不固定,因此,UDP套接字的数据接收函数定义了存储发送端地址信息的数据结构。

#include <sys/socket.h>

ssize_t recvfrom(int sock, void *buff, size_t nbytes, int flags, struct sockaddr *from, socklen_t addrlen);
    -> 成功时返回接收的字节数,失败时返回-1

基于UDP的回声服务器端/客户端

UDP通信函数调用流程

UDP不同于TCP,不存在请求连接和受理连接的过程,因此某种意义上并没有明确的服务器端和客户端之分。如下是示例源码。

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include <arpa/inet.h>
 6 #include <sys/socket.h>
 7 
 8 #define BUF_SIZE 30
 9 void error_handling(char *message);
10 
11 int main(int argc, char *argv[])
12 {
13     int serv_sock;
14     char message[BUF_SIZE];
15     int str_len;
16     socklen_t clnt_adr_sz;
17     
18     struct sockaddr_in serv_adr, clnt_adr;
19     if(argc!=2){
20         printf("Usage : %s <port>\n", argv[0]);
21         exit(1);
22     }
23     
24     serv_sock=socket(PF_INET, SOCK_DGRAM, 0);
25     if(serv_sock==-1)
26         error_handling("UDP socket creation error");
27     
28     memset(&serv_adr, 0, sizeof(serv_adr));
29     serv_adr.sin_family=AF_INET;
30     serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
31     serv_adr.sin_port=htons(atoi(argv[1]));
32     
33     if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
34         error_handling("bind() error");
35 
36     while(1) 
37     {
38         clnt_adr_sz=sizeof(clnt_adr);
39         str_len=recvfrom(serv_sock, message, BUF_SIZE, 0, 
40                                 (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
41         sendto(serv_sock, message, str_len, 0, 
42                                 (struct sockaddr*)&clnt_adr, clnt_adr_sz);
43     }    
44     close(serv_sock);
45     return 0;
46 }
47 
48 void error_handling(char *message)
49 {
50     fputs(message, stderr);
51     fputc(\'\n\', stderr);
52     exit(1);
53 }
uecho_server
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include <arpa/inet.h>
 6 #include <sys/socket.h>
 7 
 8 #define BUF_SIZE 30
 9 void error_handling(char *message);
10 
11 int main(int argc, char *argv[])
12 {
13     int sock;
14     char message[BUF_SIZE];
15     int str_len;
16     socklen_t adr_sz;
17     
18     struct sockaddr_in serv_adr, from_adr;
19     if(argc!=3){
20         printf("Usage : %s <IP> <port>\n", argv[0]);
21         exit(1);
22     }
23     
24     sock=socket(PF_INET, SOCK_DGRAM, 0);   
25     if(sock==-1)
26         error_handling("socket() error");
27     
28     memset(&serv_adr, 0, sizeof(serv_adr));
29     serv_adr.sin_family=AF_INET;
30     serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
31     serv_adr.sin_port=htons(atoi(argv[2]));
32     
33     while(1)
34     {
35         fputs("Insert message(q to quit): ", stdout);
36         fgets(message, sizeof(message), stdin);     
37         if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))    
38             break;
39         
40         sendto(sock, message, strlen(message), 0, 
41                     (struct sockaddr*)&serv_adr, sizeof(serv_adr));
42         adr_sz=sizeof(from_adr);
43         str_len=recvfrom(sock, message, BUF_SIZE, 0, 
44                     (struct sockaddr*)&from_adr, &adr_sz);
45 
46         message[str_len]=0;
47         printf("Message from server: %s", message);
48     }    
49     close(sock);
50     return 0;
51 }
52 
53 void error_handling(char *message)
54 {
55     fputs(message, stderr);
56     fputc(\'\n\', stderr);
57     exit(1);
58 }
uecho_client

示例代码运行结果

UDP客户端套接字的地址分配

从上述示例源码来看,服务器端UDP套接字需要手动bind地址信息,而客户端UDP套接字则无此过程。我们已经知道,客户端TCP套接字是在调用connect函数的时机,由操作系统为我们自动绑定了地址信息;而客户端UDP套接字同样存在该过程,如果没有手动bind地址信息,则在首次调用sendto函数时自动分配IP和端口号等地址信息。和TCP一样,IP是主机IP,端口号则随机分配(客户的临时端口是在第一次调用sendto 时一次性选定,不能改变;然而客户的IP地址却可以随客户发送的每个UDP数据报而变动(如果客户没有绑定一个具体的IP地址到其套接字上)。其原因在于如果客户主机是多宿的,客户有可能在两个目的地之间交替选择)。

UDP数据传输特性和connect函数调用

之前我们介绍了TCP传输数据不存在数据边界,下面将会验证UDP数据传输存在数据边界的特性,并介绍UDP传输调用connect函数的作用。

存在数据边界的UDP套接字

UDP协议具有数据边界,这就意味着数据交换的双方输入函数和输出函数必须一一对应,这样才能保证可完整接收数据。如下是验证UDP存在数据边界的示例源码。

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include <arpa/inet.h>
 6 #include <sys/socket.h>
 7 
 8 #define BUF_SIZE 30
 9 void error_handling(char *message);
10 
11 int main(int argc, char *argv[])
12 {
13     int sock;
14     char message[BUF_SIZE];
15     struct sockaddr_in my_adr, your_adr;
16     socklen_t adr_sz;
17     int str_len, i;
18 
19     if(argc!=2){
20         printf("Usage : %s <port>\n", argv[0]);
21         exit(1);
22     }
23     
24     sock=socket(PF_INET, SOCK_DGRAM, 0);
25     if(sock==-1)
26         error_handling("socket() error");
27     
28     memset(&my_adr, 0, sizeof(my_adr));
29     my_adr.sin_family=AF_INET;
30     my_adr.sin_addr.s_addr=htonl(INADDR_ANY);
31     my_adr.sin_port=htons(atoi(argv[1]));
32     
33     if(bind(sock, (struct sockaddr*)&my_adr, sizeof(my_adr))==-1)
34         error_handling("bind() error");
35     
36     for(i=0; i<3; i++)
37     {
38         sleep(5);    // delay 5 sec.
39         adr_sz=sizeof(your_adr);
40         str_len=recvfrom(sock, message, BUF_SIZE, 0, 
41                                 (struct sockaddr*)&your_adr, &adr_sz);     
42     
43         printf("Message %d: %s \n", i+1, message);
44     }
45     close(sock);    
46     return 0;
47 }
48 
49 void error_handling(char *message)
50 {
51     fputs(message, stderr);
52     fputc(\'\n\', stderr);
53     exit(1);
54 }
55 
56 /*
57 root@my_linux:/home/swyoon/tcpip# gcc bound_host1.c -o host1
58 root@my_linux:/home/swyoon/tcpip# ./host1 
59 Usage : ./host1 <port>
60 root@my_linux:/home/swyoon/tcpip# ./host1 9190
61 Message 1: Hi! 
62 Message 2: I\'m another UDP host! 
63 Message 3: Nice to meet you 
64 root@my_linux:/home/swyoon/tcpip# 
65 
66 */
bound_hostA
 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include <arpa/inet.h>
 6 #include <sys/socket.h>
 7 
 8 #define BUF_SIZE 30
 9 void error_handling(char *message);
10 
11 int main(int argc, char *argv[])
12 {
13     int sock;
14     char message[BUF_SIZE];
15     struct sockaddr_in my_adr, your_adr;
16     socklen_t adr_sz;
17     int str_len, i;
18 
19     if(argc!=2){
20         printf("Usage : %s <port>\n", argv[0]);
21         exit(1);
22     }
23     
24     sock=socket(PF_INET, SOCK_DGRAM, 0);
25     if(sock==-1)
26         error_handling("socket() error");
27     
28     memset(&my_adr, 0, sizeof(my_adr));
29     my_adr.sin_family=AF_INET;
30     my_adr.sin_addr.s_addr=htonl(INADDR_ANY);
31     my_adr.sin_port=htons(atoi(argv[1]));
32     
33     if(bind(sock, (struct sockaddr*)&my_adr, sizeof(my_adr))==-1)
34         error_handling("bind() error");
35     
36     for(i=0; i<3; i++)
37     {
38         sleep(5);    // delay 5 sec.
39         adr_sz=sizeof(your_adr);
40         str_len=recvfrom(sock, message, BUF_SIZE, 0, 
41                                 (struct sockaddr*)&your_adr, &adr_sz);     
42     
43         printf("Message %d: %s \n", i+1, message);
44     }
45     close(sock);    
46     return 0;
47 }
48 
49 void error_handling(char *message)
50 {
51     fputs(message, stderr);
52     fputc(\'\n\', stderr);
53     exit(1);
54 }
55 
56 /*
57 root@my_linux:/home/swyoon/tcpip# gcc bound_host1.c -o host1
58 root@my_linux:/home/swyoon/tcpip# ./host1 
59 Usage : ./host1 <port>
60 root@my_linux:/home/swyoon/tcpip# ./host1 9190
61 Message 1: Hi! 
62 Message 2: I\'m another UDP host! 
63 Message 3: Nice to meet you 
64 root@my_linux:/home/swyoon/tcpip# 
65 
66 */
bound_hostB

示例代码运行结果

调用connect函数的UDP套接字

TCP套接字需要手动注册传输数据的目标IP和端口号,而UDP则是调用sendto函数时自动完成目标地址信息的注册,该过程如下

  • 第一阶段:向UDP套接字注册目标IP和端口号
  • 第二阶段:传输数据
  • 第三阶段:删除UDP套接字中注册的目标地址信息

每次调用sendto函数都会重复执行以上过程,这也是为什么同一个UDP套接字可和不同目标进行数据交换的原因。像UDP这种未注册目标地址信息的套接字称为未连接套接字,而TCP这种注册了目标地址信息的套接字称为已连接connected套接字。当需要和同一目标主机进行长时间通信时,UDP的这种无连接的特点则会非常低效。通过调用connect函数使UDP变为已连接套接字则会有效改善这一点,因为上述的第一阶段和第三阶段会占用整个通信过程近1/3的时间。

已连接的UDP套接字不仅可以使用之前的sendto和recvfrom函数,还可以使用没有地址信息参数的write和read函数(需要注意的是,调用connect函数的已连接UDP套接字并非真的与目标UDP套接字建立连接,仅仅是向本端UDP套接字注册了目标IP和端口号信息而已)。修改之前的ucheo_client代码为已连接UDP套接字如下。

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include <arpa/inet.h>
 6 #include <sys/socket.h>
 7 
 8 #define BUF_SIZE 30
 9 void error_handling(char *message);
10 
11 int main(int argc, char *argv[])
12 {
13     int sock;
14     char message[BUF_SIZE];
15     int str_len;
16     socklen_t adr_sz;
17     
18     struct sockaddr_in serv_adr, from_adr;
19     if(argc!=3){
20         printf("Usage : %s <IP> <port>\n", argv[0]);
21         exit(1);
22     }
23     
24     sock=socket(PF_INET, SOCK_DGRAM, 0);   
25     if(sock==-1)
26         error_handling("socket() error");
27     
28     memset(&serv_adr, 0, sizeof(serv_adr));
29     serv_adr.sin_family=AF_INET;
30     serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
31     serv_adr.sin_port=htons(atoi(argv[2]));
32     
33     connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
34 
35     while(1)
36     {
37         fputs("Insert message(q to quit): ", stdout);
38         fgets(message, sizeof(message), stdin);     
39         if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))    
40             break;
41         /*
42         sendto(sock, message, strlen(message), 0, 
43                     (struct sockaddr*)&serv_adr, sizeof(serv_adr));
44         */
45         write(sock, message, strlen(message));
46 
47         /*
48         adr_sz=sizeof(from_adr);
49         str_len=recvfrom(sock, message, BUF_SIZE, 0, 
50                     (struct sockaddr*)&from_adr, &adr_sz);
51         */
52         str_len=read(sock, message, sizeof(message)-1);
53 
54         message[str_len]=0;
55         printf("Message from server: %s", message);
56     }    
57     close(sock);
58     return 0;
59 }
60 
61 void error_handling(char *message)
62 {
63     fputs(message, stderr);
64     fputc(\'\n\', stderr);
65     exit(1);
66 }
uecho_con_client

关于recvfrom函数的思考

recvfrom是一个阻塞函数,那么该函数的返回时机是怎样的?

显然如果客户端正常收到应答数据,recvfrom自然可以返回。但如果发生其他情况呢?

对端调用close函数关闭UDP套接字时是否会发送EOF信息,本端recvfrom函数又会有什么动作吗?是否会像TCP套接字的read函数那样收到EOF信息而返回0?

由于UDP套接字无连接的特性,即使对端调用close函数关闭套接字,本端也不会有任何感知,recvfrom自然不会返回。那如果是调用了connect函数的已连接UDP套接字呢,服务端的close函数调用是否会使客户端的recvfrom函数退出阻塞状态?

仍然不会。因为调用connect函数的已连接UDP套接字并非真的像TCP套接字那样建立了连接,仅仅是为了数据交换的便利性向本端UDP套接字注册了目标地址信息而已;而对端并不能感知到这些,close函数自然也不会向TCP那样向本端发送文件结束标志EOF。因此,正常情况下,只有接收到发送端消息的recvfrom函数才会退出阻塞状态而返回。

如果一个客户端数据报丢失(譬如说,被客户主机与服务主机之间的某个路由器丢弃),客户端将永远阻塞于recvfrom 调用,等待一个永远不会到达的服务器应答。类似地,如果客户端数据报到达服务器,但是服务器的应答丢失了,客户端也将永远阻塞于recvfrom 调用。防止这样永久阻塞的一般方法是给客户端的recvfrom 调用设置一个超时时间。

关于recvfrom函数和UDP协议的进一步内容可以参考《UNIX网络编程》等相关书籍。

分类:

技术点:

相关文章: