原博文連線：http://blog.chinaunix.net/uid-24716553-id-5609723.html

netlink是一種用於使用者空間程序與核心間通訊的方法，也可以用於使用者程序之間的通訊（IPC）。
netlink和ioctl比較相似，都能從使用者空間向核心空間通訊， 但netlink是一種非同步通訊機制，而ioctl是同步通訊機制。且ioctl不能從核心向用戶空間傳送訊息。

下面我們結合例項來進一步瞭解netlink。我們的例子是使用者態傳送一串資料給核心態，核心接收到後，返回"I am from kernel!"給使用者態程式。

核心態（以核心版本3.13為例）

先來了解下核心中netlink相關的資料結構和函式。

使用netlink_kernel_create()函式建立核心套接字服務，函式型別：

1. static inline struct sock *netlink_kernel_create(struct net *net, int unit, struct netlink_kernel_cfg *cfg);

函式返回建立的struct sock物件指標。struct sock (定義在include\linux\net.h) 結構是核心網路系統中最常見的結構之一。它的使用基本貫穿L2,L3,L4層，而且是各層之間的一個聯絡，無論傳送還是接收的資料包都要被存到sock結構中的緩衝佇列中。
函式引數net是網路名稱空間，如果沒自定義網路名稱空間的話，就使用核心預設的init_net。
unit是netlink型別，核心已經定義了21個(在include/uapi/linux/netlink.h中)，如果要增加我們自己的netlink型別，就必須定義新的值，但要注意，新的值必須小於MAX_LINKS（32）
cfg是netlink的配置資訊。該結構體定義如下：

1. struct netlink_kernel_cfg {
   
   
2.         unsigned int groups;
   
3.         unsigned int flags;
   
4.         void (*input)(struct sk_buff *skb);
   
5.         struct mutex *
   cb_mutex;
   
6.         int (*bind)(struct net *net, int group);
   
7.         void (*unbind)(struct net *net, int group);
   
8.         bool (*compare)(struct net *net, struct sock *sk);
   
9. };

其中最重要的是input域，該函式用於處理使用者空間傳送到核心方向的資料。核心接收到資料包後，會傳給input函式。

來看程式碼：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/timer.h>
   
4. #include <linux/time.h>
   
5. #include <linux/types.h>
   
6. #include <net/sock.h>
   
7. #include <net/netlink.h>
   
8. #include <linux/string.h>
   
9. 
   
10. #define NETLINK_TEST 25
    
11. #define MAX_MSGSIZE 1024
    
12. 
    
13. struct sock *nl_sk = NULL;
    
14. 
    
15. void send_msg(char *message, int pid)
    
16. {
    
17.         struct sk_buff *skb;
    
18.         struct nlmsghdr *nlh;
    
19.         int len = NLMSG_SPACE(MAX_MSGSIZE);
    
20. 
    
21.         if (!message || !nl_sk) {
    
22.                 return;
    
23.         }
    
24.         printk(KERN_INFO "pid:%d\n", pid);
    
25.         skb = alloc_skb(len, GFP_KERNEL);
    
26.         if (!skb) {
    
27.                 printk(KERN_ERR "send_msg:alloc_skb error\n");
    
28.                 return;
    
29.         }
    
30.         nlh = nlmsg_put(skb, 0, 0, 0, MAX_MSGSIZE, 0);
    
31.         NETLINK_CB(skb).portid = 0;
    
32.         NETLINK_CB(skb).dst_group = 0;
    
33.         strcpy(NLMSG_DATA(nlh), message);
    
34.         printk(KERN_INFO "my_net_link:send message '%s'.\n",(char *)NLMSG_DATA(nlh));
    
35.         netlink_unicast(nl_sk, skb, pid, MSG_DONTWAIT);
    
36. }
    
37. 
    
38. void recv_nlmsg(struct sk_buff *skb)
    
39. {
    
40.         int pid;
    
41.         struct nlmsghdr *nlh = nlmsg_hdr(skb);
    
42. 
    
43.         if (nlh->nlmsg_len < NLMSG_HDRLEN || skb->len < nlh->nlmsg_len)
    
44.                 return;
    
45. 
    
46.         printk(KERN_INFO "Message received:%s\n", (char*)NLMSG_DATA(nlh));
    
47.         pid = nlh->nlmsg_pid;
    
48.         send_msg("I am from kernel!", pid);
    
49. }
    
50. 
    
51. struct netlink_kernel_cfg nl_kernel_cfg = {
    
52.         .groups = 0,
    
53.         .flags = 0,
    
54.         .input = recv_nlmsg,
    
55.         .cb_mutex = NULL,
    
56.         .bind = NULL,
    
57.         .compare = NULL,
    
58. };
    
59. 
    
60. int netlink_init(void)
    
61. {
    
62.         nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, &nl_kernel_cfg);
    
63.         if (!nl_sk) {
    
64.                 printk(KERN_ERR "my_net_link: create netlink socket error.\n");
    
65.                 return 1;
    
66.         }
    
67.         printk(KERN_INFO "netlink_init: create netlink socket ok.\n");
    
68.         return 0;
    
69. }
    
70. 
    
71. static void netlink_exit(void)
    
72. {
    
73.         if (nl_sk != NULL)
    
74.                 sock_release(nl_sk->sk_socket);
    
75. 
    
76.         printk(KERN_INFO "my_net_link: self module exited\n");
    
77. }
    
78. 
    
79. module_init(netlink_init);
    
80. module_exit(netlink_exit);
    
81. MODULE_AUTHOR("vv1133");
    
82. MODULE_LICENSE("GPL");

程式中，載入模組時，呼叫netlink_kernel_create()建立套接字。解除安裝模組時，呼叫sock_release()釋放套接字。
netlink資料包處理函式是recv_nlmsg()，首先通過nlmsg_hdr()函式獲取到netlink報頭，netlink的訊息報頭由include/uapi/linux/netlink.h中的nlmsghdr定義：

1. struct nlmsghdr
   
2. {
   
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 PID */
   
8. };

我們通過NLMSG_DATA獲取netlink的payload並打印出來。注意，netlink的payload一般使用TLV格式，即“型別-長度-值”，但這裡我們只傳遞一個固定的字串，簡單起見就不用這個格式了。然後，通過alloc_skb()函式建立一個新的skb，並用nlmsg_put()函式填入netlink結構，填充要傳送的字串。最後呼叫netlink_unicast()傳送資料。

使用者態

對於使用者態的程式，netlink通訊與一般的socket通訊類似。只是要用sendmsg()和recvmsg()代替send()/write()和recv()/read()
具體步驟如下：

1. 建立套接字
使用者空間使用系統呼叫socket()建立netlink套接字，需要將域名設定成AF_NETLINK，型別必須是SOCK_RAW或SOCK_DGRAM，協議設定成我們的自定義netlink協議NETLINK_TEST。

2. 將本地套接字與源地址繫結
由於在netlink報頭裡要設定埠號，我們必須使用bind()函式將指定的埠與socket繫結。

3. 初始化msghdr
a. 設定目的地址資訊

1. dest_addr.nl_family = AF_NETLINK;
   
2. dest_addr.nl_pid = 0;
   
3. dest_addr.nl_groups = 0;

b. 填充netlink報頭，即nlmsghdr結構體

1. nlh = nlmsg_hdr(skb);
   
2. nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
   
3. nlh->nlmsg_pid = getpid();
   
4. nlh->nlmsg_flags = 0;

c. 將緩衝區向量iovec與訊息進行繫結，指向訊息頭。

1. iov.iov_base = (void *)nlh;
   
2. iov.iov_len = NLMSG_SPACE(MAX_PAYLOAD);

d. 填充msghdr結構體

1. struct msghdr msg;
   
2. msg.msg_name = (void *)&dest_addr;
   
3. msg.msg_namelen = sizeof(dest_addr);
   
4. msg.msg_iov = &iov;
   
5. msg.msg_iovlen = 1;

4. 呼叫sendmsg向核心傳送訊息，recvmsg從核心獲取訊息。

來看程式碼：

1. #include <sys/stat.h>
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <sys/socket.h>
   
6. #include <sys/types.h>
   
7. #include <string.h>
   
8. #include <asm/types.h>
   
9. #include <linux/netlink.h>
   
10. #include <linux/socket.h>
    
11. #include <errno.h>
    
12. 
    
13. #define MAX_PAYLOAD 1024
    
14. #define NETLINK_TEST 25
    
15. 
    
16. int main(int argc, char* argv[])
    
17. {
    
18.         int state;
    
19.         struct sockaddr_nl src_addr, dest_addr;
    
20.         struct nlmsghdr *nlh = NULL;
    
21.         struct iovec iov;
    
22.         struct msghdr msg;
    
23.         int sock_fd, retval;
    
24.         int state_smg = 0;
    
25. 
    
26.         // Create a socket
    
27.         sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);
    
28.         if(sock_fd == -1){
    
29.                 printf("error getting socket: %s", strerror(errno));
    
30.                 return -1;
    
31.         }
    
32. 
    
33.         // To prepare binding
    
34.         memset(&src_addr, 0, sizeof(src_addr));
    
35.         src_addr.nl_family = AF_NETLINK;
    
36.         src_addr.nl_pid = 100; //設定源端埠號
    
37.         src_addr.nl_groups = 0;
    
38. 
    
39.         //Bind
    
40.         retval = bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));
    
41.         if (retval < 0) {
    
42.                 printf("bind failed: %s", strerror(errno));
    
43.                 close(sock_fd);
    
44.                 return -1;
    
45.         }
    
46. 
    
47.         // To orepare create mssage
    
48.         nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));
    
49.         if (!nlh) {
    
50.                 printf("malloc nlmsghdr error!\n");
    
51.                 close(sock_fd);
    
52.                 return -1;
    
53.         }
    
54. 
    
55.         memset(&dest_addr,0,sizeof(dest_addr));
    
56.         dest_addr.nl_family = AF_NETLINK;
    
57.         dest_addr.nl_pid = 0; //設定目的埠號
    
58.         dest_addr.nl_groups = 0;
    
59.         nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
    
60.         nlh->nlmsg_pid = 100; //設定源埠
    
61.         nlh->nlmsg_flags = 0;
    
62.         strcpy(NLMSG_DATA(nlh), "Hello from client!"); //設定訊息體
    
63.         iov.iov_base = (void *)nlh;
    
64.         iov.iov_len = NLMSG_SPACE(MAX_PAYLOAD);
    
65. 
    
66.         //Create mssage
    
67.         memset(&msg, 0, sizeof(msg));
    
68.         msg.msg_name = (void *)&dest_addr;
    
69.         msg.msg_namelen = sizeof(dest_addr);
    
70.         msg.msg_iov = &iov;
    
71.         msg.msg_iovlen = 1;
    
72. 
    
73.         //send message
    
74.         printf("state_smg\n");
    
75.         state_smg = sendmsg(sock_fd,&msg,0);
    
76.         if (state_smg == -1) {
    
77.                 printf("get error sendmsg = %s\n",strerror(errno));
    
78.         }
    
79.         memset(nlh, 0, NLMSG_SPACE(MAX_PAYLOAD));
    
80. 
    
81.         //receive message
    
82.         printf("waiting received!\n");
    
83.         state = recvmsg(sock_fd, &msg, 0);
    
84.         if (state < 0) {
    
85.                 printf("state<1");
    
86.         }
    
87.         printf("Received message: %s\n", (char*)NLMSG_DATA(nlh));
    
88. 
    
89.         close(sock_fd);
    
90.         return 0;
    
91. }

執行程式：

載入模組

1. # sudo insmod netl.ko

執行客戶端程式

1. # ./client
   
2. state_smg
   
3. waiting
   
4. Received message: I am from

檢視核心列印

1. # dmesg
   
2. [ 545.278040] my_net_link: self module exited
   
3. [ 679.799672] PPP MPPE Compression module registered
   
4. [ 4368.567435] netlink_init: create netlink socket ok.
   
5. [ 4379.239327] Message received:Hello from
   
6. [ 4379.239331] pid:100
   
7. [ 4379.239333] my_net_link:send message 'I am from kernel!'.

解除安裝模組

1. # sudo rmmod netl