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