Linux内核 -- Netlink多播组消息处理技术

Netlink多播组消息处理技术文档

概述

Netlink是一种用户态与内核态之间通信的机制，支持单播和多播模式。多播组答应多个用户态进程接收同一组的广播消息，广泛应用于网络变乱、系统通知等场景。
本文将详细先容如安在内核态发送多播组消息，以及用户态如何接收并处理这些消息。

---

内核态：发送多播组消息

实现步调

• 创建Netlink套接字：通过netlink_kernel_create创建一个Netlink套接字。
  
• 构建消息：填充nlmsghdr头部和数据部分。
  
• 发送消息：利用netlink_broadcast将消息广播到指定多播组。
  

示例代码

1. #include <linux/module.h>
2. #include <linux/netlink.h>
3. #include <net/sock.h>
4. #include <linux/skbuff.h>
6. #define NETLINK_USER 31
7. #define MULTICAST_GROUP1 (1 << 0)
8. #define MULTICAST_GROUP2 (1 << 1)
10. static struct sock *nl_sock = NULL;
12. // 初始化Netlink套接字
13. static int __init netlink_init(void) {
14.     struct netlink_kernel_cfg cfg = {
15.         .groups = MULTICAST_GROUP1 | MULTICAST_GROUP2, // 支持的多播组
16.         .input = NULL, // 无需接收消息
17.     };
19.     nl_sock = netlink_kernel_create(&init_net, NETLINK_USER, &cfg);
20.     if (!nl_sock) {
21.         printk(KERN_ERR "Failed to create Netlink socket\n");
22.         return -ENOMEM;
23.     }
25.     printk(KERN_INFO "Netlink socket created\n");
26.     return 0;
27. }
29. // 向多播组发送消息
30. static void send_multicast_message(const char *message, uint32_t group) {
31.     struct sk_buff *skb;
32.     struct nlmsghdr *nlh;
33.     int msg_size = strlen(message) + 1;
35.     skb = nlmsg_new(msg_size, GFP_KERNEL);
36.     if (!skb) {
37.         printk(KERN_ERR "Failed to allocate sk_buff\n");
38.         return;
39.     }
41.     nlh = nlmsg_put(skb, 0, 0, NLMSG_DONE, msg_size, 0);
42.     strcpy(nlmsg_data(nlh), message);
44.     netlink_broadcast(nl_sock, skb, 0, group, GFP_KERNEL);
45.     printk(KERN_INFO "Message sent to group %u: %s\n", group, message);
46. }
48. // 模块加载函数
49. static int __init netlink_multicast_init(void) {
50.     int ret = netlink_init();
51.     if (ret) return ret;
53.     send_multicast_message("Hello Group 1", MULTICAST_GROUP1);
54.     send_multicast_message("Hello Group 2", MULTICAST_GROUP2);
56.     return 0;
57. }
59. // 模块卸载函数
60. static void __exit netlink_multicast_exit(void) {
61.     if (nl_sock) {
62.         netlink_kernel_release(nl_sock);
63.         printk(KERN_INFO "Netlink socket released\n");
64.     }
65. }
67. module_init(netlink_multicast_init);
68. module_exit(netlink_multicast_exit);
69. MODULE_LICENSE("GPL");

复制代码

---

用户态：接收多播组消息

实现步调

• 创建Netlink套接字：利用socket()创建用户态的Netlink套接字。
  
• 订阅多播组：通过setsockopt()将套接字加入一个或多个多播组。
  
• 接收消息：利用recvmsg()从套接字中接收消息。
  
• 处理消息：解析nlmsghdr头部并处理数据。
  

示例代码

1. #include <linux/netlink.h>
2. #include <sys/socket.h>
3. #include <string.h>
4. #include <stdlib.h>
5. #include <stdio.h>
6. #include <errno.h>
7. #include <unistd.h>
9. #define NETLINK_USER 31
10. #define MULTICAST_GROUP1 (1 << 0)
11. #define MULTICAST_GROUP2 (1 << 1)
12. #define MAX_PAYLOAD 1024
14. struct nl_msg {
15.     struct nlmsghdr hdr;
16.     char data[MAX_PAYLOAD];
17. };
19. // 初始化Netlink套接字并订阅多播组
20. int init_netlink_socket(int *sock_fd, uint32_t groups) {
21.     struct sockaddr_nl src_addr;
23.     *sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_USER);
24.     if (*sock_fd < 0) {
25.         perror("socket");
26.         return -1;
27.     }
29.     memset(&src_addr, 0, sizeof(src_addr));
30.     src_addr.nl_family = AF_NETLINK;
31.     src_addr.nl_pid = getpid(); // 当前进程PID
32.     src_addr.nl_groups = groups;
34.     if (bind(*sock_fd, (struct sockaddr *)&src_addr, sizeof(src_addr)) < 0) {
35.         perror("bind");
36.         close(*sock_fd);
37.         return -1;
38.     }
40.     if (setsockopt(*sock_fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &groups, sizeof(groups)) < 0) {
41.         perror("setsockopt NETLINK_ADD_MEMBERSHIP");
42.         close(*sock_fd);
43.         return -1;
44.     }
46.     return 0;
47. }
49. // 动态加入多播组
50. int join_multicast_group(int sock_fd, uint32_t group) {
51.     if (setsockopt(sock_fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &group, sizeof(group)) < 0) {
52.         perror("setsockopt NETLINK_ADD_MEMBERSHIP");
53.         return -1;
54.     }
55.     printf("Joined multicast group: %u\n", group);
56.     return 0;
57. }
59. // 动态退出多播组
60. int leave_multicast_group(int sock_fd, uint32_t group) {
61.     if (setsockopt(sock_fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP, &group, sizeof(group)) < 0) {
62.         perror("setsockopt NETLINK_DROP_MEMBERSHIP");
63.         return -1;
64.     }
65.     printf("Left multicast group: %u\n", group);
66.     return 0;
67. }
69. // 接收并处理消息
70. void receive_messages(int sock_fd) {
71.     struct nl_msg msg;
72.     struct sockaddr_nl src_addr;
73.     struct iovec iov;
74.     struct msghdr msghdr;
76.     while (1) {
77.         memset(&msg, 0, sizeof(msg));
78.         memset(&src_addr, 0, sizeof(src_addr));
79.         memset(&msghdr, 0, sizeof(msghdr));
81.         iov.iov_base = &msg;
82.         iov.iov_len = sizeof(msg);
83.         msghdr.msg_name = &src_addr;
84.         msghdr.msg_namelen = sizeof(src_addr);
85.         msghdr.msg_iov = &iov;
86.         msghdr.msg_iovlen = 1;
88.         int ret = recvmsg(sock_fd, &msghdr, 0);
89.         if (ret < 0) {
90.             perror("recvmsg");
91.             break;
92.         }
94.         printf("Received message from group: %u\n", src_addr.nl_groups);
95.         printf("Message: %s\n", msg.data);
96.     }
97. }
99. int main() {
100.     int sock_fd;
101.     uint32_t groups = MULTICAST_GROUP1; // 初始订阅组
103.     if (init_netlink_socket(&sock_fd, groups) < 0) {
104.         return -1;
105.     }
107.     // 动态加入组2
108.     join_multicast_group(sock_fd, MULTICAST_GROUP2);
110.     printf("Listening for multicast messages...\n");
111.     receive_messages(sock_fd);
113.     // 动态退出组2
114.     leave_multicast_group(sock_fd, MULTICAST_GROUP2);
116.     close(sock_fd);
117.     return 0;
118. }

复制代码

---

总结

通过以上步调，内核态可以发送Netlink多播组消息，用户态可以接收并处理这些消息，同时支持动态加入和退出多播组的功能。本文提供的代码可以用于实际开发中，资助实现高效的内核态与用户态通信。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。