UDP 的服务端在 Linux 上只需要四个调用:socket、bind、recvfrom、sendto。客户端更少,连 bind 都不用写。调用少,但每个参数都有实际约束,错一处往往要等到换台机器才暴露。

socket 造壳子,bind 挂牌子

int socket(int domain, int type, int protocol);

socket 在进程里创建一个套接字,返回一个非负的文件描述符;Linux 里它和 open 返回的东西同类,可以放进 select/epoll,也受 RLIMIT_NOFILE 限制。IPv4 + UDP 的三个参数固定是 AF_INET、SOCK_DGRAM、0,失败返回 -1,errno 里是具体原因。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

bind 把"这个套接字监听哪个地址和端口"告诉内核。这一步之前,结构体只是进程栈上的一个普通变量,内核什么都不知道;bind 成功返回 0,失败返回 -1,常见的失败码是 EADDRINUSE(端口被占)和 EADDRNOTAVAIL(本机没有这个地址)。

IPv4 的地址用 sockaddr_in 填:

struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = INADDR_ANY;
 
int n = bind(fd, (struct sockaddr *)&local, sizeof(local));

三个字段里有两个必须转网络序,sin_family 不用。第三个参数写 sizeof(local),不要写 sizeof(struct sockaddr)。

INADDR_ANY 的值是 0,含义是"本机所有地址"。服务器有多块网卡、每块网卡有多个 IP 时,用它就不必关心数据是从哪块网卡进来的。云服务器上更要这么写:公网 IP 通常是运营商 NAT 映射的,网卡上根本没有这个地址,bind 一个具体公网 IP 通常会返回 EADDRNOTAVAIL。这也是课件强调"不推荐写明确 IP"的原因。

服务端必须显式 bind,因为端口得众所周知、每次启动都一样;不写的话内核会随便分配一个,客户端每次都要重新问端口。

客户端不写 bind,但端口并不是凭空来的:第一次 sendto 时,内核会给这个套接字自动绑定一个本地地址和一个临时端口。原因很实际——一个主机上可能同时跑很多客户端,若每个都显式绑 8888,第二个启动的就 EADDRINUSE 了。客户端当然也可以显式 bind,多网卡机器需要指定从哪块网卡发出时就得这么做。

顺带一个写法上的区别:服务端把 socket 和 bind 放进 Init(),而不是构造函数里。构造函数没有返回值,初始化失败只能抛异常或 exit;拆成 Init() 就能把 socket、bind 的错误码按类型返回或统一退出,Start() 只负责收发。

recvfrom 的五个参数,addrlen 是又进又出

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                 struct sockaddr *src_addr, socklen_t *addrlen);
  • buf、len:接收缓冲区及其大小。写 sizeof(buf) - 1 是留一个字节给结尾的 '\0',因为后面要按字符串打印。
  • flags:通常 0;MSG_DONTWAIT 可以改成非阻塞。
  • src_addr:输出参数,返回这个报文是谁发来的。
  • addrlen:指向 socklen_t 的指针,既是传入也是传出。调用前必须填成 sizeof(peer),告诉内核缓冲区有多大;返回时内核改成实际写入的长度。

最后这个参数是 value-result 的典型。每次调用前都要重新赋值,因为内核返回时可能已经把 len 改小了;IPv4 的地址结构固定 16 字节,看不出差别,换成 IPv6 或 UNIX Domain Socket 后,下一次传入的长度就可能偏小,拿到的地址会被截断。课件里把 len 放在循环内部初始化,是对的。

返回值是实际收到的字节数,失败返回 -1。有两处和 TCP 的直觉不同:

  • n == 0 不代表对端关闭。UDP 没有连接,一个长度为 0 的报文是合法的,recvfrom 返回 0。只有 TCP 的 read 返回 0 才表示对端发了 FIN。
  • UDP 保留报文边界:一次 sendto 对应一次 recvfrom,不会像 TCP 那样把两次发送粘在一起。缓冲区比报文小时,多出来的部分被丢掉,不会留到下一次读。

课件回显时写的是 sendto(fd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len)。这里 strlen 是隐患:报文里若含 '\0'(二进制数据、或客户端发了个空字节开头的内容),长度会被截短;正确的长度就是 recvfrom 返回的 n。回显一个刚收到的报文,原样把 n 个字节发回去即可。

sendto 的地址参数正好是 recvfrom 填好的 peer,addrlen 也用同一个 len。UDP 无连接,服务端不是"回复给已连接的客户端",而是"按这个报文里带的源地址发出去",所以每个报文都得单独给地址。

一个能跑的回显服务端和客户端

/* udp_echo_server.c: gcc udp_echo_server.c -o udp_echo_server */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
 
#define BUF_SIZE 1024
 
int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s port\n", argv[0]);
        return 1;
    }
    uint16_t port = (uint16_t)strtoul(argv[1], NULL, 10);
 
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) {
        perror("socket");
        return 1;
    }
 
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = INADDR_ANY;
 
    if (bind(fd, (struct sockaddr *)&local, sizeof(local)) < 0) {
        perror("bind");
        close(fd);
        return 1;
    }
    printf("udp echo server on port %u\n", (unsigned)port);
 
    for (;;) {
        char buf[BUF_SIZE];
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
 
        ssize_t n = recvfrom(fd, buf, sizeof(buf) - 1, 0,
                             (struct sockaddr *)&peer, &len);
        if (n < 0) {
            if (errno == EINTR)
                continue;
            perror("recvfrom");
            break;
        }
        buf[n] = '\0';
 
        char ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip));
        printf("[%s:%u]# %s\n", ip, (unsigned)ntohs(peer.sin_port), buf);
 
        if (sendto(fd, buf, (size_t)n, 0,
                   (struct sockaddr *)&peer, len) < 0) {
            perror("sendto");
            break;
        }
    }
 
    close(fd);
    return 0;
}

客户端只做两件事:填好服务端地址,发一条读一条。

/* udp_echo_client.c: gcc udp_echo_client.c -o udp_echo_client */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
 
int main(int argc, char *argv[])
{
    if (argc != 3) {
        fprintf(stderr, "usage: %s server_ip server_port\n", argv[0]);
        return 1;
    }
 
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons((uint16_t)strtoul(argv[2], NULL, 10));
    if (inet_pton(AF_INET, argv[1], &server.sin_addr) != 1) {
        fprintf(stderr, "bad ip: %s\n", argv[1]);
        return 1;
    }
 
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) {
        perror("socket");
        return 1;
    }
 
    char line[1024];
    while (fgets(line, sizeof(line), stdin)) {
        size_t n = strlen(line);
        if (n > 0 && line[n - 1] == '\n')
            line[--n] = '\0';
        if (n == 0)
            continue;
 
        if (sendto(fd, line, n, 0,
                   (struct sockaddr *)&server, sizeof(server)) < 0) {
            perror("sendto");
            break;
        }
 
        char buf[1024];
        struct sockaddr_in from;
        socklen_t fromlen = sizeof(from);
        ssize_t m = recvfrom(fd, buf, sizeof(buf) - 1, 0,
                             (struct sockaddr *)&from, &fromlen);
        if (m < 0) {
            perror("recvfrom");
            break;
        }
        buf[m] = '\0';
        printf("echo: %s\n", buf);
    }
 
    close(fd);
    return 0;
}

编译两个文件,先起服务端再起客户端。在服务端机器上用 ss -uanp 能看到服务端占着 0.0.0.0:8888;客户端第一次发送之前查它是 0.0.0.0:0,发完再查就有了一个落在临时端口区间里的源端口。

把业务从网络循环里摘出去

回显服务端把"处理"写死成了原样返回。换成查字典时,网络层不该知道词典怎么查。课件的做法是给服务器一个回调:

using func_t = std::function<void(const std::string &req, std::string *resp)>;

Start() 里收到数据后调 _func(buffer, &value),再把 value 发回去。用输出参数而不是返回值,是为了让"处理成功/失败"和"结果内容"分开:函数可以只负责填结果,调用方永远有一个确定的 resp 变量可用。

词典部分是一个很直接的容器封装:构造时用 std::ifstream 打开文件,getline 逐行读,按 ": " 切开,前半做键、后半做值,塞进 std::unordered_map。查不到就返回 "Unknown"。三处细节容易出错:

  • 文件打不开只打印一行就返回,后续查询全部走 "Unknown",不会崩,但问题会被藏起来;
  • unordered_map::insert 遇到重复键不会覆盖,词典里有重复词条时保留的是先到的那条;
  • 每行都要判断空行和分隔符是否存在,否则 substr 的偏移会算错。

课件 main 里还留了一段注释掉的 lambda 写法:

// std::make_unique<UdpServer>(port, [&gdict](const std::string &message)->std::string {
//     return gdict.Translate(message);
// });

这段和当前类对不上:构造函数参数顺序是 (func, port),lambda 的签名也应是 void(const std::string &, std::string *)。它是从别的版本留下来的旧写法,照抄编译不过。

封装版把 socket/bind/recvfrom/sendto 收进一个 UdpSocket 类,UdpServer::Start(ip, port, handler) 里只剩"读—算—写"三步。服务端对象还继承了一个 nocopy 基类,把拷贝构造和赋值运算符都 delete 掉:套接字 fd 是独占资源,对象一旦被复制,两个实例析构时会对同一个 fd 调两次 close,第二次要么关掉别人的 fd,要么报 EBADF。

读的时候有个小毛病:Bind 和 SendTo 里的 sockaddr_in 都是局部变量且没有清零,sin_zero 是随机值。内核不解释这 8 个填充字节,所以功能上不报错,但按惯例应该 memset 一遍,避免以后换实现踩坑。另外 Start 的 for (;;) 后面跟着 sock_.Close(),那行永远执行不到,是循环写死后的死代码。

inet_ntoa 背后只有一块静态缓冲区

字符串和 in_addr 之间有两代转换函数:

方向老接口新接口
字符串 → 二进制inet_aton、inet_addrinet_pton
二进制 → 字符串inet_ntoainet_ntop

inet_pton/inet_ntop 的 p 是 presentation、n 是 network,参数用 void *,同时支持 IPv4 的 in_addr 和 IPv6 的 in6_addr。

老接口里 inet_addr 有个绕不开的坑:失败时返回 INADDR_NONE,而 255.255.255.255 转换出来也是这个值,调用方没法区分"写错了"和"这就是那个广播地址"。inet_pton 用返回值区分:1 成功、0 字符串不合法、-1 系统错误。

inet_ntoa 的问题更隐蔽。它返回的 char * 指向函数内部的一块静态存储区,调用方不需要释放,但下一次调用会覆盖上一次的结果。课件演示的这段代码能直接把现象打出来:

图注:两次 inet_ntoa 的结果先各自存进 ptr1、ptr2,再一起打印——两个指针指向同一块静态缓冲区,所以输出的是同一个(后一次)地址

ptr1、ptr2 都是 char *,第二次调用把第一块内容覆盖了,两个指针看到的是同一个字符串。如果把两次调用直接写在 printf 的两个参数里,结果还取决于编译器对实参的求值顺序,更不可靠。APUE 明确写了 inet_ntoa 不是线程安全的;glibc 的手册页把它标为 MT-Unsafe。多线程环境一律用 inet_ntop,缓冲区由调用者提供:

char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &addr.sin_addr, ip, sizeof(ip));

顺带看一个字节序的直观例子。inet_aton("127.0.0.1") 之后把 sin_addr 当 32 位整数打印,得到的是 0x100007f:

图注:这段程序用 inet_aton 填入 127.0.0.1,再把 sin_addr 强转成 uint32_t 打印;输出 0x100007f 说明内存里存的是网络序字节 7f 00 00 01,小端机按主机整数读出来正好反了

127.0.0.1 的网络序值是 0x7F000001,按大端字节写进内存是 7f 00 00 01;x86 按小端读这 4 个字节,得到 0x0100007f。所以 sin_addr 打印出来"不是你以为的那个数",恰恰说明它已经是网络序,不需要再转。

聊天室:一个套接字被两个线程同时读写

UDP 是全双工的,同一个 sockfd 既可以读也可以写,两个方向互不阻塞。客户端因此可以开两个线程:一个阻塞在 recvfrom 等别人说话,一个阻塞在 getline 等用户输入,收到就打印、输入就发送。两边都阻塞在同一个 fd 上也不会串,因为读写走的是两个不同的方向。

课件的客户端把收到的消息打到 stderr,测试时可以用命名管道把 2> 重定向到另一个终端;输入留在一个窗口,收到的消息出现在另一个窗口,读起来不会互相插队。

图注:左边客户端有读线程和写线程共用同一个 sockfd;右边服务端的 udpserver 把收到的消息推给线程池,由线程池里的线程做路由转发,再按在线列表逐个人 sendto

服务端不需要为每个客户端建连接,它只维护一份"在线用户"列表:

  • 每个报文都带着源地址,第一次见到某个 {ip, port} 就算上线,加进 vector<InetAddr>;
  • 转发时遍历列表,对每个用户 sendto 一次,内容前面拼上发送者的 ip:port;
  • 收到 QUIT 就从列表里删掉。

InetAddr 把 sockaddr_in 包一层,构造时顺手用 ntohs 还原端口、inet_ntoa 还原 IP,再重载 operator== 比较 ip + port,这样"是不是同一个用户"就有统一判断。

两点在课件里没有展开,但实际写起来绕不过去:

第一,_online_user 会被多个线程同时读写。课件用的是线程池,MessageRoute 在池里的线程执行,一个线程在遍历列表 sendto,另一个线程可能正在 AddUser 或 DeleteUser——vector 的迭代器会失效。要么加锁,要么把路由收敛到单线程。

第二,std::bind(&Route::MessageRoute, r.get(), sockfd, message, peer) 把参数按值复制进任务对象,message 和 peer 因此不会悬空;但 sockfd 只是个整数,任务真正执行时对应的套接字必须还活着。UDP 服务端的监听 fd 通常活到进程结束,所以这里侥幸成立,换成 TCP 的连接 fd 就得另想办法。

UDP 的"不可靠"也体现在这里:广播时某个用户丢了一个包,服务端不知道,也不会重发;客户端发出的 QUIT 丢了,那个人就一直留在列表里。这些都要业务层自己补,协议层不提供。