NetLink内核套接字案例分析

发布于：2025-03-15 ⋅ 阅读:(16) ⋅ 点赞:(0)

一、基础知识

        Netlink 是 Linux 系统中一种内核与用户空间通信的高效机制，而 Netlink 消息是这种通信的核心载体。它允许用户态程序（如网络配置工具、监控工具）与内核子系统（如网络协议栈、设备驱动）交换数据，例如获取网络接口信息、配置路由表、接收内核事件通知等。

Netlink 消息的组成

一个完整的 Netlink 消息由两部分构成：

  1. 消息头（struct nlmsghdr）
    定义消息的元信息，例如消息类型、长度、序列号等。

    struct nlmsghdr {
    __u32 nlmsg_len;    // 消息总长度（头部 + 数据）
    __u16 nlmsg_type;   // 消息类型（如请求、响应、错误）
    __u16 nlmsg_flags;  // 标志位（如请求标志、多部分消息标志）
    __u32 nlmsg_seq;    // 序列号（用于匹配请求和响应）
    __u32 nlmsg_pid;    // 发送方端口ID（通常为进程ID）
};

  2. 消息体（Payload）
    具体的数据内容，格式由消息类型决定。例如：

    • 路由消息：struct rtgenmsg（指定地址族）

    • 接口信息：struct ifinfomsg（接口索引、状态等）

    • 属性列表：动态附加的属性（如接口名称、MAC地址等）。

Netlink 消息的作用

Netlink 消息的核心功能是双向通信：

1. 用户空间 → 内核

用户程序通过发送 Netlink 消息向内核发起操作请求。例如：

  • 查询信息：RTM_GETLINK（获取网络接口列表）、RTM_GETROUTE（获取路由表）。

  • 配置内核：RTM_NEWLINK（创建新接口）、RTM_SETLINK（修改接口属性）。

2. 内核 → 用户空间

内核通过 Netlink 消息主动通知用户程序事件。例如：

  • 接口状态变化：网络接口启用/禁用。

  • 新设备插入：USB 设备连接、Wi-Fi 网络扫描结果。

  • 路由表更新：路由条目添加或删除。

为什么用 Netlink？

与其他内核通信方式相比，Netlink 的优势在于：

机制 特点 适用场景
Netlink 双向、异步、支持多播、结构化数据、可扩展 动态配置和实时事件通知
Sysfs 通过文件系统操作（/sys），读写简单但效率低 静态配置（如设置参数）
Procfs 通过文件系统（/proc），主要用于状态查询 读取系统信息（如进程状态）
ioctl 通过设备文件操作，接口不统一，扩展性差 设备驱动特定操作
Netlink 的独特优势

  1. 结构化数据
    消息通过二进制格式传递，避免了文本解析（如 procfs/sysfs）的开销。

  2. 异步通信
    支持非阻塞通信，用户程序无需等待内核响应。

  3. 多播支持
    内核可以向多个用户进程广播事件（如接口状态变化）。

  4. 可扩展性
    通过消息类型（nlmsg_type）和属性（struct rtattr）灵活扩展功能。

Netlink 消息的工作流程

以获取网络接口列表为例：

  1. 用户程序构造请求消息

    • 设置 nlmsghdr：nlmsg_type = RTM_GETLINK，nlmsg_flags = NLM_F_DUMP。

    • 设置 rtgenmsg：rtgen_family = AF_UNSPEC（获取所有接口）。

  2. 发送消息到内核
    通过 sendmsg 系统调用发送 Netlink 消息。

  3. 内核处理请求
    路由子系统解析消息，收集所有网络接口信息，封装为多个 Netlink 消息（可能分片）。

  4. 用户程序接收响应
    通过 recvmsg 读取消息，解析 nlmsghdr 和消息体，提取接口名称、状态等数据。

典型应用场景

  1. 网络配置工具
    iproute2 工具集（如 ip link、ip route）底层使用 Netlink 配置网络。

  1. 设备监控
    监听内核事件，如接口状态变化、新设备连接。

  2. 防火墙和策略路由
    配置 netfilter（iptables/nftables）规则或复杂路由策略。

  3. 容器网络
    容器运行时（如 Docker）通过 Netlink 管理虚拟网络设备。

 

1.nlinterfaces.c

// 程序功能：应用Netlink套接字从Linux内核打印输出所有网络接口名称
#include <bits/types/struct_iovec.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/socket.h>
#include <linux/netlink.h>  //Netlink协议相关定义
#include <linux/rtnetlink.h> // 路由相关的Netlink消息定义

#define BUFSIZE 10240

//定义一个自定义结构体ln_request_s，它包含一个 Netlink 消息头nlmsghdr和一个路由通用消息结构体rtgenmsg
struct In_request_s{
    //Netlink消息头
    struct nlmsghdr hdr;
    //路由消息通用结构，指定地址族
    struct rtgenmsg gen;
};

//功能：解析并打印网络接口信息
void rtnl_print_link(struct nlmsghdr *h){
    //struct ifinfomsg *iface：指向 Netlink 消息中包含的网络接口信息结构体
    struct ifinfomsg *iface;
    //struct rtattr *attr：指向路由属性结构体
    struct  rtattr *attr;
    int len = 0;

    //获取 Netlink 消息中实际的数据部分,计算方式：消息头地址 + 头部大小
    iface = NLMSG_DATA(h);
    //获取 Netlink 消息中有效负载的长度
    len = RTM_PAYLOAD(h);

    //遍历路由属性
    for(attr = IFLA_RTA(iface);RTA_OK(attr,len);attr = RTA_NEXT(attr,len)){
        switch (attr->rta_type){
            //如果属性是接口名称就打印
            case IFLA_IFNAME:
                printf("接口名称%d : %s\n", iface->ifi_index, (char *)RTA_DATA(attr));
                break;
            default:
                break;
        }
    }
}

int main(int argc,char *argv[]){
    //Netlink地址结构，用于绑定套接字
    struct sockaddr_nl nkernel;
    //消息头结构，用于 sendmsg 和 recvmsg
    struct msghdr msg;
    //分散、聚集I/O结构，用于消息传输,主要跟readv、writev等缓冲区合并有关，用于一次I/O操作处理多个缓冲区
    struct iovec io;
    //自定义请求结构
    struct In_request_s req;
    //s为套接字描述符,end为循环结束标志
    int s = -1, end = 0, ret;
    //接收缓冲区
    char buf[BUFSIZE];

    //初始化Netlink地址结构
    memset(&nkernel,0,sizeof(nkernel));
    nkernel.nl_family = AF_NETLINK;    //这里与内核通信所以不使用AF_INET
    nkernel.nl_groups = 0; // 不加入任何组播组

    //创建套接字
    /*
    AF_NETLINK: 使用 Netlink 协议族。
    SOCK_RAW: 原始套接字类型，允许直接操作 Netlink 消息。
    NETLINK_ROUTE: 路由子系统，用于获取网络接口和路由信息。
    */
    if ((s = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) < 0){
        printf("创建Netlink套接字失败.\n");
        exit(EXIT_FAILURE);
    }

    //构造Netlink请求消息
    memset(&req, 0, sizeof(req));
    //#define NLMSG_LENGTH(len) ((len) + NLMSG_ALIGN(sizeof(struct nlmsghdr)))
    //nlmsg_len: 消息总长度（头部 + rtgenmsg 结构体），通过 NLMSG_LENGTH 计算对齐后的长度
    req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
    //请求获取网络接口信息
    req.hdr.nlmsg_type = RTM_GETLINK;
    //标志为请求消息，并要求返回所有条目
    req.hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
    //序列号，用于匹配请求和响应
    req.hdr.nlmsg_seq = 1;
    //发送方进程 ID
    req.hdr.nlmsg_pid = getpid();
    //指定地址族为 IPv4（可改为 AF_UNSPEC 获取所有接口）
    req.gen.rtgen_family = AF_INET;

    //设置I/O向量和消息头
    memset(&io, 0, sizeof(io));
    io.iov_base = &req;
    io.iov_len = req.hdr.nlmsg_len;

    memset(&msg, 0, sizeof(msg));
    msg.msg_iov = &io;          // 指向 I/O 向量
    msg.msg_iovlen = 1;         // 向量数量为 1
    msg.msg_name = &nkernel;    // 目标地址（内核）
    msg.msg_namelen = sizeof(nkernel);

    //发送请求消息
    if ((ret = sendmsg(s, &msg, 0)) < 0) {
        perror("发送消息失败");
        close(s);
        exit(EXIT_FAILURE);
    }

    //接收并解析内核响应,，当接收到 NLMSG_DONE 消息时，end 会被置为 1，从而退出循环
    while(!end){
        //定义一个指向 nlmsghdr 结构体的指针 msg_ptr，用于遍历接收到的 Netlink 消息
        struct nlmsghdr *msg_ptr;
        //用于记录还未处理的消息长度
        int remaining_len;

        memset(buf, 0, BUFSIZE);
        io.iov_base = buf;
        io.iov_len = BUFSIZE;

        if ((ret = recvmsg(s, &msg, 0)) < 0) {
            if (errno == EINTR) continue;  // 处理中断
            perror("接收消息失败");
            close(s);
            exit(EXIT_FAILURE);
        }

        // 处理消息分片（NLMSG_TRUNC标志）
        if (msg.msg_flags & MSG_TRUNC) {
            fprintf(stderr, "警告：消息被截断，考虑增大缓冲区\n");
        }
        //将 msg_ptr 指针指向接收缓冲区 buf 的起始位置，将其视为第一个 Netlink 消息的头部
        msg_ptr = (struct nlmsghdr *)buf;
        //将 remaining_len 初始化为接收到的消息总长度 ret
        remaining_len = ret;

        for (; NLMSG_OK(msg_ptr, remaining_len);   //NLMSG_OK(msg_ptr, remaining_len)：这是一个宏，用于检查 msg_ptr 指向的 Netlink 消息是否有效，即消息长度是否足够且未超出剩余未处理的消息长度
            msg_ptr = NLMSG_NEXT(msg_ptr, remaining_len)) {  //将 msg_ptr 指针移动到下一个 Netlink 消息的头部，并更新 remaining_len 的值
            //内核在回复单播请求时，会将 nlmsg_pid 设置为用户进程的 PID（即 self_pid）
            if (msg_ptr->nlmsg_pid != getpid()) {
                fprintf(stderr, "收到非本进程的消息，已忽略 (PID: %u)\n", msg_ptr->nlmsg_pid);
                continue;
            }   

            switch (msg_ptr->nlmsg_type) {
                case NLMSG_ERROR: {  //如果消息类型为 NLMSG_ERROR，表示内核返回了错误信息
                    struct nlmsgerr *err = NLMSG_DATA(msg_ptr);  //使用 NLMSG_DATA 宏获取消息中的错误信息结构体 nlmsgerr 的指针
                    if (err->error != 0) {
                        fprintf(stderr, "内核返回错误: %s\n", strerror(-err->error));
                        close(s);
                        exit(EXIT_FAILURE);
                    }
                    break;
                }
                case NLMSG_DONE: //如果消息类型为 NLMSG_DONE，表示内核已经发送完所有请求的信息，将 end 标志置为 1，退出循环
                    end = 1;
                    break;
                case RTM_NEWLINK: //如果消息类型为 RTM_NEWLINK，表示接收到了新的网络接口信息。调用 rtnl_print_link 函数处理该消息，打印网络接口的相关信息
                    rtnl_print_link(msg_ptr);
                    break;
                default:   //如果消息类型不是上述几种情况，输出忽略消息的信息，包含消息类型和消息长度
                    printf("忽略消息：type=%d, len=%d\n",
                           msg_ptr->nlmsg_type, msg_ptr->nlmsg_len);
                    break;
            }
        }

        // 处理未对齐的剩余数据
        if (remaining_len > 0) {
            fprintf(stderr, "剩余%d字节未处理数据\n", remaining_len);
        }
    }

    close(s);  // 确保关闭套接字
    return 0;
}

编译运行：

二、ipaddress.c

// 显示IPv4，应用Netlink套接字从Linux内核中获取所有网络接口的IP地址
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <errno.h>

#define BUFFERSIZE 10240

// 定义一个自定义结构体 netlink_reqest_s，它包含一个 Netlink 消息头 nlmsghdr 和一个路由通用消息结构体 rtgenmsg
struct netlink_reqest_s {
    // Netlink 消息头
    struct nlmsghdr hdr;
    // 路由消息通用结构，指定地址族
    struct rtgenmsg gen;
};

// 功能：解析并打印网络接口的 IP 地址信息
void rtnetlink_disp_address(struct nlmsghdr *h) {
    // struct ifaddrmsg *addr：指向 Netlink 消息中包含的网络地址信息结构体
    struct ifaddrmsg *addr;
    // struct rtattr *attr：指向路由属性结构体
    struct rtattr *attr;
    // 用于记录 Netlink 消息中有效负载的长度
    int len;

    // 获取 Netlink 消息中实际的数据部分，计算方式：消息头地址 + 头部大小
    addr = NLMSG_DATA(h);
    // 获取 Netlink 消息中有效负载的长度
    len = RTM_PAYLOAD(h);

    /* 循环输出 Netlink 所有属性消息：网络接口名称及 IP 地址 */
    for (attr = IFA_RTA(addr); RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) {
        switch (attr->rta_type) {
            // 如果属性是接口名称就打印
            case IFA_LABEL:
                printf("网络接口名称 : %s\n", (char *)RTA_DATA(attr));
                break;
            // 如果属性是本地 IP 地址就打印
            case IFA_LOCAL: {
                // 获取 IP 地址的二进制表示
                int ip = *(int *)RTA_DATA(attr);
                // 用于存储 IP 地址的四个字节
                unsigned char bytes[4];
                // 提取 IP 地址的四个字节
                bytes[0] = ip & 0xFF;
                bytes[1] = (ip >> 8) & 0xFF;
                bytes[2] = (ip >> 16) & 0xFF;
                bytes[3] = (ip >> 24) & 0xFF;
                // 打印网络 IP 地址
                printf("网络 IP 地址为 : %d.%d.%d.%d\n\n", bytes[0], bytes[1], bytes[2], bytes[3]);
                break;
            }
            default:
                break;
        }
    }
}

int main(void) {
    // Netlink 地址结构，用于绑定套接字
    struct sockaddr_nl kerl;
    // 套接字描述符
    int s;
    // 循环结束标志
    int end = 0;
    // 接收到的消息长度
    int len;
    // 消息头结构，用于 sendmsg 和 recvmsg
    struct msghdr msg;
    // 自定义请求结构
    struct netlink_reqest_s req;
    // 分散、聚集 I/O 结构，用于消息传输
    struct iovec io;
    // 接收缓冲区
    char buffer[BUFFERSIZE];

    // 初始化 Netlink 地址结构
    memset(&kerl, 0, sizeof(kerl));
    // 使用 Netlink 协议族
    kerl.nl_family = AF_NETLINK;
    // 不加入任何组播组
    kerl.nl_groups = 0;

    // 创建套接字
    /*
    AF_NETLINK: 使用 Netlink 协议族。
    SOCK_RAW: 原始套接字类型，允许直接操作 Netlink 消息。
    NETLINK_ROUTE: 路由子系统，用于获取网络接口和路由信息。
    */
    if ((s = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) < 0) {
        perror("创建 Netlink 套接字失败");
        exit(EXIT_FAILURE);
    }

    // 构造 Netlink 请求消息
    memset(&req, 0, sizeof(req));
    // 消息总长度（头部 + rtgenmsg 结构体），通过 NLMSG_LENGTH 计算对齐后的长度
    req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
    // 请求获取网络接口地址信息
    req.hdr.nlmsg_type = RTM_GETADDR;
    // 标志为请求消息，并要求返回所有条目
    req.hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
    // 序列号，用于匹配请求和响应
    req.hdr.nlmsg_seq = 1;
    // 发送方进程 ID
    req.hdr.nlmsg_pid = getpid();
    // 指定地址族为 IPv4
    req.gen.rtgen_family = AF_INET;

    // 设置 I/O 向量和消息头
    memset(&io, 0, sizeof(io));
    io.iov_base = &req;
    io.iov_len = req.hdr.nlmsg_len;

    memset(&msg, 0, sizeof(msg));
    msg.msg_iov = &io;          // 指向 I/O 向量
    msg.msg_iovlen = 1;         // 向量数量为 1
    msg.msg_name = &kerl;       // 目标地址（内核）
    msg.msg_namelen = sizeof(kerl);

    // 发送请求消息
    if (sendmsg(s, &msg, 0) < 0) {
        perror("发送消息失败");
        close(s);
        exit(EXIT_FAILURE);
    }

    // 接收并解析内核响应，当接收到 NLMSG_DONE 消息时，end 会被置为 1，从而退出循环
    while (!end) {
        // 定义一个指向 nlmsghdr 结构体的指针 msg_ptr，用于遍历接收到的 Netlink 消息
        struct nlmsghdr *msg_ptr;
        // 用于记录还未处理的消息长度
        int remaining_len;

        // 清空接收缓冲区
        memset(buffer, 0, BUFFERSIZE);
        io.iov_base = buffer;
        io.iov_len = BUFFERSIZE;

        // 接收消息
        if ((len = recvmsg(s, &msg, 0)) < 0) {
            if (errno == EINTR) continue;  // 处理中断
            perror("接收消息失败");
            close(s);
            exit(EXIT_FAILURE);
        }

        // 处理消息分片（NLMSG_TRUNC 标志）
        if (msg.msg_flags & MSG_TRUNC) {
            fprintf(stderr, "警告：消息被截断，考虑增大缓冲区\n");
        }

        // 将 msg_ptr 指针指向接收缓冲区 buffer 的起始位置，将其视为第一个 Netlink 消息的头部
        msg_ptr = (struct nlmsghdr *)buffer;
        // 将 remaining_len 初始化为接收到的消息总长度 len
        remaining_len = len;

        for (; NLMSG_OK(msg_ptr, remaining_len);  // NLMSG_OK(msg_ptr, remaining_len)：这是一个宏，用于检查 msg_ptr 指向的 Netlink 消息是否有效，即消息长度是否足够且未超出剩余未处理的消息长度
             msg_ptr = NLMSG_NEXT(msg_ptr, remaining_len)) {  // 将 msg_ptr 指针移动到下一个 Netlink 消息的头部，并更新 remaining_len 的值
            // 内核在回复单播请求时，会将 nlmsg_pid 设置为用户进程的 PID（即 self_pid）
            if (msg_ptr->nlmsg_pid != getpid()) {
                fprintf(stderr, "收到非本进程的消息，已忽略 (PID: %u)\n", msg_ptr->nlmsg_pid);
                continue;
            }

            switch (msg_ptr->nlmsg_type) {
                // 如果消息类型为 NLMSG_ERROR，表示内核返回了错误信息
                case NLMSG_ERROR: {
                    // 使用 NLMSG_DATA 宏获取消息中的错误信息结构体 nlmsgerr 的指针
                    struct nlmsgerr *err = NLMSG_DATA(msg_ptr);
                    if (err->error != 0) {
                        fprintf(stderr, "内核返回错误: %s\n", strerror(-err->error));
                        close(s);
                        exit(EXIT_FAILURE);
                    }
                    break;
                }
                // 如果消息类型为 NLMSG_DONE，表示内核已经发送完所有请求的信息，将 end 标志置为 1，退出循环
                case NLMSG_DONE:
                    end = 1;
                    break;
                // 如果消息类型为 RTM_NEWADDR，表示接收到了新的网络接口地址信息。调用 rtnetlink_disp_address 函数处理该消息，打印网络接口的相关信息
                case RTM_NEWADDR:
                    rtnetlink_disp_address(msg_ptr);
                    break;
                // 如果消息类型不是上述几种情况，输出忽略消息的信息，包含消息类型和消息长度
                default:
                    printf("忽略消息：type=%d, len=%d\n", msg_ptr->nlmsg_type, msg_ptr->nlmsg_len);
                    break;
            }
        }

        // 处理未对齐的剩余数据
        if (remaining_len > 0) {
            fprintf(stderr, "剩余 %d 字节未处理数据\n", remaining_len);
        }
    }

    // 确保关闭套接字
    close(s);
    return 0;
}

编译运行：

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布