1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
70static struct sock *mroute_socket;
71
72
73
74
75
76
77static DEFINE_RWLOCK(mrt_lock);
78
79
80
81
82
83static struct vif_device vif_table[MAXVIFS];
84static int maxvif;
85
86#define VIF_EXISTS(idx) (vif_table[idx].dev != NULL)
87
88static int mroute_do_assert;
89static int mroute_do_pim;
90
91static struct mfc_cache *mfc_cache_array[MFC_LINES];
92
93static struct mfc_cache *mfc_unres_queue;
94static atomic_t cache_resolve_queue_len;
95
96
97static DEFINE_SPINLOCK(mfc_unres_lock);
98
99
100
101
102
103
104
105
106
107static struct kmem_cache *mrt_cachep __read_mostly;
108
109static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
110static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert);
111static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
112
113#ifdef CONFIG_IP_PIMSM_V2
114static struct net_protocol pim_protocol;
115#endif
116
117static struct timer_list ipmr_expire_timer;
118
119
120
121static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
122{
123 dev_close(dev);
124
125 dev = __dev_get_by_name(&init_net, "tunl0");
126 if (dev) {
127 struct ifreq ifr;
128 mm_segment_t oldfs;
129 struct ip_tunnel_parm p;
130
131 memset(&p, 0, sizeof(p));
132 p.iph.daddr = v->vifc_rmt_addr.s_addr;
133 p.iph.saddr = v->vifc_lcl_addr.s_addr;
134 p.iph.version = 4;
135 p.iph.ihl = 5;
136 p.iph.protocol = IPPROTO_IPIP;
137 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
138 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
139
140 oldfs = get_fs(); set_fs(KERNEL_DS);
141 dev->do_ioctl(dev, &ifr, SIOCDELTUNNEL);
142 set_fs(oldfs);
143 }
144}
145
146static
147struct net_device *ipmr_new_tunnel(struct vifctl *v)
148{
149 struct net_device *dev;
150
151 dev = __dev_get_by_name(&init_net, "tunl0");
152
153 if (dev) {
154 int err;
155 struct ifreq ifr;
156 mm_segment_t oldfs;
157 struct ip_tunnel_parm p;
158 struct in_device *in_dev;
159
160 memset(&p, 0, sizeof(p));
161 p.iph.daddr = v->vifc_rmt_addr.s_addr;
162 p.iph.saddr = v->vifc_lcl_addr.s_addr;
163 p.iph.version = 4;
164 p.iph.ihl = 5;
165 p.iph.protocol = IPPROTO_IPIP;
166 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
167 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
168
169 oldfs = get_fs(); set_fs(KERNEL_DS);
170 err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
171 set_fs(oldfs);
172
173 dev = NULL;
174
175 if (err == 0 && (dev = __dev_get_by_name(&init_net, p.name)) != NULL) {
176 dev->flags |= IFF_MULTICAST;
177
178 in_dev = __in_dev_get_rtnl(dev);
179 if (in_dev == NULL)
180 goto failure;
181
182 ipv4_devconf_setall(in_dev);
183 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
184
185 if (dev_open(dev))
186 goto failure;
187 dev_hold(dev);
188 }
189 }
190 return dev;
191
192failure:
193
194 rtnl_unlock();
195 rtnl_lock();
196
197 unregister_netdevice(dev);
198 return NULL;
199}
200
201#ifdef CONFIG_IP_PIMSM
202
203static int reg_vif_num = -1;
204
205static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
206{
207 read_lock(&mrt_lock);
208 dev->stats.tx_bytes += skb->len;
209 dev->stats.tx_packets++;
210 ipmr_cache_report(skb, reg_vif_num, IGMPMSG_WHOLEPKT);
211 read_unlock(&mrt_lock);
212 kfree_skb(skb);
213 return 0;
214}
215
216static void reg_vif_setup(struct net_device *dev)
217{
218 dev->type = ARPHRD_PIMREG;
219 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
220 dev->flags = IFF_NOARP;
221 dev->hard_start_xmit = reg_vif_xmit;
222 dev->destructor = free_netdev;
223}
224
225static struct net_device *ipmr_reg_vif(void)
226{
227 struct net_device *dev;
228 struct in_device *in_dev;
229
230 dev = alloc_netdev(0, "pimreg", reg_vif_setup);
231
232 if (dev == NULL)
233 return NULL;
234
235 if (register_netdevice(dev)) {
236 free_netdev(dev);
237 return NULL;
238 }
239 dev->iflink = 0;
240
241 rcu_read_lock();
242 if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
243 rcu_read_unlock();
244 goto failure;
245 }
246
247 ipv4_devconf_setall(in_dev);
248 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
249 rcu_read_unlock();
250
251 if (dev_open(dev))
252 goto failure;
253
254 dev_hold(dev);
255
256 return dev;
257
258failure:
259
260 rtnl_unlock();
261 rtnl_lock();
262
263 unregister_netdevice(dev);
264 return NULL;
265}
266#endif
267
268
269
270
271
272
273static int vif_delete(int vifi, int notify)
274{
275 struct vif_device *v;
276 struct net_device *dev;
277 struct in_device *in_dev;
278
279 if (vifi < 0 || vifi >= maxvif)
280 return -EADDRNOTAVAIL;
281
282 v = &vif_table[vifi];
283
284 write_lock_bh(&mrt_lock);
285 dev = v->dev;
286 v->dev = NULL;
287
288 if (!dev) {
289 write_unlock_bh(&mrt_lock);
290 return -EADDRNOTAVAIL;
291 }
292
293#ifdef CONFIG_IP_PIMSM
294 if (vifi == reg_vif_num)
295 reg_vif_num = -1;
296#endif
297
298 if (vifi+1 == maxvif) {
299 int tmp;
300 for (tmp=vifi-1; tmp>=0; tmp--) {
301 if (VIF_EXISTS(tmp))
302 break;
303 }
304 maxvif = tmp+1;
305 }
306
307 write_unlock_bh(&mrt_lock);
308
309 dev_set_allmulti(dev, -1);
310
311 if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
312 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
313 ip_rt_multicast_event(in_dev);
314 }
315
316 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify)
317 unregister_netdevice(dev);
318
319 dev_put(dev);
320 return 0;
321}
322
323
324
325
326
327static void ipmr_destroy_unres(struct mfc_cache *c)
328{
329 struct sk_buff *skb;
330 struct nlmsgerr *e;
331
332 atomic_dec(&cache_resolve_queue_len);
333
334 while ((skb=skb_dequeue(&c->mfc_un.unres.unresolved))) {
335 if (ip_hdr(skb)->version == 0) {
336 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
337 nlh->nlmsg_type = NLMSG_ERROR;
338 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
339 skb_trim(skb, nlh->nlmsg_len);
340 e = NLMSG_DATA(nlh);
341 e->error = -ETIMEDOUT;
342 memset(&e->msg, 0, sizeof(e->msg));
343
344 rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid);
345 } else
346 kfree_skb(skb);
347 }
348
349 kmem_cache_free(mrt_cachep, c);
350}
351
352
353
354
355static void ipmr_expire_process(unsigned long dummy)
356{
357 unsigned long now;
358 unsigned long expires;
359 struct mfc_cache *c, **cp;
360
361 if (!spin_trylock(&mfc_unres_lock)) {
362 mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
363 return;
364 }
365
366 if (atomic_read(&cache_resolve_queue_len) == 0)
367 goto out;
368
369 now = jiffies;
370 expires = 10*HZ;
371 cp = &mfc_unres_queue;
372
373 while ((c=*cp) != NULL) {
374 if (time_after(c->mfc_un.unres.expires, now)) {
375 unsigned long interval = c->mfc_un.unres.expires - now;
376 if (interval < expires)
377 expires = interval;
378 cp = &c->next;
379 continue;
380 }
381
382 *cp = c->next;
383
384 ipmr_destroy_unres(c);
385 }
386
387 if (atomic_read(&cache_resolve_queue_len))
388 mod_timer(&ipmr_expire_timer, jiffies + expires);
389
390out:
391 spin_unlock(&mfc_unres_lock);
392}
393
394
395
396static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
397{
398 int vifi;
399
400 cache->mfc_un.res.minvif = MAXVIFS;
401 cache->mfc_un.res.maxvif = 0;
402 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
403
404 for (vifi=0; vifi<maxvif; vifi++) {
405 if (VIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) {
406 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
407 if (cache->mfc_un.res.minvif > vifi)
408 cache->mfc_un.res.minvif = vifi;
409 if (cache->mfc_un.res.maxvif <= vifi)
410 cache->mfc_un.res.maxvif = vifi + 1;
411 }
412 }
413}
414
415static int vif_add(struct vifctl *vifc, int mrtsock)
416{
417 int vifi = vifc->vifc_vifi;
418 struct vif_device *v = &vif_table[vifi];
419 struct net_device *dev;
420 struct in_device *in_dev;
421 int err;
422
423
424 if (VIF_EXISTS(vifi))
425 return -EADDRINUSE;
426
427 switch (vifc->vifc_flags) {
428#ifdef CONFIG_IP_PIMSM
429 case VIFF_REGISTER:
430
431
432
433
434 if (reg_vif_num >= 0)
435 return -EADDRINUSE;
436 dev = ipmr_reg_vif();
437 if (!dev)
438 return -ENOBUFS;
439 err = dev_set_allmulti(dev, 1);
440 if (err) {
441 unregister_netdevice(dev);
442 dev_put(dev);
443 return err;
444 }
445 break;
446#endif
447 case VIFF_TUNNEL:
448 dev = ipmr_new_tunnel(vifc);
449 if (!dev)
450 return -ENOBUFS;
451 err = dev_set_allmulti(dev, 1);
452 if (err) {
453 ipmr_del_tunnel(dev, vifc);
454 dev_put(dev);
455 return err;
456 }
457 break;
458 case 0:
459 dev = ip_dev_find(&init_net, vifc->vifc_lcl_addr.s_addr);
460 if (!dev)
461 return -EADDRNOTAVAIL;
462 err = dev_set_allmulti(dev, 1);
463 if (err) {
464 dev_put(dev);
465 return err;
466 }
467 break;
468 default:
469 return -EINVAL;
470 }
471
472 if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
473 return -EADDRNOTAVAIL;
474 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
475 ip_rt_multicast_event(in_dev);
476
477
478
479
480 v->rate_limit=vifc->vifc_rate_limit;
481 v->local=vifc->vifc_lcl_addr.s_addr;
482 v->remote=vifc->vifc_rmt_addr.s_addr;
483 v->flags=vifc->vifc_flags;
484 if (!mrtsock)
485 v->flags |= VIFF_STATIC;
486 v->threshold=vifc->vifc_threshold;
487 v->bytes_in = 0;
488 v->bytes_out = 0;
489 v->pkt_in = 0;
490 v->pkt_out = 0;
491 v->link = dev->ifindex;
492 if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
493 v->link = dev->iflink;
494
495
496 write_lock_bh(&mrt_lock);
497 v->dev=dev;
498#ifdef CONFIG_IP_PIMSM
499 if (v->flags&VIFF_REGISTER)
500 reg_vif_num = vifi;
501#endif
502 if (vifi+1 > maxvif)
503 maxvif = vifi+1;
504 write_unlock_bh(&mrt_lock);
505 return 0;
506}
507
508static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp)
509{
510 int line=MFC_HASH(mcastgrp,origin);
511 struct mfc_cache *c;
512
513 for (c=mfc_cache_array[line]; c; c = c->next) {
514 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
515 break;
516 }
517 return c;
518}
519
520
521
522
523static struct mfc_cache *ipmr_cache_alloc(void)
524{
525 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
526 if (c==NULL)
527 return NULL;
528 c->mfc_un.res.minvif = MAXVIFS;
529 return c;
530}
531
532static struct mfc_cache *ipmr_cache_alloc_unres(void)
533{
534 struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
535 if (c==NULL)
536 return NULL;
537 skb_queue_head_init(&c->mfc_un.unres.unresolved);
538 c->mfc_un.unres.expires = jiffies + 10*HZ;
539 return c;
540}
541
542
543
544
545
546static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
547{
548 struct sk_buff *skb;
549 struct nlmsgerr *e;
550
551
552
553
554
555 while ((skb=__skb_dequeue(&uc->mfc_un.unres.unresolved))) {
556 if (ip_hdr(skb)->version == 0) {
557 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
558
559 if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
560 nlh->nlmsg_len = (skb_tail_pointer(skb) -
561 (u8 *)nlh);
562 } else {
563 nlh->nlmsg_type = NLMSG_ERROR;
564 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
565 skb_trim(skb, nlh->nlmsg_len);
566 e = NLMSG_DATA(nlh);
567 e->error = -EMSGSIZE;
568 memset(&e->msg, 0, sizeof(e->msg));
569 }
570
571 rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid);
572 } else
573 ip_mr_forward(skb, c, 0);
574 }
575}
576
577
578
579
580
581
582
583
584static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert)
585{
586 struct sk_buff *skb;
587 const int ihl = ip_hdrlen(pkt);
588 struct igmphdr *igmp;
589 struct igmpmsg *msg;
590 int ret;
591
592#ifdef CONFIG_IP_PIMSM
593 if (assert == IGMPMSG_WHOLEPKT)
594 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
595 else
596#endif
597 skb = alloc_skb(128, GFP_ATOMIC);
598
599 if (!skb)
600 return -ENOBUFS;
601
602#ifdef CONFIG_IP_PIMSM
603 if (assert == IGMPMSG_WHOLEPKT) {
604
605
606
607
608
609 skb_push(skb, sizeof(struct iphdr));
610 skb_reset_network_header(skb);
611 skb_reset_transport_header(skb);
612 msg = (struct igmpmsg *)skb_network_header(skb);
613 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
614 msg->im_msgtype = IGMPMSG_WHOLEPKT;
615 msg->im_mbz = 0;
616 msg->im_vif = reg_vif_num;
617 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
618 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
619 sizeof(struct iphdr));
620 } else
621#endif
622 {
623
624
625
626
627
628 skb->network_header = skb->tail;
629 skb_put(skb, ihl);
630 skb_copy_to_linear_data(skb, pkt->data, ihl);
631 ip_hdr(skb)->protocol = 0;
632 msg = (struct igmpmsg *)skb_network_header(skb);
633 msg->im_vif = vifi;
634 skb->dst = dst_clone(pkt->dst);
635
636
637
638
639
640 igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
641 igmp->type =
642 msg->im_msgtype = assert;
643 igmp->code = 0;
644 ip_hdr(skb)->tot_len = htons(skb->len);
645 skb->transport_header = skb->network_header;
646 }
647
648 if (mroute_socket == NULL) {
649 kfree_skb(skb);
650 return -EINVAL;
651 }
652
653
654
655
656 if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
657 if (net_ratelimit())
658 printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
659 kfree_skb(skb);
660 }
661
662 return ret;
663}
664
665
666
667
668
669static int
670ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
671{
672 int err;
673 struct mfc_cache *c;
674 const struct iphdr *iph = ip_hdr(skb);
675
676 spin_lock_bh(&mfc_unres_lock);
677 for (c=mfc_unres_queue; c; c=c->next) {
678 if (c->mfc_mcastgrp == iph->daddr &&
679 c->mfc_origin == iph->saddr)
680 break;
681 }
682
683 if (c == NULL) {
684
685
686
687
688 if (atomic_read(&cache_resolve_queue_len)>=10 ||
689 (c=ipmr_cache_alloc_unres())==NULL) {
690 spin_unlock_bh(&mfc_unres_lock);
691
692 kfree_skb(skb);
693 return -ENOBUFS;
694 }
695
696
697
698
699 c->mfc_parent = -1;
700 c->mfc_origin = iph->saddr;
701 c->mfc_mcastgrp = iph->daddr;
702
703
704
705
706 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
707
708
709
710 spin_unlock_bh(&mfc_unres_lock);
711
712 kmem_cache_free(mrt_cachep, c);
713 kfree_skb(skb);
714 return err;
715 }
716
717 atomic_inc(&cache_resolve_queue_len);
718 c->next = mfc_unres_queue;
719 mfc_unres_queue = c;
720
721 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
722 }
723
724
725
726
727 if (c->mfc_un.unres.unresolved.qlen>3) {
728 kfree_skb(skb);
729 err = -ENOBUFS;
730 } else {
731 skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
732 err = 0;
733 }
734
735 spin_unlock_bh(&mfc_unres_lock);
736 return err;
737}
738
739
740
741
742
743static int ipmr_mfc_delete(struct mfcctl *mfc)
744{
745 int line;
746 struct mfc_cache *c, **cp;
747
748 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
749
750 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
751 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
752 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
753 write_lock_bh(&mrt_lock);
754 *cp = c->next;
755 write_unlock_bh(&mrt_lock);
756
757 kmem_cache_free(mrt_cachep, c);
758 return 0;
759 }
760 }
761 return -ENOENT;
762}
763
764static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
765{
766 int line;
767 struct mfc_cache *uc, *c, **cp;
768
769 line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
770
771 for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
772 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
773 c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
774 break;
775 }
776
777 if (c != NULL) {
778 write_lock_bh(&mrt_lock);
779 c->mfc_parent = mfc->mfcc_parent;
780 ipmr_update_thresholds(c, mfc->mfcc_ttls);
781 if (!mrtsock)
782 c->mfc_flags |= MFC_STATIC;
783 write_unlock_bh(&mrt_lock);
784 return 0;
785 }
786
787 if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
788 return -EINVAL;
789
790 c=ipmr_cache_alloc();
791 if (c==NULL)
792 return -ENOMEM;
793
794 c->mfc_origin=mfc->mfcc_origin.s_addr;
795 c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
796 c->mfc_parent=mfc->mfcc_parent;
797 ipmr_update_thresholds(c, mfc->mfcc_ttls);
798 if (!mrtsock)
799 c->mfc_flags |= MFC_STATIC;
800
801 write_lock_bh(&mrt_lock);
802 c->next = mfc_cache_array[line];
803 mfc_cache_array[line] = c;
804 write_unlock_bh(&mrt_lock);
805
806
807
808
809
810 spin_lock_bh(&mfc_unres_lock);
811 for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
812 cp = &uc->next) {
813 if (uc->mfc_origin == c->mfc_origin &&
814 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
815 *cp = uc->next;
816 if (atomic_dec_and_test(&cache_resolve_queue_len))
817 del_timer(&ipmr_expire_timer);
818 break;
819 }
820 }
821 spin_unlock_bh(&mfc_unres_lock);
822
823 if (uc) {
824 ipmr_cache_resolve(uc, c);
825 kmem_cache_free(mrt_cachep, uc);
826 }
827 return 0;
828}
829
830
831
832
833
834static void mroute_clean_tables(struct sock *sk)
835{
836 int i;
837
838
839
840
841 for (i=0; i<maxvif; i++) {
842 if (!(vif_table[i].flags&VIFF_STATIC))
843 vif_delete(i, 0);
844 }
845
846
847
848
849 for (i=0;i<MFC_LINES;i++) {
850 struct mfc_cache *c, **cp;
851
852 cp = &mfc_cache_array[i];
853 while ((c = *cp) != NULL) {
854 if (c->mfc_flags&MFC_STATIC) {
855 cp = &c->next;
856 continue;
857 }
858 write_lock_bh(&mrt_lock);
859 *cp = c->next;
860 write_unlock_bh(&mrt_lock);
861
862 kmem_cache_free(mrt_cachep, c);
863 }
864 }
865
866 if (atomic_read(&cache_resolve_queue_len) != 0) {
867 struct mfc_cache *c;
868
869 spin_lock_bh(&mfc_unres_lock);
870 while (mfc_unres_queue != NULL) {
871 c = mfc_unres_queue;
872 mfc_unres_queue = c->next;
873 spin_unlock_bh(&mfc_unres_lock);
874
875 ipmr_destroy_unres(c);
876
877 spin_lock_bh(&mfc_unres_lock);
878 }
879 spin_unlock_bh(&mfc_unres_lock);
880 }
881}
882
883static void mrtsock_destruct(struct sock *sk)
884{
885 rtnl_lock();
886 if (sk == mroute_socket) {
887 IPV4_DEVCONF_ALL(sock_net(sk), MC_FORWARDING)--;
888
889 write_lock_bh(&mrt_lock);
890 mroute_socket=NULL;
891 write_unlock_bh(&mrt_lock);
892
893 mroute_clean_tables(sk);
894 }
895 rtnl_unlock();
896}
897
898
899
900
901
902
903
904
905int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
906{
907 int ret;
908 struct vifctl vif;
909 struct mfcctl mfc;
910
911 if (optname != MRT_INIT) {
912 if (sk != mroute_socket && !capable(CAP_NET_ADMIN))
913 return -EACCES;
914 }
915
916 switch (optname) {
917 case MRT_INIT:
918 if (sk->sk_type != SOCK_RAW ||
919 inet_sk(sk)->num != IPPROTO_IGMP)
920 return -EOPNOTSUPP;
921 if (optlen!=sizeof(int))
922 return -ENOPROTOOPT;
923
924 rtnl_lock();
925 if (mroute_socket) {
926 rtnl_unlock();
927 return -EADDRINUSE;
928 }
929
930 ret = ip_ra_control(sk, 1, mrtsock_destruct);
931 if (ret == 0) {
932 write_lock_bh(&mrt_lock);
933 mroute_socket=sk;
934 write_unlock_bh(&mrt_lock);
935
936 IPV4_DEVCONF_ALL(sock_net(sk), MC_FORWARDING)++;
937 }
938 rtnl_unlock();
939 return ret;
940 case MRT_DONE:
941 if (sk!=mroute_socket)
942 return -EACCES;
943 return ip_ra_control(sk, 0, NULL);
944 case MRT_ADD_VIF:
945 case MRT_DEL_VIF:
946 if (optlen!=sizeof(vif))
947 return -EINVAL;
948 if (copy_from_user(&vif,optval,sizeof(vif)))
949 return -EFAULT;
950 if (vif.vifc_vifi >= MAXVIFS)
951 return -ENFILE;
952 rtnl_lock();
953 if (optname==MRT_ADD_VIF) {
954 ret = vif_add(&vif, sk==mroute_socket);
955 } else {
956 ret = vif_delete(vif.vifc_vifi, 0);
957 }
958 rtnl_unlock();
959 return ret;
960
961
962
963
964
965 case MRT_ADD_MFC:
966 case MRT_DEL_MFC:
967 if (optlen!=sizeof(mfc))
968 return -EINVAL;
969 if (copy_from_user(&mfc,optval, sizeof(mfc)))
970 return -EFAULT;
971 rtnl_lock();
972 if (optname==MRT_DEL_MFC)
973 ret = ipmr_mfc_delete(&mfc);
974 else
975 ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
976 rtnl_unlock();
977 return ret;
978
979
980
981 case MRT_ASSERT:
982 {
983 int v;
984 if (get_user(v,(int __user *)optval))
985 return -EFAULT;
986 mroute_do_assert=(v)?1:0;
987 return 0;
988 }
989#ifdef CONFIG_IP_PIMSM
990 case MRT_PIM:
991 {
992 int v;
993
994 if (get_user(v,(int __user *)optval))
995 return -EFAULT;
996 v = (v) ? 1 : 0;
997
998 rtnl_lock();
999 ret = 0;
1000 if (v != mroute_do_pim) {
1001 mroute_do_pim = v;
1002 mroute_do_assert = v;
1003#ifdef CONFIG_IP_PIMSM_V2
1004 if (mroute_do_pim)
1005 ret = inet_add_protocol(&pim_protocol,
1006 IPPROTO_PIM);
1007 else
1008 ret = inet_del_protocol(&pim_protocol,
1009 IPPROTO_PIM);
1010 if (ret < 0)
1011 ret = -EAGAIN;
1012#endif
1013 }
1014 rtnl_unlock();
1015 return ret;
1016 }
1017#endif
1018
1019
1020
1021
1022 default:
1023 return -ENOPROTOOPT;
1024 }
1025}
1026
1027
1028
1029
1030
1031int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
1032{
1033 int olr;
1034 int val;
1035
1036 if (optname!=MRT_VERSION &&
1037#ifdef CONFIG_IP_PIMSM
1038 optname!=MRT_PIM &&
1039#endif
1040 optname!=MRT_ASSERT)
1041 return -ENOPROTOOPT;
1042
1043 if (get_user(olr, optlen))
1044 return -EFAULT;
1045
1046 olr = min_t(unsigned int, olr, sizeof(int));
1047 if (olr < 0)
1048 return -EINVAL;
1049
1050 if (put_user(olr,optlen))
1051 return -EFAULT;
1052 if (optname==MRT_VERSION)
1053 val=0x0305;
1054#ifdef CONFIG_IP_PIMSM
1055 else if (optname==MRT_PIM)
1056 val=mroute_do_pim;
1057#endif
1058 else
1059 val=mroute_do_assert;
1060 if (copy_to_user(optval,&val,olr))
1061 return -EFAULT;
1062 return 0;
1063}
1064
1065
1066
1067
1068
1069int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1070{
1071 struct sioc_sg_req sr;
1072 struct sioc_vif_req vr;
1073 struct vif_device *vif;
1074 struct mfc_cache *c;
1075
1076 switch (cmd) {
1077 case SIOCGETVIFCNT:
1078 if (copy_from_user(&vr,arg,sizeof(vr)))
1079 return -EFAULT;
1080 if (vr.vifi>=maxvif)
1081 return -EINVAL;
1082 read_lock(&mrt_lock);
1083 vif=&vif_table[vr.vifi];
1084 if (VIF_EXISTS(vr.vifi)) {
1085 vr.icount=vif->pkt_in;
1086 vr.ocount=vif->pkt_out;
1087 vr.ibytes=vif->bytes_in;
1088 vr.obytes=vif->bytes_out;
1089 read_unlock(&mrt_lock);
1090
1091 if (copy_to_user(arg,&vr,sizeof(vr)))
1092 return -EFAULT;
1093 return 0;
1094 }
1095 read_unlock(&mrt_lock);
1096 return -EADDRNOTAVAIL;
1097 case SIOCGETSGCNT:
1098 if (copy_from_user(&sr,arg,sizeof(sr)))
1099 return -EFAULT;
1100
1101 read_lock(&mrt_lock);
1102 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1103 if (c) {
1104 sr.pktcnt = c->mfc_un.res.pkt;
1105 sr.bytecnt = c->mfc_un.res.bytes;
1106 sr.wrong_if = c->mfc_un.res.wrong_if;
1107 read_unlock(&mrt_lock);
1108
1109 if (copy_to_user(arg,&sr,sizeof(sr)))
1110 return -EFAULT;
1111 return 0;
1112 }
1113 read_unlock(&mrt_lock);
1114 return -EADDRNOTAVAIL;
1115 default:
1116 return -ENOIOCTLCMD;
1117 }
1118}
1119
1120
1121static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1122{
1123 struct net_device *dev = ptr;
1124 struct vif_device *v;
1125 int ct;
1126
1127 if (!net_eq(dev_net(dev), &init_net))
1128 return NOTIFY_DONE;
1129
1130 if (event != NETDEV_UNREGISTER)
1131 return NOTIFY_DONE;
1132 v=&vif_table[0];
1133 for (ct=0;ct<maxvif;ct++,v++) {
1134 if (v->dev==dev)
1135 vif_delete(ct, 1);
1136 }
1137 return NOTIFY_DONE;
1138}
1139
1140
1141static struct notifier_block ip_mr_notifier={
1142 .notifier_call = ipmr_device_event,
1143};
1144
1145
1146
1147
1148
1149
1150
1151static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1152{
1153 struct iphdr *iph;
1154 struct iphdr *old_iph = ip_hdr(skb);
1155
1156 skb_push(skb, sizeof(struct iphdr));
1157 skb->transport_header = skb->network_header;
1158 skb_reset_network_header(skb);
1159 iph = ip_hdr(skb);
1160
1161 iph->version = 4;
1162 iph->tos = old_iph->tos;
1163 iph->ttl = old_iph->ttl;
1164 iph->frag_off = 0;
1165 iph->daddr = daddr;
1166 iph->saddr = saddr;
1167 iph->protocol = IPPROTO_IPIP;
1168 iph->ihl = 5;
1169 iph->tot_len = htons(skb->len);
1170 ip_select_ident(iph, skb->dst, NULL);
1171 ip_send_check(iph);
1172
1173 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1174 nf_reset(skb);
1175}
1176
1177static inline int ipmr_forward_finish(struct sk_buff *skb)
1178{
1179 struct ip_options * opt = &(IPCB(skb)->opt);
1180
1181 IP_INC_STATS_BH(dev_net(skb->dst->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
1182
1183 if (unlikely(opt->optlen))
1184 ip_forward_options(skb);
1185
1186 return dst_output(skb);
1187}
1188
1189
1190
1191
1192
1193static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1194{
1195 const struct iphdr *iph = ip_hdr(skb);
1196 struct vif_device *vif = &vif_table[vifi];
1197 struct net_device *dev;
1198 struct rtable *rt;
1199 int encap = 0;
1200
1201 if (vif->dev == NULL)
1202 goto out_free;
1203
1204#ifdef CONFIG_IP_PIMSM
1205 if (vif->flags & VIFF_REGISTER) {
1206 vif->pkt_out++;
1207 vif->bytes_out+=skb->len;
1208 vif->dev->stats.tx_bytes += skb->len;
1209 vif->dev->stats.tx_packets++;
1210 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1211 kfree_skb(skb);
1212 return;
1213 }
1214#endif
1215
1216 if (vif->flags&VIFF_TUNNEL) {
1217 struct flowi fl = { .oif = vif->link,
1218 .nl_u = { .ip4_u =
1219 { .daddr = vif->remote,
1220 .saddr = vif->local,
1221 .tos = RT_TOS(iph->tos) } },
1222 .proto = IPPROTO_IPIP };
1223 if (ip_route_output_key(&init_net, &rt, &fl))
1224 goto out_free;
1225 encap = sizeof(struct iphdr);
1226 } else {
1227 struct flowi fl = { .oif = vif->link,
1228 .nl_u = { .ip4_u =
1229 { .daddr = iph->daddr,
1230 .tos = RT_TOS(iph->tos) } },
1231 .proto = IPPROTO_IPIP };
1232 if (ip_route_output_key(&init_net, &rt, &fl))
1233 goto out_free;
1234 }
1235
1236 dev = rt->u.dst.dev;
1237
1238 if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1239
1240
1241
1242
1243
1244 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
1245 ip_rt_put(rt);
1246 goto out_free;
1247 }
1248
1249 encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1250
1251 if (skb_cow(skb, encap)) {
1252 ip_rt_put(rt);
1253 goto out_free;
1254 }
1255
1256 vif->pkt_out++;
1257 vif->bytes_out+=skb->len;
1258
1259 dst_release(skb->dst);
1260 skb->dst = &rt->u.dst;
1261 ip_decrease_ttl(ip_hdr(skb));
1262
1263
1264
1265 if (vif->flags & VIFF_TUNNEL) {
1266 ip_encap(skb, vif->local, vif->remote);
1267
1268 vif->dev->stats.tx_packets++;
1269 vif->dev->stats.tx_bytes += skb->len;
1270 }
1271
1272 IPCB(skb)->flags |= IPSKB_FORWARDED;
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285 NF_HOOK(PF_INET, NF_INET_FORWARD, skb, skb->dev, dev,
1286 ipmr_forward_finish);
1287 return;
1288
1289out_free:
1290 kfree_skb(skb);
1291 return;
1292}
1293
1294static int ipmr_find_vif(struct net_device *dev)
1295{
1296 int ct;
1297 for (ct=maxvif-1; ct>=0; ct--) {
1298 if (vif_table[ct].dev == dev)
1299 break;
1300 }
1301 return ct;
1302}
1303
1304
1305
1306static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1307{
1308 int psend = -1;
1309 int vif, ct;
1310
1311 vif = cache->mfc_parent;
1312 cache->mfc_un.res.pkt++;
1313 cache->mfc_un.res.bytes += skb->len;
1314
1315
1316
1317
1318 if (vif_table[vif].dev != skb->dev) {
1319 int true_vifi;
1320
1321 if (skb->rtable->fl.iif == 0) {
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333 goto dont_forward;
1334 }
1335
1336 cache->mfc_un.res.wrong_if++;
1337 true_vifi = ipmr_find_vif(skb->dev);
1338
1339 if (true_vifi >= 0 && mroute_do_assert &&
1340
1341
1342
1343
1344
1345 (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1346 time_after(jiffies,
1347 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1348 cache->mfc_un.res.last_assert = jiffies;
1349 ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1350 }
1351 goto dont_forward;
1352 }
1353
1354 vif_table[vif].pkt_in++;
1355 vif_table[vif].bytes_in+=skb->len;
1356
1357
1358
1359
1360 for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1361 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1362 if (psend != -1) {
1363 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1364 if (skb2)
1365 ipmr_queue_xmit(skb2, cache, psend);
1366 }
1367 psend=ct;
1368 }
1369 }
1370 if (psend != -1) {
1371 if (local) {
1372 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1373 if (skb2)
1374 ipmr_queue_xmit(skb2, cache, psend);
1375 } else {
1376 ipmr_queue_xmit(skb, cache, psend);
1377 return 0;
1378 }
1379 }
1380
1381dont_forward:
1382 if (!local)
1383 kfree_skb(skb);
1384 return 0;
1385}
1386
1387
1388
1389
1390
1391
1392int ip_mr_input(struct sk_buff *skb)
1393{
1394 struct mfc_cache *cache;
1395 int local = skb->rtable->rt_flags&RTCF_LOCAL;
1396
1397
1398
1399
1400 if (IPCB(skb)->flags&IPSKB_FORWARDED)
1401 goto dont_forward;
1402
1403 if (!local) {
1404 if (IPCB(skb)->opt.router_alert) {
1405 if (ip_call_ra_chain(skb))
1406 return 0;
1407 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1408
1409
1410
1411
1412
1413
1414 read_lock(&mrt_lock);
1415 if (mroute_socket) {
1416 nf_reset(skb);
1417 raw_rcv(mroute_socket, skb);
1418 read_unlock(&mrt_lock);
1419 return 0;
1420 }
1421 read_unlock(&mrt_lock);
1422 }
1423 }
1424
1425 read_lock(&mrt_lock);
1426 cache = ipmr_cache_find(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1427
1428
1429
1430
1431 if (cache==NULL) {
1432 int vif;
1433
1434 if (local) {
1435 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1436 ip_local_deliver(skb);
1437 if (skb2 == NULL) {
1438 read_unlock(&mrt_lock);
1439 return -ENOBUFS;
1440 }
1441 skb = skb2;
1442 }
1443
1444 vif = ipmr_find_vif(skb->dev);
1445 if (vif >= 0) {
1446 int err = ipmr_cache_unresolved(vif, skb);
1447 read_unlock(&mrt_lock);
1448
1449 return err;
1450 }
1451 read_unlock(&mrt_lock);
1452 kfree_skb(skb);
1453 return -ENODEV;
1454 }
1455
1456 ip_mr_forward(skb, cache, local);
1457
1458 read_unlock(&mrt_lock);
1459
1460 if (local)
1461 return ip_local_deliver(skb);
1462
1463 return 0;
1464
1465dont_forward:
1466 if (local)
1467 return ip_local_deliver(skb);
1468 kfree_skb(skb);
1469 return 0;
1470}
1471
1472#ifdef CONFIG_IP_PIMSM_V1
1473
1474
1475
1476
1477int pim_rcv_v1(struct sk_buff * skb)
1478{
1479 struct igmphdr *pim;
1480 struct iphdr *encap;
1481 struct net_device *reg_dev = NULL;
1482
1483 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1484 goto drop;
1485
1486 pim = igmp_hdr(skb);
1487
1488 if (!mroute_do_pim ||
1489 skb->len < sizeof(*pim) + sizeof(*encap) ||
1490 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1491 goto drop;
1492
1493 encap = (struct iphdr *)(skb_transport_header(skb) +
1494 sizeof(struct igmphdr));
1495
1496
1497
1498
1499
1500
1501 if (!ipv4_is_multicast(encap->daddr) ||
1502 encap->tot_len == 0 ||
1503 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1504 goto drop;
1505
1506 read_lock(&mrt_lock);
1507 if (reg_vif_num >= 0)
1508 reg_dev = vif_table[reg_vif_num].dev;
1509 if (reg_dev)
1510 dev_hold(reg_dev);
1511 read_unlock(&mrt_lock);
1512
1513 if (reg_dev == NULL)
1514 goto drop;
1515
1516 skb->mac_header = skb->network_header;
1517 skb_pull(skb, (u8*)encap - skb->data);
1518 skb_reset_network_header(skb);
1519 skb->dev = reg_dev;
1520 skb->protocol = htons(ETH_P_IP);
1521 skb->ip_summed = 0;
1522 skb->pkt_type = PACKET_HOST;
1523 dst_release(skb->dst);
1524 skb->dst = NULL;
1525 reg_dev->stats.rx_bytes += skb->len;
1526 reg_dev->stats.rx_packets++;
1527 nf_reset(skb);
1528 netif_rx(skb);
1529 dev_put(reg_dev);
1530 return 0;
1531 drop:
1532 kfree_skb(skb);
1533 return 0;
1534}
1535#endif
1536
1537#ifdef CONFIG_IP_PIMSM_V2
1538static int pim_rcv(struct sk_buff * skb)
1539{
1540 struct pimreghdr *pim;
1541 struct iphdr *encap;
1542 struct net_device *reg_dev = NULL;
1543
1544 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1545 goto drop;
1546
1547 pim = (struct pimreghdr *)skb_transport_header(skb);
1548 if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1549 (pim->flags&PIM_NULL_REGISTER) ||
1550 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1551 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1552 goto drop;
1553
1554
1555 encap = (struct iphdr *)(skb_transport_header(skb) +
1556 sizeof(struct pimreghdr));
1557 if (!ipv4_is_multicast(encap->daddr) ||
1558 encap->tot_len == 0 ||
1559 ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1560 goto drop;
1561
1562 read_lock(&mrt_lock);
1563 if (reg_vif_num >= 0)
1564 reg_dev = vif_table[reg_vif_num].dev;
1565 if (reg_dev)
1566 dev_hold(reg_dev);
1567 read_unlock(&mrt_lock);
1568
1569 if (reg_dev == NULL)
1570 goto drop;
1571
1572 skb->mac_header = skb->network_header;
1573 skb_pull(skb, (u8*)encap - skb->data);
1574 skb_reset_network_header(skb);
1575 skb->dev = reg_dev;
1576 skb->protocol = htons(ETH_P_IP);
1577 skb->ip_summed = 0;
1578 skb->pkt_type = PACKET_HOST;
1579 dst_release(skb->dst);
1580 reg_dev->stats.rx_bytes += skb->len;
1581 reg_dev->stats.rx_packets++;
1582 skb->dst = NULL;
1583 nf_reset(skb);
1584 netif_rx(skb);
1585 dev_put(reg_dev);
1586 return 0;
1587 drop:
1588 kfree_skb(skb);
1589 return 0;
1590}
1591#endif
1592
1593static int
1594ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1595{
1596 int ct;
1597 struct rtnexthop *nhp;
1598 struct net_device *dev = vif_table[c->mfc_parent].dev;
1599 u8 *b = skb_tail_pointer(skb);
1600 struct rtattr *mp_head;
1601
1602 if (dev)
1603 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1604
1605 mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1606
1607 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1608 if (c->mfc_un.res.ttls[ct] < 255) {
1609 if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1610 goto rtattr_failure;
1611 nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1612 nhp->rtnh_flags = 0;
1613 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1614 nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1615 nhp->rtnh_len = sizeof(*nhp);
1616 }
1617 }
1618 mp_head->rta_type = RTA_MULTIPATH;
1619 mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1620 rtm->rtm_type = RTN_MULTICAST;
1621 return 1;
1622
1623rtattr_failure:
1624 nlmsg_trim(skb, b);
1625 return -EMSGSIZE;
1626}
1627
1628int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1629{
1630 int err;
1631 struct mfc_cache *cache;
1632 struct rtable *rt = skb->rtable;
1633
1634 read_lock(&mrt_lock);
1635 cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1636
1637 if (cache==NULL) {
1638 struct sk_buff *skb2;
1639 struct iphdr *iph;
1640 struct net_device *dev;
1641 int vif;
1642
1643 if (nowait) {
1644 read_unlock(&mrt_lock);
1645 return -EAGAIN;
1646 }
1647
1648 dev = skb->dev;
1649 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1650 read_unlock(&mrt_lock);
1651 return -ENODEV;
1652 }
1653 skb2 = skb_clone(skb, GFP_ATOMIC);
1654 if (!skb2) {
1655 read_unlock(&mrt_lock);
1656 return -ENOMEM;
1657 }
1658
1659 skb_push(skb2, sizeof(struct iphdr));
1660 skb_reset_network_header(skb2);
1661 iph = ip_hdr(skb2);
1662 iph->ihl = sizeof(struct iphdr) >> 2;
1663 iph->saddr = rt->rt_src;
1664 iph->daddr = rt->rt_dst;
1665 iph->version = 0;
1666 err = ipmr_cache_unresolved(vif, skb2);
1667 read_unlock(&mrt_lock);
1668 return err;
1669 }
1670
1671 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1672 cache->mfc_flags |= MFC_NOTIFY;
1673 err = ipmr_fill_mroute(skb, cache, rtm);
1674 read_unlock(&mrt_lock);
1675 return err;
1676}
1677
1678#ifdef CONFIG_PROC_FS
1679
1680
1681
1682struct ipmr_vif_iter {
1683 int ct;
1684};
1685
1686static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1687 loff_t pos)
1688{
1689 for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
1690 if (!VIF_EXISTS(iter->ct))
1691 continue;
1692 if (pos-- == 0)
1693 return &vif_table[iter->ct];
1694 }
1695 return NULL;
1696}
1697
1698static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1699 __acquires(mrt_lock)
1700{
1701 read_lock(&mrt_lock);
1702 return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
1703 : SEQ_START_TOKEN;
1704}
1705
1706static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1707{
1708 struct ipmr_vif_iter *iter = seq->private;
1709
1710 ++*pos;
1711 if (v == SEQ_START_TOKEN)
1712 return ipmr_vif_seq_idx(iter, 0);
1713
1714 while (++iter->ct < maxvif) {
1715 if (!VIF_EXISTS(iter->ct))
1716 continue;
1717 return &vif_table[iter->ct];
1718 }
1719 return NULL;
1720}
1721
1722static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1723 __releases(mrt_lock)
1724{
1725 read_unlock(&mrt_lock);
1726}
1727
1728static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1729{
1730 if (v == SEQ_START_TOKEN) {
1731 seq_puts(seq,
1732 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
1733 } else {
1734 const struct vif_device *vif = v;
1735 const char *name = vif->dev ? vif->dev->name : "none";
1736
1737 seq_printf(seq,
1738 "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
1739 vif - vif_table,
1740 name, vif->bytes_in, vif->pkt_in,
1741 vif->bytes_out, vif->pkt_out,
1742 vif->flags, vif->local, vif->remote);
1743 }
1744 return 0;
1745}
1746
1747static const struct seq_operations ipmr_vif_seq_ops = {
1748 .start = ipmr_vif_seq_start,
1749 .next = ipmr_vif_seq_next,
1750 .stop = ipmr_vif_seq_stop,
1751 .show = ipmr_vif_seq_show,
1752};
1753
1754static int ipmr_vif_open(struct inode *inode, struct file *file)
1755{
1756 return seq_open_private(file, &ipmr_vif_seq_ops,
1757 sizeof(struct ipmr_vif_iter));
1758}
1759
1760static const struct file_operations ipmr_vif_fops = {
1761 .owner = THIS_MODULE,
1762 .open = ipmr_vif_open,
1763 .read = seq_read,
1764 .llseek = seq_lseek,
1765 .release = seq_release_private,
1766};
1767
1768struct ipmr_mfc_iter {
1769 struct mfc_cache **cache;
1770 int ct;
1771};
1772
1773
1774static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1775{
1776 struct mfc_cache *mfc;
1777
1778 it->cache = mfc_cache_array;
1779 read_lock(&mrt_lock);
1780 for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1781 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
1782 if (pos-- == 0)
1783 return mfc;
1784 read_unlock(&mrt_lock);
1785
1786 it->cache = &mfc_unres_queue;
1787 spin_lock_bh(&mfc_unres_lock);
1788 for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1789 if (pos-- == 0)
1790 return mfc;
1791 spin_unlock_bh(&mfc_unres_lock);
1792
1793 it->cache = NULL;
1794 return NULL;
1795}
1796
1797
1798static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1799{
1800 struct ipmr_mfc_iter *it = seq->private;
1801 it->cache = NULL;
1802 it->ct = 0;
1803 return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
1804 : SEQ_START_TOKEN;
1805}
1806
1807static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1808{
1809 struct mfc_cache *mfc = v;
1810 struct ipmr_mfc_iter *it = seq->private;
1811
1812 ++*pos;
1813
1814 if (v == SEQ_START_TOKEN)
1815 return ipmr_mfc_seq_idx(seq->private, 0);
1816
1817 if (mfc->next)
1818 return mfc->next;
1819
1820 if (it->cache == &mfc_unres_queue)
1821 goto end_of_list;
1822
1823 BUG_ON(it->cache != mfc_cache_array);
1824
1825 while (++it->ct < MFC_LINES) {
1826 mfc = mfc_cache_array[it->ct];
1827 if (mfc)
1828 return mfc;
1829 }
1830
1831
1832 read_unlock(&mrt_lock);
1833 it->cache = &mfc_unres_queue;
1834 it->ct = 0;
1835
1836 spin_lock_bh(&mfc_unres_lock);
1837 mfc = mfc_unres_queue;
1838 if (mfc)
1839 return mfc;
1840
1841 end_of_list:
1842 spin_unlock_bh(&mfc_unres_lock);
1843 it->cache = NULL;
1844
1845 return NULL;
1846}
1847
1848static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1849{
1850 struct ipmr_mfc_iter *it = seq->private;
1851
1852 if (it->cache == &mfc_unres_queue)
1853 spin_unlock_bh(&mfc_unres_lock);
1854 else if (it->cache == mfc_cache_array)
1855 read_unlock(&mrt_lock);
1856}
1857
1858static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1859{
1860 int n;
1861
1862 if (v == SEQ_START_TOKEN) {
1863 seq_puts(seq,
1864 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
1865 } else {
1866 const struct mfc_cache *mfc = v;
1867 const struct ipmr_mfc_iter *it = seq->private;
1868
1869 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1870 (unsigned long) mfc->mfc_mcastgrp,
1871 (unsigned long) mfc->mfc_origin,
1872 mfc->mfc_parent,
1873 mfc->mfc_un.res.pkt,
1874 mfc->mfc_un.res.bytes,
1875 mfc->mfc_un.res.wrong_if);
1876
1877 if (it->cache != &mfc_unres_queue) {
1878 for (n = mfc->mfc_un.res.minvif;
1879 n < mfc->mfc_un.res.maxvif; n++ ) {
1880 if (VIF_EXISTS(n)
1881 && mfc->mfc_un.res.ttls[n] < 255)
1882 seq_printf(seq,
1883 " %2d:%-3d",
1884 n, mfc->mfc_un.res.ttls[n]);
1885 }
1886 }
1887 seq_putc(seq, '\n');
1888 }
1889 return 0;
1890}
1891
1892static const struct seq_operations ipmr_mfc_seq_ops = {
1893 .start = ipmr_mfc_seq_start,
1894 .next = ipmr_mfc_seq_next,
1895 .stop = ipmr_mfc_seq_stop,
1896 .show = ipmr_mfc_seq_show,
1897};
1898
1899static int ipmr_mfc_open(struct inode *inode, struct file *file)
1900{
1901 return seq_open_private(file, &ipmr_mfc_seq_ops,
1902 sizeof(struct ipmr_mfc_iter));
1903}
1904
1905static const struct file_operations ipmr_mfc_fops = {
1906 .owner = THIS_MODULE,
1907 .open = ipmr_mfc_open,
1908 .read = seq_read,
1909 .llseek = seq_lseek,
1910 .release = seq_release_private,
1911};
1912#endif
1913
1914#ifdef CONFIG_IP_PIMSM_V2
1915static struct net_protocol pim_protocol = {
1916 .handler = pim_rcv,
1917};
1918#endif
1919
1920
1921
1922
1923
1924
1925int __init ip_mr_init(void)
1926{
1927 int err;
1928
1929 mrt_cachep = kmem_cache_create("ip_mrt_cache",
1930 sizeof(struct mfc_cache),
1931 0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1932 NULL);
1933 if (!mrt_cachep)
1934 return -ENOMEM;
1935
1936 setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
1937 err = register_netdevice_notifier(&ip_mr_notifier);
1938 if (err)
1939 goto reg_notif_fail;
1940#ifdef CONFIG_PROC_FS
1941 err = -ENOMEM;
1942 if (!proc_net_fops_create(&init_net, "ip_mr_vif", 0, &ipmr_vif_fops))
1943 goto proc_vif_fail;
1944 if (!proc_net_fops_create(&init_net, "ip_mr_cache", 0, &ipmr_mfc_fops))
1945 goto proc_cache_fail;
1946#endif
1947 return 0;
1948#ifdef CONFIG_PROC_FS
1949proc_cache_fail:
1950 proc_net_remove(&init_net, "ip_mr_vif");
1951proc_vif_fail:
1952 unregister_netdevice_notifier(&ip_mr_notifier);
1953#endif
1954reg_notif_fail:
1955 del_timer(&ipmr_expire_timer);
1956 kmem_cache_destroy(mrt_cachep);
1957 return err;
1958}