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