netlink

用以实现用户进程与内核进程通信
netlink 套接字的最大特点是对中断过程的支持

内核与用户数据交换
sysfs、sysctl、netlink、procfs、seq_file、debugfs和relayfs

优点

1. Netlink通过socket API；而ioctl和proc文件系统均需要通过程序加入相应的设备或文件
2. Netlink使用socket缓存队列，是一种异步通信机制，而ioctl是同步通信机制，如果传输的数据量较大，会影响系统性能
3. Netlink支持多播，属于一个Netlink组的模块和进程都能获得该多播消息
4. Netlink允许内核发起会话，而ioctl和系统调用只能由用户空间进程发起

用户空间

int socket(int domain, int type, int protocol);

domain：PF_NETLINK

struct sockaddr_nl
{
    sa_family_t    nl_family;
    unsigned short nl_pad;
    __u32          nl_pid;
    __u32          nl_groups;
};

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

nl_pid：接收或发送消息的进程ID，如果希望内核处理消息或多播消息，就把该字段设置为 0，否则设置为处理消息的进程ID（线程使用pthread_self() << 16 | getpid()）
nl_groups：指定多播组。bind 函数把调用进程加入到该字段指定的多播组，如果设置为 0，表示调用者不加入任何多播组

//netlink消息头
struct nlmsghdr
{
  __u32 nlmsg_len;   /* Length of message *///包含头
  __u16 nlmsg_type;  /* Message type*/
  __u16 nlmsg_flags; /* Additional flags */
  __u32 nlmsg_seq;   /* Sequence number */
  __u32 nlmsg_pid;   /* Sending process PID *///源端口
};

/*总长度*/
#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))
/*字节对齐*/
#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )

nlmsg_len：消息的总长度(包含消息头)。一般地，使用NLMSG_LENGTH来计算对齐后的总长度
nlmsg_type：应用内部定义的消息类型

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

nlmsg_flags：附加在消息上的额外说明信息
nlmsg_seq 和 nlmsg_pid：用于应用追踪消息，前者表示顺序号，后者为消息来源进程 ID

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);

举例

#include <linux/types.h>
#include <linux/netlink.h>

#define NL_IMP2 31
#define IMP2_U_PID 0 //消息类型

static int skfd;
skfd = socket(PF_NETLINK, SOCK_RAW, NL_IMP2);
if(skfd < 0)
{
    printf("can not create a netlink socket
");
    exit(0);
}

struct sockaddr_nl local;
memset(&local, 0, sizeof(local));
local.nl_family = AF_NETLINK;
local.nl_pid = 0; //向内核发送
local.nl_groups = 0;

if(bind(skfd, (struct sockaddr*)&local, sizeof(local)) != 0)
{
    printf("bind() error
");
    return -1;
}

struct nlmsghdr hdr;
memset(&hdr, 0, sizeof(hdr));
hdr.nlmsg_len = NLMSG_LENGTH(0); //没有多余的数据
hdr.nlmsg_flags = 0;
hdr.nlmsg_type = NL_T_XX; //自定义消息类型
hdr.nlmsg_pid = getpid(); //发送者的PID

sendto(skfd, &hdr, hdr.nlmsg_len, 0, (struct sockaddr*)&local, sizeof(local));

//接收
typedef struct
{
    struct nlmsghdr hdr;
    struct packet_info icmp_info;
}info;

while(1)
{
    len = sizeof(struct sockaddr_nl);
    rcvlen = recvfrom(skfd, &info, sizeof(info), 0, (struct sockaddr*)&local, &len);
}

内核空间

struct sock *netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len));

unit：netlink协议类型
input：当有消息到达，会被引用
sk：和返回值一致

在input中，你可以直接处理收到的数据，也可以不处理，在大量数据传输的情况下，在input中处理是不明智的，正确的方式应该是建立一个内核线程专门接收数据，没有数据的时候该内核线程睡眠，一旦有了数据，input回调函数唤醒这个内核线程就是了

内核空间发送数据使用独立创建的sk_buff缓冲区

#define NLMSG_LENGTH(len) ((len)+NLMSG_ALIGN(sizeof(struct nlmsghdr)))
#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))

NLMSG_ALIGN(len)：得到不小于len且字节对齐的最小数值
NLMSG_LENGTH(len)：计算数据部分长度为len时实际的消息长度
NLMSG_SPACE(len)：返回不小于NLMSG_LENGTH(len)且字节对齐的最小数值

#define NLMSG_DATA(nlh) ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))

取得消息的数据部分首地址

#define NETLINK_CB(skb) (*(struct netlink_skb_parms*)&((skb)->cb))

NETLINK_CB(skb).pid = 0;
NETLINK_CB(skb).dst_pid = 0;
NETLINK_CB(skb).dst_group = 1;

pid：发送者进程ID，对于内核，它为0
dst_pid：接收者进程ID，如果目标为组或内核，它为0
dst_group：目标组地址，如果目标为某一进程或内核，它为0

netlink_unicast()发布单播消息

int netlink_unicast(struct sock *sk, struct sk_buff *skb, u32 pid, int nonblock);

pid：接收消息进程的pid
nonblock：该函数是否为非阻塞。如果为1，该函数将在没有接收缓存可利用时立即返回，而如果为0，该函数在没有接收缓存可利用时睡眠

void netlink_broadcast(struct sock *sk, struct sk_buff *skb, u32 pid, u32 group, int allocation);

group：接收消息的多播组。如果发送给多个多播组，就把该参数设置为多个多播组组ID的位或
allocation：GFP_ATOMIC用于原子的上下文（即不可以睡眠）；GFP_KERNEL用于非原子上下文

#define NLMSG_PUT(skb, pid, seq, type, len)
({ if (skb_tailroom(skb) < (int)NLMSG_SPACE(len)) goto nlmsg_failure; __nlmsg_put(skb, pid, seq, type, len); })

static __inline__ struct nlmsghdr *__nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq, int type, int len)
{
    struct nlmsghdr *nlh;
    int size = NLMSG_LENGTH(len);
    nlh = (struct nlmsghdr*)skb_put(skb, NLMSG_ALIGN(size));
    nlh->nlmsg_type = type;
    nlh->nlmsg_len = size;
    nlh->nlmsg_flags = 0;
    nlh->nlmsg_pid = pid;
    nlh->nlmsg_seq = seq;
    return nlh;
}

程序中应该定义nlmsg_failure标签

举例

#include <linux/netfilter_ipv4.h>  
#include <linux/netlink.h>
#include <net/sock.h>

nlfd = netlink_kernel_create(NL_IMP2, kernel_receive);
if(!nlfd)
{
    printk("can not create a netlink socket/n");
    return -1;
}

static void kernel_receive(struct sock *sk, int len)
{
    do
    {
        struct sk_buff *skb;
        while((skb = skb_dequeue(&sk->receive_queue)) != NULL)
        {
            struct nlmsghdr *nlh = NULL;
            if(skb->len >= sizeof(struct nlmsghdr)
            {
                nlh = (struct nlmsghdr *)skb->data;
                if((nlh->nlmsg_len >= sizeof(struct nlmsghdr)) && (skb->len >= nlh->nlmsg_len))
                {
                    //自定义消息
                    if(nlh->nlmsg_type == IMP2_U_PID)       
                    {
                        ；
                    }
                    //socket关闭
                    else if(nlh->nlmsg_type == IMP2_CLOSE)
                    {
                        ；
                    }
                }
            }
        }
        kfree_skb(skb);
    }while(nlfd && nlfd->receive_queue.qlen);
}

if(nlfd)
{
    sock_release(nlfd->socket);
}

//发送
struct sk_buff *skb;
struct nlmsghdr *nlh;
struct packet_info *packet;

/*计算消息总长*/
size = NLMSG_SPACE(sizeof(*info));

/*分配一个新的套接字缓存*/
skb = alloc_skb(size, GFP_ATOMIC);

/*初始化一个netlink消息首部*/
nlh = NLMSG_PUT(skb, 0, 0, NL_T_XX, size-sizeof(*nlh));
nlh->nlmsg_len = size;

/*跳过消息首部，指向数据区*/
packet = NLMSG_DATA(nlh);

/*初始化数据区*/
memset(packet, 0, sizeof(struct packet_info));

/*填充待发送的数据*/
packet->src = info->src;
packet->dest = info->dest;

/*设置控制字段*/
NETLINK_CB(skb).dst_groups = 0;

/*发送数据到目的pid*/
ret = netlink_unicast(nlfd, skb, pid, MSG_DONTWAIT);

2.6内核netlink
从2.6.24开始，linux内部对netlink的实现机制和调用接口进行了很大的调整，特别是函数 netlink_kernel_create()，最新的参数有6个之多

extern struct sock *netlink_kernel_create(struct net *net,
                          int unit, unsigned int groups,
                          void (*input)(struct sk_buff *skb),
                          struct mutex *cb_mutex,
                          struct module *module);

net：使用&init_net，定义在linux/net/core/net_namespace.c 中，此外在linux/include/net/net_namespace.h中也有外部定义，直接作为参数使用即可
unit：同上
input：同上，但不需要自己调用调度的方法，让内核进程阻塞以便等待消息到来了
module：THIS_MODULE，定义在module.h，表示当前模块