Linux netlink之添加一个简单协议

一、netlink简介

netlink协议是一种基于socket的IPC机制，可用于内核与用户空间进程、用户空间进程与用户空间进程通信，如图所示：

netlink协议基于BSD socket和AF_NETLINK地址簇(address family)，使用32位的端口号寻址(以前称作PID)，每个netlink协议(或称作总线，man手册中则称之为netlink family)，通常与一个或一组内核服务/组件相关联，如NETLINK_ROUTE用于获取和设置路由与链路信息、NETLINK_KOBJECT_UEVENT用于内核向用户空间的udev进程发送通知等。netlink具有以下特点：
① 支持全双工、异步通信(当然同步也支持)
② 用户空间可使用标准的BSD socket接口(但netlink并没有屏蔽掉协议包的构造与解析过程，推荐使用libnl等第三方库)
③ 在内核空间使用专用的内核API接口
③ 支持多播(因此支持“总线”式通信，可实现消息订阅)
④ 在内核端可用于进程上下文与中断上下文

二、为AF_NETLINK地址簇添加新协议的方法

关于这个要添加的netlink”协议“的说法，网上有多种不一致的术语，有人称之为”netlink family“，有人称之为”bus“，还有人称之为“netlink protocol”，实际上指的是同一个东西，本文将称之为(netlink)协议。要在内核中使用netlink，需要为自己的内核服务添加新的netlink，现在有两种方法：
① 最开始的方法，使用<net/netlink.h>中的接口，即直接基于nlmsghdr。这是在Linux加入netlink机制之初添加协议的方法。该方法有个限制就是协议的数量不能超过32个，Linux3.10内核已经使用了22个。
② 使用netlink generic。netlink generic是基于第一种方法实现的，协议号为NETLINK_GENERIC。它在NETLINK_GENERIC协议之上提供了多路复用，在其之上添加的新协议称之为Generic Netlink 协议，在没有歧义的情况下，也称作Generic协议或netlink协议。

出于学习的目的，本文将使用第一种方法。

三、NetLink协议基础

netlink机制提供的协议头如图所示：

netlink协议是面向消息的，要定义自己的协议，需要基于netlink提供的协议头，即struct nlmsghdr。自定义协议按照协议头格式填充协议头内容，并定义自己的playload，通常自定义的协议体包含自定义协议头与额外的属性，netlink提供了一系列的标准方法用于对消息进行打包与拆包。struct nlmsghdr的定义如下

struct nlmsghdr {
        __u32           nlmsg_len;      /* Length of message including header */
        __u16           nlmsg_type;     /* Message content */
        __u16           nlmsg_flags;    /* Additional flags */
        __u32           nlmsg_seq;      /* Sequence number */
        __u32           nlmsg_pid;      /* Sending process port ID */
};

其中一些字段，如消息标志与消息类型字段，netlink对其作了一些预定义的值。除了这些预定义的值外，新协议可以定义自己的值。各字段含义如下：

① Total Length (32bit) 协议头与payload的总长度(包含中间对齐和payload尾部对齐的空间)
② Message Type (16bit)。除了预定义的几个类型外，新协议可以自由的加入自己的消息类型。类型对netlink核心透明
③ Message Flags (16bit)。用于描述协议的行为，对netlink核心不透明
④ Sequence Number (32bit)。可选，用于标志已发送的消息，如错误消息可以引用一个已发送消息。
⑤ Port Number (32bit)。目的端口。若未指定，则会发送给内核

四、添加协议NETLINK_TEST

1. 协议格式设计：

为简便起见，仅设计一个具有echo功能的协议。不在标准nlmsghdr之后的payload中定义自己的协议头，payload即为echo文本串，不使用netlink提供的消息标志。定义两种消息类型：NLMSG_GETECHO(用于echo请求包)和NLMSG_SETECHO(用于echo响应包。
出于学习的目的，用户进程使用socket接口收发信息。在实际的开发过程中，推荐是同libnl等库，该库提供的接口类似于内核中的那套接口，用起来非常方便。

2. 用户空间程序：

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <linux/netlink.h>
#include <sys/socket.h>
#include <strings.h>
#include <string.h>
#define NETLINK_TEST 31 // 自定义的协议号
/** 消息类型 **/
#define NLMSG_SETECHO 0x11
#define NLMSG_GETECHO 0x12
/** 最大协议负荷(固定) **/
#define MAX_PAYLOAD 101

struct sockaddr_nl src_addr, dst_addr;
struct iovec iov;
int sockfd;
struct nlmsghdr *nlh = NULL;
struct msghdr msg;

int main( int argc, char **argv)
{
    if (argc != 2) {
        printf("usage: ./a.out <str>
");
        exit(-1);
    }

    sockfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_TEST); // 创建NETLINK_TEST协议的socket
    /* 设置本地端点并绑定，用于侦听 */
    bzero(&src_addr, sizeof(src_addr));
    src_addr.nl_family = AF_NETLINK;
    src_addr.nl_pid = getpid();
    src_addr.nl_groups = 0; //未加入多播组
    bind(sockfd, (struct sockaddr*)&src_addr, sizeof(src_addr));
    /* 构造目的端点，用于发送 */
    bzero(&dst_addr, sizeof(dst_addr));
    dst_addr.nl_family = AF_NETLINK;
    dst_addr.nl_pid = 0; // 表示内核
    dst_addr.nl_groups = 0; //未指定接收多播组 
    /* 构造发送消息 */
    nlh = malloc(NLMSG_SPACE(MAX_PAYLOAD));
    nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD); //保证对齐
    nlh->nlmsg_pid = getpid();  /* self pid */
    nlh->nlmsg_flags = 0;
    nlh->nlmsg_type = NLMSG_GETECHO;
    strcpy(NLMSG_DATA(nlh), argv[1]);
    iov.iov_base = (void *)nlh;
    iov.iov_len = nlh->nlmsg_len;
    msg.msg_name = (void *)&dst_addr;
    msg.msg_namelen = sizeof(dst_addr);
    msg.msg_iov = &iov;
    msg.msg_iovlen = 1;

    sendmsg(sockfd, &msg, 0); // 发送
    /* 接收消息并打印 */
    memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
    recvmsg(sockfd, &msg, 0);
    printf(" Received message payload: %s
",
            NLMSG_DATA(nlh));

注意：客户进程可以不进行bind而直接recvmsg，这样，默认本地绑定的端口为当前进程ID，因此，在发送消息时应将源端口指定为getpid()

3. 内核模块：

#include <linux/module.h>
#include <linux/netlink.h>
#include <net/netlink.h>
#include <net/net_namespace.h>
#define NETLINK_TEST 31

#define NLMSG_SETECHO 0x11
#define NLMSG_GETECHO 0x12

static struct sock *sk; //内核端socket
static void nl_custom_data_ready(struct sk_buff *skb); //接收消息回调函数

int __init nl_custom_init(void)
{
    struct netlink_kernel_cfg nlcfg = {
        .input = nl_custom_data_ready,
    };
    sk = netlink_kernel_create(&init_net, NETLINK_TEST, &nlcfg);
    printk(KERN_INFO "initialed ok!
");
    if (!sk) {
        printk(KERN_INFO "netlink create error!
");
    }
    return 0;
}
void __exit nl_custom_exit(void)
{
    printk(KERN_INFO "existing...
");
    netlink_kernel_release(sk);
}

static void nl_custom_data_ready(struct sk_buff *skb)
{
    struct nlmsghdr *nlh;
    void *payload;
    struct sk_buff *out_skb;
    void *out_payload;
    struct nlmsghdr *out_nlh;
    int payload_len; // with padding, but ok for echo 
    nlh = nlmsg_hdr(skb);
    switch(nlh->nlmsg_type)
    {
        case NLMSG_SETECHO:
            break;
        case NLMSG_GETECHO:
            payload = nlmsg_data(nlh);
            payload_len = nlmsg_len(nlh);
            printk(KERN_INFO "payload_len = %d
", payload_len);
            printk(KERN_INFO "Recievid: %s, From: %d
", (char *)payload, nlh->nlmsg_pid);
            out_skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); //分配足以存放默认大小的sk_buff
            if (!out_skb) goto failure;
            out_nlh = nlmsg_put(out_skb, 0, 0, NLMSG_SETECHO, payload_len, 0); //填充协议头数据
            if (!out_nlh) goto failure;
            out_payload = nlmsg_data(out_nlh);
            strcpy(out_payload, "[from kernel]:"); // 在响应中加入字符串，以示区别
            strcat(out_payload, payload);
            nlmsg_unicast(sk, out_skb, nlh->nlmsg_pid);
            break;
        default:
            printk(KERN_INFO "Unknow msgtype recieved!
");
    }
    return;
failure:
    printk(KERN_INFO " failed in fun dataready!
");
}
module_init(nl_custom_init);
module_exit(nl_custom_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("a simple example for custom netlink protocal family");
MODULE_AUTHOR("RSLjdkt");

注意：上面的回调函数是在进程上下文(系统调用中)进行的，若操作比较耗时，在实际使用中通常将工作交给内核线程处理，内核线程调用skb_recv_datagram函数。

3. 模块Makefile

obj-m += nltest.o


KID := /lib/modules/`uname -r`/build
PWD := $(shell pwd)

all:
        make -C $(KID) M=$(PWD) modules

clean:
        rm -rf *.o .cmd *.ko *.mod.c .tmp_versions

4. 操作：

insmod模块后，运行用户程序，用户进程输出：

Received message payload: [from kernel]:hello

内核模块的dmesg输出：

[181170.368671] initialed ok!
[181182.745293] payload_len = 104
[181182.749476] Recievid: hello, From: 3127

其中，From后是发送端的“地址” 

参考：

Netlink Protocol Fundamentals http://www.carisma.slowglass.com/~tgr/libnl/doc/core.html#core_netlink_fundamentals

netlink socket理解 http://www.blogjava.net/jasmine214--love/archive/2012/06/01/379752.html

generic_netlink_howto http://www.linuxfoundation.org/collaborate/workgroups/networking/generic_netlink_howto#Registering_A_Family