1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <asm/uaccess.h>
20#include <linux/types.h>
21#include <linux/sched.h>
22#include <linux/errno.h>
23#include <linux/timer.h>
24#include <linux/mm.h>
25#include <linux/kernel.h>
26#include <linux/fcntl.h>
27#include <linux/stat.h>
28#include <linux/socket.h>
29#include <linux/inet.h>
30#include <linux/netdevice.h>
31#include <linux/inetdevice.h>
32#include <linux/proc_fs.h>
33#include <linux/seq_file.h>
34#include <linux/init.h>
35#include <linux/slab.h>
36#include <linux/compat.h>
37#include <net/protocol.h>
38#include <linux/skbuff.h>
39#include <net/sock.h>
40#include <net/raw.h>
41#include <linux/notifier.h>
42#include <linux/if_arp.h>
43#include <net/checksum.h>
44#include <net/netlink.h>
45#include <net/fib_rules.h>
46
47#include <net/ipv6.h>
48#include <net/ip6_route.h>
49#include <linux/mroute6.h>
50#include <linux/pim.h>
51#include <net/addrconf.h>
52#include <linux/netfilter_ipv6.h>
53#include <linux/export.h>
54#include <net/ip6_checksum.h>
55#include <linux/netconf.h>
56
57struct mr6_table {
58 struct list_head list;
59#ifdef CONFIG_NET_NS
60 struct net *net;
61#endif
62 u32 id;
63 struct sock *mroute6_sk;
64 struct timer_list ipmr_expire_timer;
65 struct list_head mfc6_unres_queue;
66 struct list_head mfc6_cache_array[MFC6_LINES];
67 struct mif_device vif6_table[MAXMIFS];
68 int maxvif;
69 atomic_t cache_resolve_queue_len;
70 bool mroute_do_assert;
71 bool mroute_do_pim;
72#ifdef CONFIG_IPV6_PIMSM_V2
73 int mroute_reg_vif_num;
74#endif
75};
76
77struct ip6mr_rule {
78 struct fib_rule common;
79};
80
81struct ip6mr_result {
82 struct mr6_table *mrt;
83};
84
85
86
87
88
89static DEFINE_RWLOCK(mrt_lock);
90
91
92
93
94
95#define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
96
97
98static DEFINE_SPINLOCK(mfc_unres_lock);
99
100
101
102
103
104
105
106
107
108static struct kmem_cache *mrt_cachep __read_mostly;
109
110static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
111static void ip6mr_free_table(struct mr6_table *mrt);
112
113static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
114 struct sk_buff *skb, struct mfc6_cache *cache);
115static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
116 mifi_t mifi, int assert);
117static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
118 struct mfc6_cache *c, struct rtmsg *rtm);
119static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
120 int cmd);
121static int ip6mr_rtm_dumproute(struct sk_buff *skb,
122 struct netlink_callback *cb);
123static void mroute_clean_tables(struct mr6_table *mrt);
124static void ipmr_expire_process(unsigned long arg);
125
126#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
127#define ip6mr_for_each_table(mrt, net) \
128 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
129
130static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
131{
132 struct mr6_table *mrt;
133
134 ip6mr_for_each_table(mrt, net) {
135 if (mrt->id == id)
136 return mrt;
137 }
138 return NULL;
139}
140
141static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
142 struct mr6_table **mrt)
143{
144 int err;
145 struct ip6mr_result res;
146 struct fib_lookup_arg arg = {
147 .result = &res,
148 .flags = FIB_LOOKUP_NOREF,
149 };
150
151 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
152 flowi6_to_flowi(flp6), 0, &arg);
153 if (err < 0)
154 return err;
155 *mrt = res.mrt;
156 return 0;
157}
158
159static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
160 int flags, struct fib_lookup_arg *arg)
161{
162 struct ip6mr_result *res = arg->result;
163 struct mr6_table *mrt;
164
165 switch (rule->action) {
166 case FR_ACT_TO_TBL:
167 break;
168 case FR_ACT_UNREACHABLE:
169 return -ENETUNREACH;
170 case FR_ACT_PROHIBIT:
171 return -EACCES;
172 case FR_ACT_BLACKHOLE:
173 default:
174 return -EINVAL;
175 }
176
177 mrt = ip6mr_get_table(rule->fr_net, rule->table);
178 if (mrt == NULL)
179 return -EAGAIN;
180 res->mrt = mrt;
181 return 0;
182}
183
184static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
185{
186 return 1;
187}
188
189static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
190 FRA_GENERIC_POLICY,
191};
192
193static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
194 struct fib_rule_hdr *frh, struct nlattr **tb)
195{
196 return 0;
197}
198
199static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
200 struct nlattr **tb)
201{
202 return 1;
203}
204
205static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
206 struct fib_rule_hdr *frh)
207{
208 frh->dst_len = 0;
209 frh->src_len = 0;
210 frh->tos = 0;
211 return 0;
212}
213
214static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
215 .family = RTNL_FAMILY_IP6MR,
216 .rule_size = sizeof(struct ip6mr_rule),
217 .addr_size = sizeof(struct in6_addr),
218 .action = ip6mr_rule_action,
219 .match = ip6mr_rule_match,
220 .configure = ip6mr_rule_configure,
221 .compare = ip6mr_rule_compare,
222 .default_pref = fib_default_rule_pref,
223 .fill = ip6mr_rule_fill,
224 .nlgroup = RTNLGRP_IPV6_RULE,
225 .policy = ip6mr_rule_policy,
226 .owner = THIS_MODULE,
227};
228
229static int __net_init ip6mr_rules_init(struct net *net)
230{
231 struct fib_rules_ops *ops;
232 struct mr6_table *mrt;
233 int err;
234
235 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
236 if (IS_ERR(ops))
237 return PTR_ERR(ops);
238
239 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
240
241 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
242 if (mrt == NULL) {
243 err = -ENOMEM;
244 goto err1;
245 }
246
247 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
248 if (err < 0)
249 goto err2;
250
251 net->ipv6.mr6_rules_ops = ops;
252 return 0;
253
254err2:
255 kfree(mrt);
256err1:
257 fib_rules_unregister(ops);
258 return err;
259}
260
261static void __net_exit ip6mr_rules_exit(struct net *net)
262{
263 struct mr6_table *mrt, *next;
264
265 rtnl_lock();
266 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
267 list_del(&mrt->list);
268 ip6mr_free_table(mrt);
269 }
270 rtnl_unlock();
271 fib_rules_unregister(net->ipv6.mr6_rules_ops);
272}
273#else
274#define ip6mr_for_each_table(mrt, net) \
275 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
276
277static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
278{
279 return net->ipv6.mrt6;
280}
281
282static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
283 struct mr6_table **mrt)
284{
285 *mrt = net->ipv6.mrt6;
286 return 0;
287}
288
289static int __net_init ip6mr_rules_init(struct net *net)
290{
291 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
292 return net->ipv6.mrt6 ? 0 : -ENOMEM;
293}
294
295static void __net_exit ip6mr_rules_exit(struct net *net)
296{
297 rtnl_lock();
298 ip6mr_free_table(net->ipv6.mrt6);
299 net->ipv6.mrt6 = NULL;
300 rtnl_unlock();
301}
302#endif
303
304static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
305{
306 struct mr6_table *mrt;
307 unsigned int i;
308
309 mrt = ip6mr_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 mrt->id = id;
317 write_pnet(&mrt->net, net);
318
319
320 for (i = 0; i < MFC6_LINES; i++)
321 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
322
323 INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
324
325 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
326 (unsigned long)mrt);
327
328#ifdef CONFIG_IPV6_PIMSM_V2
329 mrt->mroute_reg_vif_num = -1;
330#endif
331#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
332 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
333#endif
334 return mrt;
335}
336
337static void ip6mr_free_table(struct mr6_table *mrt)
338{
339 del_timer(&mrt->ipmr_expire_timer);
340 mroute_clean_tables(mrt);
341 kfree(mrt);
342}
343
344#ifdef CONFIG_PROC_FS
345
346struct ipmr_mfc_iter {
347 struct seq_net_private p;
348 struct mr6_table *mrt;
349 struct list_head *cache;
350 int ct;
351};
352
353
354static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
355 struct ipmr_mfc_iter *it, loff_t pos)
356{
357 struct mr6_table *mrt = it->mrt;
358 struct mfc6_cache *mfc;
359
360 read_lock(&mrt_lock);
361 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
362 it->cache = &mrt->mfc6_cache_array[it->ct];
363 list_for_each_entry(mfc, it->cache, list)
364 if (pos-- == 0)
365 return mfc;
366 }
367 read_unlock(&mrt_lock);
368
369 spin_lock_bh(&mfc_unres_lock);
370 it->cache = &mrt->mfc6_unres_queue;
371 list_for_each_entry(mfc, it->cache, list)
372 if (pos-- == 0)
373 return mfc;
374 spin_unlock_bh(&mfc_unres_lock);
375
376 it->cache = NULL;
377 return NULL;
378}
379
380
381
382
383
384struct ipmr_vif_iter {
385 struct seq_net_private p;
386 struct mr6_table *mrt;
387 int ct;
388};
389
390static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
391 struct ipmr_vif_iter *iter,
392 loff_t pos)
393{
394 struct mr6_table *mrt = iter->mrt;
395
396 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
397 if (!MIF_EXISTS(mrt, iter->ct))
398 continue;
399 if (pos-- == 0)
400 return &mrt->vif6_table[iter->ct];
401 }
402 return NULL;
403}
404
405static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
406 __acquires(mrt_lock)
407{
408 struct ipmr_vif_iter *iter = seq->private;
409 struct net *net = seq_file_net(seq);
410 struct mr6_table *mrt;
411
412 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
413 if (mrt == NULL)
414 return ERR_PTR(-ENOENT);
415
416 iter->mrt = mrt;
417
418 read_lock(&mrt_lock);
419 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
420 : SEQ_START_TOKEN;
421}
422
423static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
424{
425 struct ipmr_vif_iter *iter = seq->private;
426 struct net *net = seq_file_net(seq);
427 struct mr6_table *mrt = iter->mrt;
428
429 ++*pos;
430 if (v == SEQ_START_TOKEN)
431 return ip6mr_vif_seq_idx(net, iter, 0);
432
433 while (++iter->ct < mrt->maxvif) {
434 if (!MIF_EXISTS(mrt, iter->ct))
435 continue;
436 return &mrt->vif6_table[iter->ct];
437 }
438 return NULL;
439}
440
441static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
442 __releases(mrt_lock)
443{
444 read_unlock(&mrt_lock);
445}
446
447static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
448{
449 struct ipmr_vif_iter *iter = seq->private;
450 struct mr6_table *mrt = iter->mrt;
451
452 if (v == SEQ_START_TOKEN) {
453 seq_puts(seq,
454 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
455 } else {
456 const struct mif_device *vif = v;
457 const char *name = vif->dev ? vif->dev->name : "none";
458
459 seq_printf(seq,
460 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
461 vif - mrt->vif6_table,
462 name, vif->bytes_in, vif->pkt_in,
463 vif->bytes_out, vif->pkt_out,
464 vif->flags);
465 }
466 return 0;
467}
468
469static const struct seq_operations ip6mr_vif_seq_ops = {
470 .start = ip6mr_vif_seq_start,
471 .next = ip6mr_vif_seq_next,
472 .stop = ip6mr_vif_seq_stop,
473 .show = ip6mr_vif_seq_show,
474};
475
476static int ip6mr_vif_open(struct inode *inode, struct file *file)
477{
478 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
479 sizeof(struct ipmr_vif_iter));
480}
481
482static const struct file_operations ip6mr_vif_fops = {
483 .owner = THIS_MODULE,
484 .open = ip6mr_vif_open,
485 .read = seq_read,
486 .llseek = seq_lseek,
487 .release = seq_release_net,
488};
489
490static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
491{
492 struct ipmr_mfc_iter *it = seq->private;
493 struct net *net = seq_file_net(seq);
494 struct mr6_table *mrt;
495
496 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
497 if (mrt == NULL)
498 return ERR_PTR(-ENOENT);
499
500 it->mrt = mrt;
501 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
502 : SEQ_START_TOKEN;
503}
504
505static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
506{
507 struct mfc6_cache *mfc = v;
508 struct ipmr_mfc_iter *it = seq->private;
509 struct net *net = seq_file_net(seq);
510 struct mr6_table *mrt = it->mrt;
511
512 ++*pos;
513
514 if (v == SEQ_START_TOKEN)
515 return ipmr_mfc_seq_idx(net, seq->private, 0);
516
517 if (mfc->list.next != it->cache)
518 return list_entry(mfc->list.next, struct mfc6_cache, list);
519
520 if (it->cache == &mrt->mfc6_unres_queue)
521 goto end_of_list;
522
523 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
524
525 while (++it->ct < MFC6_LINES) {
526 it->cache = &mrt->mfc6_cache_array[it->ct];
527 if (list_empty(it->cache))
528 continue;
529 return list_first_entry(it->cache, struct mfc6_cache, list);
530 }
531
532
533 read_unlock(&mrt_lock);
534 it->cache = &mrt->mfc6_unres_queue;
535 it->ct = 0;
536
537 spin_lock_bh(&mfc_unres_lock);
538 if (!list_empty(it->cache))
539 return list_first_entry(it->cache, struct mfc6_cache, list);
540
541 end_of_list:
542 spin_unlock_bh(&mfc_unres_lock);
543 it->cache = NULL;
544
545 return NULL;
546}
547
548static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
549{
550 struct ipmr_mfc_iter *it = seq->private;
551 struct mr6_table *mrt = it->mrt;
552
553 if (it->cache == &mrt->mfc6_unres_queue)
554 spin_unlock_bh(&mfc_unres_lock);
555 else if (it->cache == mrt->mfc6_cache_array)
556 read_unlock(&mrt_lock);
557}
558
559static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
560{
561 int n;
562
563 if (v == SEQ_START_TOKEN) {
564 seq_puts(seq,
565 "Group "
566 "Origin "
567 "Iif Pkts Bytes Wrong Oifs\n");
568 } else {
569 const struct mfc6_cache *mfc = v;
570 const struct ipmr_mfc_iter *it = seq->private;
571 struct mr6_table *mrt = it->mrt;
572
573 seq_printf(seq, "%pI6 %pI6 %-3hd",
574 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
575 mfc->mf6c_parent);
576
577 if (it->cache != &mrt->mfc6_unres_queue) {
578 seq_printf(seq, " %8lu %8lu %8lu",
579 mfc->mfc_un.res.pkt,
580 mfc->mfc_un.res.bytes,
581 mfc->mfc_un.res.wrong_if);
582 for (n = mfc->mfc_un.res.minvif;
583 n < mfc->mfc_un.res.maxvif; n++) {
584 if (MIF_EXISTS(mrt, n) &&
585 mfc->mfc_un.res.ttls[n] < 255)
586 seq_printf(seq,
587 " %2d:%-3d",
588 n, mfc->mfc_un.res.ttls[n]);
589 }
590 } else {
591
592
593
594 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
595 }
596 seq_putc(seq, '\n');
597 }
598 return 0;
599}
600
601static const struct seq_operations ipmr_mfc_seq_ops = {
602 .start = ipmr_mfc_seq_start,
603 .next = ipmr_mfc_seq_next,
604 .stop = ipmr_mfc_seq_stop,
605 .show = ipmr_mfc_seq_show,
606};
607
608static int ipmr_mfc_open(struct inode *inode, struct file *file)
609{
610 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
611 sizeof(struct ipmr_mfc_iter));
612}
613
614static const struct file_operations ip6mr_mfc_fops = {
615 .owner = THIS_MODULE,
616 .open = ipmr_mfc_open,
617 .read = seq_read,
618 .llseek = seq_lseek,
619 .release = seq_release_net,
620};
621#endif
622
623#ifdef CONFIG_IPV6_PIMSM_V2
624
625static int pim6_rcv(struct sk_buff *skb)
626{
627 struct pimreghdr *pim;
628 struct ipv6hdr *encap;
629 struct net_device *reg_dev = NULL;
630 struct net *net = dev_net(skb->dev);
631 struct mr6_table *mrt;
632 struct flowi6 fl6 = {
633 .flowi6_iif = skb->dev->ifindex,
634 .flowi6_mark = skb->mark,
635 };
636 int reg_vif_num;
637
638 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
639 goto drop;
640
641 pim = (struct pimreghdr *)skb_transport_header(skb);
642 if (pim->type != ((PIM_VERSION << 4) | PIM_REGISTER) ||
643 (pim->flags & PIM_NULL_REGISTER) ||
644 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
645 sizeof(*pim), IPPROTO_PIM,
646 csum_partial((void *)pim, sizeof(*pim), 0)) &&
647 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
648 goto drop;
649
650
651 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
652 sizeof(*pim));
653
654 if (!ipv6_addr_is_multicast(&encap->daddr) ||
655 encap->payload_len == 0 ||
656 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
657 goto drop;
658
659 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
660 goto drop;
661 reg_vif_num = mrt->mroute_reg_vif_num;
662
663 read_lock(&mrt_lock);
664 if (reg_vif_num >= 0)
665 reg_dev = mrt->vif6_table[reg_vif_num].dev;
666 if (reg_dev)
667 dev_hold(reg_dev);
668 read_unlock(&mrt_lock);
669
670 if (reg_dev == NULL)
671 goto drop;
672
673 skb->mac_header = skb->network_header;
674 skb_pull(skb, (u8 *)encap - skb->data);
675 skb_reset_network_header(skb);
676 skb->protocol = htons(ETH_P_IPV6);
677 skb->ip_summed = CHECKSUM_NONE;
678
679 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
680
681 netif_rx(skb);
682
683 dev_put(reg_dev);
684 return 0;
685 drop:
686 kfree_skb(skb);
687 return 0;
688}
689
690static const struct inet6_protocol pim6_protocol = {
691 .handler = pim6_rcv,
692};
693
694
695
696static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
697 struct net_device *dev)
698{
699 struct net *net = dev_net(dev);
700 struct mr6_table *mrt;
701 struct flowi6 fl6 = {
702 .flowi6_oif = dev->ifindex,
703 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
704 .flowi6_mark = skb->mark,
705 };
706 int err;
707
708 err = ip6mr_fib_lookup(net, &fl6, &mrt);
709 if (err < 0) {
710 kfree_skb(skb);
711 return err;
712 }
713
714 read_lock(&mrt_lock);
715 dev->stats.tx_bytes += skb->len;
716 dev->stats.tx_packets++;
717 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
718 read_unlock(&mrt_lock);
719 kfree_skb(skb);
720 return NETDEV_TX_OK;
721}
722
723static const struct net_device_ops reg_vif_netdev_ops = {
724 .ndo_start_xmit = reg_vif_xmit,
725};
726
727static void reg_vif_setup(struct net_device *dev)
728{
729 dev->type = ARPHRD_PIMREG;
730 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
731 dev->flags = IFF_NOARP;
732 dev->netdev_ops = ®_vif_netdev_ops;
733 dev->destructor = free_netdev;
734 dev->features |= NETIF_F_NETNS_LOCAL;
735}
736
737static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
738{
739 struct net_device *dev;
740 char name[IFNAMSIZ];
741
742 if (mrt->id == RT6_TABLE_DFLT)
743 sprintf(name, "pim6reg");
744 else
745 sprintf(name, "pim6reg%u", mrt->id);
746
747 dev = alloc_netdev(0, name, reg_vif_setup);
748 if (dev == NULL)
749 return NULL;
750
751 dev_net_set(dev, net);
752
753 if (register_netdevice(dev)) {
754 free_netdev(dev);
755 return NULL;
756 }
757 dev->iflink = 0;
758
759 if (dev_open(dev))
760 goto failure;
761
762 dev_hold(dev);
763 return dev;
764
765failure:
766
767 rtnl_unlock();
768 rtnl_lock();
769
770 unregister_netdevice(dev);
771 return NULL;
772}
773#endif
774
775
776
777
778
779static int mif6_delete(struct mr6_table *mrt, int vifi, struct list_head *head)
780{
781 struct mif_device *v;
782 struct net_device *dev;
783 struct inet6_dev *in6_dev;
784
785 if (vifi < 0 || vifi >= mrt->maxvif)
786 return -EADDRNOTAVAIL;
787
788 v = &mrt->vif6_table[vifi];
789
790 write_lock_bh(&mrt_lock);
791 dev = v->dev;
792 v->dev = NULL;
793
794 if (!dev) {
795 write_unlock_bh(&mrt_lock);
796 return -EADDRNOTAVAIL;
797 }
798
799#ifdef CONFIG_IPV6_PIMSM_V2
800 if (vifi == mrt->mroute_reg_vif_num)
801 mrt->mroute_reg_vif_num = -1;
802#endif
803
804 if (vifi + 1 == mrt->maxvif) {
805 int tmp;
806 for (tmp = vifi - 1; tmp >= 0; tmp--) {
807 if (MIF_EXISTS(mrt, tmp))
808 break;
809 }
810 mrt->maxvif = tmp + 1;
811 }
812
813 write_unlock_bh(&mrt_lock);
814
815 dev_set_allmulti(dev, -1);
816
817 in6_dev = __in6_dev_get(dev);
818 if (in6_dev) {
819 in6_dev->cnf.mc_forwarding--;
820 inet6_netconf_notify_devconf(dev_net(dev),
821 NETCONFA_MC_FORWARDING,
822 dev->ifindex, &in6_dev->cnf);
823 }
824
825 if (v->flags & MIFF_REGISTER)
826 unregister_netdevice_queue(dev, head);
827
828 dev_put(dev);
829 return 0;
830}
831
832static inline void ip6mr_cache_free(struct mfc6_cache *c)
833{
834 kmem_cache_free(mrt_cachep, c);
835}
836
837
838
839
840
841static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
842{
843 struct net *net = read_pnet(&mrt->net);
844 struct sk_buff *skb;
845
846 atomic_dec(&mrt->cache_resolve_queue_len);
847
848 while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
849 if (ipv6_hdr(skb)->version == 0) {
850 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
851 nlh->nlmsg_type = NLMSG_ERROR;
852 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
853 skb_trim(skb, nlh->nlmsg_len);
854 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
855 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
856 } else
857 kfree_skb(skb);
858 }
859
860 ip6mr_cache_free(c);
861}
862
863
864
865
866static void ipmr_do_expire_process(struct mr6_table *mrt)
867{
868 unsigned long now = jiffies;
869 unsigned long expires = 10 * HZ;
870 struct mfc6_cache *c, *next;
871
872 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
873 if (time_after(c->mfc_un.unres.expires, now)) {
874
875 unsigned long interval = c->mfc_un.unres.expires - now;
876 if (interval < expires)
877 expires = interval;
878 continue;
879 }
880
881 list_del(&c->list);
882 mr6_netlink_event(mrt, c, RTM_DELROUTE);
883 ip6mr_destroy_unres(mrt, c);
884 }
885
886 if (!list_empty(&mrt->mfc6_unres_queue))
887 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
888}
889
890static void ipmr_expire_process(unsigned long arg)
891{
892 struct mr6_table *mrt = (struct mr6_table *)arg;
893
894 if (!spin_trylock(&mfc_unres_lock)) {
895 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
896 return;
897 }
898
899 if (!list_empty(&mrt->mfc6_unres_queue))
900 ipmr_do_expire_process(mrt);
901
902 spin_unlock(&mfc_unres_lock);
903}
904
905
906
907static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
908 unsigned char *ttls)
909{
910 int vifi;
911
912 cache->mfc_un.res.minvif = MAXMIFS;
913 cache->mfc_un.res.maxvif = 0;
914 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
915
916 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
917 if (MIF_EXISTS(mrt, vifi) &&
918 ttls[vifi] && ttls[vifi] < 255) {
919 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
920 if (cache->mfc_un.res.minvif > vifi)
921 cache->mfc_un.res.minvif = vifi;
922 if (cache->mfc_un.res.maxvif <= vifi)
923 cache->mfc_un.res.maxvif = vifi + 1;
924 }
925 }
926}
927
928static int mif6_add(struct net *net, struct mr6_table *mrt,
929 struct mif6ctl *vifc, int mrtsock)
930{
931 int vifi = vifc->mif6c_mifi;
932 struct mif_device *v = &mrt->vif6_table[vifi];
933 struct net_device *dev;
934 struct inet6_dev *in6_dev;
935 int err;
936
937
938 if (MIF_EXISTS(mrt, vifi))
939 return -EADDRINUSE;
940
941 switch (vifc->mif6c_flags) {
942#ifdef CONFIG_IPV6_PIMSM_V2
943 case MIFF_REGISTER:
944
945
946
947
948 if (mrt->mroute_reg_vif_num >= 0)
949 return -EADDRINUSE;
950 dev = ip6mr_reg_vif(net, mrt);
951 if (!dev)
952 return -ENOBUFS;
953 err = dev_set_allmulti(dev, 1);
954 if (err) {
955 unregister_netdevice(dev);
956 dev_put(dev);
957 return err;
958 }
959 break;
960#endif
961 case 0:
962 dev = dev_get_by_index(net, vifc->mif6c_pifi);
963 if (!dev)
964 return -EADDRNOTAVAIL;
965 err = dev_set_allmulti(dev, 1);
966 if (err) {
967 dev_put(dev);
968 return err;
969 }
970 break;
971 default:
972 return -EINVAL;
973 }
974
975 in6_dev = __in6_dev_get(dev);
976 if (in6_dev) {
977 in6_dev->cnf.mc_forwarding++;
978 inet6_netconf_notify_devconf(dev_net(dev),
979 NETCONFA_MC_FORWARDING,
980 dev->ifindex, &in6_dev->cnf);
981 }
982
983
984
985
986 v->rate_limit = vifc->vifc_rate_limit;
987 v->flags = vifc->mif6c_flags;
988 if (!mrtsock)
989 v->flags |= VIFF_STATIC;
990 v->threshold = vifc->vifc_threshold;
991 v->bytes_in = 0;
992 v->bytes_out = 0;
993 v->pkt_in = 0;
994 v->pkt_out = 0;
995 v->link = dev->ifindex;
996 if (v->flags & MIFF_REGISTER)
997 v->link = dev->iflink;
998
999
1000 write_lock_bh(&mrt_lock);
1001 v->dev = dev;
1002#ifdef CONFIG_IPV6_PIMSM_V2
1003 if (v->flags & MIFF_REGISTER)
1004 mrt->mroute_reg_vif_num = vifi;
1005#endif
1006 if (vifi + 1 > mrt->maxvif)
1007 mrt->maxvif = vifi + 1;
1008 write_unlock_bh(&mrt_lock);
1009 return 0;
1010}
1011
1012static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1013 const struct in6_addr *origin,
1014 const struct in6_addr *mcastgrp)
1015{
1016 int line = MFC6_HASH(mcastgrp, origin);
1017 struct mfc6_cache *c;
1018
1019 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1020 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1021 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1022 return c;
1023 }
1024 return NULL;
1025}
1026
1027
1028static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1029 mifi_t mifi)
1030{
1031 int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1032 struct mfc6_cache *c;
1033
1034 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1035 if (ipv6_addr_any(&c->mf6c_origin) &&
1036 ipv6_addr_any(&c->mf6c_mcastgrp) &&
1037 (c->mfc_un.res.ttls[mifi] < 255))
1038 return c;
1039
1040 return NULL;
1041}
1042
1043
1044static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1045 struct in6_addr *mcastgrp,
1046 mifi_t mifi)
1047{
1048 int line = MFC6_HASH(mcastgrp, &in6addr_any);
1049 struct mfc6_cache *c, *proxy;
1050
1051 if (ipv6_addr_any(mcastgrp))
1052 goto skip;
1053
1054 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1055 if (ipv6_addr_any(&c->mf6c_origin) &&
1056 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1057 if (c->mfc_un.res.ttls[mifi] < 255)
1058 return c;
1059
1060
1061 proxy = ip6mr_cache_find_any_parent(mrt,
1062 c->mf6c_parent);
1063 if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1064 return c;
1065 }
1066
1067skip:
1068 return ip6mr_cache_find_any_parent(mrt, mifi);
1069}
1070
1071
1072
1073
1074static struct mfc6_cache *ip6mr_cache_alloc(void)
1075{
1076 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1077 if (c == NULL)
1078 return NULL;
1079 c->mfc_un.res.minvif = MAXMIFS;
1080 return c;
1081}
1082
1083static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1084{
1085 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1086 if (c == NULL)
1087 return NULL;
1088 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1089 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1090 return c;
1091}
1092
1093
1094
1095
1096
1097static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1098 struct mfc6_cache *uc, struct mfc6_cache *c)
1099{
1100 struct sk_buff *skb;
1101
1102
1103
1104
1105
1106 while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1107 if (ipv6_hdr(skb)->version == 0) {
1108 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1109
1110 if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1111 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1112 } else {
1113 nlh->nlmsg_type = NLMSG_ERROR;
1114 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1115 skb_trim(skb, nlh->nlmsg_len);
1116 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1117 }
1118 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1119 } else
1120 ip6_mr_forward(net, mrt, skb, c);
1121 }
1122}
1123
1124
1125
1126
1127
1128
1129
1130
1131static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1132 mifi_t mifi, int assert)
1133{
1134 struct sk_buff *skb;
1135 struct mrt6msg *msg;
1136 int ret;
1137
1138#ifdef CONFIG_IPV6_PIMSM_V2
1139 if (assert == MRT6MSG_WHOLEPKT)
1140 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1141 +sizeof(*msg));
1142 else
1143#endif
1144 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1145
1146 if (!skb)
1147 return -ENOBUFS;
1148
1149
1150
1151
1152 skb->ip_summed = CHECKSUM_UNNECESSARY;
1153
1154#ifdef CONFIG_IPV6_PIMSM_V2
1155 if (assert == MRT6MSG_WHOLEPKT) {
1156
1157
1158
1159
1160
1161 skb_push(skb, -skb_network_offset(pkt));
1162
1163 skb_push(skb, sizeof(*msg));
1164 skb_reset_transport_header(skb);
1165 msg = (struct mrt6msg *)skb_transport_header(skb);
1166 msg->im6_mbz = 0;
1167 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1168 msg->im6_mif = mrt->mroute_reg_vif_num;
1169 msg->im6_pad = 0;
1170 msg->im6_src = ipv6_hdr(pkt)->saddr;
1171 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1172
1173 skb->ip_summed = CHECKSUM_UNNECESSARY;
1174 } else
1175#endif
1176 {
1177
1178
1179
1180
1181 skb_put(skb, sizeof(struct ipv6hdr));
1182 skb_reset_network_header(skb);
1183 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1184
1185
1186
1187
1188 skb_put(skb, sizeof(*msg));
1189 skb_reset_transport_header(skb);
1190 msg = (struct mrt6msg *)skb_transport_header(skb);
1191
1192 msg->im6_mbz = 0;
1193 msg->im6_msgtype = assert;
1194 msg->im6_mif = mifi;
1195 msg->im6_pad = 0;
1196 msg->im6_src = ipv6_hdr(pkt)->saddr;
1197 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1198
1199 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1200 skb->ip_summed = CHECKSUM_UNNECESSARY;
1201 }
1202
1203 if (mrt->mroute6_sk == NULL) {
1204 kfree_skb(skb);
1205 return -EINVAL;
1206 }
1207
1208
1209
1210
1211 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1212 if (ret < 0) {
1213 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1214 kfree_skb(skb);
1215 }
1216
1217 return ret;
1218}
1219
1220
1221
1222
1223
1224static int
1225ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1226{
1227 bool found = false;
1228 int err;
1229 struct mfc6_cache *c;
1230
1231 spin_lock_bh(&mfc_unres_lock);
1232 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1233 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1234 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1235 found = true;
1236 break;
1237 }
1238 }
1239
1240 if (!found) {
1241
1242
1243
1244
1245 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1246 (c = ip6mr_cache_alloc_unres()) == NULL) {
1247 spin_unlock_bh(&mfc_unres_lock);
1248
1249 kfree_skb(skb);
1250 return -ENOBUFS;
1251 }
1252
1253
1254
1255
1256 c->mf6c_parent = -1;
1257 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1258 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1259
1260
1261
1262
1263 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1264 if (err < 0) {
1265
1266
1267
1268 spin_unlock_bh(&mfc_unres_lock);
1269
1270 ip6mr_cache_free(c);
1271 kfree_skb(skb);
1272 return err;
1273 }
1274
1275 atomic_inc(&mrt->cache_resolve_queue_len);
1276 list_add(&c->list, &mrt->mfc6_unres_queue);
1277 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1278
1279 ipmr_do_expire_process(mrt);
1280 }
1281
1282
1283
1284
1285 if (c->mfc_un.unres.unresolved.qlen > 3) {
1286 kfree_skb(skb);
1287 err = -ENOBUFS;
1288 } else {
1289 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1290 err = 0;
1291 }
1292
1293 spin_unlock_bh(&mfc_unres_lock);
1294 return err;
1295}
1296
1297
1298
1299
1300
1301static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1302 int parent)
1303{
1304 int line;
1305 struct mfc6_cache *c, *next;
1306
1307 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1308
1309 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1310 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1311 ipv6_addr_equal(&c->mf6c_mcastgrp,
1312 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1313 (parent == -1 || parent == c->mf6c_parent)) {
1314 write_lock_bh(&mrt_lock);
1315 list_del(&c->list);
1316 write_unlock_bh(&mrt_lock);
1317
1318 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1319 ip6mr_cache_free(c);
1320 return 0;
1321 }
1322 }
1323 return -ENOENT;
1324}
1325
1326static int ip6mr_device_event(struct notifier_block *this,
1327 unsigned long event, void *ptr)
1328{
1329 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1330 struct net *net = dev_net(dev);
1331 struct mr6_table *mrt;
1332 struct mif_device *v;
1333 int ct;
1334 LIST_HEAD(list);
1335
1336 if (event != NETDEV_UNREGISTER)
1337 return NOTIFY_DONE;
1338
1339 ip6mr_for_each_table(mrt, net) {
1340 v = &mrt->vif6_table[0];
1341 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1342 if (v->dev == dev)
1343 mif6_delete(mrt, ct, &list);
1344 }
1345 }
1346 unregister_netdevice_many(&list);
1347
1348 return NOTIFY_DONE;
1349}
1350
1351static struct notifier_block ip6_mr_notifier = {
1352 .notifier_call = ip6mr_device_event
1353};
1354
1355
1356
1357
1358
1359static int __net_init ip6mr_net_init(struct net *net)
1360{
1361 int err;
1362
1363 err = ip6mr_rules_init(net);
1364 if (err < 0)
1365 goto fail;
1366
1367#ifdef CONFIG_PROC_FS
1368 err = -ENOMEM;
1369 if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1370 goto proc_vif_fail;
1371 if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1372 goto proc_cache_fail;
1373#endif
1374
1375 return 0;
1376
1377#ifdef CONFIG_PROC_FS
1378proc_cache_fail:
1379 remove_proc_entry("ip6_mr_vif", net->proc_net);
1380proc_vif_fail:
1381 ip6mr_rules_exit(net);
1382#endif
1383fail:
1384 return err;
1385}
1386
1387static void __net_exit ip6mr_net_exit(struct net *net)
1388{
1389#ifdef CONFIG_PROC_FS
1390 remove_proc_entry("ip6_mr_cache", net->proc_net);
1391 remove_proc_entry("ip6_mr_vif", net->proc_net);
1392#endif
1393 ip6mr_rules_exit(net);
1394}
1395
1396static struct pernet_operations ip6mr_net_ops = {
1397 .init = ip6mr_net_init,
1398 .exit = ip6mr_net_exit,
1399};
1400
1401int __init ip6_mr_init(void)
1402{
1403 int err;
1404
1405 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1406 sizeof(struct mfc6_cache),
1407 0, SLAB_HWCACHE_ALIGN,
1408 NULL);
1409 if (!mrt_cachep)
1410 return -ENOMEM;
1411
1412 err = register_pernet_subsys(&ip6mr_net_ops);
1413 if (err)
1414 goto reg_pernet_fail;
1415
1416 err = register_netdevice_notifier(&ip6_mr_notifier);
1417 if (err)
1418 goto reg_notif_fail;
1419#ifdef CONFIG_IPV6_PIMSM_V2
1420 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1421 pr_err("%s: can't add PIM protocol\n", __func__);
1422 err = -EAGAIN;
1423 goto add_proto_fail;
1424 }
1425#endif
1426 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1427 ip6mr_rtm_dumproute, NULL);
1428 return 0;
1429#ifdef CONFIG_IPV6_PIMSM_V2
1430add_proto_fail:
1431 unregister_netdevice_notifier(&ip6_mr_notifier);
1432#endif
1433reg_notif_fail:
1434 unregister_pernet_subsys(&ip6mr_net_ops);
1435reg_pernet_fail:
1436 kmem_cache_destroy(mrt_cachep);
1437 return err;
1438}
1439
1440void ip6_mr_cleanup(void)
1441{
1442 unregister_netdevice_notifier(&ip6_mr_notifier);
1443 unregister_pernet_subsys(&ip6mr_net_ops);
1444 kmem_cache_destroy(mrt_cachep);
1445}
1446
1447static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1448 struct mf6cctl *mfc, int mrtsock, int parent)
1449{
1450 bool found = false;
1451 int line;
1452 struct mfc6_cache *uc, *c;
1453 unsigned char ttls[MAXMIFS];
1454 int i;
1455
1456 if (mfc->mf6cc_parent >= MAXMIFS)
1457 return -ENFILE;
1458
1459 memset(ttls, 255, MAXMIFS);
1460 for (i = 0; i < MAXMIFS; i++) {
1461 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1462 ttls[i] = 1;
1463
1464 }
1465
1466 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1467
1468 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1469 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1470 ipv6_addr_equal(&c->mf6c_mcastgrp,
1471 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1472 (parent == -1 || parent == mfc->mf6cc_parent)) {
1473 found = true;
1474 break;
1475 }
1476 }
1477
1478 if (found) {
1479 write_lock_bh(&mrt_lock);
1480 c->mf6c_parent = mfc->mf6cc_parent;
1481 ip6mr_update_thresholds(mrt, c, ttls);
1482 if (!mrtsock)
1483 c->mfc_flags |= MFC_STATIC;
1484 write_unlock_bh(&mrt_lock);
1485 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1486 return 0;
1487 }
1488
1489 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1490 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1491 return -EINVAL;
1492
1493 c = ip6mr_cache_alloc();
1494 if (c == NULL)
1495 return -ENOMEM;
1496
1497 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1498 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1499 c->mf6c_parent = mfc->mf6cc_parent;
1500 ip6mr_update_thresholds(mrt, c, ttls);
1501 if (!mrtsock)
1502 c->mfc_flags |= MFC_STATIC;
1503
1504 write_lock_bh(&mrt_lock);
1505 list_add(&c->list, &mrt->mfc6_cache_array[line]);
1506 write_unlock_bh(&mrt_lock);
1507
1508
1509
1510
1511
1512 found = false;
1513 spin_lock_bh(&mfc_unres_lock);
1514 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1515 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1516 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1517 list_del(&uc->list);
1518 atomic_dec(&mrt->cache_resolve_queue_len);
1519 found = true;
1520 break;
1521 }
1522 }
1523 if (list_empty(&mrt->mfc6_unres_queue))
1524 del_timer(&mrt->ipmr_expire_timer);
1525 spin_unlock_bh(&mfc_unres_lock);
1526
1527 if (found) {
1528 ip6mr_cache_resolve(net, mrt, uc, c);
1529 ip6mr_cache_free(uc);
1530 }
1531 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1532 return 0;
1533}
1534
1535
1536
1537
1538
1539static void mroute_clean_tables(struct mr6_table *mrt)
1540{
1541 int i;
1542 LIST_HEAD(list);
1543 struct mfc6_cache *c, *next;
1544
1545
1546
1547
1548 for (i = 0; i < mrt->maxvif; i++) {
1549 if (!(mrt->vif6_table[i].flags & VIFF_STATIC))
1550 mif6_delete(mrt, i, &list);
1551 }
1552 unregister_netdevice_many(&list);
1553
1554
1555
1556
1557 for (i = 0; i < MFC6_LINES; i++) {
1558 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1559 if (c->mfc_flags & MFC_STATIC)
1560 continue;
1561 write_lock_bh(&mrt_lock);
1562 list_del(&c->list);
1563 write_unlock_bh(&mrt_lock);
1564
1565 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1566 ip6mr_cache_free(c);
1567 }
1568 }
1569
1570 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1571 spin_lock_bh(&mfc_unres_lock);
1572 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1573 list_del(&c->list);
1574 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1575 ip6mr_destroy_unres(mrt, c);
1576 }
1577 spin_unlock_bh(&mfc_unres_lock);
1578 }
1579}
1580
1581static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1582{
1583 int err = 0;
1584 struct net *net = sock_net(sk);
1585
1586 rtnl_lock();
1587 write_lock_bh(&mrt_lock);
1588 if (likely(mrt->mroute6_sk == NULL)) {
1589 mrt->mroute6_sk = sk;
1590 net->ipv6.devconf_all->mc_forwarding++;
1591 inet6_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
1592 NETCONFA_IFINDEX_ALL,
1593 net->ipv6.devconf_all);
1594 }
1595 else
1596 err = -EADDRINUSE;
1597 write_unlock_bh(&mrt_lock);
1598
1599 rtnl_unlock();
1600
1601 return err;
1602}
1603
1604int ip6mr_sk_done(struct sock *sk)
1605{
1606 int err = -EACCES;
1607 struct net *net = sock_net(sk);
1608 struct mr6_table *mrt;
1609
1610 rtnl_lock();
1611 ip6mr_for_each_table(mrt, net) {
1612 if (sk == mrt->mroute6_sk) {
1613 write_lock_bh(&mrt_lock);
1614 mrt->mroute6_sk = NULL;
1615 net->ipv6.devconf_all->mc_forwarding--;
1616 inet6_netconf_notify_devconf(net,
1617 NETCONFA_MC_FORWARDING,
1618 NETCONFA_IFINDEX_ALL,
1619 net->ipv6.devconf_all);
1620 write_unlock_bh(&mrt_lock);
1621
1622 mroute_clean_tables(mrt);
1623 err = 0;
1624 break;
1625 }
1626 }
1627 rtnl_unlock();
1628
1629 return err;
1630}
1631
1632struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1633{
1634 struct mr6_table *mrt;
1635 struct flowi6 fl6 = {
1636 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
1637 .flowi6_oif = skb->dev->ifindex,
1638 .flowi6_mark = skb->mark,
1639 };
1640
1641 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1642 return NULL;
1643
1644 return mrt->mroute6_sk;
1645}
1646
1647
1648
1649
1650
1651
1652
1653
1654int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1655{
1656 int ret, parent = 0;
1657 struct mif6ctl vif;
1658 struct mf6cctl mfc;
1659 mifi_t mifi;
1660 struct net *net = sock_net(sk);
1661 struct mr6_table *mrt;
1662
1663 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1664 if (mrt == NULL)
1665 return -ENOENT;
1666
1667 if (optname != MRT6_INIT) {
1668 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1669 return -EACCES;
1670 }
1671
1672 switch (optname) {
1673 case MRT6_INIT:
1674 if (sk->sk_type != SOCK_RAW ||
1675 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1676 return -EOPNOTSUPP;
1677 if (optlen < sizeof(int))
1678 return -EINVAL;
1679
1680 return ip6mr_sk_init(mrt, sk);
1681
1682 case MRT6_DONE:
1683 return ip6mr_sk_done(sk);
1684
1685 case MRT6_ADD_MIF:
1686 if (optlen < sizeof(vif))
1687 return -EINVAL;
1688 if (copy_from_user(&vif, optval, sizeof(vif)))
1689 return -EFAULT;
1690 if (vif.mif6c_mifi >= MAXMIFS)
1691 return -ENFILE;
1692 rtnl_lock();
1693 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1694 rtnl_unlock();
1695 return ret;
1696
1697 case MRT6_DEL_MIF:
1698 if (optlen < sizeof(mifi_t))
1699 return -EINVAL;
1700 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1701 return -EFAULT;
1702 rtnl_lock();
1703 ret = mif6_delete(mrt, mifi, NULL);
1704 rtnl_unlock();
1705 return ret;
1706
1707
1708
1709
1710
1711 case MRT6_ADD_MFC:
1712 case MRT6_DEL_MFC:
1713 parent = -1;
1714 case MRT6_ADD_MFC_PROXY:
1715 case MRT6_DEL_MFC_PROXY:
1716 if (optlen < sizeof(mfc))
1717 return -EINVAL;
1718 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1719 return -EFAULT;
1720 if (parent == 0)
1721 parent = mfc.mf6cc_parent;
1722 rtnl_lock();
1723 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1724 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1725 else
1726 ret = ip6mr_mfc_add(net, mrt, &mfc,
1727 sk == mrt->mroute6_sk, parent);
1728 rtnl_unlock();
1729 return ret;
1730
1731
1732
1733
1734 case MRT6_ASSERT:
1735 {
1736 int v;
1737
1738 if (optlen != sizeof(v))
1739 return -EINVAL;
1740 if (get_user(v, (int __user *)optval))
1741 return -EFAULT;
1742 mrt->mroute_do_assert = v;
1743 return 0;
1744 }
1745
1746#ifdef CONFIG_IPV6_PIMSM_V2
1747 case MRT6_PIM:
1748 {
1749 int v;
1750
1751 if (optlen != sizeof(v))
1752 return -EINVAL;
1753 if (get_user(v, (int __user *)optval))
1754 return -EFAULT;
1755 v = !!v;
1756 rtnl_lock();
1757 ret = 0;
1758 if (v != mrt->mroute_do_pim) {
1759 mrt->mroute_do_pim = v;
1760 mrt->mroute_do_assert = v;
1761 }
1762 rtnl_unlock();
1763 return ret;
1764 }
1765
1766#endif
1767#ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1768 case MRT6_TABLE:
1769 {
1770 u32 v;
1771
1772 if (optlen != sizeof(u32))
1773 return -EINVAL;
1774 if (get_user(v, (u32 __user *)optval))
1775 return -EFAULT;
1776
1777 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1778 return -EINVAL;
1779 if (sk == mrt->mroute6_sk)
1780 return -EBUSY;
1781
1782 rtnl_lock();
1783 ret = 0;
1784 if (!ip6mr_new_table(net, v))
1785 ret = -ENOMEM;
1786 raw6_sk(sk)->ip6mr_table = v;
1787 rtnl_unlock();
1788 return ret;
1789 }
1790#endif
1791
1792
1793
1794
1795 default:
1796 return -ENOPROTOOPT;
1797 }
1798}
1799
1800
1801
1802
1803
1804int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1805 int __user *optlen)
1806{
1807 int olr;
1808 int val;
1809 struct net *net = sock_net(sk);
1810 struct mr6_table *mrt;
1811
1812 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1813 if (mrt == NULL)
1814 return -ENOENT;
1815
1816 switch (optname) {
1817 case MRT6_VERSION:
1818 val = 0x0305;
1819 break;
1820#ifdef CONFIG_IPV6_PIMSM_V2
1821 case MRT6_PIM:
1822 val = mrt->mroute_do_pim;
1823 break;
1824#endif
1825 case MRT6_ASSERT:
1826 val = mrt->mroute_do_assert;
1827 break;
1828 default:
1829 return -ENOPROTOOPT;
1830 }
1831
1832 if (get_user(olr, optlen))
1833 return -EFAULT;
1834
1835 olr = min_t(int, olr, sizeof(int));
1836 if (olr < 0)
1837 return -EINVAL;
1838
1839 if (put_user(olr, optlen))
1840 return -EFAULT;
1841 if (copy_to_user(optval, &val, olr))
1842 return -EFAULT;
1843 return 0;
1844}
1845
1846
1847
1848
1849
1850int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1851{
1852 struct sioc_sg_req6 sr;
1853 struct sioc_mif_req6 vr;
1854 struct mif_device *vif;
1855 struct mfc6_cache *c;
1856 struct net *net = sock_net(sk);
1857 struct mr6_table *mrt;
1858
1859 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1860 if (mrt == NULL)
1861 return -ENOENT;
1862
1863 switch (cmd) {
1864 case SIOCGETMIFCNT_IN6:
1865 if (copy_from_user(&vr, arg, sizeof(vr)))
1866 return -EFAULT;
1867 if (vr.mifi >= mrt->maxvif)
1868 return -EINVAL;
1869 read_lock(&mrt_lock);
1870 vif = &mrt->vif6_table[vr.mifi];
1871 if (MIF_EXISTS(mrt, vr.mifi)) {
1872 vr.icount = vif->pkt_in;
1873 vr.ocount = vif->pkt_out;
1874 vr.ibytes = vif->bytes_in;
1875 vr.obytes = vif->bytes_out;
1876 read_unlock(&mrt_lock);
1877
1878 if (copy_to_user(arg, &vr, sizeof(vr)))
1879 return -EFAULT;
1880 return 0;
1881 }
1882 read_unlock(&mrt_lock);
1883 return -EADDRNOTAVAIL;
1884 case SIOCGETSGCNT_IN6:
1885 if (copy_from_user(&sr, arg, sizeof(sr)))
1886 return -EFAULT;
1887
1888 read_lock(&mrt_lock);
1889 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1890 if (c) {
1891 sr.pktcnt = c->mfc_un.res.pkt;
1892 sr.bytecnt = c->mfc_un.res.bytes;
1893 sr.wrong_if = c->mfc_un.res.wrong_if;
1894 read_unlock(&mrt_lock);
1895
1896 if (copy_to_user(arg, &sr, sizeof(sr)))
1897 return -EFAULT;
1898 return 0;
1899 }
1900 read_unlock(&mrt_lock);
1901 return -EADDRNOTAVAIL;
1902 default:
1903 return -ENOIOCTLCMD;
1904 }
1905}
1906
1907#ifdef CONFIG_COMPAT
1908struct compat_sioc_sg_req6 {
1909 struct sockaddr_in6 src;
1910 struct sockaddr_in6 grp;
1911 compat_ulong_t pktcnt;
1912 compat_ulong_t bytecnt;
1913 compat_ulong_t wrong_if;
1914};
1915
1916struct compat_sioc_mif_req6 {
1917 mifi_t mifi;
1918 compat_ulong_t icount;
1919 compat_ulong_t ocount;
1920 compat_ulong_t ibytes;
1921 compat_ulong_t obytes;
1922};
1923
1924int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1925{
1926 struct compat_sioc_sg_req6 sr;
1927 struct compat_sioc_mif_req6 vr;
1928 struct mif_device *vif;
1929 struct mfc6_cache *c;
1930 struct net *net = sock_net(sk);
1931 struct mr6_table *mrt;
1932
1933 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1934 if (mrt == NULL)
1935 return -ENOENT;
1936
1937 switch (cmd) {
1938 case SIOCGETMIFCNT_IN6:
1939 if (copy_from_user(&vr, arg, sizeof(vr)))
1940 return -EFAULT;
1941 if (vr.mifi >= mrt->maxvif)
1942 return -EINVAL;
1943 read_lock(&mrt_lock);
1944 vif = &mrt->vif6_table[vr.mifi];
1945 if (MIF_EXISTS(mrt, vr.mifi)) {
1946 vr.icount = vif->pkt_in;
1947 vr.ocount = vif->pkt_out;
1948 vr.ibytes = vif->bytes_in;
1949 vr.obytes = vif->bytes_out;
1950 read_unlock(&mrt_lock);
1951
1952 if (copy_to_user(arg, &vr, sizeof(vr)))
1953 return -EFAULT;
1954 return 0;
1955 }
1956 read_unlock(&mrt_lock);
1957 return -EADDRNOTAVAIL;
1958 case SIOCGETSGCNT_IN6:
1959 if (copy_from_user(&sr, arg, sizeof(sr)))
1960 return -EFAULT;
1961
1962 read_lock(&mrt_lock);
1963 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1964 if (c) {
1965 sr.pktcnt = c->mfc_un.res.pkt;
1966 sr.bytecnt = c->mfc_un.res.bytes;
1967 sr.wrong_if = c->mfc_un.res.wrong_if;
1968 read_unlock(&mrt_lock);
1969
1970 if (copy_to_user(arg, &sr, sizeof(sr)))
1971 return -EFAULT;
1972 return 0;
1973 }
1974 read_unlock(&mrt_lock);
1975 return -EADDRNOTAVAIL;
1976 default:
1977 return -ENOIOCTLCMD;
1978 }
1979}
1980#endif
1981
1982static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1983{
1984 IP6_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1985 IPSTATS_MIB_OUTFORWDATAGRAMS);
1986 IP6_ADD_STATS_BH(dev_net(skb_dst(skb)->dev), ip6_dst_idev(skb_dst(skb)),
1987 IPSTATS_MIB_OUTOCTETS, skb->len);
1988 return dst_output(skb);
1989}
1990
1991
1992
1993
1994
1995static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
1996 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1997{
1998 struct ipv6hdr *ipv6h;
1999 struct mif_device *vif = &mrt->vif6_table[vifi];
2000 struct net_device *dev;
2001 struct dst_entry *dst;
2002 struct flowi6 fl6;
2003
2004 if (vif->dev == NULL)
2005 goto out_free;
2006
2007#ifdef CONFIG_IPV6_PIMSM_V2
2008 if (vif->flags & MIFF_REGISTER) {
2009 vif->pkt_out++;
2010 vif->bytes_out += skb->len;
2011 vif->dev->stats.tx_bytes += skb->len;
2012 vif->dev->stats.tx_packets++;
2013 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2014 goto out_free;
2015 }
2016#endif
2017
2018 ipv6h = ipv6_hdr(skb);
2019
2020 fl6 = (struct flowi6) {
2021 .flowi6_oif = vif->link,
2022 .daddr = ipv6h->daddr,
2023 };
2024
2025 dst = ip6_route_output(net, NULL, &fl6);
2026 if (dst->error) {
2027 dst_release(dst);
2028 goto out_free;
2029 }
2030
2031 skb_dst_drop(skb);
2032 skb_dst_set(skb, dst);
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045 dev = vif->dev;
2046 skb->dev = dev;
2047 vif->pkt_out++;
2048 vif->bytes_out += skb->len;
2049
2050
2051
2052 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2053 goto out_free;
2054
2055 ipv6h = ipv6_hdr(skb);
2056 ipv6h->hop_limit--;
2057
2058 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2059
2060 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD, skb, skb->dev, dev,
2061 ip6mr_forward2_finish);
2062
2063out_free:
2064 kfree_skb(skb);
2065 return 0;
2066}
2067
2068static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2069{
2070 int ct;
2071
2072 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2073 if (mrt->vif6_table[ct].dev == dev)
2074 break;
2075 }
2076 return ct;
2077}
2078
2079static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2080 struct sk_buff *skb, struct mfc6_cache *cache)
2081{
2082 int psend = -1;
2083 int vif, ct;
2084 int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2085
2086 vif = cache->mf6c_parent;
2087 cache->mfc_un.res.pkt++;
2088 cache->mfc_un.res.bytes += skb->len;
2089
2090 if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2091 struct mfc6_cache *cache_proxy;
2092
2093
2094
2095
2096 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2097 if (cache_proxy &&
2098 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2099 goto forward;
2100 }
2101
2102
2103
2104
2105 if (mrt->vif6_table[vif].dev != skb->dev) {
2106 cache->mfc_un.res.wrong_if++;
2107
2108 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2109
2110
2111
2112
2113
2114 (mrt->mroute_do_pim ||
2115 cache->mfc_un.res.ttls[true_vifi] < 255) &&
2116 time_after(jiffies,
2117 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2118 cache->mfc_un.res.last_assert = jiffies;
2119 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2120 }
2121 goto dont_forward;
2122 }
2123
2124forward:
2125 mrt->vif6_table[vif].pkt_in++;
2126 mrt->vif6_table[vif].bytes_in += skb->len;
2127
2128
2129
2130
2131 if (ipv6_addr_any(&cache->mf6c_origin) &&
2132 ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2133 if (true_vifi >= 0 &&
2134 true_vifi != cache->mf6c_parent &&
2135 ipv6_hdr(skb)->hop_limit >
2136 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2137
2138
2139
2140
2141 psend = cache->mf6c_parent;
2142 goto last_forward;
2143 }
2144 goto dont_forward;
2145 }
2146 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2147
2148 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2149 ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2150 if (psend != -1) {
2151 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2152 if (skb2)
2153 ip6mr_forward2(net, mrt, skb2, cache, psend);
2154 }
2155 psend = ct;
2156 }
2157 }
2158last_forward:
2159 if (psend != -1) {
2160 ip6mr_forward2(net, mrt, skb, cache, psend);
2161 return;
2162 }
2163
2164dont_forward:
2165 kfree_skb(skb);
2166}
2167
2168
2169
2170
2171
2172
2173int ip6_mr_input(struct sk_buff *skb)
2174{
2175 struct mfc6_cache *cache;
2176 struct net *net = dev_net(skb->dev);
2177 struct mr6_table *mrt;
2178 struct flowi6 fl6 = {
2179 .flowi6_iif = skb->dev->ifindex,
2180 .flowi6_mark = skb->mark,
2181 };
2182 int err;
2183
2184 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2185 if (err < 0) {
2186 kfree_skb(skb);
2187 return err;
2188 }
2189
2190 read_lock(&mrt_lock);
2191 cache = ip6mr_cache_find(mrt,
2192 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2193 if (cache == NULL) {
2194 int vif = ip6mr_find_vif(mrt, skb->dev);
2195
2196 if (vif >= 0)
2197 cache = ip6mr_cache_find_any(mrt,
2198 &ipv6_hdr(skb)->daddr,
2199 vif);
2200 }
2201
2202
2203
2204
2205 if (cache == NULL) {
2206 int vif;
2207
2208 vif = ip6mr_find_vif(mrt, skb->dev);
2209 if (vif >= 0) {
2210 int err = ip6mr_cache_unresolved(mrt, vif, skb);
2211 read_unlock(&mrt_lock);
2212
2213 return err;
2214 }
2215 read_unlock(&mrt_lock);
2216 kfree_skb(skb);
2217 return -ENODEV;
2218 }
2219
2220 ip6_mr_forward(net, mrt, skb, cache);
2221
2222 read_unlock(&mrt_lock);
2223
2224 return 0;
2225}
2226
2227
2228static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2229 struct mfc6_cache *c, struct rtmsg *rtm)
2230{
2231 int ct;
2232 struct rtnexthop *nhp;
2233 struct nlattr *mp_attr;
2234 struct rta_mfc_stats mfcs;
2235
2236
2237 if (c->mf6c_parent >= MAXMIFS)
2238 return -ENOENT;
2239
2240 if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2241 nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2242 return -EMSGSIZE;
2243 mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2244 if (mp_attr == NULL)
2245 return -EMSGSIZE;
2246
2247 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2248 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2249 nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2250 if (nhp == NULL) {
2251 nla_nest_cancel(skb, mp_attr);
2252 return -EMSGSIZE;
2253 }
2254
2255 nhp->rtnh_flags = 0;
2256 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2257 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2258 nhp->rtnh_len = sizeof(*nhp);
2259 }
2260 }
2261
2262 nla_nest_end(skb, mp_attr);
2263
2264 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2265 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2266 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2267 if (nla_put(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs) < 0)
2268 return -EMSGSIZE;
2269
2270 rtm->rtm_type = RTN_MULTICAST;
2271 return 1;
2272}
2273
2274int ip6mr_get_route(struct net *net,
2275 struct sk_buff *skb, struct rtmsg *rtm, int nowait)
2276{
2277 int err;
2278 struct mr6_table *mrt;
2279 struct mfc6_cache *cache;
2280 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2281
2282 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2283 if (mrt == NULL)
2284 return -ENOENT;
2285
2286 read_lock(&mrt_lock);
2287 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2288 if (!cache && skb->dev) {
2289 int vif = ip6mr_find_vif(mrt, skb->dev);
2290
2291 if (vif >= 0)
2292 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2293 vif);
2294 }
2295
2296 if (!cache) {
2297 struct sk_buff *skb2;
2298 struct ipv6hdr *iph;
2299 struct net_device *dev;
2300 int vif;
2301
2302 if (nowait) {
2303 read_unlock(&mrt_lock);
2304 return -EAGAIN;
2305 }
2306
2307 dev = skb->dev;
2308 if (dev == NULL || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2309 read_unlock(&mrt_lock);
2310 return -ENODEV;
2311 }
2312
2313
2314 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2315 if (!skb2) {
2316 read_unlock(&mrt_lock);
2317 return -ENOMEM;
2318 }
2319
2320 skb_reset_transport_header(skb2);
2321
2322 skb_put(skb2, sizeof(struct ipv6hdr));
2323 skb_reset_network_header(skb2);
2324
2325 iph = ipv6_hdr(skb2);
2326 iph->version = 0;
2327 iph->priority = 0;
2328 iph->flow_lbl[0] = 0;
2329 iph->flow_lbl[1] = 0;
2330 iph->flow_lbl[2] = 0;
2331 iph->payload_len = 0;
2332 iph->nexthdr = IPPROTO_NONE;
2333 iph->hop_limit = 0;
2334 iph->saddr = rt->rt6i_src.addr;
2335 iph->daddr = rt->rt6i_dst.addr;
2336
2337 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2338 read_unlock(&mrt_lock);
2339
2340 return err;
2341 }
2342
2343 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2344 cache->mfc_flags |= MFC_NOTIFY;
2345
2346 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2347 read_unlock(&mrt_lock);
2348 return err;
2349}
2350
2351static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2352 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2353 int flags)
2354{
2355 struct nlmsghdr *nlh;
2356 struct rtmsg *rtm;
2357 int err;
2358
2359 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2360 if (nlh == NULL)
2361 return -EMSGSIZE;
2362
2363 rtm = nlmsg_data(nlh);
2364 rtm->rtm_family = RTNL_FAMILY_IP6MR;
2365 rtm->rtm_dst_len = 128;
2366 rtm->rtm_src_len = 128;
2367 rtm->rtm_tos = 0;
2368 rtm->rtm_table = mrt->id;
2369 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2370 goto nla_put_failure;
2371 rtm->rtm_type = RTN_MULTICAST;
2372 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2373 if (c->mfc_flags & MFC_STATIC)
2374 rtm->rtm_protocol = RTPROT_STATIC;
2375 else
2376 rtm->rtm_protocol = RTPROT_MROUTED;
2377 rtm->rtm_flags = 0;
2378
2379 if (nla_put(skb, RTA_SRC, 16, &c->mf6c_origin) ||
2380 nla_put(skb, RTA_DST, 16, &c->mf6c_mcastgrp))
2381 goto nla_put_failure;
2382 err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2383
2384 if (err < 0 && err != -ENOENT)
2385 goto nla_put_failure;
2386
2387 return nlmsg_end(skb, nlh);
2388
2389nla_put_failure:
2390 nlmsg_cancel(skb, nlh);
2391 return -EMSGSIZE;
2392}
2393
2394static int mr6_msgsize(bool unresolved, int maxvif)
2395{
2396 size_t len =
2397 NLMSG_ALIGN(sizeof(struct rtmsg))
2398 + nla_total_size(4)
2399 + nla_total_size(sizeof(struct in6_addr))
2400 + nla_total_size(sizeof(struct in6_addr))
2401 ;
2402
2403 if (!unresolved)
2404 len = len
2405 + nla_total_size(4)
2406 + nla_total_size(0)
2407 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2408
2409 + nla_total_size(sizeof(struct rta_mfc_stats))
2410 ;
2411
2412 return len;
2413}
2414
2415static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2416 int cmd)
2417{
2418 struct net *net = read_pnet(&mrt->net);
2419 struct sk_buff *skb;
2420 int err = -ENOBUFS;
2421
2422 skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2423 GFP_ATOMIC);
2424 if (skb == NULL)
2425 goto errout;
2426
2427 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2428 if (err < 0)
2429 goto errout;
2430
2431 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2432 return;
2433
2434errout:
2435 kfree_skb(skb);
2436 if (err < 0)
2437 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2438}
2439
2440static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2441{
2442 struct net *net = sock_net(skb->sk);
2443 struct mr6_table *mrt;
2444 struct mfc6_cache *mfc;
2445 unsigned int t = 0, s_t;
2446 unsigned int h = 0, s_h;
2447 unsigned int e = 0, s_e;
2448
2449 s_t = cb->args[0];
2450 s_h = cb->args[1];
2451 s_e = cb->args[2];
2452
2453 read_lock(&mrt_lock);
2454 ip6mr_for_each_table(mrt, net) {
2455 if (t < s_t)
2456 goto next_table;
2457 if (t > s_t)
2458 s_h = 0;
2459 for (h = s_h; h < MFC6_LINES; h++) {
2460 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2461 if (e < s_e)
2462 goto next_entry;
2463 if (ip6mr_fill_mroute(mrt, skb,
2464 NETLINK_CB(cb->skb).portid,
2465 cb->nlh->nlmsg_seq,
2466 mfc, RTM_NEWROUTE,
2467 NLM_F_MULTI) < 0)
2468 goto done;
2469next_entry:
2470 e++;
2471 }
2472 e = s_e = 0;
2473 }
2474 spin_lock_bh(&mfc_unres_lock);
2475 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2476 if (e < s_e)
2477 goto next_entry2;
2478 if (ip6mr_fill_mroute(mrt, skb,
2479 NETLINK_CB(cb->skb).portid,
2480 cb->nlh->nlmsg_seq,
2481 mfc, RTM_NEWROUTE,
2482 NLM_F_MULTI) < 0) {
2483 spin_unlock_bh(&mfc_unres_lock);
2484 goto done;
2485 }
2486next_entry2:
2487 e++;
2488 }
2489 spin_unlock_bh(&mfc_unres_lock);
2490 e = s_e = 0;
2491 s_h = 0;
2492next_table:
2493 t++;
2494 }
2495done:
2496 read_unlock(&mrt_lock);
2497
2498 cb->args[2] = e;
2499 cb->args[1] = h;
2500 cb->args[0] = t;
2501
2502 return skb->len;
2503}
2504