发送和接收多播数据包问题！好像数据包没有出去！【问题解决】

dolphin1987

想做的有两个方面
1. 自己在内核中申请一个skb，然后手工构造多播数据包成功之后，从指定的eth0发送出去，
2. 在pre_routing钩子点注册一个钩子函数，然后截获上面发送的多播数据包。

问解决在三楼。

头都整晕了，请高手指点指点

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/netdevice.h>
   
4. #include <linux/skbuff.h>
   
5. #include <net/sock.h>
   
6. #include <net/route.h>
   
7. #include <net/ip.h>
   
8. #include <net/udp.h>
   
9. #include <linux/ip.h>
   
10. #include <linux/netfilter_ipv4.h>
    
11. #include <linux/list.h>
    
12. #include <linux/netdevice.h>
    
13. #include <linux/skbuff.h>
    
14. 
    
15. #include <sync_multicast.h>
    
16. 
    
17. /*
    
18. * date 20120730
    
19. *
    
20. */
    
21. #define SYNC_PORT 0x0727 /*mulitcast port 1831*/
    
22. 
    
23. MODULE_LICENSE("GPL");
    
24. MODULE_AUTHOR("c");
    
25. 
    
26. 
    
27. 
    
28. __be32 master_ip = 0xe0000040;/*multicaste addr 224.0.0.64*/
    
29. unsigned char        mac_addr[ETH_ALEN]={0x01,0x00,0x5e,0x00,0x00,0x40};
    
30. char eth_name[] = "eth0";
    
31. struct net_device *egress;
    
32. char test[] = "hello,multicast!\n";
    
33. 
    
34. /* need  a locker ?*/
    
35. struct slave_ip *slave_ip; /*multicast addr-- backup ip*/
    
36. 
    
37. int is_slave_ip( __be32 dst)
    
38. {
    
39.         int ret = 0;
    
40.         struct slave_ip *pos;
    
41.         if (slave_ip){
    
42.                 return 0;
    
43.         }
    
44.         list_for_each_entry(pos,&slave_ip->list,list){
    
45.                 if(pos->ipaddr == dst){
    
46.                         ret = 1;
    
47.                         break;
    
48.                 }
    
49.         }
    
50. 
    
51.         return ret;
    
52. 
    
53. }
    
54. 
    
55. int sync_multicast(struct sk_buff *skb)
    
56. {
    
57.         struct iphdr *iph;
    
58.         struct udphdr *udph;
    
59.         struct ethhdr *ethh;
    
60. 
    
61.         int total_len,eth_len,ip_len,udp_len,header_len;
    
62. 
    
63. 
    
64.         udp_len = sizeof(test) + sizeof(struct udphdr);
    
65.         ip_len = eth_len = udp_len + sizeof(struct iphdr);
    
66.         total_len = eth_len + ETH_HLEN + NET_IP_ALIGN;
    
67.         header_len = total_len - sizeof(test);
    
68. /* reserve all the headers */        
    
69.         skb_reserve(skb,LL_MAX_HEADER + header_len);
    
70. 
    
71.         /* copy the payload to buff */
    
72.         skb_copy_to_linear_data(skb,test,sizeof(test));
    
73.         skb->len += sizeof(test);
    
74. 
    
75.         /* move to udp header*/
    
76.         skb_push(skb,sizeof(struct udphdr));
    
77.         skb_reset_transport_header(skb);
    
78.         udph = udp_hdr(skb);
    
79.         udph->source = htons(SYNC_PORT);
    
80.         udph->dest = htons(SYNC_PORT);
    
81.         udph->len = udp_len;
    
82.         udph->check = csum_tcpudp_magic(htonl(master_ip),
    
83.                         htonl(master_ip),
    
84.                         udp_len,IPPROTO_UDP,
    
85.                         csum_partial(udph,udp_len,0));
    
86.         if(udph->check == 0)
    
87.                 udph->check = CSUM_MANGLED_0;
    
88. 
    
89.         /* move to ip header*/
    
90.         skb_push(skb,sizeof(struct iphdr));
    
91.         skb_reset_network_header(skb);
    
92.         iph = ip_hdr(skb);
    
93.         iph->version = 4;
    
94.         iph->ihl = sizeof(struct iphdr)/4;
    
95.         iph->tos= 0;
    
96.         iph->id = 0;
    
97.         iph->frag_off = htons(IP_DF);
    
98.         iph->protocol =        IPPROTO_UDP;
    
99.         iph->ttl = 64;
    
100.         iph->check = 0;
     
101.         /* XXXXXXXXXXXXXXXXXX*/
     
102.         iph->saddr = htonl(master_ip);
     
103.         iph->daddr = htonl(master_ip);
     
104.         iph->check = ip_fast_csum((unsigned char *)iph,iph->ihl);
     
105. 
     
106.         /* move to eth header*/
     
107.         ethh = (struct ethhdr *)skb_push(skb,ETH_HLEN);
     
108.         skb_reset_mac_header(skb);
     
109.         skb->protocol = ethh->h_proto = htons(ETH_P_IP);
     
110.         memcpy(ethh->h_source,mac_addr,ETH_ALEN);
     
111.         memcpy(ethh->h_dest,mac_addr,ETH_ALEN);
     
112. 
     
113.         int i;
     
114. 
     
115.         for (i = 0 ; i < 6; i++){
     
116.                
     
117.                 printk(KERN_ALERT "%x \n",ethh->h_dest[i]);
     
118.                
     
119.         }
     
120.         for (i = 0 ; i < 6; i++){
     
121.                
     
122.                 printk(KERN_ALERT "%x \n",ethh->h_source[i]);
     
123.                
     
124.         }
     
125.        
     
126.         //printk(KERN_ALERT "%x \n",iph->saddr);
     
127.         /* specify outing net device*/
     
128.         skb->dev = egress;
     
129. 
     
130.         /* directly send the skb from egress*/
     
131.         int ret;
     
132.         ret = dev_queue_xmit(skb);
     
133.         printk(KERN_ALERT "%i \n",ret);
     
134. 
     
135. 
     
136.         return 0;
     
137. }
     
138. int sync_send_msg(char *conn)
     
139. {
     
140.         struct sk_buff *nskb;
     
141. 
     
142.         int total_len,eth_len,ip_len,udp_len,header_len;
     
143. 
     
144. 
     
145.         udp_len = sizeof(test) + sizeof(struct udphdr);
     
146.         ip_len = eth_len = udp_len + sizeof(struct iphdr);
     
147.         total_len = eth_len + ETH_HLEN + NET_IP_ALIGN;
     
148.         header_len = total_len - sizeof(test);
     
149. 
     
150.         nskb = alloc_skb(LL_MAX_HEADER
     
151.                         + total_len,GFP_ATOMIC);
     
152.         if(!nskb){
     
153.                 printk(KERN_ALERT "EROR not enough memory!\n");
     
154.                 return 0;
     
155.         }
     
156.         sync_multicast(nskb);
     
157.         return 0;
     
158. }
     
159. EXPORT_SYMBOL(sync_send_msg);
     
160. 
     
161. int sync_rcv_msg(struct sk_buff *skb)
     
162. {
     
163.         printk(KERN_ALERT "recieve a special multicast packet!\n");
     
164.         return 0;
     
165. }
     
166. /*
     
167. * the capture hook function
     
168. */
     
169. static unsigned int
     
170. sync_rcv_skb(unsigned int hook,
     
171.                 struct sk_buff *skb,
     
172.                 const struct net_device *in,
     
173.                 const struct net_device *out,
     
174.                 int (*okfn)(struct sk_buff *))
     
175. {
     
176.         struct iphdr *iph;
     
177.         struct udphdr *udph;
     
178.        
     
179. 
     
180. 
     
181.         iph = ip_hdr(skb);
     
182.         udph = (struct udphdr *)((void *)skb->data + ip_hdrlen(skb));
     
183. 
     
184.        
     
185.         if(hook != NF_INET_PRE_ROUTING)
     
186.                 return NF_ACCEPT;
     
187.         /*the packet must be a multicast packet*/
     
188. 
     
189.         if (iph->protocol != IPPROTO_UDP)
     
190.                 return NF_ACCEPT;
     
191.         printk(KERN_ALERT "recieve a UDP packet!\n");
     
192.         /*
     
193.          * if (!is_slave_ip(ntohl(iph->daddr)))
     
194.                 return NF_ACCEPT;
     
195.                 */
     
196.        
     
197.         if (ntohs(udph->source) != cpu_to_be16(SYNC_PORT) ||
     
198.                         ntohs(udph->dest) != cpu_to_be16(SYNC_PORT))
     
199.                 return NF_ACCEPT;
     
200.                
     
201.         sync_rcv_msg(skb);
     
202. 
     
203. 
     
204.         //return NF_DROP;
     
205.         return NF_ACCEPT;
     
206. 
     
207. }
     
208. /*
     
209. * this hook capture the multicast packets
     
210. */
     
211. static struct nf_hook_ops pre_capture __read_mostly=
     
212. {
     
213.         .hook                =sync_rcv_skb,
     
214.         .owner                =THIS_MODULE,
     
215.         .pf                        =PF_INET,
     
216.         .hooknum        =NF_INET_PRE_ROUTING,
     
217.         .priority        =NF_IP_PRI_RAW,
     
218. };
     
219. static int __init sync_multicast_init(void)
     
220. {
     
221.         int ret;
     
222.         ret = nf_register_hook(&pre_capture);
     
223.         if(ret < 0)
     
224.                 printk(KERN_ALERT "ERROR,registering hook failed\n");
     
225.         else
     
226.                 printk(KERN_ALERT "register success!\n");
     
227.         egress = dev_get_by_name(&init_net,eth_name);
     
228.         if(egress)
     
229.                 printk(KERN_ALERT "find specical device\n");
     
230. 
     
231.         sync_send_msg( (char* )0);
     
232. 
     
233.         return 0;
     
234. }
     
235. static void __exit sync_multicast_exit(void)
     
236. {
     
237.         nf_unregister_hook(&pre_capture);
     
238.         dev_put(egress);
     
239.         printk(KERN_ALERT "Sync_multicate：Goodbye!\n");
     
240. }
     
241. 
     
242. module_init(sync_multicast_init);
     
243. module_exit(sync_multicast_exit);
     

复制代码

头文件 sync_multicast.h

1. 
   
2. #ifndef __SYNC_MULTICAST_H
   
3. #define __SYNC_MULTICAST_H
   
4. 
   
5. 
   
6. struct slave_ip{
   
7.         struct list_head list;
   
8.         __be32 ipaddr;
   
9. };
   
10. #endif
    

复制代码

Makefile文件

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

复制代码

dolphin1987

回复 1# dolphin1987


    自己来坐沙发哈。

利用tcpdump抓包分析，发送包是成功的，另外，对方也可以接收到数据包，但是数据包没有传到我注册的钩子点。

还在继续找原因，

大家帮忙分析一哈。

dolphin1987

回复 1# dolphin1987


    终于找到了问题，这个问题还是得怪自己太粗心了，也要怪wireshark不够智能（呵呵，搭上一个）

问题原因：没有给IP包的tot_len赋值，但是用wireshark抓包分析时，ip数据包长度和tot_len明显不一样，但是还不提示错误。
这样ip包还没有到达我注册的钩子点时，在ip包错误检查环节都已经被drop掉了。

Godbach

回复 1# dolphin1987
感谢 LZ 分享解决方法 :wink:


   

dolphin1987

回复 4# Godbach


    相互帮助，自己的很多问题，也是在cu找到了解决方法和思路。