通過netlink實現內核模塊和應用層通信

skb常用操作函數，比較容易弄混

skb_put : skb->tail += len, skb->len += len
skb_pull: skb->data += len, skb->len -= len
skb_push: skb->data -= len, skb->len += len

內核版本Linux2.6.38，編譯環境gcc 4.4.4，CentOS6.0

內核模塊代碼：

1. /*
2. * author: [email protected]
3. * date : 2011-10-29
4. */
5. #include <linux/module.h>
6. #include <linux/netlink.h>
7. #include <linux/sched.h>
8. #include <net/sock.h>
9. #include <linux/proc_fs.h>
10. #include <linux/netfilter.h>
11. #include <linux/netfilter_ipv4.h>
12. #include <linux/ip.h>
13. #include <linux/tcp.h>
14. #include <linux/icmp.h>
15. #include <linux/udp.h>
17. #define NETLINK_TEST 30
19. /* 調試信息 */
20. #define LOGMSG(fmt, arg...) \
21. do{ \
22. printk("[func:%s,line:%d]: "fmt, __FUNCTION__, __LINE__, ##arg); \
23. }while(0)
24. /* 錯誤信息 */
25. #define LOGERR(fmt, arg...) \
26. do{ \
27. printk("[func:%s,line:%d]: "fmt, __FUNCTION__, __LINE__, ##arg); \
28. }while(0)
29. /* 斷言 */
30. #define ASSERT(expr) \
31. if (unlikely(!(expr))) { \
32. printk("Assertion failed! %s,%s,%s,line=%d\n", \
33. #expr, __FILE__, __func__, __LINE__); \
34. }
35. /* 消息最大值 */
36. #define MAX_MSG_LEN 1024
37. enum{
38. NLMSG_TYPE_NONE = 0,
39. NLMSG_TYPE_SETPID, /* 設置PID */
40. NLMSG_TYPE_KERNEL, /* 消息來自內核 */
41. NLMSG_TYPE_APP, /* 消息來自應用層 */
42. };
43. struct nlmsg{
44. int type; /* 消息類型 */
45. int len; /* 消息長度，包括頭部 */
46. char msg[MAX_MSG_LEN]; /* 消息正文 */
47. };
48. /* netlink socket */
49. static struct sock *g_nl_sk = NULL;
50. static int g_nlpid = -1; /* 應用層接收程序PID */
52. /*
53. * 發送整個從ip頭開始的skb數據到應用層
54. *
55. * param[in]: sk, skb發送目的socket
56. * param[in]: skb, 待發送的skb
57. * return -1, 失敗; 0, 成功
58. * */
59. int nl_sendskb(struct sock *sk, struct sk_buff *skb)
60. {
61. struct iphdr *iph = NULL;
62. struct nlmsghdr *nlh = NULL;
63. struct sk_buff *nl_skb = NULL;
65. int skb_len = 0;
67. ASSERT(skb != NULL);
68. ASSERT(sk != NULL);
69. if(g_nlpid < 0)
70. return 0;
72. iph = ip_hdr(skb);
73. skb_len = iph->tot_len;
74. /* NLMSG_SPACE: sizeof(struct nlmsghdr) + len按4字節對齊 */
75. nl_skb = alloc_skb(NLMSG_SPACE(skb_len), GFP_ATOMIC);
76. if(!nl_skb)
77. {
78. LOGERR("nl_skb == NULL, failed!\n");
79. return -1;
80. }
81. /*
82. * static inline struct nlmsghdr *nlmsg_put(struct sk_buff *skb, u32 pid, u32 seq,
83. * int type, int payload, int flags);
84. * 設置skb->tail指針指向skb->data + sizeof(struct nlmsghdr) + payload
85. * skb->len = sizeof(struct nlmsghdr) + payload
86. */
87. nlh = nlmsg_put(nl_skb, 0, 0, 0, NLMSG_SPACE(skb_len) - sizeof(struct nlmsghdr), 0);
88. NETLINK_CB(nl_skb).pid = 0; /* 0代表數據來自內核 */
89. memcpy(NLMSG_DATA(nlh), (char *)iph, htons(iph->tot_len));
90. /* 將數據發送給進程號22345的進程 */
91. return netlink_unicast(sk, nl_skb, g_nlpid , MSG_DONTWAIT);
92. }
93. /*
94. * 發送字符串到應用層
95. *
96. * param[in]: sk, 數據發往的socket
97. * param[in]: pmsg, 待發送字符串
98. * param[in]: msglen, 待發送字符串長度
99. *
100. * return: -1, 失敗; 0, 成功
101. * */
102. int nl_sendmsg(struct sock *sk, struct nlmsg *pmsg)
103. {
104. struct nlmsghdr *nlh = NULL;
105. struct sk_buff *nl_skb = NULL;
106. int msglen = pmsg->len;
108. ASSERT(pmsg != NULL);
109. ASSERT(sk != NULL);
111. if(g_nlpid < 0)
112. return 0;
113. nl_skb = alloc_skb(NLMSG_SPACE(msglen), GFP_ATOMIC);
114. if(!nl_skb)
115. {
116. LOGERR("nl_skb == NULL, msglen = %d, failed!\n", msglen);
117. return -1;
118. }
120. nlh = nlmsg_put(nl_skb, 0, 0, 0,
121. NLMSG_SPACE(msglen) - NLMSG_HDRLEN, 0);
122. NETLINK_CB(nl_skb).pid = 0;
123. memcpy(NLMSG_DATA(nlh), pmsg, msglen);
125. return netlink_unicast(sk, nl_skb, g_nlpid , MSG_DONTWAIT);
126. }
127. /*
128. * 從應用層接收數據, netlink_kernel_create注冊的回調
129. * param[in]: skb, 包含netlink數據的skb
130. *
131. * skb常用操作函數
132. * skb_put : skb->tail += len, skb->len += len
133. * skb_pull: skb->data += len, skb->len -= len
134. * skb_push: skb->data -= len, skb->len += len
135. */
136. static void nl_recvmsg(struct sk_buff *skb)
137. {
138. struct nlmsg *pmsg = NULL;
139. struct nlmsghdr *nlh = NULL;
140. uint32_t rlen = 0;
142. while(skb->len >= NLMSG_SPACE(0))
143. {
144. nlh = nlmsg_hdr(skb);
145. if(nlh->nlmsg_len < sizeof(*nlh) || skb->len < nlh->nlmsg_len)
146. return;
147. rlen = NLMSG_ALIGN(nlh->nlmsg_len);
148. if(rlen > skb->len)
149. rlen = skb->len;
150. pmsg = (struct nlmsg*)NLMSG_DATA(nlh);
151. switch(pmsg->type)
152. {
153. case NLMSG_TYPE_SETPID:
154. g_nlpid = nlh->nlmsg_pid;
155. LOGMSG("pid: %d\n", g_nlpid);
156. LOGMSG("msg: %s\n", pmsg->msg);
157. break;
158. case NLMSG_TYPE_KERNEL:
159. break;
160. case NLMSG_TYPE_APP:
161. break;
162. }
163. /* 獲取下一條netlink消息 */
164. skb_pull(skb, rlen);
165. }
166. }
168. /*
169. * netfilter PRE_ROUTING鉤子
170. * */
171. unsigned int pre_routing_hook(unsigned int hooknum,
172. struct sk_buff *skb,
173. const struct net_device *in,
174. const struct net_device *out,
175. int (*okfn)(struct sk_buff *))
176. {
177. char *psend = "msg for kernel";
178. struct nlmsg msg;
179. int ret = 0;
181. msg.type = NLMSG_TYPE_KERNEL;
182. msg.len = strlen(psend) + offsetof(struct nlmsg, msg) + 1;
183. memcpy(msg.msg, psend, msg.len);
184. //ret = nl_sendskb(g_nl_sk, skb);
185. ret = nl_sendmsg(g_nl_sk, &msg);
186. //LOGMSG("ok\n");
187. return NF_ACCEPT;
188. }
190. static struct nf_hook_ops local_in_ops __read_mostly = {
191. .hook = pre_routing_hook,
192. .owner = THIS_MODULE,
193. .pf = PF_INET,
194. .hooknum = NF_INET_PRE_ROUTING,
195. .priority = NF_IP_PRI_FIRST
196. };
198. static int __init nl_init(void)
199. {
200. int ret = 0;
201. /*
202. * struct sock *netlink_kernel_create(struct net *net, int unit, unsigned int groups,
203. * void (*input)(struct sk_buff *skb),
204. * struct mutex *cb_mutex, struct module *module)
205. */
206. g_nl_sk = netlink_kernel_create(&init_net, NETLINK_TEST, 0, nl_recvmsg, NULL, THIS_MODULE);
207. if (!g_nl_sk) {
208. LOGERR("Fail to create netlink socket.\n");
209. return -1;
210. }
212. ret = nf_register_hook(&local_in_ops);
213. if(ret < 0)
214. {
215. LOGMSG("nf_register_hook failed!\n");
216. goto sock_release;
217. }
218. LOGMSG("ok!\n");
219. return 0;
221. sock_release:
222. if(g_nl_sk)
223. sock_release(g_nl_sk->sk_socket);
224. return -1;
225. }
227. static void __exit nl_exit(void)
228. {
229. synchronize_sched();
230. if(g_nl_sk)
231. sock_release(g_nl_sk->sk_socket);
232. nf_unregister_hook(&local_in_ops);
233. LOGMSG("ok!\n");
234. }
236. module_init(nl_init);
237. module_exit(nl_exit);
238. MODULE_LICENSE("GPL");
239. MODULE_AUTHOR("[email protected]");