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