Linux Netlink Socket 原理与实战：全面对比 TCP 通信

参数解读：

• AF_NETLINK：地址族，告诉内核这是 Netlink 通信
• SOCK_RAW：Netlink 只有这种类型（或者 SOCK_DGRAM，效果相同）
• NETLINK_ROUTE：我们要与内核的路由子系统对话

步骤 2：Bind（绑定本地地址）

这一步可能让你困惑：本机通信为什么还要 bind？因为 Netlink 需要给每个 socket 一个唯一的'地址'，这样内核才能把消息正确地投递给你。

struct sockaddr_nl local_addr;
memset(&local_addr, 0, sizeof(local_addr));
local_addr.nl_family = AF_NETLINK;
local_addr.nl_pid = getpid(); // 用自己的 PID 作为唯一标识
local_addr.nl_groups = 0; // 不加入多播组

if (bind(sock_fd, (struct sockaddr*)&local_addr, sizeof(local_addr)) < 0) {
    perror("bind");
    close(sock_fd);
    return -1;
}

关键点：

• nl_pid：不一定是进程 PID，但必须是唯一的 32 位整数。通常单线程程序用 getpid() 就足够了；如果同一进程有多个 Netlink socket，可以用 pthread_self() << 16 | getpid() 生成
• nl_groups：如果想接收多播消息（比如路由变化事件），设置对应的位掩码；否则填 0

步骤 3：构造 Netlink 消息

Netlink 消息有固定的格式，每个消息都必须包含一个头部（struct nlmsghdr）：

struct nlmsghdr {
    __u32 nlmsg_len;      /* 消息总长度（包括头部） */
    __u16 nlmsg_type;     /* 消息类型（自定义或标准类型） */
    __u16 nlmsg_flags;    /* 标志（如 NLM_F_REQUEST 表示请求） */
    __u32 nlmsg_seq;      /* 序列号（用于匹配请求和响应） */
    __u32 nlmsg_pid;      /* 发送方端口 ID（我们 bind 时设的 pid） */
};

构造消息的代码示例：

#define MAX_PAYLOAD 1024
char buffer[NLMSG_SPACE(MAX_PAYLOAD)];
struct nlmsghdr* nlh = (struct nlmsghdr*)buffer;
nlh->nlmsg_len = NLMSG_LENGTH(MAX_PAYLOAD);
nlh->nlmsg_type = 1; // 自定义消息类型
nlh->nlmsg_flags = NLM_F_REQUEST; // 这是一个请求
nlh->nlmsg_seq = 1; // 序列号
nlh->nlmsg_pid = getpid(); // 发送方 PID

// 填充负载数据
char* payload = NLMSG_DATA(nlh);
strcpy(payload, "Hello Kernel!");

这里有几个宏需要理解：

• NLMSG_SPACE(len)：计算给定负载长度所需的缓冲区总大小（包括对齐）
• NLMSG_LENGTH(len)：计算消息总长度（不包括对齐填充）
• NLMSG_DATA(nlh)：获取负载部分的指针

步骤 4：指定目标地址并发送

我们要发给内核，所以目标地址的 nl_pid 设为 0（内核的'端口号'）：

struct sockaddr_nl kernel_addr;
memset(&kernel_addr, 0, sizeof(kernel_addr));
kernel_addr.nl_family = AF_NETLINK;
kernel_addr.nl_pid = 0; // 发给内核
kernel_addr.nl_groups = 0;

struct iovec iov;
iov.iov_base = (void*)nlh;
iov.iov_len = nlh->nlmsg_len;

struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void*)&kernel_addr;
msg.msg_namelen = sizeof(kernel_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;

int ret = sendmsg(sock_fd, &msg, 0);
if (ret < 0) {
    perror("sendmsg");
}

这里使用 sendmsg 而不是 sendto，因为 Netlink 消息需要同时传递目标地址和消息体（通过 iovec 结构）。

步骤 5：接收回复

发送请求后，内核会回复一个或多个消息。需要循环接收直到收到结束标记：

char recv_buf[8192];
struct sockaddr_nl src_addr;
socklen_t addr_len = sizeof(src_addr);

int len = recvfrom(sock_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr*)&src_addr, &addr_len);
struct nlmsghdr* nlh_reply = (struct nlmsghdr*)recv_buf;

while (NLMSG_OK(nlh_reply, len)) {
    if (nlh_reply->nlmsg_type == NLMSG_DONE) {
        break; // 多部分消息结束
    }
    if (nlh_reply->nlmsg_type == NLMSG_ERROR) {
        struct nlmsgerr* err = (struct nlmsgerr*)NLMSG_DATA(nlh_reply);
        printf("错误码：%d\n", err->error);
        break;
    }
    // 处理数据...
    printf("收到回复：%s\n", (char*)NLMSG_DATA(nlh_reply));
    nlh_reply = NLMSG_NEXT(nlh_reply, len);
}

宏 NLMSG_OK 用于遍历可能的多条消息，它会检查消息长度和对齐。

完整示例：获取路由表信息

下面是一个完整的例子，用 Netlink 获取系统的路由表信息：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>

int main() {
    int sock_fd;
    struct sockaddr_nl local_addr, kernel_addr;
    struct nlmsghdr* nlh;
    struct msghdr msg;
    struct iovec iov;
    char buf[8192];

    // 创建 socket
    sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

    // bind 本地地址
    memset(&local_addr, 0, sizeof(local_addr));
    local_addr.nl_family = AF_NETLINK;
    local_addr.nl_pid = getpid();
    bind(sock_fd, (struct sockaddr*)&local_addr, sizeof(local_addr));

    // 构造请求消息（获取路由表）
    nlh = (struct nlmsghdr*)buf;
    nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
    nlh->nlmsg_type = RTM_GETROUTE; // 获取路由表
    nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
    nlh->nlmsg_seq = 1;
    nlh->nlmsg_pid = getpid();

    // 设置目标地址（内核）
    memset(&kernel_addr, 0, sizeof(kernel_addr));
    kernel_addr.nl_family = AF_NETLINK;
    kernel_addr.nl_pid = 0;

    // 发送
    iov.iov_base = (void*)nlh;
    iov.iov_len = nlh->nlmsg_len;
    memset(&msg, 0, sizeof(msg));
    msg.msg_name = (void*)&kernel_addr;
    msg.msg_namelen = sizeof(kernel_addr);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;
    sendmsg(sock_fd, &msg, 0);

    // 接收回复
    int len;
    while ((len = recv(sock_fd, buf, sizeof(buf), 0)) > 0) {
        struct nlmsghdr* nlp = (struct nlmsghdr*)buf;
        for (; NLMSG_OK(nlp, len); nlp = NLMSG_NEXT(nlp, len)) {
            if (nlp->nlmsg_type == NLMSG_DONE) {
                goto done;
            }
            if (nlp->nlmsg_type == RTM_NEWROUTE) {
                printf("收到一条路由条目\n");
                // 这里可以解析具体的路由信息
            }
        }
    }

done:
    close(sock_fd);
    return 0;
}

三、Netlink vs TCP：殊途不同归

现在我们把 Netlink 和我们最熟悉的 TCP socket 放在一起比较。虽然它们都用 socket API，但设计哲学完全不同。

对比表格

核心差异详解

1. 通信对象和范围

TCP 设计的初衷是跨越网络边界，让不同机器上的进程可以通信。它要处理复杂的网络环境：丢包、乱序、拥塞、MTU 分片等等。

Netlink 则完全不需要操心这些——它的通信范围仅限于本机。消息从用户态进程发出，直接进入内核的消息队列，没有网络层的参与。

2. 协议栈的差异

当你用 TCP 发送 'Hello'：

用户程序 → socket 缓冲区 → TCP 层（加 TCP 头）→ IP 层（加 IP 头）→ 链路层（加 MAC 头）→ 网卡 → 网络 

这一路下来，数据被层层封装，经历多次拷贝和校验。

而 Netlink 的路径简单得多：

用户程序 → 构造 Netlink 消息 → socket 缓冲区 → 内核 Netlink 核心 → 目标内核模块 

没有协议头的层层封装，没有网卡的参与，效率自然更高。

3. 连接的语义

TCP 是面向连接的。在通信之前，必须通过三次握手建立连接，通信结束后还要四次挥手断开连接。连接是 TCP 可靠性的基础。

Netlink 是无连接的。你随时可以发送消息给内核（nl_pid=0）或其他进程，不需要事先建立连接。当然，如果你只想和一个对端通信，可以用 connect() 绑定默认地址，之后直接用 send() 而不用每次都指定目标。

4. 谁可以主动发起通信？

这是 Netlink 最革命性的设计。

在 TCP 世界里，服务器可以被动接受连接，但主动发起数据推送的永远是客户端（除非客户端先请求）。但在系统管理场景中，内核经常需要主动通知用户程序：网线掉了、新设备插入了、路由变了…

Netlink 完美解决了这个问题：内核可以在任何时间向绑定了特定多播组的用户程序发送消息。这就是所谓的全双工通信——双方都可以随时发起对话。

5. 消息边界 vs 字节流

TCP 是字节流协议，它不保留消息边界。如果你连续发送两个 'hello'，接收方可能一次收到 'hellohello'，也可能分多次收到。应用层需要自己设计消息边界（如加长度头、特殊分隔符）。

Netlink 是消息协议，每条 sendmsg 发送的数据对应一个完整的 Netlink 消息，接收方 recvmsg 一次正好拿到一条消息（如果缓冲区够大）。这对应用层开发来说省心不少。

四、什么时候用 Netlink，什么时候用 TCP？

用 Netlink 的场景

1. 网络配置管理：你想实现一个类似 ip 命令的工具，修改 IP 地址、路由表
2. 监控网络事件：监听网卡状态变化、路由更新
3. 与内核模块通信：你写了一个内核模块，需要和用户态程序交换数据
4. 获取系统信息：获取链路状态、ARP 表、邻居信息等
5. 设备热插拔监控：监听 USB、SD 卡等设备的插拔事件

用 TCP 的场景

1. Web 服务器/客户端：HTTP 协议基于 TCP
2. 数据库连接：MySQL、PostgreSQL 都使用 TCP
3. 远程登录：SSH、Telnet
4. 文件传输：FTP、SCP
5. 任何需要跨机器通信的场景

五、总结：殊途同归的 socket API

Netlink 和 TCP 共用同一套 socket API，这是 Linux 设计哲学的美妙之处——统一的接口，多样的实现。

• 创建：都是 socket()，只是参数不同
• 绑定：都是 bind()，只是地址结构不同
• 发送：都是 sendmsg()/sendto()，只是目标地址含义不同
• 接收：都是 recvmsg()/recvfrom()

但背后的机制天差地别：

• TCP 是网络通信协议，用于跨机器
• Netlink 是内核 IPC 机制，用于本机内核 - 用户通信