Chinaunix首页 | 论坛 | 博客
  • 博客访问: 355553
  • 博文数量: 21
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 215
  • 用 户 组: 普通用户
  • 注册时间: 2018-11-27 17:55
文章分类
文章存档

2019年(21)

我的朋友

分类: C/C++

2019-02-02 12:56:12

一、什么是Netlink通信机制

   Netlink套接字是用以实现用户进程与内核进程通信的一种特殊的进程间通信(IPC) ,也是网络应用程序与内核通信的最常用的接口。

    Netlink 是一种特殊的 socket,它是 Linux 所特有的,类似于 BSD 中的AF_ROUTE 但又远比它的功能强大,目前在Linux 内核中
    使用netlink 进行应用与内核通信的应用很多; 包括:路由 daemon(NETLINK_ROUTE),用户态 socket 协议(NETLINK_USERSOCK),
    防火墙(NETLINK_FIREWALL),netfilter 子系统(NETLINK_NETFILTER),内核事件向用户态通知(NETLINK_KOBJECT_UEVENT),
    通用 netlink(NETLINK_GENERIC)等。
    
    Netlink 是一种在内核与用户应用间进行双向数据传输的非常好的方式,用户态应用使用标准的 socket API 就可以使用 netlink 提供的强大功能,
    内核态需要使用专门的内核 API 来使用 netlink。
    Netlink 相对于系统调用ioctl 以及 /proc文件系统而言具有以下优点:
    1,netlink使用简单,只需要在include/linux/netlink.h中增加一个新类型的 netlink 协议定义即可,(如 #define NETLINK_TEST 20 然后,内核和用户态应用就可以立即通过 socket API 使用该 netlink 协议类型进行数据交换);
    2. netlink是一种异步通信机制,在内核与用户态应用之间传递的消息保存在socket缓存队列中,发送消息只是把消息保存在接收者的socket的接收队列,而不需要等待接收者收到消息;
    3.使用 netlink 的内核部分可以采用模块的方式实现,使用 netlink 的应用部分和内核部分没有编译时依赖;
    4.netlink 支持多播,内核模块或应用可以把消息多播给一个netlink组,属于该neilink 组的任何内核模块或应用都能接收到该消息,内核事件向用户态的通知机制就使用了这一特性;
    5.内核可以使用 netlink 首先发起会话;


、netlink实例

(1)用户态程序 (sendto(), recvfrom())

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/socket.h>
  4. #include <string.h>
  5. #include <linux/netlink.h>
  6. #include <stdint.h>
  7. #include <unistd.h>
  8. #include <errno.h>

  9. #define NETLINK_TEST 30
  10. #define MSG_LEN 125
  11. #define MAX_PLOAD 125

  12. typedef struct _user_msg_info
  13. {
  14.     struct nlmsghdr hdr;
  15.     char msg[MSG_LEN];
  16. } user_msg_info;

  17. int main(int argc, char **argv)
  18. {
  19.     int skfd;
  20.     int ret;
  21.     user_msg_info u_info;
  22.     socklen_t len;
  23.     struct nlmsghdr *nlh = NULL;
  24.     struct sockaddr_nl saddr, daddr;
  25.     char *umsg = "hello netlink!!";

  26.     /* 创建NETLINK socket */
  27.     skfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);
  28.     if(skfd == -1)
  29.     {
  30.         perror("create socket error\n");
  31.         return -1;
  32.     }

  33.     memset(&saddr, 0, sizeof(saddr));
  34.     saddr.nl_family = AF_NETLINK; //AF_NETLINK
  35.     saddr.nl_pid = 100; /* port ID */
  36.     saddr.nl_groups = 0;  //如果是接收内核的多播,这里不能填0
  37.     if(bind(skfd, (struct sockaddr *)&saddr, sizeof(saddr)) != 0)
  38.     {
  39.         perror("bind() error\n");
  40.         close(skfd);
  41.         return -1;
  42.     }

  43.     memset(&daddr, 0, sizeof(daddr));
  44.     daddr.nl_family = AF_NETLINK;
  45.     daddr.nl_pid = 0; // to kernel
  46.     daddr.nl_groups = 0;

  47.     nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PLOAD));
  48.     memset(nlh, 0, sizeof(struct nlmsghdr));
  49.     nlh->nlmsg_len = NLMSG_SPACE(MAX_PLOAD);
  50.     nlh->nlmsg_flags = 0;
  51.     nlh->nlmsg_type = 0;
  52.     nlh->nlmsg_seq = 0;
  53.     nlh->nlmsg_pid = saddr.nl_pid; //self port

  54.     memcpy(NLMSG_DATA(nlh), umsg, strlen(umsg));
  55.     ret = sendto(skfd, nlh, nlh->nlmsg_len, 0, (struct sockaddr *)&daddr, sizeof(struct sockaddr_nl));
  56.     if(!ret)
  57.     {
  58.         perror("sendto error\n");
  59.         close(skfd);
  60.         exit(-1);
  61.     }
  62.     printf("send kernel:%s\n", umsg);

  63.     memset(&u_info, 0, sizeof(u_info));
  64.     len = sizeof(struct sockaddr_nl);
  65.     ret = recvfrom(skfd, &u_info, sizeof(user_msg_info), 0, (struct sockaddr *)&daddr, &len);
  66.     if(!ret)
  67.     {
  68.         perror("recv form kernel error\n");
  69.         close(skfd);
  70.         exit(-1);
  71.     }

  72.     printf("from kernel:%s\n", u_info.msg);
  73.     close(skfd);

  74.     free((void *)nlh);
  75.     return 0;
  76. }
Netlink 内核模块代码:

点击(此处)折叠或打开

  1. /****************************************
  2. * Author: zhangwj
  3. * Date: 2017-01-19
  4. * Filename: netlink_test.c
  5. * Descript: netlink of kernel
  6. * Kernel: 3.10.0-327.22.2.el7.x86_64
  7. * Warning:
  8. ******************************************/

  9. #include <linux/init.h>
  10. #include <linux/module.h>
  11. #include <linux/types.h>
  12. #include <net/sock.h>
  13. #include <linux/netlink.h>

  14. #define NETLINK_TEST 30
  15. #define MSG_LEN 125
  16. #define USER_PORT 100

  17. MODULE_LICENSE("GPL");
  18. MODULE_AUTHOR("zhangwj");
  19. MODULE_DESCRIPTION("netlink example");

  20. struct sock *nlsk = NULL;
  21. extern struct net init_net;

  22. int send_usrmsg(char *pbuf, uint16_t len)
  23. {
  24.     struct sk_buff *nl_skb;
  25.     struct nlmsghdr *nlh;

  26.     int ret;

  27.     /* 创建sk_buff 空间 */
  28.     nl_skb = nlmsg_new(len, GFP_ATOMIC);
  29.     if(!nl_skb)
  30.     {
  31.         printk("netlink alloc failure\n");
  32.         return -1;
  33.     }

  34.     /* 设置netlink消息头部 */
  35.     nlh = nlmsg_put(nl_skb, 0, 0, NETLINK_TEST, len, 0);
  36.     if(nlh == NULL)
  37.     {
  38.         printk("nlmsg_put failaure \n");
  39.         nlmsg_free(nl_skb);
  40.         return -1;
  41.     }

  42.     /* 拷贝数据发送 */
  43.     memcpy(nlmsg_data(nlh), pbuf, len);
  44.     ret = netlink_unicast(nlsk, nl_skb, USER_PORT, MSG_DONTWAIT);

  45.     return ret;
  46. }

  47. static void netlink_rcv_msg(struct sk_buff *skb)
  48. {
  49.     struct nlmsghdr *nlh = NULL;
  50.     char *umsg = NULL;
  51.     char *kmsg = "hello users!!!";

  52.     if(skb->len >= nlmsg_total_size(0))
  53.     {
  54.         nlh = nlmsg_hdr(skb);
  55.         umsg = NLMSG_DATA(nlh);
  56.         if(umsg)
  57.         {
  58.             printk("kernel recv from user: %s\n", umsg);
  59.             send_usrmsg(kmsg, strlen(kmsg));
  60.         }
  61.     }
  62. }

  63. struct netlink_kernel_cfg cfg = {
  64.         .input = netlink_rcv_msg, /* set recv callback */
  65. };

  66. int test_netlink_init(void)
  67. {
  68.     /* create netlink socket */
  69.     nlsk = (struct sock *)netlink_kernel_create(&init_net, NETLINK_TEST, &cfg);
  70.     if(nlsk == NULL)
  71.     {
  72.         printk("netlink_kernel_create error !\n");
  73.         return -1;
  74.     }
  75.     printk("test_netlink_init\n");
  76.     
  77.     return 0;
  78. }

  79. void test_netlink_exit(void)
  80. {
  81.     if (nlsk){
  82.         netlink_kernel_release(nlsk); /* release ..*/
  83.         nlsk = NULL;
  84.     }
  85.     printk("test_netlink_exit!\n");
  86. }

  87. module_init(test_netlink_init);
  88. module_exit(test_netlink_exit)
Makeflie:

点击(此处)折叠或打开

  1. #
  2. #Desgin of Netlink
  3. #

  4. MODULE_NAME :=netlink_test
  5. obj-m :=$(MODULE_NAME).o

  6. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
  7. PWD := $(shell pwd)

  8. all:
  9.     $(MAKE) -C $(KERNELDIR) M=$(PWD)

  10. clean:
  11.     $(MAKE) -C $(KERNELDIR) M=$(PWD) clean

运行结果:

首先将编译出来的Netlink内核模块插入到系统当中(insmod netlink_test.ko)可以看到如下:


点击(此处)折叠或打开

  1. [root@localhost nt_2nd]# insmod netlink_test.ko
  2. [root@localhost nt_2nd]# dmesg
  3. [25024.276345] test_netlink_init
接着运行应用程序:./a.out

点击(此处)折叠或打开

  1. [root@localhost nt_2nd]# ./a.out
  2. send kernel:hello
  3. from kernel:hello
  4. [root@localhost nt_2nd]# dmesg
  5. [25024.276345] test_netlink_init
  6. [25117.548350] kernel recv from user: hello
  7. [root@localhost nt_2nd]#

三、Netlink常用数据结构及函数

 用户态应用使用标准的 socket API有(sendto()),recvfrom(); sendmsg(), recvmsg())

 下面简单介绍几种NETLINK用户态通信的常用数据结构

 1、用户态数据结构

   Netlink通信跟常用UDP Socket通信类似:
 struct sockaddr_nl 是netlink通信地址跟普通socket struct sockaddr_in类似
  struct sockaddr_nl结构: 


点击(此处)折叠或打开

  1. struct sockaddr_nl {
  2.     __kernel_sa_family_t nl_family; /* AF_NETLINK (跟AF_INET对应)*/
  3.     unsigned short nl_pad; /* zero */
  4.     __u32 nl_pid; /* port ID */
  5.     __u32 nl_groups; /* multicast groups mask */
  6. };
  如果netlink的协议是 NETLINK_ROUTE,那一般要监听多播了,nl_groups一般可以或上下面几个常用的值:
  定义位于retnetlink.h,RTMGRP_*格式
RTMGRP_LINK         - 当网卡变动时会触发这个多播组,例如插拔网线、增减网卡设备、启用禁用接口等
RTMGRP_IPV4_IFADDR  - 当ipv4地址变动时会触发这个多播组,例如修改IP
RTMGRP_IPV4_ROUTE   - 当ipv4路由变动时会触发这个多播组
RTMGRP_IPV6_IFADDR  - 当ipv6地址变动时会触发这个多播组,例如修改IP
RTMGRP_IPV6_ROUTE   - 当ipv6路由变动时会触发这个多播组


struct nlmsghd
 结构:

点击(此处)折叠或打开

  1. /* struct nlmsghd 是netlink消息头*/
  2. struct nlmsghdr {
  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 port ID */
  8. };
(1)nlmsg_len:整个netlink消息的长度(包含消息头);

(2)nlmsg_type:消息状态,内核在include/uapi/linux/netlink.h中定义了以下4种通用的消息类型,它们分别是:

点击(此处)折叠或打开

  1. #define NLMSG_NOOP 0x1 /* Nothing. */
  2. #define NLMSG_ERROR 0x2 /* Error */
  3. #define NLMSG_DONE 0x3 /* End of a dump */
  4. #define NLMSG_OVERRUN 0x4 /* Data lost */

  5. #define NLMSG_MIN_TYPE 0x10 /* < 0x10: reserved control messages */

  6. /*NLMSG_NOOP:不执行任何动作,必须将该消息丢弃;
  7. NLMSG_ERROR:消息发生错误;
  8. NLMSG_DONE:标识分组消息的末尾;
  9. NLMSG_OVERRUN:缓冲区溢出,表示某些消息已经丢失。
  10. NLMSG_MIN_TYPEK:预留 */
(3)nlmsg_flags:消息标记,它们用以表示消息的类型,如下

点击(此处)折叠或打开

  1. /* Flags values */

  2. #define NLM_F_REQUEST 1 /* It is request message. */
  3. #define NLM_F_MULTI 2 /* Multipart message, terminated by NLMSG_DONE */
  4. #define NLM_F_ACK 4 /* Reply with ack, with zero or error code */
  5. #define NLM_F_ECHO 8 /* Echo this request */
  6. #define NLM_F_DUMP_INTR 16 /* Dump was inconsistent due to sequence change */

  7. /* Modifiers to GET request */
  8. #define NLM_F_ROOT 0x100 /* specify tree root */
  9. #define NLM_F_MATCH 0x200 /* return all matching */
  10. #define NLM_F_ATOMIC 0x400 /* atomic GET */
  11. #define NLM_F_DUMP (NLM_F_ROOT|NLM_F_MATCH)

  12. /* Modifiers to NEW request */
  13. #define NLM_F_REPLACE 0x100 /* Override existing */
  14. #define NLM_F_EXCL 0x200 /* Do not touch, if it exists */
  15. #define NLM_F_CREATE 0x400 /* Create, if it does not exist */
  16. #define NLM_F_APPEND 0x800 /* Add to end of list */
(4)nlmsg_seq:消息序列号,用以将消息排队,有些类似TCP协议中的序号(不完全一样),但是netlink的这个字段是可选的,不强制使用;
(5)nlmsg_pid:发送端口的ID号,对于内核来说该值就是0,对于用户进程来说就是其socket所绑定的ID号。

 2. netlink 内核数据结构、常用宏及函数:

netlink消息类型:

点击(此处)折叠或打开

  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 /* Unused number, formerly ip_queue */
  5. #define NETLINK_SOCK_DIAG 4 /* 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_RDMA 20
  22. #define NETLINK_CRYPTO 21 /* Crypto layer */

  23. #define NETLINK_INET_DIAG NETLINK_SOCK_DIAG

  24. #define MAX_LINKS 32


netlink 内核常用函数:

netlink_kernel_create内核函数用于创建 内核socket用用户态通信 


点击(此处)折叠或打开

  1. static inline struct sock *
  2. netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg)
  3. /* net: net指向所在的网络命名空间, 一般默认传入的是&init_net(不需要定义); 定义在net_namespace.c(extern struct net init_net);
  4.    unit:netlink协议类型
  5.    cfg: cfg存放的是netlink内核配置参数(如下)
  6. */

  7. /* optional Netlink kernel configuration parameters */
  8. struct netlink_kernel_cfg {
  9.     unsigned int groups;
  10.     unsigned int flags;
  11.     void (*input)(struct sk_buff *skb); /* input 回调函数 */
  12.     struct mutex *cb_mutex;
  13.     void (*bind)(int group);
  14.     bool (*compare)(struct net *net, struct sock *sk);
  15. };
单播netlink_unicast() 和 多播netlink_broadcast()

点击(此处)折叠或打开

  1. /* 来发送单播消息 */
  2. extern int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 portid, int nonblock);
  3. /* ssk: netlink socket
  4.    skb: skb buff 指针
  5.    portid: 通信的端口号
  6.    nonblock:表示该函数是否为非阻塞,如果为1,该函数将在没有接收缓存可利用时立即返回,而如果为0,该函数在没有接收缓存可利用 定时睡眠
  7. */

  8. /* 用来发送多播消息 */
  9. extern int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 portid,
  10.                  __u32 group, gfp_t allocation);
  11. /* ssk: 同上(对应netlink_kernel_create 返回值)、
  12.    skb: 内核skb buff
  13.    portid: 端口id
  14.    group: 是所有目标多播组对应掩码的"OR"操作的合值。
  15.    allocation: 指定内核内存分配方式,通常GFP_ATOMIC用于中断上下文,而GFP_KERNEL用于其他场合。
  16.                 这个参数的存在是因为该API可能需要分配一个或多个缓冲区来对多播消息进行clone
  17. */

参考:
https://www.cnblogs.com/wenqiang/p/6306727.html




阅读(529) | 评论(0) | 转发(0) |
0

上一篇:没有了

下一篇:Linux 网卡驱动学习

给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册