用户空间和内核空间通讯之【Netlink 】

点击(此处)折叠或打开

1. struct nlmsghdr
   
2. {
   
3.     __u32        nlmsg_len;    /* Length of message including header */
   
4.     __u16        nlmsg_type;    /* Message content */
   
5.     __u16        nlmsg_flags;    /* Additional flags */
   
6.     __u32        nlmsg_seq;    /* Sequence number */
   
7.     __u32        nlmsg_pid;    /* Sending process PID */
   
8. };

点击(此处)折叠或打开

1. struct nlmsgerr
   
2. {
   
3.     int        error; //标准的错误码，定义在errno.h头文件中。可以用perror()来解释
   
4.     struct nlmsghdr msg; //指明了哪条消息触发了结构体中error这个错误值
   
5. };

点击(此处)折叠或打开

1. struct sockaddr_nl
   
2. {
   
3.     sa_family_t    nl_family;    /*该字段总是为AF_NETLINK    */
   
4.     unsigned short    nl_pad;        /* 目前未用到，填充为0*/
   
5.     __u32        nl_pid;        /* process pid    */
   
6.     __u32        nl_groups;    /* multicast groups mask */
   
7. };

点击(此处)折叠或打开

1. pthread_self() << 16 | getpid();

点击(此处)折叠或打开

1. #define NETLINK_ROUTE        0    /* Routing/device hook                */
   
2. #define NETLINK_UNUSED        1    /* Unused number                */
   
3. #define NETLINK_USERSOCK    2    /* Reserved for user mode socket protocols     */
   
4. #define NETLINK_FIREWALL    3    /* Firewalling hook                */
   
5. #define NETLINK_INET_DIAG    4    /* INET socket monitoring            */
   
6. #define NETLINK_NFLOG        5    /* netfilter/iptables ULOG */
   
7. #define NETLINK_XFRM        6    /* ipsec */
   
8. #define NETLINK_SELINUX        7    /* SELinux event notifications */
   
9. #define NETLINK_ISCSI        8    /* Open-iSCSI */
   
10. #define NETLINK_AUDIT        9    /* auditing */
    
11. #define NETLINK_FIB_LOOKUP    10    
    
12. #define NETLINK_CONNECTOR    11
    
13. #define NETLINK_NETFILTER    12    /* netfilter subsystem */
    
14. #define NETLINK_IP6_FW        13
    
15. #define NETLINK_DNRTMSG        14    /* DECnet routing messages */
    
16. #define NETLINK_KOBJECT_UEVENT    15    /* Kernel messages to userspace */
    
17. #define NETLINK_GENERIC        16
    
18. /* leave room for NETLINK_DM (DM Events) */
    
19. #define NETLINK_SCSITRANSPORT    18    /* SCSI Transports */
    
20. #define NETLINK_ECRYPTFS    19
21. #define NETLINK_TEST    20 /* 用户添加的自定义协议 */

点击(此处)折叠或打开

1. #include <sys/stat.h>
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <sys/socket.h>
   
6. #include <sys/types.h>
   
7. #include <string.h>
   
8. #include <asm/types.h>
   
9. #include <linux/netlink.h>
   
10. #include <linux/socket.h>
    
11. 
    
12. #define MAX_PAYLOAD 1024 /*消息最大负载为1024字节*/
    
13. 
    
14. int main(int argc, char* argv[])
    
15. {
    
16.     struct sockaddr_nl dest_addr;
    
17.     struct nlmsghdr *nlh = NULL;
    
18.     struct iovec iov;
    
19.     int sock_fd=-1;
    
20.     struct msghdr msg;
21.         

1.     if(-1 == (sock_fd=socket(PF_NETLINK, SOCK_RAW,NETLINK_TEST))){ //创建套接字
   
2.             perror("can't create netlink socket!");
   
3.             return 1;
   
4.     }
   
5.     memset(&dest_addr, 0, sizeof(dest_addr));
   
6.     dest_addr.nl_family = AF_NETLINK;
   
7.     dest_addr.nl_pid = 0; /*我们的消息是发给内核的*/
   
8.     dest_addr.nl_groups = 0; /*在本示例中不存在使用该值的情况*/
9.         
10.     //将套接字和Netlink地址结构体进行绑定

1.     if(-1 == bind(sock_fd, (struct sockaddr*)&dest_addr, sizeof(dest_addr))){
   
2.           perror("can't bind sockfd with sockaddr_nl!");
   
3.           return 1;
   
4.     }
   
5. 
   
6.     if(NULL == (nlh=(struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD)))){
   
7.           perror("alloc mem failed!");
   
8.           return 1;
   
9.     }
   
10. 
    
11.     memset(nlh,0,MAX_PAYLOAD);
    
12.     /* 填充Netlink消息头部 */
    
13.     nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    
14.     nlh->nlmsg_pid = 0;
    
15.     nlh->nlmsg_type = NLMSG_NOOP; //指明我们的Netlink是消息负载是一条空消息
    
16.     nlh->nlmsg_flags = 0;
    
17. 
    
18.     /*设置Netlink的消息内容，来自我们命令行输入的第一个参数*/
    
19.     strcpy(NLMSG_DATA(nlh), argv[1]);
    
20. 
    
21.     /*这个是模板，暂时不用纠结为什么要这样用。有时间详细讲解socket时再说*/
    
22.     memset(&iov, 0, sizeof(iov));
    
23.     iov.iov_base = (void *)nlh;
    
24.     iov.iov_len = nlh->nlmsg_len;
    
25.     memset(&msg, 0, sizeof(msg));
    
26.     msg.msg_iov = &iov;
    
27.     msg.msg_iovlen = 1;
    
28. 
    
29.     sendmsg(sock_fd, &msg, 0); //通过Netlink socket向内核发送消息
30. 
    
31.     /* 关闭netlink套接字 */
    
32.     close(sock_fd);
    
33.     free(nlh);
    
34.     return 0;
    
35. }

点击(此处)折叠或打开

1. #include <linux/kernel.h>
   
2. #include <linux/module.h>
   
3. #include <linux/skbuff.h>
   
4. #include <linux/init.h>
   
5. #include <linux/ip.h>
   
6. #include <linux/types.h>
   
7. #include <linux/sched.h>
   
8. #include <net/sock.h>
   
9. #include <linux/netlink.h>
   
10. 
    
11. MODULE_LICENSE("GPL");
    
12. MODULE_AUTHOR("Koorey King");
    
13. 
    
14. struct sock *nl_sk = NULL;
    
15. static void nl_data_ready (struct sock *sk, int len)
    
16. {
    
17.     struct sk_buff *skb;
    
18.     struct nlmsghdr *nlh = NULL;
    
19. 
    
20.     while((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL)
    
21.     {
    
22.           nlh = (struct nlmsghdr *)skb->data;
    
23.           printk("%s: received netlink message payload: %s \n", __FUNCTION__, (char*)NLMSG_DATA(nlh));
    
24.           kfree_skb(skb);
    
25.     }
    
26.     printk("recvied finished!\n");
    
27. }
    
28. 
    
29. static int __init myinit_module()
    
30. {
    
31.     printk("my netlink in\n");
    
32.     nl_sk = netlink_kernel_create(NETLINK_TEST,0,nl_data_ready,THIS_MODULE);
    
33.     return 0;
    
34. }
    
35. 
    
36. static void __exit mycleanup_module()
    
37. {
    
38.     printk("my netlink out!\n");
    
39.     sock_release(nl_sk->sk_socket);
    
40. }
    
41. 
    
42. module_init(myinit_module);
    
43. module_exit(mycleanup_module);

点击(此处)折叠或打开

1. #include <sys/stat.h>
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <sys/socket.h>
   
6. #include <sys/types.h>
   
7. #include <string.h>
   
8. #include <asm/types.h>
   
9. #include <linux/netlink.h>
   
10. #include <linux/socket.h>
    
11. 
    
12. #define MAX_PAYLOAD 1024 /*消息最大负载为1024字节*/
    
13. 
    
14. int main(int argc, char* argv[])
    
15. {
    
16.     struct sockaddr_nl dest_addr;
    
17.     struct nlmsghdr *nlh = NULL;
    
18.     struct iovec iov;
    
19.     int sock_fd=-1;
    
20.     struct msghdr msg;
    
21. 
    
22.     if(-1 == (sock_fd=socket(PF_NETLINK, SOCK_RAW,NETLINK_TEST))){
    
23.           perror("can't create netlink socket!");
    
24.           return 1;
    
25.     }
    
26.     memset(&dest_addr, 0, sizeof(dest_addr));
    
27.     dest_addr.nl_family = AF_NETLINK;
    
28.     dest_addr.nl_pid = 0; /*我们的消息是发给内核的*/
    
29.     dest_addr.nl_groups = 0; /*在本示例中不存在使用该值的情况*/
    
30. 
    
31.     if(-1 == bind(sock_fd, (struct sockaddr*)&dest_addr, sizeof(dest_addr))){
    
32.           perror("can't bind sockfd with sockaddr_nl!");
    
33.           return 1;
    
34.     }
    
35.     if(NULL == (nlh=(struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD)))){
    
36.           perror("alloc mem failed!");
    
37.           return 1;
    
38.     }
    
39.     
40.     memset(nlh,0,MAX_PAYLOAD);
    
41.     /* 填充Netlink消息头部 */
    
42.     nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    
43.     nlh->nlmsg_pid = getpid();//我们希望得到内核回应，所以得告诉内核我们ID号
    
44.     nlh->nlmsg_type = NLMSG_NOOP; //指明我们的Netlink是消息负载是一条空消息
    
45.     nlh->nlmsg_flags = 0;
    
46. 
    
47.     /*设置Netlink的消息内容，来自我们命令行输入的第一个参数*/
    
48.     strcpy(NLMSG_DATA(nlh), argv[1]);
    
49. 
    
50.     /*这个是模板，暂时不用纠结为什么要这样用。*/
    
51.     memset(&iov, 0, sizeof(iov));
    
52.     iov.iov_base = (void *)nlh;
    
53.     iov.iov_len = nlh->nlmsg_len;
    
54.     memset(&msg, 0, sizeof(msg));
    
55.     msg.msg_iov = &iov;
    
56.     msg.msg_iovlen = 1;
    
57. 
    
58.     sendmsg(sock_fd, &msg, 0); //通过Netlink socket向内核发送消息
59. 
    
60.     //接收内核消息的消息
    
61.     printf("waiting message from kernel!\n");
    
62.     memset((char*)NLMSG_DATA(nlh),0,1024);
    
63.     recvmsg(sock_fd,&msg,0);
    
64.     printf("Got response: %s\n",NLMSG_DATA(nlh));
    
65. 
    
66.     /* 关闭netlink套接字 */
    
67.     close(sock_fd);
    
68.     free(nlh);
    
69.     return 0;
    
70. }

点击(此处)折叠或打开

1. #include <linux/kernel.h>
   
2. #include <linux/module.h>
   
3. #include <linux/skbuff.h>
   
4. #include <linux/init.h>
   
5. #include <linux/ip.h>
   
6. #include <linux/types.h>
   
7. #include <linux/sched.h>
   
8. #include <net/sock.h>
   
9. #include <net/netlink.h> /*该文头文件里包含了linux/netlink.h，因为我们要用到net/netlink.h中的某些API函数，nlmsg_pug()*/
   
10. 
    
11. MODULE_LICENSE("GPL");
    
12. MODULE_AUTHOR("Koorey King");
    
13. 
    
14. struct sock *nl_sk = NULL;
    
15. //向用户空间发送消息的接口
    
16. void sendnlmsg(char *message,int dstPID)
    
17. {
    
18.     struct sk_buff *skb;
    
19.     struct nlmsghdr *nlh;
    
20.     int len = NLMSG_SPACE(MAX_MSGSIZE);
    
21.     int slen = 0;
    
22. 
    
23.     if(!message || !nl_sk){
    
24.         return;
    
25.     }
    
26. 
    
27.     // 为新的 sk_buffer申请空间
    
28.     skb = alloc_skb(len, GFP_KERNEL);
    
29.     if(!skb){
    
30.         printk(KERN_ERR "my_net_link: alloc_skb Error./n");
    
31.         return;
    
32.     }
    
33. 
    
34.     slen = strlen(message)+1;
    
35. 
    
36.     //用nlmsg_put()来设置netlink消息头部
    
37.     nlh = nlmsg_put(skb, 0, 0, 0, MAX_MSGSIZE, 0);
    
38. 
    
39.     // 设置Netlink的控制块
    
40.     NETLINK_CB(skb).pid = 0; // 消息发送者的id标识，如果是内核发的则置0
    
41.     NETLINK_CB(skb).dst_group = 0; //如果目的组为内核或某一进程，该字段也置0
    
42. 
    
43.     message[slen] = '\0';
    
44.     memcpy(NLMSG_DATA(nlh), message, slen+1);
    
45. 
    
46.     //通过netlink_unicast()将消息发送用户空间由dstPID所指定了进程号的进程
    
47.     netlink_unicast(nl_sk,skb,dstPID,0);
    
48.     printk("send OK!\n");
    
49.     return;
    
50. }
    
51. 
    
52. static void nl_data_ready (struct sock *sk, int len)
    
53. {
    
54.     struct sk_buff *skb;
    
55.     struct nlmsghdr *nlh = NULL;
    
56. 
    
57.     while((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL)
    
58.     {
    
59.         nlh = (struct nlmsghdr *)skb->data;
    
60.         printk("%s: received netlink message payload: %s \n", __FUNCTION__, (char*)NLMSG_DATA(nlh));
    
61.         kfree_skb(skb);
    
62.         sendnlmsg("I see you",nlh->nlmsg_pid); //发送者的进程ID我们已经将其存储在了netlink消息头部里的nlmsg_pid字段里，所以这里可以拿来用。
63.     }
    
64.     printk("recvied finished!\n");
    
65. }
    
66. 
    
67. static int __init myinit_module()
    
68. {
    
69.     printk("my netlink in\n");
    
70.     nl_sk = netlink_kernel_create(NETLINK_TEST,0,nl_data_ready,THIS_MODULE);
    
71.     return 0;
    
72. }
    
73. 
    
74. static void __exit mycleanup_module()
    
75. {
    
76.     printk("my netlink out!\n");
    
77.     sock_release(nl_sk->sk_socket);
    
78. }
    
79. 
    
80. module_init(myinit_module);
    
81. module_exit(mycleanup_module);

点击(此处)折叠或打开

1. #include <sys/stat.h>
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <sys/socket.h>
   
6. #include <sys/types.h>
   
7. #include <string.h>
   
8. #include <asm/types.h>
   
9. #include <linux/netlink.h>
   
10. #include <linux/socket.h>
    
11. 
    
12. #define MAX_PAYLOAD 1024 /*消息最大负载为1024字节*/
    
13. 
    
14. int main(int argc, char* argv[])
    
15. {
    
16.     struct sockaddr_nl dest_addr;
    
17.     struct nlmsghdr *nlh = NULL;
    
18.     //struct iovec iov;
    
19.     int sock_fd=-1;
    
20.     //struct msghdr msg;
    
21. 
    
22.     if(-1 == (sock_fd=socket(PF_NETLINK, SOCK_RAW,NETLINK_TEST))){
    
23.           perror("can't create netlink socket!");
    
24.           return 1;
    
25.     }
    
26.     memset(&dest_addr, 0, sizeof(dest_addr));
    
27.     dest_addr.nl_family = AF_NETLINK;
    
28.     dest_addr.nl_pid = 0; /*我们的消息是发给内核的*/
    
29.     dest_addr.nl_groups = 0; /*在本示例中不存在使用该值的情况*/
    
30. 
    
31.    /*不再调用bind()函数了
32.    if(-1 == bind(sock_fd, (struct sockaddr*)&dest_addr, sizeof(dest_addr))){
    
33.           perror("can't bind sockfd with sockaddr_nl!");
    
34.           return 1;
    
35.    }*/
    
36. 
    
37.    if(NULL == (nlh=(struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD)))){
    
38.           perror("alloc mem failed!");
    
39.           return 1;
    
40.    }
    
41.    memset(nlh,0,MAX_PAYLOAD);
    
42.    /* 填充Netlink消息头部 */
    
43.    nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    
44.    nlh->nlmsg_pid = getpid();//我们希望得到内核回应，所以得告诉内核我们ID号
    
45.    nlh->nlmsg_type = NLMSG_NOOP; //指明我们的Netlink是消息负载是一条空消息
    
46.    nlh->nlmsg_flags = 0;
    
47. 
    
48.    /*设置Netlink的消息内容，来自我们命令行输入的第一个参数*/
    
49.    strcpy(NLMSG_DATA(nlh), argv[1]);
    
50. 
    
51.    /*这个模板就用不上了。*/
52.    /*
    
53.    memset(&iov, 0, sizeof(iov));
    
54.    iov.iov_base = (void *)nlh;
    
55.    iov.iov_len = nlh->nlmsg_len;
    
56.    memset(&msg, 0, sizeof(msg));
    
57.    msg.msg_iov = &iov;
    
58.    msg.msg_iovlen = 1;
    
59.    */
    
60. 
    
61.    //sendmsg(sock_fd, &msg, 0); //不再用这种方式发消息到内核
    
62.    sendto(sock_fd,nlh,NLMSG_LENGTH(MAX_PAYLOAD),0,(struct sockaddr*)(&dest_addr),sizeof(dest_addr)); 
    
63.         
    
64.    //接收内核消息的消息
    
65.    printf("waiting message from kernel!\n");
    
66.    //memset((char*)NLMSG_DATA(nlh),0,1024);
    
67.    memset(nlh,0,MAX_PAYLOAD); //清空整个Netlink消息头包括消息头和负载
    
68.    //recvmsg(sock_fd,&msg,0);
    
69.    recvfrom(sock_fd,nlh,NLMSG_LENGTH(MAX_PAYLOAD),0,(struct sockaddr*)(&dest_addr),NULL);
    
70.    printf("Got response: %s\n",NLMSG_DATA(nlh)); 
    
71. 
    
72.    /* 关闭netlink套接字 */
    
73.    close(sock_fd);
    
74.    free(nlh);
    
75.    return 0;
    
76. }

点击(此处)折叠或打开

1. #define NETLINK_ROUTE        0    /* Routing/device hook                */
   
2. #define NETLINK_UNUSED        1    /* Unused number                */
   
3. #define NETLINK_USERSOCK    2    /* Reserved for user mode socket protocols     */
   
4. #define NETLINK_FIREWALL    3    /* Firewalling hook                */
   
5. #define NETLINK_INET_DIAG    4    /* INET socket monitoring            */
   
6. #define NETLINK_NFLOG        5    /* netfilter/iptables ULOG */
   
7. #define NETLINK_XFRM        6    /* ipsec */
   
8. #define NETLINK_SELINUX        7    /* SELinux event notifications */
   
9. #define NETLINK_ISCSI        8    /* Open-iSCSI */
   
10. #define NETLINK_AUDIT        9    /* auditing */
    
11. #define NETLINK_FIB_LOOKUP    10    
    
12. #define NETLINK_CONNECTOR    11
    
13. #define NETLINK_NETFILTER    12    /* netfilter subsystem */
    
14. #define NETLINK_IP6_FW        13
    
15. #define NETLINK_DNRTMSG        14    /* DECnet routing messages */
    
16. #define NETLINK_KOBJECT_UEVENT    15    /* Kernel messages to userspace */
    
17. #define NETLINK_GENERIC        16
    
18. /* leave room for NETLINK_DM (DM Events) */
    
19. #define NETLINK_SCSITRANSPORT    18    /* SCSI Transports */
    
20. #define NETLINK_ECRYPTFS    19
    
21. #define NETLINK_TEST 20 /* 用户添加的自定义协议 */

点击(此处)折叠或打开

1. static u32 netlink_group_mask(u32 group)
   
2. {
   
3.     return group ? 1 << (group - 1) : 0;
   
4. }

点击(此处)折叠或打开

1. #include <sys/stat.h>
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <sys/socket.h>
   
6. #include <sys/types.h>
   
7. #include <string.h>
   
8. #include <asm/types.h>
   
9. #include <linux/netlink.h>
   
10. #include <linux/socket.h>
    
11. #include <errno.h>
    
12. 
    
13. #define MAX_PAYLOAD 1024 // Netlink消息的最大载荷的长度
    
14. 
    
15. unsigned int netlink_group_mask(unsigned int group)
    
16. {
    
17.     return group ? 1 << (group - 1) : 0;
    
18. }
    
19. 
    
20. int main(int argc, char* argv[])
    
21. {
    
22.     struct sockaddr_nl src_addr;
    
23.     struct nlmsghdr *nlh = NULL;
    
24.     struct iovec iov;
    
25.     struct msghdr msg;
    
26.     int sock_fd, retval;
    
27. 
    
28.     // 创建Socket
    
29.     sock_fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_TEST);
    
30.     if(sock_fd == -1){
    
31.         printf("error getting socket: %s", strerror(errno));
    
32.         return -1;
    
33.     }
    
34. 
    
35.     memset(&src_addr, 0, sizeof(src_addr));
    
36.     src_addr.nl_family = PF_NETLINK;
    
37.     src_addr.nl_pid = 0; // 表示我们要从内核接收多播消息。注意：该字段为0有双重意义，另一个意义是表示我们发送的数据的目的地址是内核。
    
38.     src_addr.nl_groups = netlink_group_mask(atoi(argv[1])); // 多播组的掩码，组号来自我们执行程序时输入的第一个参数
    
39. 
    
40.     // 因为我们要加入到一个多播组，所以必须调用bind()。
    
41.     retval = bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));
    
42.     if(retval < 0){
    
43.         printf("bind failed: %s", strerror(errno));
    
44.         close(sock_fd);
    
45.         return -1;
    
46.     }
    
47. 
    
48.     // 为接收Netlink消息申请存储空间
    
49.     nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));
    
50.     if(!nlh){
    
51.         printf("malloc nlmsghdr error!\n");
    
52.         close(sock_fd);
    
53.         return -1;
    
54.     }
    
55. 
    
56.     memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
    
57.     iov.iov_base = (void *)nlh;
    
58.     iov.iov_len = NLMSG_SPACE(MAX_PAYLOAD);
    
59. 
    
60.     memset(&msg, 0, sizeof(msg));
    
61.     msg.msg_iov = &iov;
    
62.     msg.msg_iovlen = 1;
    
63. 
    
64.     // 从内核接收消息
    
65.     printf("waitinf for...\n");
    
66.     recvmsg(sock_fd, &msg, 0);
    
67.     printf("Received message: %s \n", NLMSG_DATA(nlh));
    
68.     
    
69.     close(sock_fd);
    
70. 
    
71.     return 0;
    
72. }

点击(此处)折叠或打开

1. #include <linux/kernel.h>
   
2. #include <linux/module.h>
   
3. #include <linux/skbuff.h>
   
4. #include <linux/init.h>
   
5. #include <linux/ip.h>
   
6. #include <linux/types.h>
   
7. #include <linux/sched.h>
   
8. #include <net/sock.h>
   
9. #include <net/netlink.h> 
   
10. 
    
11. MODULE_LICENSE("GPL");
    
12. MODULE_AUTHOR("Koorey King");
    
13. 
    
14. struct sock *nl_sk = NULL;
    
15. static struct task_struct *mythread = NULL; //内核线程对象
    
16. 
    
17. //向用户空间发送消息的接口
    
18. void sendnlmsg(char *message/*,int dstPID*/)
    
19. {
    
20.     struct sk_buff *skb;
    
21.     struct nlmsghdr *nlh;
    
22.     int len = NLMSG_SPACE(MAX_MSGSIZE);
    
23.     int slen = 0;
    
24. 
    
25.     if(!message || !nl_sk){
    
26.         return;
    
27.     }
    
28. 
    
29.     // 为新的 sk_buffer申请空间
    
30.     skb = alloc_skb(len, GFP_KERNEL);
    
31.     if(!skb){
    
32.         printk(KERN_ERR "my_net_link: alloc_skb Error./n");
    
33.         return;
    
34.     }
    
35. 
    
36.     slen = strlen(message)+1;
    
37. 
    
38.     //用nlmsg_put()来设置netlink消息头部
    
39.     nlh = nlmsg_put(skb, 0, 0, 0, MAX_MSGSIZE, 0);
    
40. 
    
41.     // 设置Netlink的控制块里的相关信息
    
42.     NETLINK_CB(skb).pid = 0; // 消息发送者的id标识，如果是内核发的则置0
    
43.     NETLINK_CB(skb).dst_group = 5; //多播组号为5，但置成0好像也可以。
    
44. 
    
45.     message[slen] = '\0';
    
46.     memcpy(NLMSG_DATA(nlh), message, slen+1);
    
47. 
    
48.     //通过netlink_unicast()将消息发送用户空间由dstPID所指定了进程号的进程
    
49.     //netlink_unicast(nl_sk,skb,dstPID,0);
    
50.     netlink_broadcast(nl_sk, skb, 0,5, GFP_KERNEL); //发送多播消息到多播组5，这里我故意没有用1之类的“常见”值，目的就是为了证明我们上面提到的多播组号和多播组号掩码之间的对应关系
    
51.     printk("send OK!\n");
    
52.     return;
    
53. }
    
54. 
    
55. //每隔1秒钟发送一条“I am from kernel!”消息，共发10个报文
    
56. static int sending_thread(void *data)
57. {
    
58.      int i = 10;
    
59.      struct completion cmpl;
    
60.      while(i--){
    
61.             init_completion(&cmpl);
    
62.             wait_for_completion_timeout(&cmpl, 1 * HZ);
    
63.             sendnlmsg("I am from kernel!");
    
64.      }
    
65.      printk("sending thread exited!");
    
66.      return 0;
    
67. }
    
68. 
    
69. static int __init myinit_module()
    
70. {
    
71.     printk("my netlink in\n");
    
72.     nl_sk = netlink_kernel_create(NETLINK_TEST,0,NULL,THIS_MODULE);
    
73. 
    
74.     if(!nl_sk){
    
75.         printk(KERN_ERR "my_net_link: create netlink socket error.\n");
    
76.         return 1;
    
77.     }
    
78. 
    
79.     printk("my netlink: create netlink socket ok.\n");
    
80.     mythread = kthread_run(sending_thread,NULL,"thread_sender");
    
81.     return 0;
    
82. }
    
83. 
    
84. static void __exit mycleanup_module()
    
85. {
    
86.     if(nl_sk != NULL){
    
87.         sock_release(nl_sk->sk_socket);
    
88. }
    
89. printk("my netlink out!\n");
    
90. }
    
91. 
    
92. module_init(myinit_module);
    
93. module_exit(mycleanup_module);

点击(此处)折叠或打开

1. struct sk_buff {
   
2.     /* These two members must be first. */
   
3.     struct sk_buff        *next;
   
4.     struct sk_buff        *prev;
   
5.     … …
   
6.     /*
   
7.      * This is the control buffer. It is free to use for every
   
8.      * layer. Please put your private variables there. If you
   
9.      * want to keep them across layers you have to do a skb_clone()
   
10.      * first. This is owned by whoever has the skb queued ATM.
    
11.      */
    
12.     char            cb[48];
    
13. 
    
14.     … …
15. }

点击(此处)折叠或打开

1. struct netlink_skb_parms
   
2. {
   
3.     struct ucred        creds;        /* Skb credentials    */
   
4.     __u32            pid;
   
5.     __u32            dst_group;
   
6.     kernel_cap_t        eff_cap;
   
7.     __u32            loginuid;    /* Login (audit) uid */
   
8.     __u32            sid;        /* SELinux security id */
   
9. };

点击(此处)折叠或打开

1. NETLINK_CB(skb).pid=xx;
   
2. NETLINK_CB(skb).dst_group=xx;