我们也可以给 UDP 找一个类似的例子，这个例子就是邮寄明信片。

UDP 编程

image.png

recvfrom 和 sendto 是 UDP 用来接收和发送报文的两个主要函数：

  1. #include <sys/socket.h>
  3. ssize_t recvfrom(int sockfd, void *buff, size_t nbytes, int flags, 
  4. 　　　　　　　　　　struct sockaddr *from, socklen_t *addrlen); 
  6. ssize_t sendto(int sockfd, const void *buff, size_t nbytes, int flags,
  7.                 const struct sockaddr *to, socklen_t addrlen);

recvfrom:

  • flags: I/O 相关参数, 暂时用不到, 设置为0
  • TCP 是通过 accept 函数拿到的描述字信息来决定对端的信息
  • UDP 报文每次接收都会获取对端的信息，也就是说报文和报文之间是没有上下文的

sendto:

UDP 服务端例子

#include "lib/common.h"

static int count;

static void recvfrom_int(int signo) {
    printf("\nreceived %d datagrams\n", count);
    exit(0);
}


int main(int argc, char **argv) {
    int socket_fd;
    socket_fd = socket(AF_INET, SOCK_DGRAM, 0);

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERV_PORT);

    bind(socket_fd, (struct sockaddr *) &server_addr, sizeof(server_addr));

    socklen_t client_len;
    char message[MAXLINE]; // MAXLINE 没有+1
    count = 0;

    signal(SIGINT, recvfrom_int);

    struct sockaddr_in client_addr;
    client_len = sizeof(client_addr);
    for (;;) {
        int n = recvfrom(socket_fd, message, MAXLINE, 0, (struct sockaddr *) &client_addr, &client_len);
        message[n] = 0;
        printf("received %d bytes: %s\n", n, message);

        char send_line[MAXLINE];
        sprintf(send_line, "Hi, %s", message);

        sendto(socket_fd, send_line, strlen(send_line), 0, (struct sockaddr *) &client_addr, client_len);

        count++;
    }

}

UDP 客户端例子

从标准输入中读取输入的字符串后，发送给服务端，并且把服务端经过处理的报文打印到标准输出上。

#include "lib/common.h"

# define    MAXLINE     4096

int main(int argc, char **argv) {
    if (argc != 2) {
        error(1, 0, "usage: udpclient <IPaddress>");
    }

    int socket_fd;
    socket_fd = socket(AF_INET, SOCK_DGRAM, 0);

    struct sockaddr_in server_addr;
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET, argv[1], &server_addr.sin_addr);

    socklen_t server_len = sizeof(server_addr);

    struct sockaddr *reply_addr;
    reply_addr = malloc(server_len);

    char send_line[MAXLINE], recv_line[MAXLINE + 1];
    socklen_t len;
    int n;

    while (fgets(send_line, MAXLINE, stdin) != NULL) {
        int i = strlen(send_line);
        if (send_line[i - 1] == '\n') {
            send_line[i - 1] = 0;
        }

        printf("now sending %s\n", send_line);
        size_t rt = sendto(socket_fd, send_line, strlen(send_line), 0, (struct sockaddr *) &server_addr, server_len);
        if (rt < 0) {
            error(1, errno, "send failed ");
        }
        printf("send bytes: %zu \n", rt);

        len = 0;
        n = recvfrom(socket_fd, recv_line, MAXLINE, 0, reply_addr, &len);
        if (n < 0)
            error(1, errno, "recvfrom failed");
        recv_line[n] = 0;
        fputs(recv_line, stdout);
        fputs("\n", stdout);
    }

    exit(0);
}

场景一：只运行客户端

如果我们只运行客户端，程序会一直阻塞在 recvfrom 上。

$ ./udpclient 127.0.0.1
1 # 估计是原文错误
now sending g1
send bytes: 2
<阻塞在这里>

TCP 客户端的 connect 函数会直接返回“Connection refused”报错信息

场景二：先开启服务端，再开启客户端

# 1. 开启服务端
$./udpserver
received 2 bytes: g1
received 2 bytes: g2

# 2. 开启客户端
$./udpclient 127.0.0.1
g1
now sending g1
send bytes: 2
Hi, g1
g2
now sending g2
send bytes: 2
Hi, g2

场景三: 开启服务端，再一次开启两个客户端

在服务端开启之后，依次开启两个客户端，并发送报文

# 1. 服务端
$./udpserver
received 2 bytes: g1
received 2 bytes: g2
received 2 bytes: g3
received 2 bytes: g4

# 2. 第一个客户端
$./udpclient 127.0.0.1
now sending g1
send bytes: 2
Hi, g1
g3
now sending g3
send bytes: 2
Hi, g3

# 3. 第二个客户端
$./udpclient 127.0.0.1
now sending g2
send bytes: 2
Hi, g2
g4
now sending g4
send bytes: 2
Hi, g4

如果我们此时把服务器端进程杀死，就可以看到信号函数在进程退出之前，打印出服务器端接收到的报文个数。

$ ./udpserver
received 2 bytes: g1
received 2 bytes: g2
received 2 bytes: g3
received 2 bytes: g4
^C
received 4 datagrams

之后，我们再重启服务器端进程，并使用客户端 1 和客户端 2 继续发送新的报文，我们可以看到和 TCP 非常不同的结果。
**

# 1. 服务端
$ ./udpserver
received 2 bytes: g1
received 2 bytes: g2
received 2 bytes: g3
received 2 bytes: g4
^C
received 4 datagrams
$ ./udpserver
received 2 bytes: g5
received 2 bytes: g6

# 2. 第一个客户端

$./udpclient 127.0.0.1
now sending g1
send bytes: 2
Hi, g1
g3
now sending g3
send bytes: 2
Hi, g3
g5
now sending g5
send bytes: 2
Hi, g5

# 3. 第二个客户端
$./udpclient 127.0.0.1
now sending g2
send bytes: 2
Hi, g2
g4
now sending g4
send bytes: 2
Hi, g4
g6
now sending g6
send bytes: 2
Hi, g6

TCP 断联之后必须重新连接才可以发送报文信息。但是 UDP 报文的“无连接”的特点，可以在 UDP 服务器重启之后，继续进行报文的发送，这就是 UDP 报文“无上下文”的最好说明。

总结

  • UDP 是无连接的数据报程序，和 TCP 不同，不需要三次握手建立一条连接。
  • UDP 程序通过 recvfrom 和 sendto 函数直接收发数据报报文。

精选留言

许童童

第一个场景中，可以添加超时时间做处理，当然你也可以自己实现一个复杂的请求-确认模式，那这样就跟TCP类似了，HTTP/3就是这样做的。

用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) - UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。
由于IP有最大MTU，因此，
UDP 包的大小应该是 1500 - IP头(20) - UDP头(8) = 1472(Bytes)
TCP 包的大小应该是 1500 - IP头(20) - TCP头(20) = 1460 (Bytes)

何赫赫

老师，UDP没有发送缓冲区这个概念吗

作者回复: 实际上不存在UDP发送缓冲区，因为发往UDP发送缓冲区的包只要超过一定阈值(值很小)就可以发往对端。所以我们一般认为UDP是没有发送缓冲区的。