Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發 >> 關於android開發 >> Linux Netlink基本使用

Linux Netlink基本使用

日期:2016/3/15 9:13:51      編輯:關於android開發

Linux Netlink基本使用


Netlink基本使用
——lvyilong316

1.什麼是Netlink

什麼是Netlink?Netlink是linux提供的用於內核和用戶態進程之間的通信方式。但是注意雖然Netlink主要用於用戶空間和內核空間的通信,但是也能用於用戶空間的兩個進程通信。只是進程間通信有其他很多方式,一般不用Netlink。除非需要用到Netlink的廣播特性時。

那麼Netlink有什麼優勢呢?一般來說用戶空間和內核空間的通信方式有三種:/proc、ioctl、Netlink。而前兩種都是單向的,但是Netlink可以實現雙工通信。

Netlink協議基於BSDsocket和AF_NETLINK地址簇(addressfamily),使用32位的端口號尋址(以前稱作PID),每個Netlink協議(或稱作總線,man手冊中則稱之為netlinkfamily),通常與一個或一組內核服務/組件相關聯,如NETLINK_ROUTE用於獲取和設置路由與鏈路信息、NETLINK_KOBJECT_UEVENT用於內核向用戶空間的udev進程發送通知等。netlink具有以下特點:

①支持全雙工、異步通信(當然同步也支持)

②用戶空間可使用標准的BSDsocket接口(但netlink並沒有屏蔽掉協議包的構造與解析過程,推薦使用libnl等第三方庫)

③在內核空間使用專用的內核API接口

④支持多播(因此支持“總線”式通信,可實現消息訂閱)

⑤在內核端可用於進程上下文與中斷上下文

如何學習Netlink?我覺得最好的方式就是將Netlink和UDPsocket對比學習。因為他們真的很對地方相似。AF_NETLINK和AF_INET對應,是一個協議族,而NETLINK_ROUTE、NETLINK_GENERIC這些是協議,對應於UDP。

那麼我們主要關注Netlink和UDPsocket之間的不同點,其中最重要的一點就是:使用UDPsocket發送數據包時,用戶無需構造UDP數據包的包頭,內核協議棧會根據原、目的地址(sockaddr_in)填充頭部信息。但是Netlink需要我們自己構造一個包頭(這個包頭有什麼用,我們後面再說)。

一般我們使用Netlink都要指定一個協議,我們可以使用內核為我們預留的NETLINK_GENERIC(定義在linux/netlink.h中),也可以使用我們自定義的協議,其實就是定義一個內核還沒有占用的數字。下面我們用NETLINK_TEST做為我們定義的協議寫一個例子(注意:自定義協議不一定非要添加到linux/netlink.h中,只要用戶態和內核態代碼都能找到該定義就行)。我們知道使用UDP發送報文有兩種方式:sendto和sendmsg,同樣Netlink也支持這兩種方式。下面先看使用sendmsg的方式。

2.用戶態數據結構

首先看一下幾個重要的數據結構的關系:

2.1structmsghdr

msghdr這個結構在socket變成中就會用到,並不算Netlink專有的,這裡不在過多說明。只說明一下如何更好理解這個結構的功能。我們知道socket消息的發送和接收函數一般有這幾對:recv/send、readv/writev、recvfrom/sendto。當然還有recvmsg/sendmsg,前面三對函數各有各的特點功能,而recvmsg/sendmsg就是要囊括前面三對的所有功能,當然還有自己特殊的用途。msghdr的前兩個成員就是為了滿足recvfrom/sendto的功能,中間兩個成員msg_iov和msg_iovlen則是為了滿足readv/writev的功能,而最後的msg_flags則是為了滿足recv/send中flag的功能,剩下的msg_control和msg_controllen則是滿足recvmsg/sendmsg特有的功能。

2.2Structsockaddr_ln

Structsockaddr_ln為Netlink的地址,和我們通常socket編程中的sockaddr_in作用一樣,他們的結構對比如下。

structsockaddr_nl{}的詳細定義和描述如下:

  1. struct sockaddr_nl
  2. {
  3. sa_family_t nl_family; /*該字段總是為AF_NETLINK */
  4. unsigned short nl_pad; /* 目前未用到,填充為0*/
  5. __u32 nl_pid; /* process pid */
  6. __u32 nl_groups; /* multicast groups mask */
  7. };

(1)nl_pid:在Netlink規范裡,PID全稱是Port-ID(32bits),其主要作用是用於唯一的標識一個基於netlink的socket通道。通常情況下nl_pid都設置為當前進程的進程號。前面我們也說過,Netlink不僅可以實現用戶-內核空間的通信還可使現實用戶空間兩個進程之間,或內核空間兩個進程之間的通信。該屬性為0時一般指內核。

(2)nl_groups:如果用戶空間的進程希望加入某個多播組,則必須執行bind()系統調用。該字段指明了調用者希望加入的多播組號的掩碼(注意不是組號,後面我們會詳細講解這個字段)。如果該字段為0則表示調用者不希望加入任何多播組。對於每個隸屬於Netlink協議域的協議,最多可支持32個多播組(因為nl_groups的長度為32比特),每個多播組用一個比特來表示。

2.3structnlmsghdr

Netlink的報文由消息頭和消息體構成,structnlmsghdr即為消息頭。消息頭定義在文件裡,由結構體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. };

消息頭中各成員屬性的解釋及說明:

(1)nlmsg_len:整個消息的長度,按字節計算。包括了Netlink消息頭本身。

(2)nlmsg_type:消息的類型,即是數據還是控制消息。目前(內核版本2.6.21)Netlink僅支持四種類型的控制消息,如下:

a)NLMSG_NOOP-空消息,什麼也不做;

b)NLMSG_ERROR-指明該消息中包含一個錯誤;

c)NLMSG_DONE-如果內核通過Netlink隊列返回了多個消息,那麼隊列的最後一條消息的類型為NLMSG_DONE,其余所有消息的nlmsg_flags屬性都被設置NLM_F_MULTI位有效。

d)NLMSG_OVERRUN-暫時沒用到。

(3)nlmsg_flags:附加在消息上的額外說明信息,如上面提到的NLM_F_MULTI。

那消息體怎麼設置呢?可以使用NLMSG_DATA,具體見後面例子。

3.用戶態范例一

l客戶端1

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

上面程序首先向內核發送一條消息;“Helloyou”,然後進入循環一直等待讀取內核的回復,並將收到的回復打印出來。如果看上面程序感覺很吃力,那麼應該首先復習一下UDP中使用sendmsg的用法,特別時structmsghdr的結構要清楚,這裡再贅述。下面主要分析與UDP發送數據包的不同點:

1.socket地址結構不同,UDP為sockaddr_in,Netlink為structsockaddr_nl;

2.與UDP發送數據相比,Netlink多了一個消息頭結構structnlmsghdr需要我們構造。

注意代碼注釋中的A、B、C三處分別設置了pid。首先解釋一下什麼是pid,網上很多文章把這個字段說成是進程的pid,其實這完全是望文生義。這裡的pid和進程pid沒有什麼關系,僅僅相當於UDP的port。對於UDP來說port和ip標示一個地址,那對我們的NETLINK_TEST協議(注意Netlink本身不是一個協議)來說,pid就唯一標示了一個地址。所以你如果用進程pid做為標示當然也是可以的。當然同樣的pid對於NETLINK_TEST協議和內核定義的其他使用Netlink的協議是不沖突的(就像TCP的80端口和UDP的80端口)。

下面分析這三處設置pid分別有什麼作用,首先A和B位置的比較好理解,這是在地址(sockaddr_nl)上進行的設置,就是相當於設置源地址和目的地址(其實是端口),只是注意B處設置pid為0,0就代表是內核,可以理解為內核專用的pid,那麼用戶進程就不能用0做為自己的pid嗎?這個只能說如果你非要用也是可以的,只是會產生一些問題,後面在分析。接下來看為什麼C處的消息頭仍然需要設置pid呢?這裡首先要知道一個前提:內核不會像UDP一樣根據我們設置的原、目的地址為我們構造消息頭,所以我們不在包頭寫入我們自己的地址(pid),那內核怎麼知道是誰發來的報文呢?當然如果內核只是處理消息不需要回復進程的話捨不設置這個消息頭pid都可以。

所以每個pid的設置功能不同:A處的設置是要設置發送者的源地址,有人會說既然源地址又不會自動填充到報文中,我們為什麼還要設置這個,因為你還可能要接收回復啊。就像寄信,你連“門牌號”都沒有,即使你在寫信時候寫上你的地址是100號,對方回信目的地址也是100號,但是郵局發現根本沒有這個地址怎麼可能把信送到你手裡呢?所以A的主要作用是注冊源地址,保證可以收到回復,如果不需要回復當然可以簡單將pid設置為0;B處自然就是收信人的地址,pid為0代表內核的地址,假如有一個進程在101號上注冊了地址,並調用了recvmsg,如果你將B處的pid設置為101,那數據包就發給了另一個進程,這就實現了使用Netlink進行進程間通信;C相當於你在信封上寫的源地址,通常情況下這個應該和你的真實地址(A)處注冊的源地址相同,當然你要是不想收到回信,又想惡搞一下或者有特殊需求,你可以寫成其他進程注冊的pid(比如101)。這和我們現實中寄信是一樣的,你給你朋友寫封情書,把寫信人寫成你的另一個好基友,然後後果你懂得……

好了,有了這個例子我們就大概知道用戶態怎麼使用Netlink了,至於我們沒有用到的nl_groups等其他信息後面講到再說,下面看下內核是怎麼處理Netlink的。

4.內核Netlinkapi

4.1創建netlinksocket


  1. struct sock *netlink_kernel_create(struct net *net,
  2. int unit,unsigned int groups,
  3. void (*input)(struct sk_buff *skb),
  4. struct mutex *cb_mutex,struct module *module);

參數說明:

(1)net:是一個網絡名字空間namespace,在不同的名字空間裡面可以有自己的轉發信息庫,有自己的一套net_device等等。默認情況下都是使用init_net這個全局變量。

(2)unit:表示netlink協議類型,如NETLINK_TEST、NETLINK_SELINUX。

(3)groups:多播地址。

(4)input:為內核模塊定義的netlink消息處理函數,當有消息到達這個netlinksocket時,該input函數指針就會被引用,且只有此函數返回時,調用者的sendmsg才能返回。

(5)cb_mutex:為訪問數據時的互斥信號量。

(6)module:一般為THIS_MODULE。

4.2發送單播消息netlink_unicast

  1. int netlink_unicast(struct sock *ssk, struct sk_buff *skb, u32 pid, int nonblock)

參數說明:

(1)ssk:為函數netlink_kernel_create()返回的socket。

(2)skb:存放消息,它的data字段指向要發送的netlink消息結構,而skb的控制塊保存了消息的地址信息,宏NETLINK_CB(skb)就用於方便設置該控制塊。

(3)pid:為接收此消息進程的pid,即目標地址,如果目標為組或內核,它設置為0。

(4)nonblock:表示該函數是否為非阻塞,如果為1,該函數將在沒有接收緩存可利用時立即返回;而如果為0,該函數在沒有接收緩存可利用定時睡眠。

4.3發送廣播消息netlink_broadcast

  1. int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 pid, u32 group, gfp_t allocation)

前面的三個參數與netlink_unicast相同,參數group為接收消息的多播組,該參數的每一個位代表一個多播組,因此如果發送給多個多播組,就把該參數設置為多個多播組組ID的位或。參數allocation為內核內存分配類型,一般地為GFP_ATOMIC或GFP_KERNEL,GFP_ATOMIC用於原子的上下文(即不可以睡眠),而GFP_KERNEL用於非原子上下文。

4.4釋放netlinksocket

  1. void netlink_kernel_release(struct sock *sk)

5.內核態程序范例一

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #define NETLINK_TEST 25
  9. #define MAX_MSGSIZE 1024
  10. int stringlength(char *s);
  11. int err;
  12. struct sock *nl_sk = NULL;
  13. int flag = 0;
  14. //向用戶態進程回發消息
  15. void sendnlmsg(char *message, int pid)
  16. {
  17. struct sk_buff *skb_1;
  18. struct nlmsghdr *nlh;
  19. int len = NLMSG_SPACE(MAX_MSGSIZE);
  20. int slen = 0;
  21. if(!message || !nl_sk)
  22. {
  23. return ;
  24. }
  25. printk(KERN_ERR "pid:%d\n",pid);
  26. skb_1 = alloc_skb(len,GFP_KERNEL);
  27. if(!skb_1)
  28. {
  29. printk(KERN_ERR "my_net_link:alloc_skb error\n");
  30. }
  31. slen = stringlength(message);
  32. nlh = nlmsg_put(skb_1,0,0,0,MAX_MSGSIZE,0);
  33. NETLINK_CB(skb_1).pid = 0;
  34. NETLINK_CB(skb_1).dst_group = 0;
  35. message[slen]= '\0';
  36. memcpy(NLMSG_DATA(nlh),message,slen+1);
  37. printk("my_net_link:send message '%s'.\n",(char *)NLMSG_DATA(nlh));
  38. netlink_unicast(nl_sk,skb_1,pid,MSG_DONTWAIT);
  39. }
  40. int stringlength(char *s)
  41. {
  42. int slen = 0;
  43. for(; *s; s++)
  44. {
  45. slen++;
  46. }
  47. return slen;
  48. }
  49. //接收用戶態發來的消息
  50. void nl_data_ready(struct sk_buff *__skb)
  51. {
  52. struct sk_buff *skb;
  53. struct nlmsghdr *nlh;
  54. char str[100];
  55. struct completion cmpl;
  56. printk("begin data_ready\n");
  57. int i=10;
  58. int pid;
  59. skb = skb_get (__skb);
  60. if(skb->len >= NLMSG_SPACE(0))
  61. {
  62. nlh = nlmsg_hdr(skb);
  63. memcpy(str, NLMSG_DATA(nlh), sizeof(str));
  64. printk("Message received:%s\n",str) ;
  65. pid = nlh->nlmsg_pid;
  66. while(i--)
  67. {//我們使用completion做延時,每3秒鐘向用戶態回發一個消息
  68. init_completion(&cmpl);
  69. wait_for_completion_timeout(&cmpl,3 * HZ);
  70. sendnlmsg("I am from kernel!",pid);
  71. }
  72. flag = 1;
  73. kfree_skb(skb);
  74. }
  75. }
  76. // Initialize netlink
  77. int netlink_init(void)
  78. {
  79. nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, 1,
  80. nl_data_ready, NULL, THIS_MODULE);
  81. if(!nl_sk){
  82. printk(KERN_ERR "my_net_link: create netlink socket error.\n");
  83. return 1;
  84. }
  85. printk("my_net_link_4: create netlink socket ok.\n");
  86. return 0;
  87. }
  88. static void netlink_exit(void)
  89. {
  90. if(nl_sk != NULL){
  91. sock_release(nl_sk->sk_socket);
  92. }
  93. printk("my_net_link: self module exited\n");
  94. }
  95. module_init(netlink_init);
  96. module_exit(netlink_exit);
  97. MODULE_AUTHOR("yilong");
  98. MODULE_LICENSE("GPL");

附上內核代碼的Makefile文件:

  1. ifneq ($(KERNELRELEASE),)
  2. obj-m :=netl.o
  3. else
  4. KERNELDIR ?=/lib/modules/$(shell uname -r)/build
  5. PWD :=$(shell pwd)
  6. default:
  7. $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
  8. endif

6.程序結構分析

我們將內核模塊insmod後,運行用戶態程序,結果如下:

這個結果復合我們的預期,但是運行過程中打印出“state_smg”卡了好久才輸出了後面的結果。這時候查看客戶進程是處於D狀態的(不了解D狀態的同學可以google一下)。這是為什麼呢?因為進程使用Netlink向內核發數據是同步,內核向進程發數據是異步。什麼意思呢?也就是用戶進程調用sendmsg發送消息後,內核會調用相應的接收函數,但是一定到這個接收函數執行完用戶態的sendmsg才能夠返回。我們在內核態的接收函數中調用了10次回發函數,每次都等待3秒鐘,所以內核接收函數30秒後才返回,所以我們用戶態程序的sendmsg也要等30秒後才返回。相反,內核回發的數據不用等待用戶程序接收,這是因為內核所發的數據會暫時存放在一個隊列中。

再來回到之前的一個問題,用戶態程序的源地址(pid)可以用0嗎?我把上面的用戶程序的A和C處pid都改為了0,結果一運行就死機了。為什麼呢?我們看一下內核代碼的邏輯,收到用戶消息後,根據消息中的pid發送回去,而pid為0,內核並不認為這是用戶程序,認為是自身,所有又將回發的10個消息發給了自己(內核),這樣就陷入了一個死循環,而用戶態這時候進程一直處於D。

另外一個問題,如果同時啟動兩個用戶進程會是什麼情況?答案是再調用bind時出錯:“Addressalreadyinuse”,這個同UDP一樣,同一個地址同一個port如果沒有設置SO_REUSEADDR兩次bind就會出錯,之後我用同樣的方式再Netlink的socket上設置了SO_REUSEADDR,但是並沒有什麼效果。

7.用戶態范例二

之前我們說過UDP可以使用sendmsg/recvmsg也可以使用sendto/recvfrom,那麼Netlink同樣也可以使用sendto/recvfrom。具體實現如下:

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. #include
  8. #include
  9. #include
  10. #include
  11. #include
  12. #define MAX_PAYLOAD 1024 // maximum payload size
  13. #define NETLINK_TEST 25
  14. int main(int argc, char* argv[])
  15. {
  16. struct sockaddr_nl src_addr, dest_addr;
  17. struct nlmsghdr *nlh = NULL;
  18. int sock_fd, retval;
  19. int state,state_smg = 0;
  20. // Create a socket
  21. sock_fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_TEST);
  22. if(sock_fd == -1){
  23. printf("error getting socket: %s", strerror(errno));
  24. return -1;
  25. }
  26. // To prepare binding
  27. memset(&src_addr, 0, sizeof(src_addr));
  28. src_addr.nl_family = AF_NETLINK;
  29. src_addr.nl_pid = 100;
  30. src_addr.nl_groups = 0;
  31. //Bind
  32. retval = bind(sock_fd, (struct sockaddr*)&src_addr, sizeof(src_addr));
  33. if(retval < 0){
  34. printf("bind failed: %s", strerror(errno));
  35. close(sock_fd);
  36. return -1;
  37. }
  38. // To orepare create mssage head
  39. nlh = (struct nlmsghdr *)malloc(NLMSG_SPACE(MAX_PAYLOAD));
  40. if(!nlh){
  41. printf("malloc nlmsghdr error!\n");
  42. close(sock_fd);
  43. return -1;
  44. }
  45. memset(&dest_addr,0,sizeof(dest_addr));
  46. dest_addr.nl_family = AF_NETLINK;
  47. dest_addr.nl_pid = 0;
  48. dest_addr.nl_groups = 0;
  49. nlh->nlmsg_len = NLMSG_SPACE(MAX_PAYLOAD);
  50. nlh->nlmsg_pid = 100;
  51. nlh->nlmsg_flags = 0;
  52. strcpy(NLMSG_DATA(nlh),"Hello you!");
  53. //send message
  54. printf("state_smg\n");
  55. sendto(sock_fd,nlh,NLMSG_LENGTH(MAX_PAYLOAD),0,(struct sockaddr*)(&dest_addr),sizeof(dest_addr));
  56. if(state_smg == -1)
  57. {
  58. printf("get error sendmsg = %s\n",strerror(errno));
  59. }
  60. memset(nlh,0,NLMSG_SPACE(MAX_PAYLOAD));
  61. //receive message
  62. printf("waiting received!\n");
  63. while(1){
  64. printf("In while recvmsg\n");
  65. state=recvfrom(sock_fd,nlh,NLMSG_LENGTH(MAX_PAYLOAD),0,NULL,NULL);
  66. if(state<0)
  67. {
  68. printf("state<1");
  69. }
  70. printf("Received message: %s\n",(char *) NLMSG_DATA(nlh));
  71. memset(nlh,0,NLMSG_SPACE(MAX_PAYLOAD));
  72. }
  73. close(sock_fd);
  74. return 0;
  75. }

熟悉UDP編程的同學看到這個程序一定很熟悉,除了多了一個Netlink消息頭的設置。但是我們發現程序中調用了bind函數,這個函數再UDP編程中的客戶端不是必須的,因為我們不需要把UDPsocket與某個地址關聯,同時再發送UDP數據包時內核會為我們分配一個隨即的端口。但是對於Netlink必須要有這一步bind,因為Netlink內核可不會為我們分配一個pid。再強調一遍消息頭(nlmsghdr)中的pid是告訴內核接收端要回復的地址,但是這個地址存不存在內核並不關心,這個地址只有用戶端調用了bind後才存在。

再說一個體外話,我們看到這兩個例子都是用戶態首先發起的,那Netlink是否支持內核態主動發起的情況呢?當然是可以的,只是內核一般需要事件觸發,這裡,只要和用戶態約定號一個地址(pid),內核直接調用netlink_unicast就可以了。

  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved