目录
1.2 netlink通信地址 struct sockaddr_nl
简介：
Netlink socket 是一种Linux特有的socket，用于实现用户空间与内核空间通信的一种特殊的进程间通信方式(IPC) ，也是网络应用程序与内核通信的最常用的接口。
Netlink 是一种在内核和用户应用间进行双向数据传输的非常好的方式，用户态应用使用标准的 socket API 就能使用 Netlink 提供的强大功能，内核态需要使用专门的内核 API 来使用 Netlink。Netlink 的接口分为应用层接口和内核接口，我们需要在应用程序实现策略，然后在内核实现机制。
用户空间和内核空间的常用通信方式有三种：proc、ioctl、Netlink
（1） /proc-单向：虚拟文件系统，用户获取内核信息，输出数据
（2） ioctl-单向：不能发送异步信息，用户向内核传送命令
（3）netlink-双向：kernel可以启动传输，而不是仅限于响应用户空间请求而返回信息
1、netlink 优点
- 支持全双工、异步通信
- 用户空间使用标准的socket接口即可进行通信
- 支持多播
- 在内核端可用于进程上下文与中断上下文
2、netlink常用场景
- 获取或修改路由信息
- 监听TCP协议数据报文
- 防火墙
- netfilter子系统
- 内核事件向用户态通知
一、netlink常用数据结构及函数
1、netlink应用层数据结构及函数
网络编程对比netlink：网络编程中我们是使用 IP地址 + 端口号 进行寻址的，而 netlink 则是通过 协议类型+进程ID 进行寻址的，其中 协议类型 会在调用 socket接口 的时候指定。
1.1 消息结构
netlink中的message包含消息头和消息体，消息头占16字节，后面跟的是消息体（数据）。
- Message Length：总长度，包括netlink消息头在内的总字节数，占4字节；
- type：消息类型，往往用于协议流程。内核定义了多个标准的消息类型。内核已经使用 netlink实现了多种协议，每个协议都有特定的类型和功能，占2字节；
- Flags：消息标志，占2字节；
- Sequence number：序列号，该项是可选项，类似TCP协议中的报文号。占4字节；
- PID（port ID）：端口号，发送端的端口ID号，占4字节；
消息头 nlmsghdr 结构体：
struct nlmsghdr {
__u32 nlmsg_len; /* 包括netlink消息头在内，整个消息长度 */
__u16 nlmsg_type; /* 消息类型 */
__u16 nlmsg_flags; /* 消息标志 */
__u32 nlmsg_seq; /* 消息报文的序列号 */
__u32 nlmsg_pid; /* 发送端口的ID号，对于内核来说该值就是0，对于用户进程来说就是其socket所绑定的ID号 */
};1.2 netlink通信地址 struct sockaddr_nl
struct sockaddr_nl 是netlink通信地址跟普通socket struct sockaddr_in类似
struct sockaddr_nl {
__kernel_sa_family_t nl_family; /* AF_NETLINK */
unsigned short nl_pad; /* 目前未用到，填充为0 */
__u32 nl_pid; /* port ID （通信端口号），0表示发送给kernel*/
__u32 nl_groups; /* 多播组掩码 */
};2、netlink内核数据结构及函数
2.1 常用宏
netlink消息类型及常用宏
/******************** netlink消息类型 ********************/
#define NETLINK_ROUTE 0 /* Routing/device hook */
#define NETLINK_UNUSED 1 /* Unused number */
#define NETLINK_USERSOCK 2 /* Reserved for user mode socket protocols */
#define NETLINK_FIREWALL 3 /* Unused number, formerly ip_queue */
#define NETLINK_SOCK_DIAG 4 /* 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
/* leave room for NETLINK_DM (DM Events) */
#define NETLINK_SCSITRANSPORT 18 /* SCSI Transports */
#define NETLINK_ECRYPTFS 19
#define NETLINK_RDMA 20
#define NETLINK_CRYPTO 21 /* Crypto layer */
#define NETLINK_INET_DIAG NETLINK_SOCK_DIAG
#define MAX_LINKS 32
/******************** netlink常用宏 ********************/
#define NLMSG_ALIGNTO 4U
/* 宏NLMSG_ALIGN(len)用于得到不小于len且字节对齐的最小数值 */
#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )
/* Netlink 头部长度 */
#define NLMSG_HDRLEN ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))
/* 计算消息数据len的真实消息长度（消息体 + 消息头）*/
#define NLMSG_LENGTH(len) ((len) + NLMSG_HDRLEN)
/* 宏NLMSG_SPACE(len)返回不小于NLMSG_LENGTH(len)且字节对齐的最小数值 */
#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))
/* 宏NLMSG_DATA(nlh)用于取得消息的数据部分的首地址，设置和读取消息数据部分时需要使用该宏 */
#define NLMSG_DATA(nlh) ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))
/* 宏NLMSG_NEXT(nlh,len)用于得到下一个消息的首地址, 同时len 变为剩余消息的长度 */
#define NLMSG_NEXT(nlh,len) ((len) -= NLMSG_ALIGN((nlh)->nlmsg_len), \
(struct nlmsghdr*)(((char*)(nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
/* 判断消息是否 >len */
#define NLMSG_OK(nlh,len) ((len) >= (int)sizeof(struct nlmsghdr) && \
(nlh)->nlmsg_len >= sizeof(struct nlmsghdr) && \
(nlh)->nlmsg_len <= (len))
/* NLMSG_PAYLOAD(nlh,len) 用于返回payload的长度*/
#define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len)))2.2 常用函数
1）netlink_kernel_create
static inline struct sock *
netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg)
功能：创建内核 socket，以提供和用户态通信
参数：
- net: net指向所在的网络命名空间namespace, 默认情况传入&init_net(不需要定义)这个全局变量；
- unit：netlink协议类型，如NETLINK_TEST、NETLINK_SELINUX等;
- cfg： cfg存放的是netlink内核配置参数（如下）
struct netlink_kernel_cfg {
unsigned int groups;
unsigned int flags;
void (*input)(struct sk_buff *skb); //input 回调函数
struct mutex *cb_mutex;
int (*bind)(struct net *net, int group);
void (*unbind)(struct net *net, int group);
bool (*compare)(struct net *net, struct sock *sk);
};2）单播函数 netlink_unicast()
int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 portid, int nonblock)
功能：发送单播消息
参数：
- ssk: netlink socket（netlink_kernel_create 的返回值）；
- skb: skb buff 指针；
- portid： 通信的端口号；
- nonblock：表示该函数是否为非阻塞，如果为1，该函数将在没有接收缓存可利用时立即返回，而如果为0，该函数在没有接收缓存可利用 定时睡眠；
3）多播函数 netlink_broadcast()
int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 portid,
__u32 group, gfp_t allocation)
功能：发送多播消息
参数：
- ssk: netlink socket（netlink_kernel_create 的返回值）；
- skb: 内核skb buff；
- portid： 端口id；
- group: 是所有目标多播组对应掩码的"OR"操作的合值；
- allocation: 指定内核内存分配方式，通常GFP_ATOMIC用于中断上下文，而GFP_KERNEL用于其他场合。这个参数的存在是因为该API可能需要分配一个或多个缓冲区来对多播消息进行clone；
二、代码实例
代码示例分为用户态和内核态netlink实现。
1、用户态netlink程序
1.1 netlink应用层基本步骤
(1) 使用 socket 声明套接字
int socket(int domain, int type, int protocol)
- domain：表示协议簇，在 netlink 中一般为 AF_NETLINK。
- type：表示套接字类型，在 netlink 中一般为 SOCK_RAW。
- protocol：表示协议类型，在 netlink 中可以是内核支持的协议，也可以是自定义协议。
自定义协议例如：
#define NETLINK_TEST 23 //自定义协议
......
int skfd = 0;
skfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);(2) 使用 bind 绑定 本地地址 到套接字
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) //绑定
/* sockaddr_nl 是 netlink 使用的地址数据结构，与网络编程不同 */
struct sockaddr_nl {
__kernel_sa_family_t nl_family; //一般为AF_NETLINK
unsigned short nl_pad; //无需填充
__u32 nl_pid; //与内核通信的进程的PID，0 则代表地址为内核
__u32 nl_groups; //多播组号，netlink支持多播
};
例如：
struct sockaddr_nl nlsrc_addr = {0};
/* 设置本地socket地址 */
nlsrc_addr.nl_family = AF_NETLINK;
nlsrc_addr.nl_pid = getpid();
nlsrc_addr.nl_groups = 0;
/* 绑定套接字 */
if(bind(skfd, (struct sockaddr*)&nlsrc_addr, addr_len) != 0)
{
printf("bind addr error\n");
return -1;
}(3) 构造消息
(4) 接收/发送消息
netlink 有 2 套收发消息的接口，分别是 sendto/recvfrom、sendmsg/recvmsg。
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);1.2 netlink用户空间代码
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <linux/netlink.h>
#define NETLINK_TEST 17
#define RX_BUF_SIZE 100 //接收buf size
#define MAX_PLOAD 100 //发送message内存size
typedef struct
{
struct nlmsghdr hdr;
char msg[RX_BUF_SIZE];
}RX_KERNEL_MSG;
int main(int argc, char* argv[])
{
char *data = "This message is from user's space";
//初始化
struct sockaddr_nl src_addr, dest_addr; //sockaddr_nl 是 netlink 使用的地址数据结构
int skfd, ret, rxlen = sizeof(struct sockaddr_nl);
struct nlmsghdr *message;
RX_KERNEL_MSG info;
char *retval;
/* 1.创建NETLINK socket */
skfd = socket(PF_NETLINK, SOCK_RAW, NETLINK_TEST);
if(skfd < 0){
printf("can not create a netlink socket\n");
return -1;
}
//初始化 netlink 源地址
memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid();
src_addr.nl_groups = 0;
if(bind(skfd, (struct sockaddr *)&src_addr, sizeof(src_addr)) != 0){
printf("bind() error\n");
return -1;
}
//初始化 netlink 目标地址
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; //0表示发送给kernel
dest_addr.nl_groups = 0; //多播组
/* 2.设置消息 */
message = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PLOAD));
memset(message, '\0', sizeof(struct nlmsghdr));
message->nlmsg_len = NLMSG_SPACE(strlen(data)); //包括netlink消息头在内，整个消息长度
message->nlmsg_flags = 0; //消息标志
message->nlmsg_type = 0; //消息类型
message->nlmsg_seq = 0; //消息报文的序列号
message->nlmsg_pid = src_addr.nl_pid; //消息中加入本应用端口pid，内核应答时往此pid写入
retval = memcpy(NLMSG_DATA(message), data, strlen(data)); //数据
// printf("User Send: %s, len:%d\r\n", (char *)NLMSG_DATA(message), message->nlmsg_len);
/* 3.发送消息 */
ret = sendto(skfd, message, message->nlmsg_len, 0,(struct sockaddr *)&dest_addr, sizeof(dest_addr)); //将message消息发送给内核
if(!ret){
perror("send pid:");
exit(-1);
}
/* 4.接收内核发来的信息 */
ret = recvfrom(skfd, &info, sizeof(RX_KERNEL_MSG), 0, (struct sockaddr*)&dest_addr, &rxlen);
if(!ret){
perror("recv form kerner:");
exit(-1);
}
printf("User Receive ACK from kernel:%s\r\n",(char *)info.msg);
//内核和用户进行通信
close(skfd);
free((void *)message);
return 0;
}2、内核空间代码
2.1 netlink内核态编程步骤
内核接口与应用层接口相似，其过程和使用的接口如下：
(1) 创建socket并注册回调
struct netlink_kernel_cfg {
unsigned int groups;
unsigned int flags;
void (*input)(struct sk_buff *skb); /* 接收回调函数 */
struct mutex *cb_mutex;
int (*bind)(struct net *net, int group);
void (*unbind)(struct net *net, int group);
bool (*compare)(struct net *net, struct sock *sk);
};
/* 创建接口，其中，参数net 一般为 &init_net */
static inline struct sock *netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg)
/* 释放接口 */
void netlink_kernel_release(struct sock *sk);(2) 构造消息
//sk_buff 为内核中 Netlink 使用的数据结构体，下面分别是分配、使用、释放的接口
static inline struct sk_buff *alloc_skb(unsigned int size, gfp_t priority)
static inline struct sk_buff *skb_get(struct sk_buff *skb)
void kfree_skb(struct sk_buff *skb);
//下面为构建消息内容的接口
static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int payload, int flags)大概的调用方法为：
//NLMSG_SPACE计算包括消息头在内的消息长度
size_t size = max(NLMSG_SPACE(message_size), (size_t)NLMSG_GOODSIZE);
//分配sk_buff内存
sk_buff * log_skb = alloc_skb(size, GFP_ATOMIC);
//构造消息结构体
nlmsghdr *nlh = nlmsg_put(log_skb, /*pid*/0, /*seq*/0, type,
message_size, 0);
//将要发送的数据复制到消息结构体上
if(payload != NULL) {
memcpy(nlmsg_data(nlh), payload, size);
}(3) 接收/发送消息
发送消息有单播、广播两个接口，可以根据实际业务选择使用。
int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 portid, int nonblock);
int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, __u32 portid, __u32 group, gfp_t allocation);2.2 netlink内核态模块代码
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <net/sock.h>
#include <linux/netlink.h>
#define NETLINK_TEST 17
struct {
__u32 pid;
}user_process;
static struct sock *netlinkfd = NULL;
/* 发送到用户空间 */
int send_to_user(int _pid, char *pbuf, uint16_t len)
{
struct sk_buff *nl_skb;
struct nlmsghdr *nlh;
int ret;
/* 创建sk_buff 空间 */
nl_skb = nlmsg_new(len, GFP_ATOMIC);
if(!nl_skb)
{
printk("netlink alloc failure\n");
return -1;
}
/* 设置netlink消息头部 */
nlh = nlmsg_put(nl_skb, 0, 0, NETLINK_TEST, len, 0);
if(nlh == NULL)
{
printk("nlmsg_put failaure \n");
nlmsg_free(nl_skb);
return -1;
}
/* 拷贝数据发送 */
memcpy(nlmsg_data(nlh), pbuf, len);
ret = netlink_unicast(netlinkfd, nl_skb, _pid, MSG_DONTWAIT); //发送数据
return ret;
}
/* 接收回调函数 */
static void netlink_rcv_msg(struct sk_buff *skb)
{
struct nlmsghdr *nlh = NULL;
char *data = NULL;
char *kmsg = "hello users!!!";
nlh = nlmsg_hdr(skb);
if(skb->len >= NLMSG_SPACE(0))
{
data = NLMSG_DATA(nlh); //数据
if (data)
{
user_process.pid = nlh->nlmsg_pid; //数据从用户端口ID获取
printk("kernel recv from user pid %d: %s\n", user_process.pid, data);
send_to_user(user_process.pid, kmsg, strlen(kmsg)); //发送数据给用户pid
}
} else {
printk("%s: error skb, length:%d\n", __func__, skb->len);
}
}
struct netlink_kernel_cfg cfg = {
.input = netlink_rcv_msg, /* 设置接收回调函数 */
.groups = 0,
.flags = 0,
.cb_mutex = NULL,
.bind = NULL,
.compare = NULL,
};
int __init test_netlink_init(void)
{
/* 创建netlink socket */
netlinkfd = (struct sock *)netlink_kernel_create(&init_net, NETLINK_TEST, &cfg);
if(netlinkfd == NULL){
printk(KERN_ERR "can not create a netlink socket\n");
return -1;
}
return 0;
}
void __exit test_netlink_exit(void)
{
if (netlinkfd){
netlink_kernel_release(netlinkfd); /* release ..*/
netlinkfd = NULL;
}
printk(KERN_DEBUG "test_netlink_exit!!\n");
}
module_init(test_netlink_init);
module_exit(test_netlink_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("donga");3、测试结果
测试代码下载链接：https://download.csdn.net/download/hinewcc/89590914
将内核态代码编译成ko模块，用户态代码编译成app。insmod加载ko模块，并运行app代码：
$ insmod netlink_test.ko #加载驱动
$ ./netlink_app #运行APP
内核态收到用户态发送的数据，并发送"hello users!!!"给用户空间。
577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
