projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / ipv4 / ipmr.c
1 /*
2 * IP multicast routing support for mrouted 3.6/3.8
3 *
4 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
5 * Linux Consultancy and Custom Driver Development
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Fixes:
13 * Michael Chastain : Incorrect size of copying.
14 * Alan Cox : Added the cache manager code
15 * Alan Cox : Fixed the clone/copy bug and device race.
16 * Mike McLagan : Routing by source
17 * Malcolm Beattie : Buffer handling fixes.
18 * Alexey Kuznetsov : Double buffer free and other fixes.
19 * SVR Anand : Fixed several multicast bugs and problems.
20 * Alexey Kuznetsov : Status, optimisations and more.
21 * Brad Parker : Better behaviour on mrouted upcall
22 * overflow.
23 * Carlos Picoto : PIMv1 Support
24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
25 * Relax this requrement to work with older peers.
26 *
27 */
28
29 #include <asm/system.h>
30 #include <asm/uaccess.h>
31 #include <linux/types.h>
32 #include <linux/capability.h>
33 #include <linux/errno.h>
34 #include <linux/timer.h>
35 #include <linux/mm.h>
36 #include <linux/kernel.h>
37 #include <linux/fcntl.h>
38 #include <linux/stat.h>
39 #include <linux/socket.h>
40 #include <linux/in.h>
41 #include <linux/inet.h>
42 #include <linux/netdevice.h>
43 #include <linux/inetdevice.h>
44 #include <linux/igmp.h>
45 #include <linux/proc_fs.h>
46 #include <linux/seq_file.h>
47 #include <linux/mroute.h>
48 #include <linux/init.h>
49 #include <linux/if_ether.h>
50 #include <net/net_namespace.h>
51 #include <net/ip.h>
52 #include <net/protocol.h>
53 #include <linux/skbuff.h>
54 #include <net/route.h>
55 #include <net/sock.h>
56 #include <net/icmp.h>
57 #include <net/udp.h>
58 #include <net/raw.h>
59 #include <linux/notifier.h>
60 #include <linux/if_arp.h>
61 #include <linux/netfilter_ipv4.h>
62 #include <net/ipip.h>
63 #include <net/checksum.h>
64 #include <net/netlink.h>
65
66 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
67 #define CONFIG_IP_PIMSM 1
68 #endif
69
70 /* Big lock, protecting vif table, mrt cache and mroute socket state.
71 Note that the changes are semaphored via rtnl_lock.
72 */
73
74 static DEFINE_RWLOCK(mrt_lock);
75
76 /*
77 * Multicast router control variables
78 */
79
80 #define VIF_EXISTS(_net, _idx) ((_net)->ipv4.vif_table[_idx].dev != NULL)
81
82 static struct mfc_cache *mfc_unres_queue; /* Queue of unresolved entries */
83
84 /* Special spinlock for queue of unresolved entries */
85 static DEFINE_SPINLOCK(mfc_unres_lock);
86
87 /* We return to original Alan's scheme. Hash table of resolved
88 entries is changed only in process context and protected
89 with weak lock mrt_lock. Queue of unresolved entries is protected
90 with strong spinlock mfc_unres_lock.
91
92 In this case data path is free of exclusive locks at all.
93 */
94
95 static struct kmem_cache *mrt_cachep __read_mostly;
96
97 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
98 static int ipmr_cache_report(struct net *net,
99 struct sk_buff *pkt, vifi_t vifi, int assert);
100 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
101
102 #ifdef CONFIG_IP_PIMSM_V2
103 static struct net_protocol pim_protocol;
104 #endif
105
106 static struct timer_list ipmr_expire_timer;
107
108 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
109
110 static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
111 {
112 struct net *net = dev_net(dev);
113
114 dev_close(dev);
115
116 dev = __dev_get_by_name(net, "tunl0");
117 if (dev) {
118 const struct net_device_ops *ops = dev->netdev_ops;
119 struct ifreq ifr;
120 struct ip_tunnel_parm p;
121
122 memset(&p, 0, sizeof(p));
123 p.iph.daddr = v->vifc_rmt_addr.s_addr;
124 p.iph.saddr = v->vifc_lcl_addr.s_addr;
125 p.iph.version = 4;
126 p.iph.ihl = 5;
127 p.iph.protocol = IPPROTO_IPIP;
128 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
129 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
130
131 if (ops->ndo_do_ioctl) {
132 mm_segment_t oldfs = get_fs();
133
134 set_fs(KERNEL_DS);
135 ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
136 set_fs(oldfs);
137 }
138 }
139 }
140
141 static
142 struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
143 {
144 struct net_device *dev;
145
146 dev = __dev_get_by_name(net, "tunl0");
147
148 if (dev) {
149 const struct net_device_ops *ops = dev->netdev_ops;
150 int err;
151 struct ifreq ifr;
152 struct ip_tunnel_parm p;
153 struct in_device *in_dev;
154
155 memset(&p, 0, sizeof(p));
156 p.iph.daddr = v->vifc_rmt_addr.s_addr;
157 p.iph.saddr = v->vifc_lcl_addr.s_addr;
158 p.iph.version = 4;
159 p.iph.ihl = 5;
160 p.iph.protocol = IPPROTO_IPIP;
161 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
162 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
163
164 if (ops->ndo_do_ioctl) {
165 mm_segment_t oldfs = get_fs();
166
167 set_fs(KERNEL_DS);
168 err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
169 set_fs(oldfs);
170 } else
171 err = -EOPNOTSUPP;
172
173 dev = NULL;
174
175 if (err == 0 &&
176 (dev = __dev_get_by_name(net, p.name)) != NULL) {
177 dev->flags |= IFF_MULTICAST;
178
179 in_dev = __in_dev_get_rtnl(dev);
180 if (in_dev == NULL)
181 goto failure;
182
183 ipv4_devconf_setall(in_dev);
184 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
185
186 if (dev_open(dev))
187 goto failure;
188 dev_hold(dev);
189 }
190 }
191 return dev;
192
193 failure:
194 /* allow the register to be completed before unregistering. */
195 rtnl_unlock();
196 rtnl_lock();
197
198 unregister_netdevice(dev);
199 return NULL;
200 }
201
202 #ifdef CONFIG_IP_PIMSM
203
204 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
205 {
206 struct net *net = dev_net(dev);
207
208 read_lock(&mrt_lock);
209 dev->stats.tx_bytes += skb->len;
210 dev->stats.tx_packets++;
211 ipmr_cache_report(net, skb, net->ipv4.mroute_reg_vif_num,
212 IGMPMSG_WHOLEPKT);
213 read_unlock(&mrt_lock);
214 kfree_skb(skb);
215 return NETDEV_TX_OK;
216 }
217
218 static const struct net_device_ops reg_vif_netdev_ops = {
219 .ndo_start_xmit = reg_vif_xmit,
220 };
221
222 static void reg_vif_setup(struct net_device *dev)
223 {
224 dev->type = ARPHRD_PIMREG;
225 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
226 dev->flags = IFF_NOARP;
227 dev->netdev_ops = &reg_vif_netdev_ops,
228 dev->destructor = free_netdev;
229 dev->features |= NETIF_F_NETNS_LOCAL;
230 }
231
232 static struct net_device *ipmr_reg_vif(struct net *net)
233 {
234 struct net_device *dev;
235 struct in_device *in_dev;
236
237 dev = alloc_netdev(0, "pimreg", reg_vif_setup);
238
239 if (dev == NULL)
240 return NULL;
241
242 dev_net_set(dev, net);
243
244 if (register_netdevice(dev)) {
245 free_netdev(dev);
246 return NULL;
247 }
248 dev->iflink = 0;
249
250 rcu_read_lock();
251 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
252 rcu_read_unlock();
253 goto failure;
254 }
255
256 ipv4_devconf_setall(in_dev);
257 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
258 rcu_read_unlock();
259
260 if (dev_open(dev))
261 goto failure;
262
263 dev_hold(dev);
264
265 return dev;
266
267 failure:
268 /* allow the register to be completed before unregistering. */
269 rtnl_unlock();
270 rtnl_lock();
271
272 unregister_netdevice(dev);
273 return NULL;
274 }
275 #endif
276
277 /*
278 * Delete a VIF entry
279 * @notify: Set to 1, if the caller is a notifier_call
280 */
281
282 static int vif_delete(struct net *net, int vifi, int notify)
283 {
284 struct vif_device *v;
285 struct net_device *dev;
286 struct in_device *in_dev;
287
288 if (vifi < 0 || vifi >= net->ipv4.maxvif)
289 return -EADDRNOTAVAIL;
290
291 v = &net->ipv4.vif_table[vifi];
292
293 write_lock_bh(&mrt_lock);
294 dev = v->dev;
295 v->dev = NULL;
296
297 if (!dev) {
298 write_unlock_bh(&mrt_lock);
299 return -EADDRNOTAVAIL;
300 }
301
302 #ifdef CONFIG_IP_PIMSM
303 if (vifi == net->ipv4.mroute_reg_vif_num)
304 net->ipv4.mroute_reg_vif_num = -1;
305 #endif
306
307 if (vifi+1 == net->ipv4.maxvif) {
308 int tmp;
309 for (tmp=vifi-1; tmp>=0; tmp--) {
310 if (VIF_EXISTS(net, tmp))
311 break;
312 }
313 net->ipv4.maxvif = tmp+1;
314 }
315
316 write_unlock_bh(&mrt_lock);
317
318 dev_set_allmulti(dev, -1);
319
320 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
321 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
322 ip_rt_multicast_event(in_dev);
323 }
324
325 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify)
326 unregister_netdevice(dev);
327
328 dev_put(dev);
329 return 0;
330 }
331
332 static inline void ipmr_cache_free(struct mfc_cache *c)
333 {
334 release_net(mfc_net(c));
335 kmem_cache_free(mrt_cachep, c);
336 }
337
338 /* Destroy an unresolved cache entry, killing queued skbs
339 and reporting error to netlink readers.
340 */
341
342 static void ipmr_destroy_unres(struct mfc_cache *c)
343 {
344 struct sk_buff *skb;
345 struct nlmsgerr *e;
346 struct net *net = mfc_net(c);
347
348 atomic_dec(&net->ipv4.cache_resolve_queue_len);
349
350 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
351 if (ip_hdr(skb)->version == 0) {
352 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
353 nlh->nlmsg_type = NLMSG_ERROR;
354 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
355 skb_trim(skb, nlh->nlmsg_len);
356 e = NLMSG_DATA(nlh);
357 e->error = -ETIMEDOUT;
358 memset(&e->msg, 0, sizeof(e->msg));
359
360 rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
361 } else
362 kfree_skb(skb);
363 }
364
365 ipmr_cache_free(c);
366 }
367
368
369 /* Single timer process for all the unresolved queue. */
370
371 static void ipmr_expire_process(unsigned long dummy)
372 {
373 unsigned long now;
374 unsigned long expires;
375 struct mfc_cache *c, **cp;
376
377 if (!spin_trylock(&mfc_unres_lock)) {
378 mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
379 return;
380 }
381
382 if (mfc_unres_queue == NULL)
383 goto out;
384
385 now = jiffies;
386 expires = 10*HZ;
387 cp = &mfc_unres_queue;
388
389 while ((c=*cp) != NULL) {
390 if (time_after(c->mfc_un.unres.expires, now)) {
391 unsigned long interval = c->mfc_un.unres.expires - now;
392 if (interval < expires)
393 expires = interval;
394 cp = &c->next;
395 continue;
396 }
397
398 *cp = c->next;
399
400 ipmr_destroy_unres(c);
401 }
402
403 if (mfc_unres_queue != NULL)
404 mod_timer(&ipmr_expire_timer, jiffies + expires);
405
406 out:
407 spin_unlock(&mfc_unres_lock);
408 }
409
410 /* Fill oifs list. It is called under write locked mrt_lock. */
411
412 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
413 {
414 int vifi;
415 struct net *net = mfc_net(cache);
416
417 cache->mfc_un.res.minvif = MAXVIFS;
418 cache->mfc_un.res.maxvif = 0;
419 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
420
421 for (vifi = 0; vifi < net->ipv4.maxvif; vifi++) {
422 if (VIF_EXISTS(net, vifi) &&
423 ttls[vifi] && ttls[vifi] < 255) {
424 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
425 if (cache->mfc_un.res.minvif > vifi)
426 cache->mfc_un.res.minvif = vifi;
427 if (cache->mfc_un.res.maxvif <= vifi)
428 cache->mfc_un.res.maxvif = vifi + 1;
429 }
430 }
431 }
432
433 static int vif_add(struct net *net, struct vifctl *vifc, int mrtsock)
434 {
435 int vifi = vifc->vifc_vifi;
436 struct vif_device *v = &net->ipv4.vif_table[vifi];
437 struct net_device *dev;
438 struct in_device *in_dev;
439 int err;
440
441 /* Is vif busy ? */
442 if (VIF_EXISTS(net, vifi))
443 return -EADDRINUSE;
444
445 switch (vifc->vifc_flags) {
446 #ifdef CONFIG_IP_PIMSM
447 case VIFF_REGISTER:
448 /*
449 * Special Purpose VIF in PIM
450 * All the packets will be sent to the daemon
451 */
452 if (net->ipv4.mroute_reg_vif_num >= 0)
453 return -EADDRINUSE;
454 dev = ipmr_reg_vif(net);
455 if (!dev)
456 return -ENOBUFS;
457 err = dev_set_allmulti(dev, 1);
458 if (err) {
459 unregister_netdevice(dev);
460 dev_put(dev);
461 return err;
462 }
463 break;
464 #endif
465 case VIFF_TUNNEL:
466 dev = ipmr_new_tunnel(net, vifc);
467 if (!dev)
468 return -ENOBUFS;
469 err = dev_set_allmulti(dev, 1);
470 if (err) {
471 ipmr_del_tunnel(dev, vifc);
472 dev_put(dev);
473 return err;
474 }
475 break;
476 case 0:
477 dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
478 if (!dev)
479 return -EADDRNOTAVAIL;
480 err = dev_set_allmulti(dev, 1);
481 if (err) {
482 dev_put(dev);
483 return err;
484 }
485 break;
486 default:
487 return -EINVAL;
488 }
489
490 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
491 return -EADDRNOTAVAIL;
492 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
493 ip_rt_multicast_event(in_dev);
494
495 /*
496 * Fill in the VIF structures
497 */
498 v->rate_limit = vifc->vifc_rate_limit;
499 v->local = vifc->vifc_lcl_addr.s_addr;
500 v->remote = vifc->vifc_rmt_addr.s_addr;
501 v->flags = vifc->vifc_flags;
502 if (!mrtsock)
503 v->flags |= VIFF_STATIC;
504 v->threshold = vifc->vifc_threshold;
505 v->bytes_in = 0;
506 v->bytes_out = 0;
507 v->pkt_in = 0;
508 v->pkt_out = 0;
509 v->link = dev->ifindex;
510 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
511 v->link = dev->iflink;
512
513 /* And finish update writing critical data */
514 write_lock_bh(&mrt_lock);
515 v->dev = dev;
516 #ifdef CONFIG_IP_PIMSM
517 if (v->flags&VIFF_REGISTER)
518 net->ipv4.mroute_reg_vif_num = vifi;
519 #endif
520 if (vifi+1 > net->ipv4.maxvif)
521 net->ipv4.maxvif = vifi+1;
522 write_unlock_bh(&mrt_lock);
523 return 0;
524 }
525
526 static struct mfc_cache *ipmr_cache_find(struct net *net,
527 __be32 origin,
528 __be32 mcastgrp)
529 {
530 int line = MFC_HASH(mcastgrp, origin);
531 struct mfc_cache *c;
532
533 for (c = net->ipv4.mfc_cache_array[line]; c; c = c->next) {
534 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
535 break;
536 }
537 return c;
538 }
539
540 /*
541 * Allocate a multicast cache entry
542 */
543 static struct mfc_cache *ipmr_cache_alloc(struct net *net)
544 {
545 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
546 if (c == NULL)
547 return NULL;
548 c->mfc_un.res.minvif = MAXVIFS;
549 mfc_net_set(c, net);
550 return c;
551 }
552
553 static struct mfc_cache *ipmr_cache_alloc_unres(struct net *net)
554 {
555 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
556 if (c == NULL)
557 return NULL;
558 skb_queue_head_init(&c->mfc_un.unres.unresolved);
559 c->mfc_un.unres.expires = jiffies + 10*HZ;
560 mfc_net_set(c, net);
561 return c;
562 }
563
564 /*
565 * A cache entry has gone into a resolved state from queued
566 */
567
568 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
569 {
570 struct sk_buff *skb;
571 struct nlmsgerr *e;
572
573 /*
574 * Play the pending entries through our router
575 */
576
577 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
578 if (ip_hdr(skb)->version == 0) {
579 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
580
581 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
582 nlh->nlmsg_len = (skb_tail_pointer(skb) -
583 (u8 *)nlh);
584 } else {
585 nlh->nlmsg_type = NLMSG_ERROR;
586 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
587 skb_trim(skb, nlh->nlmsg_len);
588 e = NLMSG_DATA(nlh);
589 e->error = -EMSGSIZE;
590 memset(&e->msg, 0, sizeof(e->msg));
591 }
592
593 rtnl_unicast(skb, mfc_net(c), NETLINK_CB(skb).pid);
594 } else
595 ip_mr_forward(skb, c, 0);
596 }
597 }
598
599 /*
600 * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
601 * expects the following bizarre scheme.
602 *
603 * Called under mrt_lock.
604 */
605
606 static int ipmr_cache_report(struct net *net,
607 struct sk_buff *pkt, vifi_t vifi, int assert)
608 {
609 struct sk_buff *skb;
610 const int ihl = ip_hdrlen(pkt);
611 struct igmphdr *igmp;
612 struct igmpmsg *msg;
613 int ret;
614
615 #ifdef CONFIG_IP_PIMSM
616 if (assert == IGMPMSG_WHOLEPKT)
617 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
618 else
619 #endif
620 skb = alloc_skb(128, GFP_ATOMIC);
621
622 if (!skb)
623 return -ENOBUFS;
624
625 #ifdef CONFIG_IP_PIMSM
626 if (assert == IGMPMSG_WHOLEPKT) {
627 /* Ugly, but we have no choice with this interface.
628 Duplicate old header, fix ihl, length etc.
629 And all this only to mangle msg->im_msgtype and
630 to set msg->im_mbz to "mbz" :-)
631 */
632 skb_push(skb, sizeof(struct iphdr));
633 skb_reset_network_header(skb);
634 skb_reset_transport_header(skb);
635 msg = (struct igmpmsg *)skb_network_header(skb);
636 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
637 msg->im_msgtype = IGMPMSG_WHOLEPKT;
638 msg->im_mbz = 0;
639 msg->im_vif = net->ipv4.mroute_reg_vif_num;
640 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
641 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
642 sizeof(struct iphdr));
643 } else
644 #endif
645 {
646
647 /*
648 * Copy the IP header
649 */
650
651 skb->network_header = skb->tail;
652 skb_put(skb, ihl);
653 skb_copy_to_linear_data(skb, pkt->data, ihl);
654 ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */
655 msg = (struct igmpmsg *)skb_network_header(skb);
656 msg->im_vif = vifi;
657 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
658
659 /*
660 * Add our header
661 */
662
663 igmp=(struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
664 igmp->type =
665 msg->im_msgtype = assert;
666 igmp->code = 0;
667 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
668 skb->transport_header = skb->network_header;
669 }
670
671 if (net->ipv4.mroute_sk == NULL) {
672 kfree_skb(skb);
673 return -EINVAL;
674 }
675
676 /*
677 * Deliver to mrouted
678 */
679 ret = sock_queue_rcv_skb(net->ipv4.mroute_sk, skb);
680 if (ret < 0) {
681 if (net_ratelimit())
682 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
683 kfree_skb(skb);
684 }
685
686 return ret;
687 }
688
689 /*
690 * Queue a packet for resolution. It gets locked cache entry!
691 */
692
693 static int
694 ipmr_cache_unresolved(struct net *net, vifi_t vifi, struct sk_buff *skb)
695 {
696 int err;
697 struct mfc_cache *c;
698 const struct iphdr *iph = ip_hdr(skb);
699
700 spin_lock_bh(&mfc_unres_lock);
701 for (c=mfc_unres_queue; c; c=c->next) {
702 if (net_eq(mfc_net(c), net) &&
703 c->mfc_mcastgrp == iph->daddr &&
704 c->mfc_origin == iph->saddr)
705 break;
706 }
707
708 if (c == NULL) {
709 /*
710 * Create a new entry if allowable
711 */
712
713 if (atomic_read(&net->ipv4.cache_resolve_queue_len) >= 10 ||
714 (c = ipmr_cache_alloc_unres(net)) == NULL) {
715 spin_unlock_bh(&mfc_unres_lock);
716
717 kfree_skb(skb);
718 return -ENOBUFS;
719 }
720
721 /*
722 * Fill in the new cache entry
723 */
724 c->mfc_parent = -1;
725 c->mfc_origin = iph->saddr;
726 c->mfc_mcastgrp = iph->daddr;
727
728 /*
729 * Reflect first query at mrouted.
730 */
731 err = ipmr_cache_report(net, skb, vifi, IGMPMSG_NOCACHE);
732 if (err < 0) {
733 /* If the report failed throw the cache entry
734 out - Brad Parker
735 */
736 spin_unlock_bh(&mfc_unres_lock);
737
738 ipmr_cache_free(c);
739 kfree_skb(skb);
740 return err;
741 }
742
743 atomic_inc(&net->ipv4.cache_resolve_queue_len);
744 c->next = mfc_unres_queue;
745 mfc_unres_queue = c;
746
747 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
748 }
749
750 /*
751 * See if we can append the packet
752 */
753 if (c->mfc_un.unres.unresolved.qlen>3) {
754 kfree_skb(skb);
755 err = -ENOBUFS;
756 } else {
757 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
758 err = 0;
759 }
760
761 spin_unlock_bh(&mfc_unres_lock);
762 return err;
763 }
764
765 /*
766 * MFC cache manipulation by user space mroute daemon
767 */
768
769 static int ipmr_mfc_delete(struct net *net, struct mfcctl *mfc)
770 {
771 int line;
772 struct mfc_cache *c, **cp;
773
774 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
775
776 for (cp = &net->ipv4.mfc_cache_array[line];
777 (c = *cp) != NULL; cp = &c->next) {
778 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
779 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
780 write_lock_bh(&mrt_lock);
781 *cp = c->next;
782 write_unlock_bh(&mrt_lock);
783
784 ipmr_cache_free(c);
785 return 0;
786 }
787 }
788 return -ENOENT;
789 }
790
791 static int ipmr_mfc_add(struct net *net, struct mfcctl *mfc, int mrtsock)
792 {
793 int line;
794 struct mfc_cache *uc, *c, **cp;
795
796 line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
797
798 for (cp = &net->ipv4.mfc_cache_array[line];
799 (c = *cp) != NULL; cp = &c->next) {
800 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
801 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
802 break;
803 }
804
805 if (c != NULL) {
806 write_lock_bh(&mrt_lock);
807 c->mfc_parent = mfc->mfcc_parent;
808 ipmr_update_thresholds(c, mfc->mfcc_ttls);
809 if (!mrtsock)
810 c->mfc_flags |= MFC_STATIC;
811 write_unlock_bh(&mrt_lock);
812 return 0;
813 }
814
815 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
816 return -EINVAL;
817
818 c = ipmr_cache_alloc(net);
819 if (c == NULL)
820 return -ENOMEM;
821
822 c->mfc_origin = mfc->mfcc_origin.s_addr;
823 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
824 c->mfc_parent = mfc->mfcc_parent;
825 ipmr_update_thresholds(c, mfc->mfcc_ttls);
826 if (!mrtsock)
827 c->mfc_flags |= MFC_STATIC;
828
829 write_lock_bh(&mrt_lock);
830 c->next = net->ipv4.mfc_cache_array[line];
831 net->ipv4.mfc_cache_array[line] = c;
832 write_unlock_bh(&mrt_lock);
833
834 /*
835 * Check to see if we resolved a queued list. If so we
836 * need to send on the frames and tidy up.
837 */
838 spin_lock_bh(&mfc_unres_lock);
839 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
840 cp = &uc->next) {
841 if (net_eq(mfc_net(uc), net) &&
842 uc->mfc_origin == c->mfc_origin &&
843 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
844 *cp = uc->next;
845 atomic_dec(&net->ipv4.cache_resolve_queue_len);
846 break;
847 }
848 }
849 if (mfc_unres_queue == NULL)
850 del_timer(&ipmr_expire_timer);
851 spin_unlock_bh(&mfc_unres_lock);
852
853 if (uc) {
854 ipmr_cache_resolve(uc, c);
855 ipmr_cache_free(uc);
856 }
857 return 0;
858 }
859
860 /*
861 * Close the multicast socket, and clear the vif tables etc
862 */
863
864 static void mroute_clean_tables(struct net *net)
865 {
866 int i;
867
868 /*
869 * Shut down all active vif entries
870 */
871 for (i = 0; i < net->ipv4.maxvif; i++) {
872 if (!(net->ipv4.vif_table[i].flags&VIFF_STATIC))
873 vif_delete(net, i, 0);
874 }
875
876 /*
877 * Wipe the cache
878 */
879 for (i=0; i<MFC_LINES; i++) {
880 struct mfc_cache *c, **cp;
881
882 cp = &net->ipv4.mfc_cache_array[i];
883 while ((c = *cp) != NULL) {
884 if (c->mfc_flags&MFC_STATIC) {
885 cp = &c->next;
886 continue;
887 }
888 write_lock_bh(&mrt_lock);
889 *cp = c->next;
890 write_unlock_bh(&mrt_lock);
891
892 ipmr_cache_free(c);
893 }
894 }
895
896 if (atomic_read(&net->ipv4.cache_resolve_queue_len) != 0) {
897 struct mfc_cache *c, **cp;
898
899 spin_lock_bh(&mfc_unres_lock);
900 cp = &mfc_unres_queue;
901 while ((c = *cp) != NULL) {
902 if (!net_eq(mfc_net(c), net)) {
903 cp = &c->next;
904 continue;
905 }
906 *cp = c->next;
907
908 ipmr_destroy_unres(c);
909 }
910 spin_unlock_bh(&mfc_unres_lock);
911 }
912 }
913
914 static void mrtsock_destruct(struct sock *sk)
915 {
916 struct net *net = sock_net(sk);
917
918 rtnl_lock();
919 if (sk == net->ipv4.mroute_sk) {
920 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
921
922 write_lock_bh(&mrt_lock);
923 net->ipv4.mroute_sk = NULL;
924 write_unlock_bh(&mrt_lock);
925
926 mroute_clean_tables(net);
927 }
928 rtnl_unlock();
929 }
930
931 /*
932 * Socket options and virtual interface manipulation. The whole
933 * virtual interface system is a complete heap, but unfortunately
934 * that's how BSD mrouted happens to think. Maybe one day with a proper
935 * MOSPF/PIM router set up we can clean this up.
936 */
937
938 int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
939 {
940 int ret;
941 struct vifctl vif;
942 struct mfcctl mfc;
943 struct net *net = sock_net(sk);
944
945 if (optname != MRT_INIT) {
946 if (sk != net->ipv4.mroute_sk && !capable(CAP_NET_ADMIN))
947 return -EACCES;
948 }
949
950 switch (optname) {
951 case MRT_INIT:
952 if (sk->sk_type != SOCK_RAW ||
953 inet_sk(sk)->num != IPPROTO_IGMP)
954 return -EOPNOTSUPP;
955 if (optlen != sizeof(int))
956 return -ENOPROTOOPT;
957
958 rtnl_lock();
959 if (net->ipv4.mroute_sk) {
960 rtnl_unlock();
961 return -EADDRINUSE;
962 }
963
964 ret = ip_ra_control(sk, 1, mrtsock_destruct);
965 if (ret == 0) {
966 write_lock_bh(&mrt_lock);
967 net->ipv4.mroute_sk = sk;
968 write_unlock_bh(&mrt_lock);
969
970 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
971 }
972 rtnl_unlock();
973 return ret;
974 case MRT_DONE:
975 if (sk != net->ipv4.mroute_sk)
976 return -EACCES;
977 return ip_ra_control(sk, 0, NULL);
978 case MRT_ADD_VIF:
979 case MRT_DEL_VIF:
980 if (optlen != sizeof(vif))
981 return -EINVAL;
982 if (copy_from_user(&vif, optval, sizeof(vif)))
983 return -EFAULT;
984 if (vif.vifc_vifi >= MAXVIFS)
985 return -ENFILE;
986 rtnl_lock();
987 if (optname == MRT_ADD_VIF) {
988 ret = vif_add(net, &vif, sk == net->ipv4.mroute_sk);
989 } else {
990 ret = vif_delete(net, vif.vifc_vifi, 0);
991 }
992 rtnl_unlock();
993 return ret;
994
995 /*
996 * Manipulate the forwarding caches. These live
997 * in a sort of kernel/user symbiosis.
998 */
999 case MRT_ADD_MFC:
1000 case MRT_DEL_MFC:
1001 if (optlen != sizeof(mfc))
1002 return -EINVAL;
1003 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1004 return -EFAULT;
1005 rtnl_lock();
1006 if (optname == MRT_DEL_MFC)
1007 ret = ipmr_mfc_delete(net, &mfc);
1008 else
1009 ret = ipmr_mfc_add(net, &mfc, sk == net->ipv4.mroute_sk);
1010 rtnl_unlock();
1011 return ret;
1012 /*
1013 * Control PIM assert.
1014 */
1015 case MRT_ASSERT:
1016 {
1017 int v;
1018 if (get_user(v,(int __user *)optval))
1019 return -EFAULT;
1020 net->ipv4.mroute_do_assert = (v) ? 1 : 0;
1021 return 0;
1022 }
1023 #ifdef CONFIG_IP_PIMSM
1024 case MRT_PIM:
1025 {
1026 int v;
1027
1028 if (get_user(v,(int __user *)optval))
1029 return -EFAULT;
1030 v = (v) ? 1 : 0;
1031
1032 rtnl_lock();
1033 ret = 0;
1034 if (v != net->ipv4.mroute_do_pim) {
1035 net->ipv4.mroute_do_pim = v;
1036 net->ipv4.mroute_do_assert = v;
1037 }
1038 rtnl_unlock();
1039 return ret;
1040 }
1041 #endif
1042 /*
1043 * Spurious command, or MRT_VERSION which you cannot
1044 * set.
1045 */
1046 default:
1047 return -ENOPROTOOPT;
1048 }
1049 }
1050
1051 /*
1052 * Getsock opt support for the multicast routing system.
1053 */
1054
1055 int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
1056 {
1057 int olr;
1058 int val;
1059 struct net *net = sock_net(sk);
1060
1061 if (optname != MRT_VERSION &&
1062 #ifdef CONFIG_IP_PIMSM
1063 optname!=MRT_PIM &&
1064 #endif
1065 optname!=MRT_ASSERT)
1066 return -ENOPROTOOPT;
1067
1068 if (get_user(olr, optlen))
1069 return -EFAULT;
1070
1071 olr = min_t(unsigned int, olr, sizeof(int));
1072 if (olr < 0)
1073 return -EINVAL;
1074
1075 if (put_user(olr, optlen))
1076 return -EFAULT;
1077 if (optname == MRT_VERSION)
1078 val = 0x0305;
1079 #ifdef CONFIG_IP_PIMSM
1080 else if (optname == MRT_PIM)
1081 val = net->ipv4.mroute_do_pim;
1082 #endif
1083 else
1084 val = net->ipv4.mroute_do_assert;
1085 if (copy_to_user(optval, &val, olr))
1086 return -EFAULT;
1087 return 0;
1088 }
1089
1090 /*
1091 * The IP multicast ioctl support routines.
1092 */
1093
1094 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1095 {
1096 struct sioc_sg_req sr;
1097 struct sioc_vif_req vr;
1098 struct vif_device *vif;
1099 struct mfc_cache *c;
1100 struct net *net = sock_net(sk);
1101
1102 switch (cmd) {
1103 case SIOCGETVIFCNT:
1104 if (copy_from_user(&vr, arg, sizeof(vr)))
1105 return -EFAULT;
1106 if (vr.vifi >= net->ipv4.maxvif)
1107 return -EINVAL;
1108 read_lock(&mrt_lock);
1109 vif = &net->ipv4.vif_table[vr.vifi];
1110 if (VIF_EXISTS(net, vr.vifi)) {
1111 vr.icount = vif->pkt_in;
1112 vr.ocount = vif->pkt_out;
1113 vr.ibytes = vif->bytes_in;
1114 vr.obytes = vif->bytes_out;
1115 read_unlock(&mrt_lock);
1116
1117 if (copy_to_user(arg, &vr, sizeof(vr)))
1118 return -EFAULT;
1119 return 0;
1120 }
1121 read_unlock(&mrt_lock);
1122 return -EADDRNOTAVAIL;
1123 case SIOCGETSGCNT:
1124 if (copy_from_user(&sr, arg, sizeof(sr)))
1125 return -EFAULT;
1126
1127 read_lock(&mrt_lock);
1128 c = ipmr_cache_find(net, sr.src.s_addr, sr.grp.s_addr);
1129 if (c) {
1130 sr.pktcnt = c->mfc_un.res.pkt;
1131 sr.bytecnt = c->mfc_un.res.bytes;
1132 sr.wrong_if = c->mfc_un.res.wrong_if;
1133 read_unlock(&mrt_lock);
1134
1135 if (copy_to_user(arg, &sr, sizeof(sr)))
1136 return -EFAULT;
1137 return 0;
1138 }
1139 read_unlock(&mrt_lock);
1140 return -EADDRNOTAVAIL;
1141 default:
1142 return -ENOIOCTLCMD;
1143 }
1144 }
1145
1146
1147 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1148 {
1149 struct net_device *dev = ptr;
1150 struct net *net = dev_net(dev);
1151 struct vif_device *v;
1152 int ct;
1153
1154 if (!net_eq(dev_net(dev), net))
1155 return NOTIFY_DONE;
1156
1157 if (event != NETDEV_UNREGISTER)
1158 return NOTIFY_DONE;
1159 v = &net->ipv4.vif_table[0];
1160 for (ct = 0; ct < net->ipv4.maxvif; ct++, v++) {
1161 if (v->dev == dev)
1162 vif_delete(net, ct, 1);
1163 }
1164 return NOTIFY_DONE;
1165 }
1166
1167
1168 static struct notifier_block ip_mr_notifier = {
1169 .notifier_call = ipmr_device_event,
1170 };
1171
1172 /*
1173 * Encapsulate a packet by attaching a valid IPIP header to it.
1174 * This avoids tunnel drivers and other mess and gives us the speed so
1175 * important for multicast video.
1176 */
1177
1178 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1179 {
1180 struct iphdr *iph;
1181 struct iphdr *old_iph = ip_hdr(skb);
1182
1183 skb_push(skb, sizeof(struct iphdr));
1184 skb->transport_header = skb->network_header;
1185 skb_reset_network_header(skb);
1186 iph = ip_hdr(skb);
1187
1188 iph->version = 4;
1189 iph->tos = old_iph->tos;
1190 iph->ttl = old_iph->ttl;
1191 iph->frag_off = 0;
1192 iph->daddr = daddr;
1193 iph->saddr = saddr;
1194 iph->protocol = IPPROTO_IPIP;
1195 iph->ihl = 5;
1196 iph->tot_len = htons(skb->len);
1197 ip_select_ident(iph, skb_dst(skb), NULL);
1198 ip_send_check(iph);
1199
1200 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1201 nf_reset(skb);
1202 }
1203
1204 static inline int ipmr_forward_finish(struct sk_buff *skb)
1205 {
1206 struct ip_options * opt = &(IPCB(skb)->opt);
1207
1208 IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
1209
1210 if (unlikely(opt->optlen))
1211 ip_forward_options(skb);
1212
1213 return dst_output(skb);
1214 }
1215
1216 /*
1217 * Processing handlers for ipmr_forward
1218 */
1219
1220 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1221 {
1222 struct net *net = mfc_net(c);
1223 const struct iphdr *iph = ip_hdr(skb);
1224 struct vif_device *vif = &net->ipv4.vif_table[vifi];
1225 struct net_device *dev;
1226 struct rtable *rt;
1227 int encap = 0;
1228
1229 if (vif->dev == NULL)
1230 goto out_free;
1231
1232 #ifdef CONFIG_IP_PIMSM
1233 if (vif->flags & VIFF_REGISTER) {
1234 vif->pkt_out++;
1235 vif->bytes_out += skb->len;
1236 vif->dev->stats.tx_bytes += skb->len;
1237 vif->dev->stats.tx_packets++;
1238 ipmr_cache_report(net, skb, vifi, IGMPMSG_WHOLEPKT);
1239 goto out_free;
1240 }
1241 #endif
1242
1243 if (vif->flags&VIFF_TUNNEL) {
1244 struct flowi fl = { .oif = vif->link,
1245 .nl_u = { .ip4_u =
1246 { .daddr = vif->remote,
1247 .saddr = vif->local,
1248 .tos = RT_TOS(iph->tos) } },
1249 .proto = IPPROTO_IPIP };
1250 if (ip_route_output_key(net, &rt, &fl))
1251 goto out_free;
1252 encap = sizeof(struct iphdr);
1253 } else {
1254 struct flowi fl = { .oif = vif->link,
1255 .nl_u = { .ip4_u =
1256 { .daddr = iph->daddr,
1257 .tos = RT_TOS(iph->tos) } },
1258 .proto = IPPROTO_IPIP };
1259 if (ip_route_output_key(net, &rt, &fl))
1260 goto out_free;
1261 }
1262
1263 dev = rt->u.dst.dev;
1264
1265 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1266 /* Do not fragment multicasts. Alas, IPv4 does not
1267 allow to send ICMP, so that packets will disappear
1268 to blackhole.
1269 */
1270
1271 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
1272 ip_rt_put(rt);
1273 goto out_free;
1274 }
1275
1276 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1277
1278 if (skb_cow(skb, encap)) {
1279 ip_rt_put(rt);
1280 goto out_free;
1281 }
1282
1283 vif->pkt_out++;
1284 vif->bytes_out += skb->len;
1285
1286 skb_dst_drop(skb);
1287 skb_dst_set(skb, &rt->u.dst);
1288 ip_decrease_ttl(ip_hdr(skb));
1289
1290 /* FIXME: forward and output firewalls used to be called here.
1291 * What do we do with netfilter? -- RR */
1292 if (vif->flags & VIFF_TUNNEL) {
1293 ip_encap(skb, vif->local, vif->remote);
1294 /* FIXME: extra output firewall step used to be here. --RR */
1295 vif->dev->stats.tx_packets++;
1296 vif->dev->stats.tx_bytes += skb->len;
1297 }
1298
1299 IPCB(skb)->flags |= IPSKB_FORWARDED;
1300
1301 /*
1302 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1303 * not only before forwarding, but after forwarding on all output
1304 * interfaces. It is clear, if mrouter runs a multicasting
1305 * program, it should receive packets not depending to what interface
1306 * program is joined.
1307 * If we will not make it, the program will have to join on all
1308 * interfaces. On the other hand, multihoming host (or router, but
1309 * not mrouter) cannot join to more than one interface - it will
1310 * result in receiving multiple packets.
1311 */
1312 NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev,
1313 ipmr_forward_finish);
1314 return;
1315
1316 out_free:
1317 kfree_skb(skb);
1318 return;
1319 }
1320
1321 static int ipmr_find_vif(struct net_device *dev)
1322 {
1323 struct net *net = dev_net(dev);
1324 int ct;
1325 for (ct = net->ipv4.maxvif-1; ct >= 0; ct--) {
1326 if (net->ipv4.vif_table[ct].dev == dev)
1327 break;
1328 }
1329 return ct;
1330 }
1331
1332 /* "local" means that we should preserve one skb (for local delivery) */
1333
1334 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1335 {
1336 int psend = -1;
1337 int vif, ct;
1338 struct net *net = mfc_net(cache);
1339
1340 vif = cache->mfc_parent;
1341 cache->mfc_un.res.pkt++;
1342 cache->mfc_un.res.bytes += skb->len;
1343
1344 /*
1345 * Wrong interface: drop packet and (maybe) send PIM assert.
1346 */
1347 if (net->ipv4.vif_table[vif].dev != skb->dev) {
1348 int true_vifi;
1349
1350 if (skb_rtable(skb)->fl.iif == 0) {
1351 /* It is our own packet, looped back.
1352 Very complicated situation...
1353
1354 The best workaround until routing daemons will be
1355 fixed is not to redistribute packet, if it was
1356 send through wrong interface. It means, that
1357 multicast applications WILL NOT work for
1358 (S,G), which have default multicast route pointing
1359 to wrong oif. In any case, it is not a good
1360 idea to use multicasting applications on router.
1361 */
1362 goto dont_forward;
1363 }
1364
1365 cache->mfc_un.res.wrong_if++;
1366 true_vifi = ipmr_find_vif(skb->dev);
1367
1368 if (true_vifi >= 0 && net->ipv4.mroute_do_assert &&
1369 /* pimsm uses asserts, when switching from RPT to SPT,
1370 so that we cannot check that packet arrived on an oif.
1371 It is bad, but otherwise we would need to move pretty
1372 large chunk of pimd to kernel. Ough... --ANK
1373 */
1374 (net->ipv4.mroute_do_pim ||
1375 cache->mfc_un.res.ttls[true_vifi] < 255) &&
1376 time_after(jiffies,
1377 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1378 cache->mfc_un.res.last_assert = jiffies;
1379 ipmr_cache_report(net, skb, true_vifi, IGMPMSG_WRONGVIF);
1380 }
1381 goto dont_forward;
1382 }
1383
1384 net->ipv4.vif_table[vif].pkt_in++;
1385 net->ipv4.vif_table[vif].bytes_in += skb->len;
1386
1387 /*
1388 * Forward the frame
1389 */
1390 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1391 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1392 if (psend != -1) {
1393 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1394 if (skb2)
1395 ipmr_queue_xmit(skb2, cache, psend);
1396 }
1397 psend = ct;
1398 }
1399 }
1400 if (psend != -1) {
1401 if (local) {
1402 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1403 if (skb2)
1404 ipmr_queue_xmit(skb2, cache, psend);
1405 } else {
1406 ipmr_queue_xmit(skb, cache, psend);
1407 return 0;
1408 }
1409 }
1410
1411 dont_forward:
1412 if (!local)
1413 kfree_skb(skb);
1414 return 0;
1415 }
1416
1417
1418 /*
1419 * Multicast packets for forwarding arrive here
1420 */
1421
1422 int ip_mr_input(struct sk_buff *skb)
1423 {
1424 struct mfc_cache *cache;
1425 struct net *net = dev_net(skb->dev);
1426 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1427
1428 /* Packet is looped back after forward, it should not be
1429 forwarded second time, but still can be delivered locally.
1430 */
1431 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1432 goto dont_forward;
1433
1434 if (!local) {
1435 if (IPCB(skb)->opt.router_alert) {
1436 if (ip_call_ra_chain(skb))
1437 return 0;
1438 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1439 /* IGMPv1 (and broken IGMPv2 implementations sort of
1440 Cisco IOS <= 11.2(8)) do not put router alert
1441 option to IGMP packets destined to routable
1442 groups. It is very bad, because it means
1443 that we can forward NO IGMP messages.
1444 */
1445 read_lock(&mrt_lock);
1446 if (net->ipv4.mroute_sk) {
1447 nf_reset(skb);
1448 raw_rcv(net->ipv4.mroute_sk, skb);
1449 read_unlock(&mrt_lock);
1450 return 0;
1451 }
1452 read_unlock(&mrt_lock);
1453 }
1454 }
1455
1456 read_lock(&mrt_lock);
1457 cache = ipmr_cache_find(net, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1458
1459 /*
1460 * No usable cache entry
1461 */
1462 if (cache == NULL) {
1463 int vif;
1464
1465 if (local) {
1466 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1467 ip_local_deliver(skb);
1468 if (skb2 == NULL) {
1469 read_unlock(&mrt_lock);
1470 return -ENOBUFS;
1471 }
1472 skb = skb2;
1473 }
1474
1475 vif = ipmr_find_vif(skb->dev);
1476 if (vif >= 0) {
1477 int err = ipmr_cache_unresolved(net, vif, skb);
1478 read_unlock(&mrt_lock);
1479
1480 return err;
1481 }
1482 read_unlock(&mrt_lock);
1483 kfree_skb(skb);
1484 return -ENODEV;
1485 }
1486
1487 ip_mr_forward(skb, cache, local);
1488
1489 read_unlock(&mrt_lock);
1490
1491 if (local)
1492 return ip_local_deliver(skb);
1493
1494 return 0;
1495
1496 dont_forward:
1497 if (local)
1498 return ip_local_deliver(skb);
1499 kfree_skb(skb);
1500 return 0;
1501 }
1502
1503 #ifdef CONFIG_IP_PIMSM
1504 static int __pim_rcv(struct sk_buff *skb, unsigned int pimlen)
1505 {
1506 struct net_device *reg_dev = NULL;
1507 struct iphdr *encap;
1508 struct net *net = dev_net(skb->dev);
1509
1510 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
1511 /*
1512 Check that:
1513 a. packet is really destinted to a multicast group
1514 b. packet is not a NULL-REGISTER
1515 c. packet is not truncated
1516 */
1517 if (!ipv4_is_multicast(encap->daddr) ||
1518 encap->tot_len == 0 ||
1519 ntohs(encap->tot_len) + pimlen > skb->len)
1520 return 1;
1521
1522 read_lock(&mrt_lock);
1523 if (net->ipv4.mroute_reg_vif_num >= 0)
1524 reg_dev = net->ipv4.vif_table[net->ipv4.mroute_reg_vif_num].dev;
1525 if (reg_dev)
1526 dev_hold(reg_dev);
1527 read_unlock(&mrt_lock);
1528
1529 if (reg_dev == NULL)
1530 return 1;
1531
1532 skb->mac_header = skb->network_header;
1533 skb_pull(skb, (u8*)encap - skb->data);
1534 skb_reset_network_header(skb);
1535 skb->dev = reg_dev;
1536 skb->protocol = htons(ETH_P_IP);
1537 skb->ip_summed = 0;
1538 skb->pkt_type = PACKET_HOST;
1539 skb_dst_drop(skb);
1540 reg_dev->stats.rx_bytes += skb->len;
1541 reg_dev->stats.rx_packets++;
1542 nf_reset(skb);
1543 netif_rx(skb);
1544 dev_put(reg_dev);
1545
1546 return 0;
1547 }
1548 #endif
1549
1550 #ifdef CONFIG_IP_PIMSM_V1
1551 /*
1552 * Handle IGMP messages of PIMv1
1553 */
1554
1555 int pim_rcv_v1(struct sk_buff * skb)
1556 {
1557 struct igmphdr *pim;
1558 struct net *net = dev_net(skb->dev);
1559
1560 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1561 goto drop;
1562
1563 pim = igmp_hdr(skb);
1564
1565 if (!net->ipv4.mroute_do_pim ||
1566 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1567 goto drop;
1568
1569 if (__pim_rcv(skb, sizeof(*pim))) {
1570 drop:
1571 kfree_skb(skb);
1572 }
1573 return 0;
1574 }
1575 #endif
1576
1577 #ifdef CONFIG_IP_PIMSM_V2
1578 static int pim_rcv(struct sk_buff * skb)
1579 {
1580 struct pimreghdr *pim;
1581
1582 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1583 goto drop;
1584
1585 pim = (struct pimreghdr *)skb_transport_header(skb);
1586 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1587 (pim->flags&PIM_NULL_REGISTER) ||
1588 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1589 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1590 goto drop;
1591
1592 if (__pim_rcv(skb, sizeof(*pim))) {
1593 drop:
1594 kfree_skb(skb);
1595 }
1596 return 0;
1597 }
1598 #endif
1599
1600 static int
1601 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1602 {
1603 int ct;
1604 struct rtnexthop *nhp;
1605 struct net *net = mfc_net(c);
1606 struct net_device *dev = net->ipv4.vif_table[c->mfc_parent].dev;
1607 u8 *b = skb_tail_pointer(skb);
1608 struct rtattr *mp_head;
1609
1610 if (dev)
1611 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1612
1613 mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1614
1615 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1616 if (c->mfc_un.res.ttls[ct] < 255) {
1617 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1618 goto rtattr_failure;
1619 nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1620 nhp->rtnh_flags = 0;
1621 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1622 nhp->rtnh_ifindex = net->ipv4.vif_table[ct].dev->ifindex;
1623 nhp->rtnh_len = sizeof(*nhp);
1624 }
1625 }
1626 mp_head->rta_type = RTA_MULTIPATH;
1627 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1628 rtm->rtm_type = RTN_MULTICAST;
1629 return 1;
1630
1631 rtattr_failure:
1632 nlmsg_trim(skb, b);
1633 return -EMSGSIZE;
1634 }
1635
1636 int ipmr_get_route(struct net *net,
1637 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1638 {
1639 int err;
1640 struct mfc_cache *cache;
1641 struct rtable *rt = skb_rtable(skb);
1642
1643 read_lock(&mrt_lock);
1644 cache = ipmr_cache_find(net, rt->rt_src, rt->rt_dst);
1645
1646 if (cache == NULL) {
1647 struct sk_buff *skb2;
1648 struct iphdr *iph;
1649 struct net_device *dev;
1650 int vif;
1651
1652 if (nowait) {
1653 read_unlock(&mrt_lock);
1654 return -EAGAIN;
1655 }
1656
1657 dev = skb->dev;
1658 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1659 read_unlock(&mrt_lock);
1660 return -ENODEV;
1661 }
1662 skb2 = skb_clone(skb, GFP_ATOMIC);
1663 if (!skb2) {
1664 read_unlock(&mrt_lock);
1665 return -ENOMEM;
1666 }
1667
1668 skb_push(skb2, sizeof(struct iphdr));
1669 skb_reset_network_header(skb2);
1670 iph = ip_hdr(skb2);
1671 iph->ihl = sizeof(struct iphdr) >> 2;
1672 iph->saddr = rt->rt_src;
1673 iph->daddr = rt->rt_dst;
1674 iph->version = 0;
1675 err = ipmr_cache_unresolved(net, vif, skb2);
1676 read_unlock(&mrt_lock);
1677 return err;
1678 }
1679
1680 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1681 cache->mfc_flags |= MFC_NOTIFY;
1682 err = ipmr_fill_mroute(skb, cache, rtm);
1683 read_unlock(&mrt_lock);
1684 return err;
1685 }
1686
1687 #ifdef CONFIG_PROC_FS
1688 /*
1689 * The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1690 */
1691 struct ipmr_vif_iter {
1692 struct seq_net_private p;
1693 int ct;
1694 };
1695
1696 static struct vif_device *ipmr_vif_seq_idx(struct net *net,
1697 struct ipmr_vif_iter *iter,
1698 loff_t pos)
1699 {
1700 for (iter->ct = 0; iter->ct < net->ipv4.maxvif; ++iter->ct) {
1701 if (!VIF_EXISTS(net, iter->ct))
1702 continue;
1703 if (pos-- == 0)
1704 return &net->ipv4.vif_table[iter->ct];
1705 }
1706 return NULL;
1707 }
1708
1709 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1710 __acquires(mrt_lock)
1711 {
1712 struct net *net = seq_file_net(seq);
1713
1714 read_lock(&mrt_lock);
1715 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
1716 : SEQ_START_TOKEN;
1717 }
1718
1719 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1720 {
1721 struct ipmr_vif_iter *iter = seq->private;
1722 struct net *net = seq_file_net(seq);
1723
1724 ++*pos;
1725 if (v == SEQ_START_TOKEN)
1726 return ipmr_vif_seq_idx(net, iter, 0);
1727
1728 while (++iter->ct < net->ipv4.maxvif) {
1729 if (!VIF_EXISTS(net, iter->ct))
1730 continue;
1731 return &net->ipv4.vif_table[iter->ct];
1732 }
1733 return NULL;
1734 }
1735
1736 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1737 __releases(mrt_lock)
1738 {
1739 read_unlock(&mrt_lock);
1740 }
1741
1742 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1743 {
1744 struct net *net = seq_file_net(seq);
1745
1746 if (v == SEQ_START_TOKEN) {
1747 seq_puts(seq,
1748 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1749 } else {
1750 const struct vif_device *vif = v;
1751 const char *name = vif->dev ? vif->dev->name : "none";
1752
1753 seq_printf(seq,
1754 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1755 vif - net->ipv4.vif_table,
1756 name, vif->bytes_in, vif->pkt_in,
1757 vif->bytes_out, vif->pkt_out,
1758 vif->flags, vif->local, vif->remote);
1759 }
1760 return 0;
1761 }
1762
1763 static const struct seq_operations ipmr_vif_seq_ops = {
1764 .start = ipmr_vif_seq_start,
1765 .next = ipmr_vif_seq_next,
1766 .stop = ipmr_vif_seq_stop,
1767 .show = ipmr_vif_seq_show,
1768 };
1769
1770 static int ipmr_vif_open(struct inode *inode, struct file *file)
1771 {
1772 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
1773 sizeof(struct ipmr_vif_iter));
1774 }
1775
1776 static const struct file_operations ipmr_vif_fops = {
1777 .owner = THIS_MODULE,
1778 .open = ipmr_vif_open,
1779 .read = seq_read,
1780 .llseek = seq_lseek,
1781 .release = seq_release_net,
1782 };
1783
1784 struct ipmr_mfc_iter {
1785 struct seq_net_private p;
1786 struct mfc_cache **cache;
1787 int ct;
1788 };
1789
1790
1791 static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
1792 struct ipmr_mfc_iter *it, loff_t pos)
1793 {
1794 struct mfc_cache *mfc;
1795
1796 it->cache = net->ipv4.mfc_cache_array;
1797 read_lock(&mrt_lock);
1798 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1799 for (mfc = net->ipv4.mfc_cache_array[it->ct];
1800 mfc; mfc = mfc->next)
1801 if (pos-- == 0)
1802 return mfc;
1803 read_unlock(&mrt_lock);
1804
1805 it->cache = &mfc_unres_queue;
1806 spin_lock_bh(&mfc_unres_lock);
1807 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1808 if (net_eq(mfc_net(mfc), net) &&
1809 pos-- == 0)
1810 return mfc;
1811 spin_unlock_bh(&mfc_unres_lock);
1812
1813 it->cache = NULL;
1814 return NULL;
1815 }
1816
1817
1818 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1819 {
1820 struct ipmr_mfc_iter *it = seq->private;
1821 struct net *net = seq_file_net(seq);
1822
1823 it->cache = NULL;
1824 it->ct = 0;
1825 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
1826 : SEQ_START_TOKEN;
1827 }
1828
1829 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1830 {
1831 struct mfc_cache *mfc = v;
1832 struct ipmr_mfc_iter *it = seq->private;
1833 struct net *net = seq_file_net(seq);
1834
1835 ++*pos;
1836
1837 if (v == SEQ_START_TOKEN)
1838 return ipmr_mfc_seq_idx(net, seq->private, 0);
1839
1840 if (mfc->next)
1841 return mfc->next;
1842
1843 if (it->cache == &mfc_unres_queue)
1844 goto end_of_list;
1845
1846 BUG_ON(it->cache != net->ipv4.mfc_cache_array);
1847
1848 while (++it->ct < MFC_LINES) {
1849 mfc = net->ipv4.mfc_cache_array[it->ct];
1850 if (mfc)
1851 return mfc;
1852 }
1853
1854 /* exhausted cache_array, show unresolved */
1855 read_unlock(&mrt_lock);
1856 it->cache = &mfc_unres_queue;
1857 it->ct = 0;
1858
1859 spin_lock_bh(&mfc_unres_lock);
1860 mfc = mfc_unres_queue;
1861 while (mfc && !net_eq(mfc_net(mfc), net))
1862 mfc = mfc->next;
1863 if (mfc)
1864 return mfc;
1865
1866 end_of_list:
1867 spin_unlock_bh(&mfc_unres_lock);
1868 it->cache = NULL;
1869
1870 return NULL;
1871 }
1872
1873 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1874 {
1875 struct ipmr_mfc_iter *it = seq->private;
1876 struct net *net = seq_file_net(seq);
1877
1878 if (it->cache == &mfc_unres_queue)
1879 spin_unlock_bh(&mfc_unres_lock);
1880 else if (it->cache == net->ipv4.mfc_cache_array)
1881 read_unlock(&mrt_lock);
1882 }
1883
1884 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1885 {
1886 int n;
1887 struct net *net = seq_file_net(seq);
1888
1889 if (v == SEQ_START_TOKEN) {
1890 seq_puts(seq,
1891 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1892 } else {
1893 const struct mfc_cache *mfc = v;
1894 const struct ipmr_mfc_iter *it = seq->private;
1895
1896 seq_printf(seq, "%08lX %08lX %-3hd",
1897 (unsigned long) mfc->mfc_mcastgrp,
1898 (unsigned long) mfc->mfc_origin,
1899 mfc->mfc_parent);
1900
1901 if (it->cache != &mfc_unres_queue) {
1902 seq_printf(seq, " %8lu %8lu %8lu",
1903 mfc->mfc_un.res.pkt,
1904 mfc->mfc_un.res.bytes,
1905 mfc->mfc_un.res.wrong_if);
1906 for (n = mfc->mfc_un.res.minvif;
1907 n < mfc->mfc_un.res.maxvif; n++ ) {
1908 if (VIF_EXISTS(net, n) &&
1909 mfc->mfc_un.res.ttls[n] < 255)
1910 seq_printf(seq,
1911 " %2d:%-3d",
1912 n, mfc->mfc_un.res.ttls[n]);
1913 }
1914 } else {
1915 /* unresolved mfc_caches don't contain
1916 * pkt, bytes and wrong_if values
1917 */
1918 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
1919 }
1920 seq_putc(seq, '\n');
1921 }
1922 return 0;
1923 }
1924
1925 static const struct seq_operations ipmr_mfc_seq_ops = {
1926 .start = ipmr_mfc_seq_start,
1927 .next = ipmr_mfc_seq_next,
1928 .stop = ipmr_mfc_seq_stop,
1929 .show = ipmr_mfc_seq_show,
1930 };
1931
1932 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1933 {
1934 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
1935 sizeof(struct ipmr_mfc_iter));
1936 }
1937
1938 static const struct file_operations ipmr_mfc_fops = {
1939 .owner = THIS_MODULE,
1940 .open = ipmr_mfc_open,
1941 .read = seq_read,
1942 .llseek = seq_lseek,
1943 .release = seq_release_net,
1944 };
1945 #endif
1946
1947 #ifdef CONFIG_IP_PIMSM_V2
1948 static struct net_protocol pim_protocol = {
1949 .handler = pim_rcv,
1950 .netns_ok = 1,
1951 };
1952 #endif
1953
1954
1955 /*
1956 * Setup for IP multicast routing
1957 */
1958 static int __net_init ipmr_net_init(struct net *net)
1959 {
1960 int err = 0;
1961
1962 net->ipv4.vif_table = kcalloc(MAXVIFS, sizeof(struct vif_device),
1963 GFP_KERNEL);
1964 if (!net->ipv4.vif_table) {
1965 err = -ENOMEM;
1966 goto fail;
1967 }
1968
1969 /* Forwarding cache */
1970 net->ipv4.mfc_cache_array = kcalloc(MFC_LINES,
1971 sizeof(struct mfc_cache *),
1972 GFP_KERNEL);
1973 if (!net->ipv4.mfc_cache_array) {
1974 err = -ENOMEM;
1975 goto fail_mfc_cache;
1976 }
1977
1978 #ifdef CONFIG_IP_PIMSM
1979 net->ipv4.mroute_reg_vif_num = -1;
1980 #endif
1981
1982 #ifdef CONFIG_PROC_FS
1983 err = -ENOMEM;
1984 if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
1985 goto proc_vif_fail;
1986 if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
1987 goto proc_cache_fail;
1988 #endif
1989 return 0;
1990
1991 #ifdef CONFIG_PROC_FS
1992 proc_cache_fail:
1993 proc_net_remove(net, "ip_mr_vif");
1994 proc_vif_fail:
1995 kfree(net->ipv4.mfc_cache_array);
1996 #endif
1997 fail_mfc_cache:
1998 kfree(net->ipv4.vif_table);
1999 fail:
2000 return err;
2001 }
2002
2003 static void __net_exit ipmr_net_exit(struct net *net)
2004 {
2005 #ifdef CONFIG_PROC_FS
2006 proc_net_remove(net, "ip_mr_cache");
2007 proc_net_remove(net, "ip_mr_vif");
2008 #endif
2009 kfree(net->ipv4.mfc_cache_array);
2010 kfree(net->ipv4.vif_table);
2011 }
2012
2013 static struct pernet_operations ipmr_net_ops = {
2014 .init = ipmr_net_init,
2015 .exit = ipmr_net_exit,
2016 };
2017
2018 int __init ip_mr_init(void)
2019 {
2020 int err;
2021
2022 mrt_cachep = kmem_cache_create("ip_mrt_cache",
2023 sizeof(struct mfc_cache),
2024 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2025 NULL);
2026 if (!mrt_cachep)
2027 return -ENOMEM;
2028
2029 err = register_pernet_subsys(&ipmr_net_ops);
2030 if (err)
2031 goto reg_pernet_fail;
2032
2033 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
2034 err = register_netdevice_notifier(&ip_mr_notifier);
2035 if (err)
2036 goto reg_notif_fail;
2037 #ifdef CONFIG_IP_PIMSM_V2
2038 if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
2039 printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n");
2040 err = -EAGAIN;
2041 goto add_proto_fail;
2042 }
2043 #endif
2044 return 0;
2045
2046 #ifdef CONFIG_IP_PIMSM_V2
2047 add_proto_fail:
2048 unregister_netdevice_notifier(&ip_mr_notifier);
2049 #endif
2050 reg_notif_fail:
2051 del_timer(&ipmr_expire_timer);
2052 unregister_pernet_subsys(&ipmr_net_ops);
2053 reg_pernet_fail:
2054 kmem_cache_destroy(mrt_cachep);
2055 return err;
2056 }
kernel source for telekom puls (alcatel/mediatek)