C++ `netlink` 套接字：与 Linux 内核进行通信

哈喽，各位好！今天咱们来聊聊 C++ 里的 netlink 套接字，这家伙可是个神奇的存在，能让你的程序直接跟 Linux 内核“唠嗑”。想象一下，你写了个程序，想知道当前系统的网络接口状态，或者想配置一下防火墙规则，用 netlink 就方便多了。

什么是 Netlink？

简单来说，netlink 是一种特殊的套接字，它允许用户空间的进程和 Linux 内核之间进行双向通信。你可以把它想象成一个“管道”，一头连着你的 C++ 程序，另一头连着内核。内核可以通过这个管道主动向你发送消息，你的程序也可以通过它向内核请求信息或者执行操作。

为啥要用 Netlink？

相比于其他内核通信方式（比如 ioctl），netlink 有不少优点：

异步通信: 你可以发送一个请求，然后继续做其他事情，内核会在准备好响应后通知你。
多播支持: 内核可以向多个用户空间的进程发送相同的消息，这对于需要实时监控系统状态的程序非常有用。
标准化: netlink 有一套标准的协议和接口，使得不同模块之间的通信更加容易。
类型安全: netlink 使用属性来传递数据，可以避免一些类型转换的错误。

Netlink 的基本概念

在深入代码之前，我们需要了解几个关键的概念：

Netlink 协议族 (Family): netlink 支持多个协议族，每个协议族负责处理一类特定的消息。比如 NETLINK_ROUTE 用于路由和链路信息，NETLINK_FIREWALL 用于防火墙管理。
Netlink 消息: netlink 消息是用户空间和内核之间传递的数据单元。一个消息包含消息头和消息体。
消息头 (nlmsghdr): nlmsghdr 结构体定义了消息的基本信息，包括消息类型、长度、标志等。
消息类型 (nlmsg_type): nlmsg_type 指定了消息的含义，比如请求信息、响应信息、错误信息等。不同的协议族定义了不同的消息类型。
消息标志 (nlmsg_flags): nlmsg_flags 用于控制消息的处理方式，比如是否需要内核回复、是否是多播消息等。
Netlink 属性 (Attribute): netlink 属性是消息体中的数据单元，它使用 nlattr 结构体来表示。属性包含属性类型和属性值。
属性类型 (nla_type): nla_type 指定了属性的含义，比如接口索引、接口名称、IP 地址等。不同的协议族定义了不同的属性类型。
属性值 (nla_value): nla_value 是属性的实际数据。

C++ 代码示例：获取网络接口信息

咱们来写一个简单的 C++ 程序，使用 netlink 获取系统的网络接口信息。我们将使用 NETLINK_ROUTE 协议族，以及 RTM_GETLINK 消息类型来请求接口信息。

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <net/if.h> // 包含 if_indextoname 函数
#include <arpa/inet.h> // 包含 inet_ntop 函数

#define BUFSIZE 8192

int main() {
    // 1. 创建 Netlink 套接字
    int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sock < 0) {
        perror("socket");
        return 1;
    }

    // 2. 绑定套接字到 Netlink 地址
    sockaddr_nl addr;
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid(); // 使用进程 ID 作为 Netlink ID
    addr.nl_groups = 0;      // 不加入任何多播组

    if (bind(sock, (sockaddr*)&addr, sizeof(addr)) < 0) {
        perror("bind");
        close(sock);
        return 1;
    }

    // 3. 构造 Netlink 消息
    char buf[BUFSIZE];
    memset(buf, 0, BUFSIZE);

    nlmsghdr* nlhdr = (nlmsghdr*)buf;
    nlhdr->nlmsg_len = NLMSG_LENGTH(sizeof(ifinfomsg)); // 消息总长度，包含消息头和 ifinfomsg
    nlhdr->nlmsg_type = RTM_GETLINK;                     // 请求获取链路信息
    nlhdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;        // 请求消息，需要内核回复，获取所有接口信息
    nlhdr->nlmsg_seq = 1;                                // 序列号，用于匹配请求和响应
    nlhdr->nlmsg_pid = getpid();                           // 进程 ID

    ifinfomsg* ifinfo = (ifinfomsg*)NLMSG_DATA(nlhdr);
    ifinfo->ifi_family = AF_UNSPEC; // 获取所有地址族的接口信息

    // 4. 发送 Netlink 消息
    ssize_t bytes_sent = send(sock, buf, nlhdr->nlmsg_len, 0);
    if (bytes_sent < 0) {
        perror("send");
        close(sock);
        return 1;
    }

    // 5. 接收 Netlink 消息
    memset(buf, 0, BUFSIZE);
    ssize_t bytes_received;

    while ((bytes_received = recv(sock, buf, BUFSIZE, 0)) > 0) {
        nlmsghdr* nlhdr_recv = (nlmsghdr*)buf;

        for (; NLMSG_OK(nlhdr_recv, bytes_received); nlhdr_recv = NLMSG_NEXT(nlhdr_recv, bytes_received)) {
            // 检查消息是否完成
            if (nlhdr_recv->nlmsg_type == NLMSG_DONE) {
                std::cout << "接收完成" << std::endl;
                goto cleanup; // 结束接收循环
            }

            // 检查消息是否是错误
            if (nlhdr_recv->nlmsg_type == NLMSG_ERROR) {
                nlmsgerr* err = (nlmsgerr*)NLMSG_DATA(nlhdr_recv);
                std::cerr << "Netlink 错误: " << -err->error << std::endl;
                goto cleanup;
            }

            // 处理 RTM_NEWLINK 消息 (表示一个新的网络接口)
            if (nlhdr_recv->nlmsg_type == RTM_NEWLINK) {
                ifinfomsg* ifi = (ifinfomsg*)NLMSG_DATA(nlhdr_recv);
                int len = nlhdr_recv->nlmsg_len;
                nlattr* attr = (nlattr*)((char*)ifi + sizeof(ifinfomsg));
                int rta_len = IFLA_PAYLOAD(nlhdr_recv);
                char ifname[IF_NAMESIZE]; // 存储接口名称

                std::cout << "Interface Index: " << ifi->ifi_index << std::endl;
                std::cout << "Interface Flags: 0x" << std::hex << ifi->ifi_flags << std::dec << std::endl;
                // 遍历属性
                while (NLA_OK(attr, rta_len)) {
                    switch (attr->nla_type) {
                        case IFLA_IFNAME:
                            strncpy(ifname, (char*)NLA_DATA(attr), IF_NAMESIZE - 1);
                            ifname[IF_NAMESIZE - 1] = ''; // 确保字符串以 null 结尾
                            std::cout << "Interface Name: " << ifname << std::endl;
                            break;

                        case IFLA_ADDRESS: {
                            // 接口的 MAC 地址
                            unsigned char* mac_address = (unsigned char*)NLA_DATA(attr);
                            std::cout << "MAC Address: ";
                            for (int i = 0; i < attr->nla_len - NLA_HDRLEN; ++i) {
                                std::cout << std::hex << std::setw(2) << std::setfill('0') << (int)mac_address[i];
                                if (i < attr->nla_len - NLA_HDRLEN - 1) {
                                    std::cout << ":";
                                }
                            }
                            std::cout << std::dec << std::endl;
                            break;
                        }
                        case IFLA_STATS64: {
                            // 接口统计信息 (64 位)
                            rtnl_link_stats64* stats = (rtnl_link_stats64*)NLA_DATA(attr);
                            std::cout << "  RX Packets: " << stats->rx_packets << std::endl;
                            std::cout << "  TX Packets: " << stats->tx_packets << std::endl;
                            std::cout << "  RX Bytes: " << stats->rx_bytes << std::endl;
                            std::cout << "  TX Bytes: " << stats->tx_bytes << std::endl;
                            break;
                        }
                            // 可以根据需要添加更多属性的处理
                    }
                    attr = NLA_NEXT(attr, rta_len);
                }
                std::cout << std::endl;
            }
        }
    }

    if (bytes_received < 0) {
        perror("recv");
    }

cleanup:
    // 6. 关闭套接字
    close(sock);
    return 0;
}

代码解释:

创建 Netlink 套接字: 使用 socket() 函数创建一个 AF_NETLINK 类型的套接字。NETLINK_ROUTE 指定了协议族。
绑定套接字: 使用 bind() 函数将套接字绑定到一个 sockaddr_nl 结构体。nl_pid 字段设置为进程 ID，nl_groups 字段设置为 0，表示不加入任何多播组。
构造 Netlink 消息:
- 创建一个缓冲区 buf 来存储 netlink 消息。
- 创建一个 nlmsghdr 结构体，并设置其字段：
  - nlmsg_len: 消息的总长度。
  - nlmsg_type: 消息类型，这里设置为 RTM_GETLINK，表示请求获取链路信息。
  - nlmsg_flags: 消息标志，NLM_F_REQUEST 表示这是一个请求消息，NLM_F_DUMP 表示请求获取所有接口的信息。
  - nlmsg_seq: 序列号，用于匹配请求和响应。
  - nlmsg_pid: 进程 ID。
- 创建一个 ifinfomsg 结构体，并设置其字段：
  - ifi_family: 地址族，这里设置为 AF_UNSPEC，表示获取所有地址族的接口信息。
发送 Netlink 消息: 使用 send() 函数发送 netlink 消息到内核。
接收 Netlink 消息: 使用 recv() 函数接收来自内核的 netlink 消息。
- 循环接收消息，直到接收到 NLMSG_DONE 类型的消息，或者发生错误。
- 使用 NLMSG_OK() 宏判断是否还有未处理的消息。
- 使用 NLMSG_NEXT() 宏移动到下一个消息。
- 如果消息类型是 RTM_NEWLINK，表示接收到一个新的网络接口的信息。
  - 创建一个 ifinfomsg 结构体来解析接口信息。
  - 遍历消息中的 netlink 属性，获取接口名称、MAC 地址等信息。
关闭套接字: 使用 close() 函数关闭套接字。

编译和运行

使用以下命令编译代码：

g++ netlink_example.cpp -o netlink_example

运行程序：

sudo ./netlink_example

注意，需要使用 sudo 运行程序，因为获取网络接口信息需要 root 权限。

代码改进与扩展

上面的代码只是一个简单的示例，你可以根据自己的需求进行改进和扩展：

错误处理: 添加更完善的错误处理机制，比如检查 recv() 函数的返回值，处理不同的 netlink 错误码。
属性解析: 解析更多的 netlink 属性，比如 IP 地址、子网掩码、广播地址等。
消息过滤: 根据接口类型、状态等条件过滤消息。
异步处理: 使用非阻塞套接字和 epoll 等技术实现异步 netlink 通信。
封装: 将 netlink 通信封装成一个类，提供更友好的 API。

Netlink 协议族

协议族	描述
`NETLINK_ROUTE`	路由和链路信息。用于获取和修改路由表、接口信息、地址信息等。
`NETLINK_FIREWALL`	防火墙管理。用于配置 iptables 规则。
`NETLINK_INET_DIAG`	TCP/UDP 连接诊断。用于获取 TCP 和 UDP 连接的信息，比如状态、地址、端口等。
`NETLINK_NFLOG`	Netfilter 日志。用于接收 Netfilter 记录的日志信息。
`NETLINK_AUDIT`	审计。用于接收系统审计事件。
`NETLINK_KOBJECT_UEVENT`	内核对象事件。用于接收内核对象（比如设备）的事件通知，比如设备插入、移除等。
`NETLINK_GENERIC`	通用 Netlink。用于定义自定义的 Netlink 协议。

总结

netlink 套接字是 C++ 程序与 Linux 内核通信的强大工具。通过它，你可以获取系统信息、配置内核参数、监控系统事件等等。虽然 netlink 的 API 比较底层，但是只要理解了基本概念和原理，就可以灵活地使用它来解决各种实际问题。

希望今天的讲解对你有所帮助！掌握netlink之后，你会感觉自己仿佛拥有了某种超能力，可以洞察内核的秘密，并控制它的行为。祝你编程愉快！

发表回复 取消回复

发表回复取消回复