Netlink是Linux内核提供的一种用于内核与用户空间进程之间通信的机制。

Netlink是Linux内核提供的一种用于内核与用户空间进程之间通信的机制。它允许内核向用户空间发送消息，同时也可以接收用户空间的请求并做出相应的响应。

Netlink的主要功能包括：
内核通知：
当网络事件发生时，例如接口状态变化、路由变化等，内核可以通过Netlink向用户空间发送通知。这样，用户空间的应用程序可以及时了解网络状态的变化，并做出相应的处理。

#include 
#include 

/* 假设我们有一个网络接口的回调函数 */
void network_interface_change(struct net_device *dev) {
    struct sk_buff *skb;
    struct nlmsghdr *nlh;
    struct ifinfomsg *ifi;
    char *data;

    /* 创建Netlink消息 */
    skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
    if (!skb) {
        printk(KERN_ERR "Failed to allocate Netlink socket buffer\n");
        return;
    }

    data = skb_put(skb, NLMSG_SPACE(sizeof(*ifi)));
    nlh = nlmsg_put(skb, 0, 0, RTM_NEWLINK, sizeof(*ifi), 0);
    if (!nlh) {
        printk(KERN_ERR "Failed to create Netlink message\n");
        kfree_skb(skb);
        return;
    }

    ifi = nlmsg_data(nlh);
    memset(ifi, 0, sizeof(*ifi));
    ifi->ifi_family = AF_PACKET;
    ifi->ifi_change = IFF_UP | IFF_RUNNING; // 设置网络接口状态变化为启用状态
    memcpy(ifi->ifi_name, dev->name, IFNAMSIZ); // 复制网络接口名称到消息中

    /* 通过Netlink发送消息到用户空间 */
    netlink_broadcast(netlink_socket, skb, 0, RTNLGRP_LINK, GFP_KERNEL);
}

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define NETLINK_USER 27

struct msg_data {
    struct nlmsghdr nlh;
    char ifname[IFNAMSIZ]; // 接口名称
    char status[10]; // 接口状态
};

int main(void) {
    int sockfd;
    struct sockaddr_nl addr;
    struct msg_data msg;
    int status;

    // 创建Netlink套接字
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_USER);
    if (sockfd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置接收数据包的Netlink地址结构体
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid(); // 设置接收消息的进程ID为当前进程ID
    addr.nl_groups = RTMGRP_LINK; // 设置接收的数据包类型为链接相关的数据包

    // 绑定套接字到Netlink地址结构体
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 接收来自内核的通知消息
    while (1) {
        status = recvfrom(sockfd, &msg, sizeof(msg), MSG_DONTWAIT, (struct sockaddr *)&addr, sizeof(addr)); // 接收消息
        if (status < 0) {
            perror("recvfrom");
            exit(EXIT_FAILURE);
        }
        if (msg.nlh.nlmsg_type == RTM_NEWLINK) { // 判断消息类型为接口状态变化通知
            printf("Interface status changed: %s %s\n", msg.ifname, msg.status); // 输出接口名称和状态变化信息
            // 在这里可以根据接口状态变化进行相应的处理逻辑
        } else {
            printf("Received other message type: %d\n", msg.nlh.nlmsg_type); // 处理其他类型的消息
        }
    }

    return 0;
}

用户空间请求：
用户空间的应用程序可以通过Netlink向内核发送请求，例如配置网络接口、修改路由表等。这些请求会被内核接收并处理，然后内核通过Netlink将处理结果返回给用户空间的应用程序。

#include 
#include 
#include 
#include 
#include 
#include 

int main() {
    int sockfd;
    struct nl_msg *msg;
    struct nlattr *tb[IFLA_MAX + 1];
    struct rtmsg *rtm;
    char buf[4096];
    ssize_t n;
    int status;

    // 创建Netlink套接字
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sockfd < 0) {
        perror("Failed to create Netlink socket");
        exit(EXIT_FAILURE);
    }

    // 创建Netlink消息
    msg = nlmsg_alloc();
    if (!msg) {
        perror("Failed to allocate Netlink message");
        exit(EXIT_FAILURE);
    }

    // 设置消息类型和标志
    rtm = (struct rtmsg *)nlmsg_data(nlmsg_hdr(msg));
    rtm->rtm_family = AF_PACKET;
    rtm->rtm_ifindex = 0; // 设置要配置的网络接口的索引
    rtm->rtm_type = RTM_NEWLINK; // 设置请求类型为配置网络接口
    rtm->rtm_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL; // 设置标志为请求、创建和排他性
    rtm->rtm_msglen = NLMSG_LENGTH(sizeof(struct rtmsg)); // 设置消息长度

    // 填充消息数据
    tb[IFLA_IFNAME] = nla_alloc(); // 接口名称属性
    nla_put_string(tb[IFLA_IFNAME], "eth0"); // 设置接口名称为"eth0"
    nlmsg_end(msg, tb); // 结束消息结构体

    // 发送消息到内核
    status = nl_sendto(sockfd, msg, nlmsg_len(nlmsg_hdr(msg)));
    if (status < 0) {
        perror("Failed to send Netlink message");
        exit(EXIT_FAILURE);
    }

    // 接收内核的处理结果
    while ((n = recv(sockfd, buf, sizeof(buf), 0)) > 0) {
        status = nlmsg_parse(buf, n, tb, IFLA_MAX, NULL); // 解析消息结构体
        if (status < 0) {
            perror("Failed to parse Netlink message");
            exit(EXIT_FAILURE);
        }
        if (tb[IFLA_IFNAME]) { // 检查接口名称属性是否存在
            printf("Interface %s has been configured.\n", nla_get_string(tb[IFLA_IFNAME])); // 打印配置结果
        } else {
            printf("Failed to configure the interface.\n"); // 打印配置失败信息
        }
    }
    close(sockfd); // 关闭Netlink套接字
    return 0;
}

内核与用户空间的交互：
Netlink提供了一种机制，使得内核和用户空间可以交互地传递数据。例如，当一个网络包到达时，内核可以通过Netlink向用户空间发送一个包含该包数据的消息。用户空间的应用程序可以接收这个消息，并对其进行处理。
内核代码：

#include 
#include 

/* 内核中的代码 */
struct sk_buff *skb;
struct nlmsghdr *nlh;

/* 创建Netlink消息 */
skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
if (!skb) {
    printk(KERN_ERR "Failed to allocate Netlink socket buffer\n");
    return;
}

nlh = nlmsg_put(skb, 0, 0, NLMSG_DONE, 0, 0);
if (!nlh) {
    printk(KERN_ERR "Failed to create Netlink message\n");
    kfree_skb(skb);
    return;
}

/* 通过Netlink发送消息到用户空间 */
netlink_send(netlink_socket, skb);

用户空间代码：
在用户空间中，首先需要创建一个Netlink套接字，然后使用recvfrom()函数接收来自内核的消息。以下是一个简单的用户空间代码示例：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main() {
    int sockfd;
    struct sockaddr_nl addr;
    struct nlmsghdr *nlh;
    char buffer[4096];
    int len;
    int ret;

    /* 创建Netlink套接字 */
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sockfd < 0) {
        perror("Failed to create Netlink socket");
        exit(EXIT_FAILURE);
    }

    /* 配置目标地址 */
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = 0; // 设置目标进程ID为0，表示接收来自任意进程的消息。根据需要可以设置特定的PID。
    addr.nl_groups = RTNLGRP_LINK; // 设置消息组别为链接组别，接收与链接相关的消息。根据需要可以设置其他组别。

    /* 接收消息 */
    len = recvfrom(sockfd, buffer, sizeof(buffer), MSG_WAITALL, (struct sockaddr *)&addr, &addr.nl_len);
    if (len < 0) {
        perror("Failed to receive Netlink message");
        exit(EXIT_FAILURE);
    }

    /* 处理接收到的消息 */
    nlh = (struct nlmsghdr *)buffer;
    while (nlmsg_ok(nlh, len)) {
        // 处理消息...（根据消息类型和内容进行相应的处理）
        nlh = nlmsg_next(nlh, &len);
    }
}

Netlink的使用场景非常广泛，包括但不限于以下几个方面：
网络管理工具：
如ifconfig、ip等命令行工具，它们使用Netlink与内核进行通信，以获取或修改网络接口的状态和配置。

#include 
#include 
#include 
#include 
#include 
#include 

int main() {
    int sockfd;
    struct nl_msg *msg;
    struct nlattr *tb[IFLA_MAX + 1];
    struct rtmsg *rtm;
    char buf[4096];
    ssize_t n;
    int status;

    // 创建Netlink套接字
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sockfd < 0) {
        perror("Failed to create Netlink socket");
        exit(EXIT_FAILURE);
    }

    // 创建Netlink消息
    msg = nlmsg_alloc();
    if (!msg) {
        perror("Failed to allocate Netlink message");
        exit(EXIT_FAILURE);
    }

    // 设置消息类型和标志
    rtm = (struct rtmsg *)nlmsg_data(nlmsg_hdr(msg));
    rtm->rtm_family = AF_PACKET;
    rtm->rtm_ifindex = 0; // 设置要配置的网络接口的索引
    rtm->rtm_type = RTM_NEWLINK; // 设置请求类型为配置网络接口
    rtm->rtm_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL; // 设置标志为请求、创建和排他性
    rtm->rtm_msglen = NLMSG_LENGTH(sizeof(struct rtmsg)); // 设置消息长度

    // 填充消息数据
    tb[IFLA_IFNAME] = nla_alloc(); // 接口名称属性
    nla_put_string(tb[IFLA_IFNAME], "eth0"); // 设置接口名称为"eth0"
    nlmsg_end(msg, tb); // 结束消息结构体

    // 发送消息到内核
    status = nl_sendto(sockfd, msg, nlmsg_len(nlmsg_hdr(msg)));
    if (status < 0) {
        perror("Failed to send Netlink message");
        exit(EXIT_FAILURE);
    }

    // 接收内核的处理结果
    while ((n = recv(sockfd, buf, sizeof(buf), 0)) > 0) {
        status = nlmsg_parse(buf, n, tb, IFLA_MAX, NULL); // 解析消息结构体
        if (status < 0) {
            perror("Failed to parse Netlink message");
            exit(EXIT_FAILURE);
        }
        if (tb[IFLA_IFNAME]) { // 检查接口名称属性是否存在
            printf("Interface %s has been configured.\n", nla_get_string(tb[IFLA_IFNAME])); // 打印配置结果
        } else {
            printf("Failed to configure the interface.\n"); // 打印配置失败信息
        }
    }
    close(sockfd); // 关闭Netlink套接字
    return 0;
}

网络监控工具：
如tcpdump、wireshark等，它们使用Netlink接收内核发送的网络包数据，以进行网络流量分析和监控。

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUFFER_SIZE 4096

int main() {
    int sockfd;
    char buffer[BUFFER_SIZE];
    struct sockaddr_nl addr;
    struct nlmsghdr *nlh;
    struct rtattr *tb[IFLA_MAX + 1];
    int status;

    // 创建Netlink套接字
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sockfd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置接收数据包的Netlink地址结构体
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid(); // 设置发送消息的进程ID
    addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR; // 设置接收的数据包类型，这里接收链接和IPv4地址相关的数据包

    // 绑定套接字到Netlink地址结构体
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 接收网络包数据
    while (1) {
        status = recvfrom(sockfd, buffer, BUFFER_SIZE, MSG_DONTWAIT, (struct sockaddr *)&addr, sizeof(addr));
        if (status < 0) {
            perror("recvfrom");
            exit(EXIT_FAILURE);
        }

        // 解析网络包数据，这里只简单地打印消息类型和消息长度，实际应用中需要根据具体需求进行解析和处理
        nlh = (struct nlmsghdr *)buffer;
        while (NLMSG_OK(nlh, status)) {
            printf("Message type: %d\n", nlh->nlmsg_type);
            printf("Message length: %d\n", nlh->nlmsg_len);
            nlh = NLMSG_NEXT(nlh, status);
        }
    }

    // 关闭套接字
    close(sockfd);
    return 0;
}

网络服务守护进程：
如路由守护进程（routed）和动态主机配置协议（DHCP）服务器等，它们使用Netlink与内核进行通信，以处理网络路由和配置相关的请求。

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUFFER_SIZE 4096

int main() {
    int sockfd;
    char buffer[BUFFER_SIZE];
    struct sockaddr_nl addr;
    struct nlmsghdr *nlh;
    struct rtmsg *rtm;
    int status;

    // 创建Netlink套接字
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
    if (sockfd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置接收数据包的Netlink地址结构体
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = getpid(); // 设置发送消息的进程ID
    addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE; // 设置接收的数据包类型，这里接收链接和IPv4路由相关的数据包

    // 绑定套接字到Netlink地址结构体
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 发送路由信息到内核
    nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(sizeof(*rtm)));
    memset(nlh, 0, NLMSG_SPACE(sizeof(*rtm)));
    nlh->nlmsg_len = NLMSG_LENGTH(sizeof(*rtm));
    nlh->nlmsg_type = RTM_NEWROUTE; // 消息类型为添加路由
    nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE; // 设置消息标志为请求、创建和替换路由
    nlh->nlmsg_seq = 1; // 消息序列号
    rtm = NLMSG_DATA(nlh); // 路由信息结构体指针
    memset(rtm, 0, sizeof(*rtm));
    rtm->rtm_family = AF_INET; // 地址族为IPv4
    rtm->rtm_dst_len = 32; // 目标地址长度为32位（IPv4地址长度）
    rtm->rtm_src_len = 0; // 源地址长度为0（不指定源地址）
    rtm->rtm_tos = 0; // 服务类型为0（默认值）
    rtm->rtm_table = RT_TABLEID(RT_TABLEID_MAIN); // 路由表ID为主表（默认值）
    rtm->rtm_protocol = RTPROT_BOOT; // 路由协议为BOOTPROTO（默认值）
    rtm->rtm_scope = RT_SCOPE_UNIVERSE; // 作用域为UNIVERSE（默认值）
    rtm->rtm_type = RTN_UNICAST; // 路由类型为单播（默认值）
    strncpy(rtm->rtm_dst, "192.168.1.0", RTA_LEN-1); // 设置目标地址为192.168.1.0/24网段（示例）
    status = sendto(sockfd, nlh, nlh->nlmsg_len, 0, (struct sockaddr *)&addr, sizeof(addr)); // 发送消息到内核
    if (status < 0) {
        perror("sendto");
        exit(EXIT_FAILURE);
    }

    // 接收来自内核的路由信息响应消息
    while (1) {
        status = recvfrom(sockfd, buffer, BUFFER_SIZE, MSG_DONTWAIT, (struct sockaddr *)&addr, sizeof(addr)); // 接收消息
        if (status < 0) {
            perror("recvfrom");
            exit(EXIT_FAILURE);
        }
        nlh = (struct nlmsghdr *)buffer; // 从接收到的消息中获取NLMSGHDR结构体指针
        while (NLMSG_OK(nlh, status)) {
    // 解析消息
    switch (nlh->nlmsg_type) {
        case RTM_NEWROUTE:
            // 处理路由信息
            printf("Received RTM_NEWROUTE message\n");
            break;
        case RTM_DELROUTE:
            // 处理删除路由信息
            printf("Received RTM_DELROUTE message\n");
            break;
        default:
            // 处理其他消息类型
            printf("Received other message type: %d\n", nlh->nlmsg_type);
            break;
    }

    // 移动到下一个消息
    nlh = NLMSG_NEXT(nlh, status);
}

自定义应用程序：
开发者可以使用Netlink来编写自定义的网络应用程序，以实现特定的网络功能或服务。

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define NETLINK_USER 27

struct msg_data {
    struct nlmsghdr nlh;
    char msg[10];
};

int main(void) {
    int sockfd;
    struct sockaddr_nl addr;
    struct msg_data msg;
    int status;

    // 创建Netlink套接字
    sockfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_USER);
    if (sockfd < 0) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // 设置接收数据包的Netlink地址结构体
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    addr.nl_pid = 0; // 设置接收消息的进程ID为0，表示接收来自内核的消息
    addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE; // 设置接收的数据包类型，这里接收链接和IPv4路由相关的数据包

    // 绑定套接字到Netlink地址结构体
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind");
        exit(EXIT_FAILURE);
    }

    // 发送消息到内核
    memset(&msg, 0, sizeof(msg));
    msg.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(msg));
    msg.nlh.nlmsg_type = NLMSG_USER; // 消息类型为自定义用户消息类型
    msg.nlh.nlmsg_flags = NLM_F_REQUEST; // 设置消息标志为请求消息
    msg.nlh.nlmsg_seq = 1; // 消息序列号
    strncpy(msg.msg, "Hello Netlink", sizeof(msg.msg)); // 设置消息内容为"Hello Netlink"
    status = sendto(sockfd, &msg, msg.nlh.nlmsg_len, 0, (struct sockaddr *)&addr, sizeof(addr)); // 发送消息到内核
    if (status < 0) {
        perror("sendto");
        exit(EXIT_FAILURE);
    }

    // 接收来自内核的响应消息
    status = recvfrom(sockfd, &msg, sizeof(msg), MSG_DONTWAIT, (struct sockaddr *)&addr, sizeof(addr)); // 接收消息
    if (status < 0) {
        perror("recvfrom");
        exit(EXIT_FAILURE);
    }
    printf("Received message from kernel: %s\n", msg.msg); // 输出接收到的消息内容

    return 0;
}