netlink组播的使用

Linux的netlink机制是非常好的Linux内核与应用层进行双向交互数据的方式。其常用的单播方式可以实现内核为服务端，应用层为客户端的通信方式。如果需要实现应用层为服务端，内核为客户端的通信方式，则需要使用组播。这种场景一般是应用层守护进程需要实现获取内核的某些模块的状态信息。

内核中已经定义好的组有：

#define NETLINK_ROUTE           0       /* Routing/device hook                          */
#define NETLINK_W1              1       /* 1-wire subsystem                             */
#define NETLINK_USERSOCK        2       /* Reserved for user mode socket protocols      */
#define NETLINK_FIREWALL        3       /* Firewalling hook                             */
#define NETLINK_INET_DIAG       4       /* INET socket monitoring                       */
#define NETLINK_NFLOG           5       /* netfilter/iptables ULOG */
#define NETLINK_XFRM            6       /* ipsec */
#define NETLINK_SELINUX         7       /* SELinux event notifications */
#define NETLINK_ISCSI           8       /* Open-iSCSI */
#define NETLINK_AUDIT           9       /* auditing */
#define NETLINK_FIB_LOOKUP      10
#define NETLINK_CONNECTOR       11
#define NETLINK_NETFILTER       12      /* netfilter subsystem */
#define NETLINK_IP6_FW          13
#define NETLINK_DNRTMSG         14      /* DECnet routing messages */
#define NETLINK_KOBJECT_UEVENT  15      /* Kernel messages to userspace */
#define NETLINK_GENERIC         16

内核代码：

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <net/sock.h>
 #include <linux/socket.h>
 #include <linux/net.h>
 #include <asm/types.h>
 #include <linux/netlink.h>
 #include <linux/rtnetlink.h>
 #include <linux/skbuff.h>
 #include <linux/delay.h>

 #define NETLINK_USER 29  //User defined group, consistent in both kernel prog and user prog
 #define MYGRP 2 //User defined group, consistent in both kernel prog and user prog

 struct sock *nl_sk = NULL;

 static void send_to_user(void);

 static void send_to_user(void)
 {
     struct sk_buff *skb_out;
     struct nlmsghdr *nlh;
     int msg_size;
     char msg[] = "Hello from kernel";
     int res;

     printk(KERN_INFO "Entering: %s\n", __FUNCTION__);
     msg_size = strlen(msg);
     printk(KERN_INFO "msg_size: %d\n", msg_size);
     //msg[msg_size - 1] = '\0';
     skb_out = nlmsg_new(msg_size, );

     if (!skb_out) {
         printk(KERN_ERR "Failed to allocate new skb\n");
         return;
     }
     nlh = nlmsg_put(skb_out, , , NLMSG_DONE, msg_size, );
     //NETLINK_CB(skb_out).dst_group = 1; /* Multicast to group 1, 1<<0 */
     strncpy(nlmsg_data(nlh), msg, msg_size);

     res = nlmsg_multicast(nl_sk, skb_out, , MYGRP, );
     if (res < ) {
         printk(KERN_INFO "Error while sending bak to user, err id: %d\n", res);
     }
 }

 static int __init
 hello_init(void) {

     struct netlink_kernel_cfg cfg = {
         .groups = MYGRP,
     };
     printk("Entering: %s\n", __FUNCTION__);
     nl_sk = netlink_kernel_create(&init_net, NETLINK_USER, &cfg);
     if (!nl_sk) {
         printk(KERN_ALERT "Error creating socket.\n");
         return -;
     }

     msleep();
     send_to_user();

     return ;
 }

 static void __exit
 hello_exit(void) {

     printk(KERN_INFO "exiting hello module\n");
     netlink_kernel_release(nl_sk);
 }

 module_init(hello_init);
 module_exit(hello_exit);
 MODULE_LICENSE("GPL");

应用层代码：

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

 #define MYPROTO 29 //User defined group, consistent in both kernel prog and user prog
 #define MYMGRP 2 //User defined group, consistent in both kernel prog and user prog

 int open_netlink()
 {
     int sock = socket(AF_NETLINK,SOCK_RAW,MYPROTO);
     struct sockaddr_nl addr;

     memset((void *)&addr, , sizeof(addr));

     if (sock<)
         return sock;
     addr.nl_family = AF_NETLINK;
     addr.nl_pid = getpid();
     addr.nl_groups = MYMGRP;
     if (bind(sock,(struct sockaddr *)&addr,sizeof(addr))<)
         return -;
     return sock;
 }

 int read_event(int sock)
 {
     struct sockaddr_nl nladdr;
     struct msghdr msg;
     struct iovec iov[];
     struct nlmsghdr nlh;
     char buffer[];
     int ret;
     iov[].iov_base = (void *)&nlh;
     iov[].iov_len = sizeof(nlh);
     iov[].iov_base = (void *)buffer;
     iov[].iov_len = sizeof(buffer);
     msg.msg_name = (void *)&(nladdr);
     msg.msg_namelen = sizeof(nladdr);
     msg.msg_iov = iov;
     msg.msg_iovlen = sizeof(iov)/sizeof(iov[]);
     ret=recvmsg(sock, &msg, );
     if (ret<) {
         return ret;
     }
     printf("Received message payload: %s\n", NLMSG_DATA(&nlh));
     char *a = NLMSG_DATA(&nlh);
     int i;
     printf("Recv Data:\n");
     for(i = ; i < ; i++) {
         printf("%c", a[i]);
     }
     printf("\n");
 }

 int main(int argc, char *argv[])
 {
     int nls = open_netlink();
     if (nls<) {
         err(,"netlink");
     }

     while ()
         read_event(nls);
     return ;
 }

其中 协议类型与组号 内核要与应用层保持一致，且内核模块要先运行。