Netlink 内核实现分析 3

Netlink IPC 数据结构

#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    

/*
其中（1）nl_family始终为AF_NETLINK；
（2）nl_pad始终为0；
（3）nl_pid为netlink套接字的单播地址，在发送消息时用于表示目的套接字的地址，
在用户空间绑定时可以指定为当前进程的PID号（对于内核来说这个值为0）或者干脆不设置（在绑定bind时由内核调用netlink_autobind()
设置为当前进程的PID），但需要注意的是当用户同一个进程中需要创建多个netlink套接字时则必须保证这个值是唯一的
（一般在多线程中可以使用”pthread_self() << 16 | getpid()“这样的方法进行设置）；
（4）nl_groups表示组播组。在发送消息时用于表示目的多播组，在绑定地址时用于表示加入的多播组。这里nl_groups为一个32位无符号数，
其中的每一位表示一个   多播组，
一个netlink套接字可以加入多个多播组用以接收多个多播组的多播消息（最多支持32个）。
*/
struct sockaddr_nl {
    __kernel_sa_family_t    nl_family;    /* AF_NETLINK    */
    unsigned short    nl_pad;        /* zero        */
    __u32        nl_pid;        /* port ID    */
           __u32        nl_groups;    /* multicast groups mask */
};

netlink消息同IP消息一样，也需要遵循协议要求的格式，每个netlink消息的开头是固定长度的netlink报头，报头后才是实际的载荷。netlink报头一共占16个字节。

/*
netlink消息同IP消息一样，也需要遵循协议要求的格式，每个netlink消息的开头是固定长度的netlink报头，
报头后才是实际的载荷。netlink报头一共占16个字节，具体内容即同struct nlmsghdr中定义的一样。
*/
struct nlmsghdr {
    __u32        nlmsg_len;    /* Length of message including header */
    __u16        nlmsg_type;    /* Message content nlmsg_type：消息状态，
    内核在include/uapi/linux/netlink.h中定义了以下4种通用的消息类型，它们分别是NLMSG_NOOP NLMSG_ERROR so on
        除了这4种类型的消息以外，不同的netlink协议也可以自行添加自己所特有的消息类型，
        但是内核定义了类型保留宏（#define NLMSG_MIN_TYPE 0x10），即小于该值的消息类型值由内核保留，不可用。*/
    __u16        nlmsg_flags;    /* Additional flags NLM_F_REQUEST    so on    */
    __u32        nlmsg_seq;    /* Sequence number 消息序列号，用以将消息排队，有些类似TCP协议中的序号*/
    __u32        nlmsg_pid;    /* Sending process port ID 发送端口的ID号，对于内核来说该值就是0，对于用户进程来说就是其socket所绑定的ID号*/
};

 消息类型：

nlmsg_type：消息状态其取值有：
    NLMSG_NOOP：不执行任何动作，必须将该消息丢弃；
    NLMSG_ERROR：消息发生错误；
    NLMSG_DONE：标识分组消息的末尾；
    NLMSG_OVERRUN：缓冲区溢出，表示某些消息已经丢失。

/*
除了这4种类型的消息以外，不同的netlink协议也可以自行添加自己所特有的消息类型，
但是内核定义了类型保留宏（#define NLMSG_MIN_TYPE 0x10），即小于该值的消息类型值由内核保留，不可用。
*/
#define NLMSG_MIN_TYPE        0x10    /* < 0x10: reserved control messages */

Netlink消息处理宏

消息处理的宏定义

#define NLMSG_ALIGNTO    4U
#define NLMSG_ALIGN(len) ( ((len)+NLMSG_ALIGNTO-1) & ~(NLMSG_ALIGNTO-1) )            /* 对len执行4字节对齐 */
#define NLMSG_HDRLEN     ((int) NLMSG_ALIGN(sizeof(struct nlmsghdr)))                /* netlink消息头长度 */
#define NLMSG_LENGTH(len) ((len) + NLMSG_HDRLEN)                                    /* netlink消息载荷len加上消息头 */
#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(len))                                /* 对netlink消息全长执行字节对齐 */
#define NLMSG_DATA(nlh)  ((void*)(((char*)nlh) + NLMSG_LENGTH(0)))                    /* 获取netlink消息实际载荷位置 */
#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))                                            /* 验证消息的长度 */
#define NLMSG_PAYLOAD(nlh,len) ((nlh)->nlmsg_len - NLMSG_SPACE((len)))                /* 返回PAYLOAD的长度 */

/*
netlink的消息头后面跟着的是消息的有效载荷部分，它采用的是格式为“类型——长度——值”，简写TLV。
其中类型和长度使用属性头nlattr来表示。其中nla_len表示属性长度；nla_type表示属性类型，
它可以取值为以下几种类型（定义在include\net\netlink.h中)：
  ========================================================================
 *         Netlink Messages and Attributes Interface (As Seen On TV)
 * ------------------------------------------------------------------------
 *                          Messages Interface
 * ------------------------------------------------------------------------
 *
 * Message Format:
 *    <--- nlmsg_total_size(payload)  --->
 *    <-- nlmsg_msg_size(payload) ->
 *   +----------+- - -+-------------+- - -+-------- - -
 *   | nlmsghdr | Pad |   Payload   | Pad | nlmsghdr
 *   +----------+- - -+-------------+- - -+-------- - -
 *   nlmsg_data(nlh)---^                   ^
 *   nlmsg_next(nlh)-----------------------+
 *
 * Payload Format:
 *    <---------------------- nlmsg_len(nlh) --------------------->
 *    <------ hdrlen ------>       <- nlmsg_attrlen(nlh, hdrlen) ->
 *   +----------------------+- - -+--------------------------------+
 *   |     Family Header    | Pad |           Attributes           |
 *   +----------------------+- - -+--------------------------------+
 *   nlmsg_attrdata(nlh, hdrlen)---^
 *
 * Data Structures:
 *   struct nlmsghdr            netlink message header
 *
 * Message Construction:
 *   nlmsg_new()            create a new netlink message
 *   nlmsg_put()            add a netlink message to an skb
 *   nlmsg_put_answer()            callback based nlmsg_put()
 *   nlmsg_end()            finalize netlink message
 *   nlmsg_get_pos()            return current position in message
 *   nlmsg_trim()            trim part of message
 *   nlmsg_cancel()            cancel message construction
 *   nlmsg_free()            free a netlink message
 *
 * Message Sending:
 *   nlmsg_multicast()            multicast message to several groups
 *   nlmsg_unicast()            unicast a message to a single socket
 *   nlmsg_notify()            send notification message
 *
 * Message Length Calculations:
 *   nlmsg_msg_size(payload)        length of message w/o padding
 *   nlmsg_total_size(payload)        length of message w/ padding
 *   nlmsg_padlen(payload)        length of padding at tail
 *
 * Message Payload Access:
 *   nlmsg_data(nlh)            head of message payload
 *   nlmsg_len(nlh)            length of message payload
 *   nlmsg_attrdata(nlh, hdrlen)    head of attributes data
 *   nlmsg_attrlen(nlh, hdrlen)        length of attributes data
 *
 * Message Parsing:
 *   nlmsg_ok(nlh, remaining)        does nlh fit into remaining bytes?
 *   nlmsg_next(nlh, remaining)        get next netlink message
 *   nlmsg_parse()            parse attributes of a message
 *   nlmsg_find_attr()            find an attribute in a message
 *   nlmsg_for_each_msg()        loop over all messages
 *   nlmsg_validate()            validate netlink message incl. attrs
 *   nlmsg_for_each_attr()        loop over all attributes
 *
 * Misc:
 *   nlmsg_report()            report back to application?
 *
 * ------------------------------------------------------------------------
 *                          Attributes Interface
 * ------------------------------------------------------------------------
 *
 * Attribute Format:
 *    <------- nla_total_size(payload) ------->
 *    <---- nla_attr_size(payload) ----->
 *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
 *   |  Header  | Pad |     Payload      | Pad |  Header
 *   +----------+- - -+- - - - - - - - - +- - -+-------- - -
 *                     <- nla_len(nla) ->      ^
 *   nla_data(nla)----^                        |
 *   nla_next(nla)-----------------------------'
 *
 * Data Structures:
 *   struct nlattr            netlink attribute header
 *
 * Attribute Construction:
 *   nla_reserve(skb, type, len)    reserve room for an attribute
 *   nla_reserve_nohdr(skb, len)    reserve room for an attribute w/o hdr
 *   nla_put(skb, type, len, data)    add attribute to skb
 *   nla_put_nohdr(skb, len, data)    add attribute w/o hdr
 *   nla_append(skb, len, data)        append data to skb
 *
 * Attribute Construction for Basic Types:
 *   nla_put_u8(skb, type, value)    add u8 attribute to skb
 *   nla_put_u16(skb, type, value)    add u16 attribute to skb
 *   nla_put_u32(skb, type, value)    add u32 attribute to skb
 *   nla_put_u64_64bits(skb, type,
 *            value, padattr)    add u64 attribute to skb
 *   nla_put_s8(skb, type, value)    add s8 attribute to skb
 *   nla_put_s16(skb, type, value)    add s16 attribute to skb
 *   nla_put_s32(skb, type, value)    add s32 attribute to skb
 *   nla_put_s64(skb, type, value,
 *               padattr)        add s64 attribute to skb
 *   nla_put_string(skb, type, str)    add string attribute to skb
 *   nla_put_flag(skb, type)        add flag attribute to skb
 *   nla_put_msecs(skb, type, jiffies,
 *                 padattr)        add msecs attribute to skb
 *   nla_put_in_addr(skb, type, addr)    add IPv4 address attribute to skb
 *   nla_put_in6_addr(skb, type, addr)    add IPv6 address attribute to skb
 *
 * Nested Attributes Construction:
 *   nla_nest_start(skb, type)        start a nested attribute
 *   nla_nest_end(skb, nla)        finalize a nested attribute
 *   nla_nest_cancel(skb, nla)        cancel nested attribute construction
 *
 * Attribute Length Calculations:
 *   nla_attr_size(payload)        length of attribute w/o padding
 *   nla_total_size(payload)        length of attribute w/ padding
 *   nla_padlen(payload)        length of padding
 *
 * Attribute Payload Access:
 *   nla_data(nla)            head of attribute payload
 *   nla_len(nla)            length of attribute payload
 *
 * Attribute Payload Access for Basic Types:
 *   nla_get_u8(nla)            get payload for a u8 attribute
 *   nla_get_u16(nla)            get payload for a u16 attribute
 *   nla_get_u32(nla)            get payload for a u32 attribute
 *   nla_get_u64(nla)            get payload for a u64 attribute
 *   nla_get_s8(nla)            get payload for a s8 attribute
 *   nla_get_s16(nla)            get payload for a s16 attribute
 *   nla_get_s32(nla)            get payload for a s32 attribute
 *   nla_get_s64(nla)            get payload for a s64 attribute
 *   nla_get_flag(nla)            return 1 if flag is true
 *   nla_get_msecs(nla)            get payload for a msecs attribute
 *
 * Attribute Misc:
 *   nla_memcpy(dest, nla, count)    copy attribute into memory
 *   nla_memcmp(nla, data, size)    compare attribute with memory area
 *   nla_strlcpy(dst, nla, size)    copy attribute to a sized string
 *   nla_strcmp(nla, str)        compare attribute with string
 *
 * Attribute Parsing:
 *   nla_ok(nla, remaining)        does nla fit into remaining bytes?
 *   nla_next(nla, remaining)        get next netlink attribute
 *   nla_validate()            validate a stream of attributes
 *   nla_validate_nested()        validate a stream of nested attributes
 *   nla_find()                find attribute in stream of attributes
 *   nla_find_nested()            find attribute in nested attributes
 *   nla_parse()            parse and validate stream of attrs
 *   nla_parse_nested()            parse nested attribuets
 *   nla_for_each_attr()        loop over all attributes
 *   nla_for_each_nested()        loop over the nested attributes
 *=========================================================================
 */

 socket 发送netlink消息

#define TEST_DATA_LEN    16
#define TEST_DATA        "netlink send test"        /* 仅作为示例，内核NETLINK_ROUTE套接字无法解析 */
 
struct sockaddr_nl nladdr;
struct msghdr msg;
struct nlmsghdr *nlhdr;
struct iovec iov;
 
/* 填充目的地址结构 */
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
nladdr.nl_pid = 0;                        /* 地址为内核 */
nladdr.nl_groups = 0;                        /* 单播 */
 
/* 填充netlink消息头 */
nlhdr = (struct nlmsghdr *)malloc(NLMSG_SPACE(TEST_DATA_LEN));
 
nlhdr->nlmsg_len = NLMSG_LENGTH(TEST_DATA_LEN);
nlhdr->nlmsg_flags = NLM_F_REQUEST;
nlhdr->nlmsg_pid = get_pid();                    /* 当前套接字所绑定的ID号（此处为本进程的PID） */
nlhdr->nlmsg_seq = 0;
 
/* 填充netlink消息实际载荷 */
strcpy(NLMSG_DATA(nlhdr), TEST_DATA);
iov.iov_base = (void *)nlhdr;
iov.iov_len = nlhdr->nlmsg_len;
    
/* 填充数据消息结构 */
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)&(nladdr);
msg.msg_namelen = sizeof(nladdr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
 
/* 发送netlink消息 */
sendmsg (sock, &msg, 0); /* sock 为NETLINK_ROUTE类型套接字 */
这里调用了socket所绑定协议特有的数据发送钩子函数，其中最后一个参数为msg->msg_iter->count，
    即消息实际载荷的总长度。在前一篇文章中已经看到了对于netlink类型的套接字来说该函数被注册为netlink_sendmsg()，
    下面来分析这个函数，这个函数较长，分段分析：

根据socket 层代码分析可知：

send(fd......) 最后回调socket所绑定协议特有的数据发送钩子函数，其中最后一个参数为msg->msg_iter->count，即消息实际载荷的总长度。

对于netlink类型的套接字来说该函数被注册为netlink_sendmsg()

static int netlink_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
{
    struct sock *sk = sock->sk;
    struct netlink_sock *nlk = nlk_sk(sk);
    DECLARE_SOCKADDR(struct sockaddr_nl *, addr, msg->msg_name);
    u32 dst_portid;
    u32 dst_group;
    struct sk_buff *skb;
    int err;
    struct scm_cookie scm;
    u32 netlink_skb_flags = 0;

    if (msg->msg_flags&MSG_OOB)
        return -EOPNOTSUPP;
/*这里定义了一个struct sockaddr_nl *addr指针，它指向了msg->msg_name表示消息的目的地址（会做地址长度检查）；
然后调用scm_send()发送消息辅助数据
    */err = scm_send(sock, msg, &scm, true);
    if (err < 0)
        return err;
/*
如果用户指定了netlink消息的目的地址，则对其进行校验，然后判断当前netlink协议的NL_CFG_F_NONROOT_SEND标识是否设置，
如果设置了该标识则允许非root用户发送组播，对于NETLINK_ROUTE类型的netlink套接字，
并没有设置该标识，表明非root用户不能发送组播消息；
然后设置NETLINK_SKB_DST标识。如果用户没有指定netlink消息的目的地址，
则使用netlink套接字默认的（该值默认为0，会在调用connect系统调用时在netlink_connect()中被赋值为用户设置的值）。
注意这里dst_group经过ffs的处理后转化为组播地址位数（找到最低有效位）。
?
*/
    if (msg->msg_namelen) {
        err = -EINVAL;
        if (addr->nl_family != AF_NETLINK)
            goto out;
        dst_portid = addr->nl_pid;
        dst_group = ffs(addr->nl_groups);//用于查找一个整数中的第一个置位值(也就是bit为1的位)
        err =  -EPERM;
        if ((dst_group || dst_portid) &&
            !netlink_allowed(sock, NL_CFG_F_NONROOT_SEND))
            goto out;
        netlink_skb_flags |= NETLINK_SKB_DST;
    } else {//没有指定netlink 消息接收地址  使用默认的
        dst_portid = nlk->dst_portid;
        dst_group = nlk->dst_group;
    }

    if (!nlk->bound) {//来判断当前的netlink套接字是否被绑定过，如果没有绑定过这里调用netlink_autobind()进行动态绑定
        err = netlink_autobind(sock);
        if (err)
            goto out;
    } else {
        /* Ensure nlk is hashed and visible. */
        smp_rmb();
    }
//接下来判断需要发送的数据是否过长（长于发送缓存大小），然后通过netlink_alloc_large_skb分配skb结构（传入的参数为消息载荷的长度以及组播地址）。
    err = -EMSGSIZE;
    if (len > sk->sk_sndbuf - 32)
        goto out;
    err = -ENOBUFS;
    skb = netlink_alloc_large_skb(len, dst_group);
    if (skb == NULL)
        goto out;
/*
在成功创建skb结构之后，这里就开始初始化它，这里使用到了skb中的扩展cb字段（char cb[48] __aligned(8)，
一共48个字节用于存放netlink的地址和标识相关的附加信息足够了），同时使用宏NETLINK_CB来操作这些字段。
netlink将skb的cb字段强制定义为struct netlink_skb_parms结构：
*/
    NETLINK_CB(skb).portid    = nlk->portid;
    NETLINK_CB(skb).dst_group = dst_group;
    NETLINK_CB(skb).creds    = scm.creds;
    NETLINK_CB(skb).flags    = netlink_skb_flags;
/*
其中portid表示原端套接字所绑定的id，dst_group表示消息目的组播地址，flag为标识，sk指向原端套接字的sock结构。
这里首先将套接字绑定的portid赋值到skb得cb字段中、同时设置组播地址的数量以及netlink_skb标识（这里是已经置位NETLINK_SKB_DST）。
接下来调用最关键的调用memcpy_from_msg拷贝数据，它首先调用skb_put调整skb->tail指针，
然后执行copy_from_iter(data, len, &msg->msg_iter)将数据从msg->msg_iter中传输到skb->data中
（这是第一次内存拷贝动作！将用户空间数据直接拷贝到内核skb中）。
*/
    err = -EFAULT;
    if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
        kfree_skb(skb);
        goto out;
    }

    err = security_netlink_send(sk, skb);
    if (err) {
        kfree_skb(skb);
        goto out;
    }
/*
如果是组播发送则调用netlink_broadcast()发送消息，否则调用netlink_unicast()发送单播消息
*/
    if (dst_group) {
        atomic_inc(&skb->users);
        netlink_broadcast(sk, skb, dst_portid, dst_group, GFP_KERNEL);
    }
    err = netlink_unicast(sk, skb, dst_portid, msg->msg_flags&MSG_DONTWAIT);

out:
    scm_destroy(&scm);
    return err;
}

单播发送函数netlink_unicast()

/*
内核可以通过nlmsg_unicast()函数向应用层发送单播消息，由各个netlink协议负责调用，也有的协议是直接调用netlink_unicast()函数，
其实nlmsg_unicast()也仅是netlink_unicast()的一个封装而已：
*/
int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
            u32 portid, int nonblock)
{
    struct sock *sk;
    int err;
    long timeo;
/*
这里首先调用netlink_trim()重新裁剪skb的数据区的大小，这可能会clone出一个新的skb结构同时重新分配skb->data的内存空间
（这就出现了第三次的内存拷贝动作！），当然如果原本skb中多余的内存数据区非常小或者该内存空间是在vmalloc空间中的就不会执行上述操作，
我们现在跟随的情景上下文中就是后一种情况，并不会重新分配空间。
接下来记下发送超时等待时间，如果已经设置了MSG_DONTWAIT标识，则等待时间为0，否则返回sk->sk_sndtimeo
（该值在sock初始化时由sock_init_data()函数赋值为MAX_SCHEDULE_TIMEOUT）。

*/
    skb = netlink_trim(skb, gfp_any());

    timeo = sock_sndtimeo(ssk, nonblock);
retry:
    sk = netlink_getsockbyportid(ssk, portid);//根据目的portid号和原端sock结构查找目的端的sock结构
    if (IS_ERR(sk)) {
        kfree_skb(skb);
        return PTR_ERR(sk);
    }
    if (netlink_is_kernel(sk))//目的地址是内核空间，则调用netlink_unicast_kernel向内核进行单播，入参是目的sock、数据skb 原端sock。
        return netlink_unicast_kernel(sk, skb, ssk);
//这里首先sk_filter执行防火墙的过滤，确保可以发送以后调用netlink_attachskb将要发送的skb绑定到netlink sock上
    if (sk_filter(sk, skb)) {
        err = skb->len;
        kfree_skb(skb);
        sock_put(sk);
        return err;
    }
/*
目的sock的接收缓冲区剩余的的缓存大小小于已经提交的数据量，或者标志位已经置位了阻塞标识NETLINK_CONGESTED，
这表明数据不可以立即的送到目的端的接收缓存中。因此，
在原端不是内核socket且没有设置非阻塞标识的情况下会定义一个等待队列并等待指定的时间并返回1，
否则直接丢弃该skb数据包并返回失败。
若目的端的接收缓存区空间足够，就会调用netlink_skb_set_owner_r进行绑定。
回到netlink_unicast()函数中，可以看到若执行netlink_attachskb()的返回值为1，就会再次尝试发送操作。
最后调用netlink_sendskb()执行发送操作
*/
    err = netlink_attachskb(sk, skb, &timeo, ssk);
    if (err == 1)
        goto retry;
    if (err)
        return err;

    return netlink_sendskb(sk, skb);

/*
内核可以通过nlmsg_unicast()函数向应用层发送单播消息，由各个netlink协议负责调用，也有的协议是直接调用netlink_unicast()函数，
其实nlmsg_unicast()也仅是netlink_unicast()的一个封装而已：
*/
int netlink_unicast(struct sock *ssk, struct sk_buff *skb,
            u32 portid, int nonblock)
{
    struct sock *sk;
    int err;
    long timeo;
/*
这里首先调用netlink_trim()重新裁剪skb的数据区的大小，这可能会clone出一个新的skb结构同时重新分配skb->data的内存空间
（这就出现了第三次的内存拷贝动作！），当然如果原本skb中多余的内存数据区非常小或者该内存空间是在vmalloc空间中的就不会执行上述操作，
我们现在跟随的情景上下文中就是后一种情况，并不会重新分配空间。
接下来记下发送超时等待时间，如果已经设置了MSG_DONTWAIT标识，则等待时间为0，否则返回sk->sk_sndtimeo
（该值在sock初始化时由sock_init_data()函数赋值为MAX_SCHEDULE_TIMEOUT）。

*/
    skb = netlink_trim(skb, gfp_any());

    timeo = sock_sndtimeo(ssk, nonblock);
retry:
    sk = netlink_getsockbyportid(ssk, portid);//根据目的portid号和原端sock结构查找目的端的sock结构
    if (IS_ERR(sk)) {
        kfree_skb(skb);
        return PTR_ERR(sk);
    }
    if (netlink_is_kernel(sk))//目的地址是内核空间，则调用netlink_unicast_kernel向内核进行单播，入参是目的sock、数据skb 原端sock。
        return netlink_unicast_kernel(sk, skb, ssk);
//这里首先sk_filter执行防火墙的过滤，确保可以发送以后调用netlink_attachskb将要发送的skb绑定到netlink sock上
    if (sk_filter(sk, skb)) {
        err = skb->len;
        kfree_skb(skb);
        sock_put(sk);
        return err;
    }
/*
目的sock的接收缓冲区剩余的的缓存大小小于已经提交的数据量，或者标志位已经置位了阻塞标识NETLINK_CONGESTED，
这表明数据不可以立即的送到目的端的接收缓存中。因此，
在原端不是内核socket且没有设置非阻塞标识的情况下会定义一个等待队列并等待指定的时间并返回1，
否则直接丢弃该skb数据包并返回失败。
若目的端的接收缓存区空间足够，就会调用netlink_skb_set_owner_r进行绑定。
回到netlink_unicast()函数中，可以看到若执行netlink_attachskb()的返回值为1，就会再次尝试发送操作。
最后调用netlink_sendskb()执行发送操作
*/
    err = netlink_attachskb(sk, skb, &timeo, ssk);
    if (err == 1)
        goto retry;
    if (err)
        return err;

    return netlink_sendskb(sk, skb);
}
EXPORT_SYMBOL(netlink_unicast)

 单播发送消息：

static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
{
    int len = skb->len;

    netlink_deliver_tap(skb);
//这里的sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()，进入分析一下
//对于内核的netlink来说内核netlink的创建函数中已经将其注册为 netlink_data_ready  所以内核不能收到组播
/*
static void netlink_data_ready(struct sock *sk)
{
    BUG();
}
*/
    skb_queue_tail(&sk->sk_receive_queue, skb);
    sk->sk_data_ready(sk);//里唤醒目的接收端socket的等待队列，这样应用层套接字就可以接收并处理消息了。
    return len;
}

对于根据portid 查找sk

首先调用netlink_lookup执行查找，查找的命名空间和协议号同原端sock，它会从nl_table[protocol]的哈希表中找到已经注册的目的端sock套接字。找到以后执行校验，如若找到的socket已经connect了，则它的目的portid必须是原端的portid。
接下来判断目的的netlink socket是否是内核的netlink socket

static int netlink_unicast_kernel(struct sock *sk, struct sk_buff *skb,
                  struct sock *ssk)
{
    int ret;
    struct netlink_sock *nlk = nlk_sk(sk);
/*
目标netlink套接字是否注册了netlink_rcv()接收函数，如果没有则直接丢弃该数据包，否则继续发送流程，这里首先设置一些标识：
skb->sk = sk;      将目的sock赋值给skb->sk指针 
skb->destructor = netlink_skb_destructor;   注册destructor钩子函数 
NETLINK_CB(skb).sk = ssk;   将原端的sock保存早skb的cb扩展字段中 
最后就调用了nlk->netlink_rcv(skb)函数将消息送到内核中的目的netlink套接字中了

在内核注册netlink套接字的时候已经将其接收函数注册到了netlink_rcv中：
    struct sock *
    __netlink_kernel_create(struct net *net, int unit, struct module *module,
                struct netlink_kernel_cfg *cfg)
    {
        ......
        if (cfg && cfg->input)
            nlk_sk(sk)->netlink_rcv = cfg->input;
对于NETLINK_ROUTE类型的套接字来说就是rtnetlink_rcv了，netlink_rcv()钩子函数会接收并解析用户传下来的数据
*/
    ret = -ECONNREFUSED;
    if (nlk->netlink_rcv != NULL) {
        ret = skb->len;
        netlink_skb_set_owner_r(skb, sk);
        NETLINK_CB(skb).sk = ssk;
        netlink_deliver_tap_kernel(sk, ssk, skb);
        nlk->netlink_rcv(skb);
        consume_skb(skb);
    } else {
        kfree_skb(skb);
    }
    sock_put(sk);
    return ret;
}
/*
内核可以通过nlmsg_unicast()函数向应用层发送单播消息，由各个netlink协议负责调用，也有的协议是直接调用netlink_unicast()函数，
其实nlmsg_unicast()也仅是netlink_unicast()的一个封装而已：
*/

 Netlink发送广播消息：

int netlink_broadcast_filtered(struct sock *ssk, struct sk_buff *skb, u32 portid,
    u32 group, gfp_t allocation,
    int (*filter)(struct sock *dsk, struct sk_buff *skb, void *data),
    void *filter_data)
{
    struct net *net = sock_net(ssk);
    struct netlink_broadcast_data info;
    struct sock *sk;

    skb = netlink_trim(skb, allocation);

    info.exclude_sk = ssk;
    info.net = net;
    info.portid = portid;
    info.group = group;
    info.failure = 0;
    info.delivery_failure = 0;
    info.congested = 0;
    info.delivered = 0;
    info.allocation = allocation;
    info.skb = skb;
    info.skb2 = NULL;
    info.tx_filter = filter;
    info.tx_data = filter_data;

    /* While we sleep in clone, do not allow to change socket list */

    netlink_lock_table();
/*
初始化netlink组播数据结构netlink_broadcast_data，其中info.group中保存了目的组播地址，
然后从nl_table[ssk->sk_protocol].mc_list里边查找加入组播组的socket，并调用do_one_broadcast()函数依次发送组播数据：
*/
    sk_for_each_bound(sk, &nl_table[ssk->sk_protocol].mc_list)
        do_one_broadcast(sk, &info);

    consume_skb(skb);

    netlink_unlock_table();

    if (info.delivery_failure) {
        kfree_skb(info.skb2);
        return -ENOBUFS;
    }
    consume_skb(info.skb2);

    if (info.delivered) {
        if (info.congested && gfpflags_allow_blocking(allocation))
            yield();
        return 0;
    }
    return -ESRCH;
}

static void do_one_broadcast(struct sock *sk,
                    struct netlink_broadcast_data *p)
{
    struct netlink_sock *nlk = nlk_sk(sk);
    int val;

    if (p->exclude_sk == sk)
        return;
//这里会确保原端sock和目的端sock不是同一个，它们属于同一个网络命名空间，目的的组播地址为发送的目的组播地址等等
    if (nlk->portid == p->portid || p->group - 1 >= nlk->ngroups ||
        !test_bit(p->group - 1, nlk->groups))
        return;

    if (!net_eq(sock_net(sk), p->net)) {
        if (!(nlk->flags & NETLINK_F_LISTEN_ALL_NSID))
            return;

        if (!peernet_has_id(sock_net(sk), p->net))
            return;

        if (!file_ns_capable(sk->sk_socket->file, p->net->user_ns,
                     CAP_NET_BROADCAST))
            return;
    }

    if (p->failure) {
        netlink_overrun(sk);
        return;
    }

    sock_hold(sk);
    if (p->skb2 == NULL) {
        if (skb_shared(p->skb)) {
            p->skb2 = skb_clone(p->skb, p->allocation);
        } else {
            p->skb2 = skb_get(p->skb);
            /*
             * skb ownership may have been set when
             * delivered to a previous socket.
             */
            skb_orphan(p->skb2);
        }
    }
    if (p->skb2 == NULL) {
        netlink_overrun(sk);
        /* Clone failed. Notify ALL listeners. */
        p->failure = 1;
        if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR)
            p->delivery_failure = 1;
        goto out;
    }
    if (p->tx_filter && p->tx_filter(sk, p->skb2, p->tx_data)) {
        kfree_skb(p->skb2);
        p->skb2 = NULL;
        goto out;
    }
    if (sk_filter(sk, p->skb2)) {
        kfree_skb(p->skb2);
        p->skb2 = NULL;
        goto out;
    }
    NETLINK_CB(p->skb2).nsid = peernet2id(sock_net(sk), p->net);
    NETLINK_CB(p->skb2).nsid_is_set = true;
    /*
内核netlink套接字是无论如何也不应该接收到组播消息的。
但是对于应用层netlink套接字，该sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()，
这个函数后面再分析。
    */
    val = netlink_broadcast_deliver(sk, p->skb2);//netlink_broadcast_deliver()函数对目的sock发送数据skb：
    if (val < 0) {
        netlink_overrun(sk);
        if (nlk->flags & NETLINK_F_BROADCAST_SEND_ERROR)
            p->delivery_failure = 1;
    } else {
        p->congested |= val;
        p->delivered = 1;
        p->skb2 = NULL;
    }
out:
    sock_put(sk);
}

内核netlink套接字是无论如何也不应该接收到组播消息的。但是对于应用层netlink套接字，该sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()

static int __netlink_sendskb(struct sock *sk, struct sk_buff *skb)
{
    int len = skb->len;

    netlink_deliver_tap(skb);
//这里的sk_data_ready()钩子函数在初始化netlink函数sock_init_data()中被注册为sock_def_readable()，进入分析一下
//对于内核的netlink来说内核netlink的创建函数中已经将其注册为 netlink_data_ready  所以内核不能收到组播
/*
static void netlink_data_ready(struct sock *sk)
{
    BUG();
}
*/
    skb_queue_tail(&sk->sk_receive_queue, skb);
    sk->sk_data_ready(sk);//里唤醒目的接收端socket的等待队列，这样应用层套接字就可以接收并处理消息了。
    return len;
}