?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "ALSA: hda: Flush interrupts on disabling"
[linux/fpc-iii.git] / net / ipv6 / ip6mr.c
blobf38b22f54c09327962ed90e6cd5994e5d6c38015
1 /*
2 * Linux IPv6 multicast routing support for BSD pim6sd
3 * Based on net/ipv4/ipmr.c.
4 *
5 * (c) 2004 Mickael Hoerdt, <hoerdt@clarinet.u-strasbg.fr>
6 * LSIIT Laboratory, Strasbourg, France
7 * (c) 2004 Jean-Philippe Andriot, <jean-philippe.andriot@6WIND.com>
8 * 6WIND, Paris, France
9 * Copyright (C)2007,2008 USAGI/WIDE Project
10 * YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
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
57 struct mr6_table {
58 struct list_head list;
59 possible_net_t net;
60 u32 id;
61 struct sock *mroute6_sk;
62 struct timer_list ipmr_expire_timer;
63 struct list_head mfc6_unres_queue;
64 struct list_head mfc6_cache_array[MFC6_LINES];
65 struct mif_device vif6_table[MAXMIFS];
66 int maxvif;
67 atomic_t cache_resolve_queue_len;
68 bool mroute_do_assert;
69 bool mroute_do_pim;
70 #ifdef CONFIG_IPV6_PIMSM_V2
71 int mroute_reg_vif_num;
72 #endif
73 };
74
75 #include <linux/nospec.h>
76
77 struct ip6mr_rule {
78 struct fib_rule common;
79 };
80
81 struct ip6mr_result {
82 struct mr6_table *mrt;
83 };
84
85 /* Big lock, protecting vif table, mrt cache and mroute socket state.
86 Note that the changes are semaphored via rtnl_lock.
87 */
88
89 static DEFINE_RWLOCK(mrt_lock);
90
91 /*
92 * Multicast router control variables
93 */
94
95 #define MIF_EXISTS(_mrt, _idx) ((_mrt)->vif6_table[_idx].dev != NULL)
96
97 /* Special spinlock for queue of unresolved entries */
98 static DEFINE_SPINLOCK(mfc_unres_lock);
99
100 /* We return to original Alan's scheme. Hash table of resolved
101 entries is changed only in process context and protected
102 with weak lock mrt_lock. Queue of unresolved entries is protected
103 with strong spinlock mfc_unres_lock.
104
105 In this case data path is free of exclusive locks at all.
106 */
107
108 static struct kmem_cache *mrt_cachep __read_mostly;
109
110 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id);
111 static void ip6mr_free_table(struct mr6_table *mrt);
112
113 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
114 struct sk_buff *skb, struct mfc6_cache *cache);
115 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
116 mifi_t mifi, int assert);
117 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
118 struct mfc6_cache *c, struct rtmsg *rtm);
119 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
120 int cmd);
121 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
122 struct netlink_callback *cb);
123 static void mroute_clean_tables(struct mr6_table *mrt, bool all);
124 static 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
130 static 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
141 static 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
159 static 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)
179 return -EAGAIN;
180 res->mrt = mrt;
181 return 0;
182 }
183
184 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
185 {
186 return 1;
187 }
188
189 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
190 FRA_GENERIC_POLICY,
191 };
192
193 static 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
199 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
200 struct nlattr **tb)
201 {
202 return 1;
203 }
204
205 static 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
214 static 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 .fill = ip6mr_rule_fill,
223 .nlgroup = RTNLGRP_IPV6_RULE,
224 .policy = ip6mr_rule_policy,
225 .owner = THIS_MODULE,
226 };
227
228 static int __net_init ip6mr_rules_init(struct net *net)
229 {
230 struct fib_rules_ops *ops;
231 struct mr6_table *mrt;
232 int err;
233
234 ops = fib_rules_register(&ip6mr_rules_ops_template, net);
235 if (IS_ERR(ops))
236 return PTR_ERR(ops);
237
238 INIT_LIST_HEAD(&net->ipv6.mr6_tables);
239
240 mrt = ip6mr_new_table(net, RT6_TABLE_DFLT);
241 if (!mrt) {
242 err = -ENOMEM;
243 goto err1;
244 }
245
246 err = fib_default_rule_add(ops, 0x7fff, RT6_TABLE_DFLT, 0);
247 if (err < 0)
248 goto err2;
249
250 net->ipv6.mr6_rules_ops = ops;
251 return 0;
252
253 err2:
254 ip6mr_free_table(mrt);
255 err1:
256 fib_rules_unregister(ops);
257 return err;
258 }
259
260 static void __net_exit ip6mr_rules_exit(struct net *net)
261 {
262 struct mr6_table *mrt, *next;
263
264 rtnl_lock();
265 list_for_each_entry_safe(mrt, next, &net->ipv6.mr6_tables, list) {
266 list_del(&mrt->list);
267 ip6mr_free_table(mrt);
268 }
269 fib_rules_unregister(net->ipv6.mr6_rules_ops);
270 rtnl_unlock();
271 }
272 #else
273 #define ip6mr_for_each_table(mrt, net) \
274 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
275
276 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
277 {
278 return net->ipv6.mrt6;
279 }
280
281 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
282 struct mr6_table **mrt)
283 {
284 *mrt = net->ipv6.mrt6;
285 return 0;
286 }
287
288 static int __net_init ip6mr_rules_init(struct net *net)
289 {
290 net->ipv6.mrt6 = ip6mr_new_table(net, RT6_TABLE_DFLT);
291 return net->ipv6.mrt6 ? 0 : -ENOMEM;
292 }
293
294 static void __net_exit ip6mr_rules_exit(struct net *net)
295 {
296 rtnl_lock();
297 ip6mr_free_table(net->ipv6.mrt6);
298 net->ipv6.mrt6 = NULL;
299 rtnl_unlock();
300 }
301 #endif
302
303 static struct mr6_table *ip6mr_new_table(struct net *net, u32 id)
304 {
305 struct mr6_table *mrt;
306 unsigned int i;
307
308 mrt = ip6mr_get_table(net, id);
309 if (mrt)
310 return mrt;
311
312 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
313 if (!mrt)
314 return NULL;
315 mrt->id = id;
316 write_pnet(&mrt->net, net);
317
318 /* Forwarding cache */
319 for (i = 0; i < MFC6_LINES; i++)
320 INIT_LIST_HEAD(&mrt->mfc6_cache_array[i]);
321
322 INIT_LIST_HEAD(&mrt->mfc6_unres_queue);
323
324 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
325 (unsigned long)mrt);
326
327 #ifdef CONFIG_IPV6_PIMSM_V2
328 mrt->mroute_reg_vif_num = -1;
329 #endif
330 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
331 list_add_tail_rcu(&mrt->list, &net->ipv6.mr6_tables);
332 #endif
333 return mrt;
334 }
335
336 static void ip6mr_free_table(struct mr6_table *mrt)
337 {
338 del_timer_sync(&mrt->ipmr_expire_timer);
339 mroute_clean_tables(mrt, true);
340 kfree(mrt);
341 }
342
343 #ifdef CONFIG_PROC_FS
344
345 struct ipmr_mfc_iter {
346 struct seq_net_private p;
347 struct mr6_table *mrt;
348 struct list_head *cache;
349 int ct;
350 };
351
352
353 static struct mfc6_cache *ipmr_mfc_seq_idx(struct net *net,
354 struct ipmr_mfc_iter *it, loff_t pos)
355 {
356 struct mr6_table *mrt = it->mrt;
357 struct mfc6_cache *mfc;
358
359 read_lock(&mrt_lock);
360 for (it->ct = 0; it->ct < MFC6_LINES; it->ct++) {
361 it->cache = &mrt->mfc6_cache_array[it->ct];
362 list_for_each_entry(mfc, it->cache, list)
363 if (pos-- == 0)
364 return mfc;
365 }
366 read_unlock(&mrt_lock);
367
368 spin_lock_bh(&mfc_unres_lock);
369 it->cache = &mrt->mfc6_unres_queue;
370 list_for_each_entry(mfc, it->cache, list)
371 if (pos-- == 0)
372 return mfc;
373 spin_unlock_bh(&mfc_unres_lock);
374
375 it->cache = NULL;
376 return NULL;
377 }
378
379 /*
380 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
381 */
382
383 struct ipmr_vif_iter {
384 struct seq_net_private p;
385 struct mr6_table *mrt;
386 int ct;
387 };
388
389 static struct mif_device *ip6mr_vif_seq_idx(struct net *net,
390 struct ipmr_vif_iter *iter,
391 loff_t pos)
392 {
393 struct mr6_table *mrt = iter->mrt;
394
395 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
396 if (!MIF_EXISTS(mrt, iter->ct))
397 continue;
398 if (pos-- == 0)
399 return &mrt->vif6_table[iter->ct];
400 }
401 return NULL;
402 }
403
404 static void *ip6mr_vif_seq_start(struct seq_file *seq, loff_t *pos)
405 __acquires(mrt_lock)
406 {
407 struct ipmr_vif_iter *iter = seq->private;
408 struct net *net = seq_file_net(seq);
409 struct mr6_table *mrt;
410
411 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
412 if (!mrt)
413 return ERR_PTR(-ENOENT);
414
415 iter->mrt = mrt;
416
417 read_lock(&mrt_lock);
418 return *pos ? ip6mr_vif_seq_idx(net, seq->private, *pos - 1)
419 : SEQ_START_TOKEN;
420 }
421
422 static void *ip6mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
423 {
424 struct ipmr_vif_iter *iter = seq->private;
425 struct net *net = seq_file_net(seq);
426 struct mr6_table *mrt = iter->mrt;
427
428 ++*pos;
429 if (v == SEQ_START_TOKEN)
430 return ip6mr_vif_seq_idx(net, iter, 0);
431
432 while (++iter->ct < mrt->maxvif) {
433 if (!MIF_EXISTS(mrt, iter->ct))
434 continue;
435 return &mrt->vif6_table[iter->ct];
436 }
437 return NULL;
438 }
439
440 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
441 __releases(mrt_lock)
442 {
443 read_unlock(&mrt_lock);
444 }
445
446 static int ip6mr_vif_seq_show(struct seq_file *seq, void *v)
447 {
448 struct ipmr_vif_iter *iter = seq->private;
449 struct mr6_table *mrt = iter->mrt;
450
451 if (v == SEQ_START_TOKEN) {
452 seq_puts(seq,
453 "Interface BytesIn PktsIn BytesOut PktsOut Flags\n");
454 } else {
455 const struct mif_device *vif = v;
456 const char *name = vif->dev ? vif->dev->name : "none";
457
458 seq_printf(seq,
459 "%2td %-10s %8ld %7ld %8ld %7ld %05X\n",
460 vif - mrt->vif6_table,
461 name, vif->bytes_in, vif->pkt_in,
462 vif->bytes_out, vif->pkt_out,
463 vif->flags);
464 }
465 return 0;
466 }
467
468 static const struct seq_operations ip6mr_vif_seq_ops = {
469 .start = ip6mr_vif_seq_start,
470 .next = ip6mr_vif_seq_next,
471 .stop = ip6mr_vif_seq_stop,
472 .show = ip6mr_vif_seq_show,
473 };
474
475 static int ip6mr_vif_open(struct inode *inode, struct file *file)
476 {
477 return seq_open_net(inode, file, &ip6mr_vif_seq_ops,
478 sizeof(struct ipmr_vif_iter));
479 }
480
481 static const struct file_operations ip6mr_vif_fops = {
482 .owner = THIS_MODULE,
483 .open = ip6mr_vif_open,
484 .read = seq_read,
485 .llseek = seq_lseek,
486 .release = seq_release_net,
487 };
488
489 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
490 {
491 struct ipmr_mfc_iter *it = seq->private;
492 struct net *net = seq_file_net(seq);
493 struct mr6_table *mrt;
494
495 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
496 if (!mrt)
497 return ERR_PTR(-ENOENT);
498
499 it->mrt = mrt;
500 it->cache = NULL;
501 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
502 : SEQ_START_TOKEN;
503 }
504
505 static 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 /* exhausted cache_array, show unresolved */
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
548 static 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[it->ct])
556 read_unlock(&mrt_lock);
557 }
558
559 static 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 /* unresolved mfc_caches don't contain
592 * pkt, bytes and wrong_if values
593 */
594 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
595 }
596 seq_putc(seq, '\n');
597 }
598 return 0;
599 }
600
601 static 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
608 static 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
614 static 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
625 static 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 /* check if the inner packet is destined to mcast group */
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)
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
690 static const struct inet6_protocol pim6_protocol = {
691 .handler = pim6_rcv,
692 };
693
694 /* Service routines creating virtual interfaces: PIMREG */
695
696 static 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
723 static int reg_vif_get_iflink(const struct net_device *dev)
724 {
725 return 0;
726 }
727
728 static const struct net_device_ops reg_vif_netdev_ops = {
729 .ndo_start_xmit = reg_vif_xmit,
730 .ndo_get_iflink = reg_vif_get_iflink,
731 };
732
733 static void reg_vif_setup(struct net_device *dev)
734 {
735 dev->type = ARPHRD_PIMREG;
736 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
737 dev->flags = IFF_NOARP;
738 dev->netdev_ops = &reg_vif_netdev_ops;
739 dev->destructor = free_netdev;
740 dev->features |= NETIF_F_NETNS_LOCAL;
741 }
742
743 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
744 {
745 struct net_device *dev;
746 char name[IFNAMSIZ];
747
748 if (mrt->id == RT6_TABLE_DFLT)
749 sprintf(name, "pim6reg");
750 else
751 sprintf(name, "pim6reg%u", mrt->id);
752
753 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
754 if (!dev)
755 return NULL;
756
757 dev_net_set(dev, net);
758
759 if (register_netdevice(dev)) {
760 free_netdev(dev);
761 return NULL;
762 }
763
764 if (dev_open(dev))
765 goto failure;
766
767 dev_hold(dev);
768 return dev;
769
770 failure:
771 unregister_netdevice(dev);
772 return NULL;
773 }
774 #endif
775
776 /*
777 * Delete a VIF entry
778 */
779
780 static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
781 struct list_head *head)
782 {
783 struct mif_device *v;
784 struct net_device *dev;
785 struct inet6_dev *in6_dev;
786
787 if (vifi < 0 || vifi >= mrt->maxvif)
788 return -EADDRNOTAVAIL;
789
790 v = &mrt->vif6_table[vifi];
791
792 write_lock_bh(&mrt_lock);
793 dev = v->dev;
794 v->dev = NULL;
795
796 if (!dev) {
797 write_unlock_bh(&mrt_lock);
798 return -EADDRNOTAVAIL;
799 }
800
801 #ifdef CONFIG_IPV6_PIMSM_V2
802 if (vifi == mrt->mroute_reg_vif_num)
803 mrt->mroute_reg_vif_num = -1;
804 #endif
805
806 if (vifi + 1 == mrt->maxvif) {
807 int tmp;
808 for (tmp = vifi - 1; tmp >= 0; tmp--) {
809 if (MIF_EXISTS(mrt, tmp))
810 break;
811 }
812 mrt->maxvif = tmp + 1;
813 }
814
815 write_unlock_bh(&mrt_lock);
816
817 dev_set_allmulti(dev, -1);
818
819 in6_dev = __in6_dev_get(dev);
820 if (in6_dev) {
821 in6_dev->cnf.mc_forwarding--;
822 inet6_netconf_notify_devconf(dev_net(dev),
823 NETCONFA_MC_FORWARDING,
824 dev->ifindex, &in6_dev->cnf);
825 }
826
827 if ((v->flags & MIFF_REGISTER) && !notify)
828 unregister_netdevice_queue(dev, head);
829
830 dev_put(dev);
831 return 0;
832 }
833
834 static inline void ip6mr_cache_free(struct mfc6_cache *c)
835 {
836 kmem_cache_free(mrt_cachep, c);
837 }
838
839 /* Destroy an unresolved cache entry, killing queued skbs
840 and reporting error to netlink readers.
841 */
842
843 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
844 {
845 struct net *net = read_pnet(&mrt->net);
846 struct sk_buff *skb;
847
848 atomic_dec(&mrt->cache_resolve_queue_len);
849
850 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
851 if (ipv6_hdr(skb)->version == 0) {
852 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
853 nlh->nlmsg_type = NLMSG_ERROR;
854 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
855 skb_trim(skb, nlh->nlmsg_len);
856 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
857 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
858 } else
859 kfree_skb(skb);
860 }
861
862 ip6mr_cache_free(c);
863 }
864
865
866 /* Timer process for all the unresolved queue. */
867
868 static void ipmr_do_expire_process(struct mr6_table *mrt)
869 {
870 unsigned long now = jiffies;
871 unsigned long expires = 10 * HZ;
872 struct mfc6_cache *c, *next;
873
874 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
875 if (time_after(c->mfc_un.unres.expires, now)) {
876 /* not yet... */
877 unsigned long interval = c->mfc_un.unres.expires - now;
878 if (interval < expires)
879 expires = interval;
880 continue;
881 }
882
883 list_del(&c->list);
884 mr6_netlink_event(mrt, c, RTM_DELROUTE);
885 ip6mr_destroy_unres(mrt, c);
886 }
887
888 if (!list_empty(&mrt->mfc6_unres_queue))
889 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
890 }
891
892 static void ipmr_expire_process(unsigned long arg)
893 {
894 struct mr6_table *mrt = (struct mr6_table *)arg;
895
896 if (!spin_trylock(&mfc_unres_lock)) {
897 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
898 return;
899 }
900
901 if (!list_empty(&mrt->mfc6_unres_queue))
902 ipmr_do_expire_process(mrt);
903
904 spin_unlock(&mfc_unres_lock);
905 }
906
907 /* Fill oifs list. It is called under write locked mrt_lock. */
908
909 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
910 unsigned char *ttls)
911 {
912 int vifi;
913
914 cache->mfc_un.res.minvif = MAXMIFS;
915 cache->mfc_un.res.maxvif = 0;
916 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
917
918 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
919 if (MIF_EXISTS(mrt, vifi) &&
920 ttls[vifi] && ttls[vifi] < 255) {
921 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
922 if (cache->mfc_un.res.minvif > vifi)
923 cache->mfc_un.res.minvif = vifi;
924 if (cache->mfc_un.res.maxvif <= vifi)
925 cache->mfc_un.res.maxvif = vifi + 1;
926 }
927 }
928 cache->mfc_un.res.lastuse = jiffies;
929 }
930
931 static int mif6_add(struct net *net, struct mr6_table *mrt,
932 struct mif6ctl *vifc, int mrtsock)
933 {
934 int vifi = vifc->mif6c_mifi;
935 struct mif_device *v = &mrt->vif6_table[vifi];
936 struct net_device *dev;
937 struct inet6_dev *in6_dev;
938 int err;
939
940 /* Is vif busy ? */
941 if (MIF_EXISTS(mrt, vifi))
942 return -EADDRINUSE;
943
944 switch (vifc->mif6c_flags) {
945 #ifdef CONFIG_IPV6_PIMSM_V2
946 case MIFF_REGISTER:
947 /*
948 * Special Purpose VIF in PIM
949 * All the packets will be sent to the daemon
950 */
951 if (mrt->mroute_reg_vif_num >= 0)
952 return -EADDRINUSE;
953 dev = ip6mr_reg_vif(net, mrt);
954 if (!dev)
955 return -ENOBUFS;
956 err = dev_set_allmulti(dev, 1);
957 if (err) {
958 unregister_netdevice(dev);
959 dev_put(dev);
960 return err;
961 }
962 break;
963 #endif
964 case 0:
965 dev = dev_get_by_index(net, vifc->mif6c_pifi);
966 if (!dev)
967 return -EADDRNOTAVAIL;
968 err = dev_set_allmulti(dev, 1);
969 if (err) {
970 dev_put(dev);
971 return err;
972 }
973 break;
974 default:
975 return -EINVAL;
976 }
977
978 in6_dev = __in6_dev_get(dev);
979 if (in6_dev) {
980 in6_dev->cnf.mc_forwarding++;
981 inet6_netconf_notify_devconf(dev_net(dev),
982 NETCONFA_MC_FORWARDING,
983 dev->ifindex, &in6_dev->cnf);
984 }
985
986 /*
987 * Fill in the VIF structures
988 */
989 v->rate_limit = vifc->vifc_rate_limit;
990 v->flags = vifc->mif6c_flags;
991 if (!mrtsock)
992 v->flags |= VIFF_STATIC;
993 v->threshold = vifc->vifc_threshold;
994 v->bytes_in = 0;
995 v->bytes_out = 0;
996 v->pkt_in = 0;
997 v->pkt_out = 0;
998 v->link = dev->ifindex;
999 if (v->flags & MIFF_REGISTER)
1000 v->link = dev_get_iflink(dev);
1001
1002 /* And finish update writing critical data */
1003 write_lock_bh(&mrt_lock);
1004 v->dev = dev;
1005 #ifdef CONFIG_IPV6_PIMSM_V2
1006 if (v->flags & MIFF_REGISTER)
1007 mrt->mroute_reg_vif_num = vifi;
1008 #endif
1009 if (vifi + 1 > mrt->maxvif)
1010 mrt->maxvif = vifi + 1;
1011 write_unlock_bh(&mrt_lock);
1012 return 0;
1013 }
1014
1015 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1016 const struct in6_addr *origin,
1017 const struct in6_addr *mcastgrp)
1018 {
1019 int line = MFC6_HASH(mcastgrp, origin);
1020 struct mfc6_cache *c;
1021
1022 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1023 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1024 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1025 return c;
1026 }
1027 return NULL;
1028 }
1029
1030 /* Look for a (*,*,oif) entry */
1031 static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1032 mifi_t mifi)
1033 {
1034 int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1035 struct mfc6_cache *c;
1036
1037 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1038 if (ipv6_addr_any(&c->mf6c_origin) &&
1039 ipv6_addr_any(&c->mf6c_mcastgrp) &&
1040 (c->mfc_un.res.ttls[mifi] < 255))
1041 return c;
1042
1043 return NULL;
1044 }
1045
1046 /* Look for a (*,G) entry */
1047 static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1048 struct in6_addr *mcastgrp,
1049 mifi_t mifi)
1050 {
1051 int line = MFC6_HASH(mcastgrp, &in6addr_any);
1052 struct mfc6_cache *c, *proxy;
1053
1054 if (ipv6_addr_any(mcastgrp))
1055 goto skip;
1056
1057 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1058 if (ipv6_addr_any(&c->mf6c_origin) &&
1059 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1060 if (c->mfc_un.res.ttls[mifi] < 255)
1061 return c;
1062
1063 /* It's ok if the mifi is part of the static tree */
1064 proxy = ip6mr_cache_find_any_parent(mrt,
1065 c->mf6c_parent);
1066 if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1067 return c;
1068 }
1069
1070 skip:
1071 return ip6mr_cache_find_any_parent(mrt, mifi);
1072 }
1073
1074 /*
1075 * Allocate a multicast cache entry
1076 */
1077 static struct mfc6_cache *ip6mr_cache_alloc(void)
1078 {
1079 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1080 if (!c)
1081 return NULL;
1082 c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
1083 c->mfc_un.res.minvif = MAXMIFS;
1084 return c;
1085 }
1086
1087 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1088 {
1089 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1090 if (!c)
1091 return NULL;
1092 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1093 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1094 return c;
1095 }
1096
1097 /*
1098 * A cache entry has gone into a resolved state from queued
1099 */
1100
1101 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1102 struct mfc6_cache *uc, struct mfc6_cache *c)
1103 {
1104 struct sk_buff *skb;
1105
1106 /*
1107 * Play the pending entries through our router
1108 */
1109
1110 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1111 if (ipv6_hdr(skb)->version == 0) {
1112 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1113
1114 if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1115 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1116 } else {
1117 nlh->nlmsg_type = NLMSG_ERROR;
1118 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1119 skb_trim(skb, nlh->nlmsg_len);
1120 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1121 }
1122 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1123 } else
1124 ip6_mr_forward(net, mrt, skb, c);
1125 }
1126 }
1127
1128 /*
1129 * Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
1130 * expects the following bizarre scheme.
1131 *
1132 * Called under mrt_lock.
1133 */
1134
1135 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1136 mifi_t mifi, int assert)
1137 {
1138 struct sk_buff *skb;
1139 struct mrt6msg *msg;
1140 int ret;
1141
1142 #ifdef CONFIG_IPV6_PIMSM_V2
1143 if (assert == MRT6MSG_WHOLEPKT)
1144 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1145 +sizeof(*msg));
1146 else
1147 #endif
1148 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1149
1150 if (!skb)
1151 return -ENOBUFS;
1152
1153 /* I suppose that internal messages
1154 * do not require checksums */
1155
1156 skb->ip_summed = CHECKSUM_UNNECESSARY;
1157
1158 #ifdef CONFIG_IPV6_PIMSM_V2
1159 if (assert == MRT6MSG_WHOLEPKT) {
1160 /* Ugly, but we have no choice with this interface.
1161 Duplicate old header, fix length etc.
1162 And all this only to mangle msg->im6_msgtype and
1163 to set msg->im6_mbz to "mbz" :-)
1164 */
1165 skb_push(skb, -skb_network_offset(pkt));
1166
1167 skb_push(skb, sizeof(*msg));
1168 skb_reset_transport_header(skb);
1169 msg = (struct mrt6msg *)skb_transport_header(skb);
1170 msg->im6_mbz = 0;
1171 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1172 msg->im6_mif = mrt->mroute_reg_vif_num;
1173 msg->im6_pad = 0;
1174 msg->im6_src = ipv6_hdr(pkt)->saddr;
1175 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1176
1177 skb->ip_summed = CHECKSUM_UNNECESSARY;
1178 } else
1179 #endif
1180 {
1181 /*
1182 * Copy the IP header
1183 */
1184
1185 skb_put(skb, sizeof(struct ipv6hdr));
1186 skb_reset_network_header(skb);
1187 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1188
1189 /*
1190 * Add our header
1191 */
1192 skb_put(skb, sizeof(*msg));
1193 skb_reset_transport_header(skb);
1194 msg = (struct mrt6msg *)skb_transport_header(skb);
1195
1196 msg->im6_mbz = 0;
1197 msg->im6_msgtype = assert;
1198 msg->im6_mif = mifi;
1199 msg->im6_pad = 0;
1200 msg->im6_src = ipv6_hdr(pkt)->saddr;
1201 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1202
1203 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1204 skb->ip_summed = CHECKSUM_UNNECESSARY;
1205 }
1206
1207 if (!mrt->mroute6_sk) {
1208 kfree_skb(skb);
1209 return -EINVAL;
1210 }
1211
1212 /*
1213 * Deliver to user space multicast routing algorithms
1214 */
1215 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1216 if (ret < 0) {
1217 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1218 kfree_skb(skb);
1219 }
1220
1221 return ret;
1222 }
1223
1224 /*
1225 * Queue a packet for resolution. It gets locked cache entry!
1226 */
1227
1228 static int
1229 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1230 {
1231 bool found = false;
1232 int err;
1233 struct mfc6_cache *c;
1234
1235 spin_lock_bh(&mfc_unres_lock);
1236 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1237 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1238 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1239 found = true;
1240 break;
1241 }
1242 }
1243
1244 if (!found) {
1245 /*
1246 * Create a new entry if allowable
1247 */
1248
1249 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1250 (c = ip6mr_cache_alloc_unres()) == NULL) {
1251 spin_unlock_bh(&mfc_unres_lock);
1252
1253 kfree_skb(skb);
1254 return -ENOBUFS;
1255 }
1256
1257 /*
1258 * Fill in the new cache entry
1259 */
1260 c->mf6c_parent = -1;
1261 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1262 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1263
1264 /*
1265 * Reflect first query at pim6sd
1266 */
1267 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1268 if (err < 0) {
1269 /* If the report failed throw the cache entry
1270 out - Brad Parker
1271 */
1272 spin_unlock_bh(&mfc_unres_lock);
1273
1274 ip6mr_cache_free(c);
1275 kfree_skb(skb);
1276 return err;
1277 }
1278
1279 atomic_inc(&mrt->cache_resolve_queue_len);
1280 list_add(&c->list, &mrt->mfc6_unres_queue);
1281 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1282
1283 ipmr_do_expire_process(mrt);
1284 }
1285
1286 /*
1287 * See if we can append the packet
1288 */
1289 if (c->mfc_un.unres.unresolved.qlen > 3) {
1290 kfree_skb(skb);
1291 err = -ENOBUFS;
1292 } else {
1293 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1294 err = 0;
1295 }
1296
1297 spin_unlock_bh(&mfc_unres_lock);
1298 return err;
1299 }
1300
1301 /*
1302 * MFC6 cache manipulation by user space
1303 */
1304
1305 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1306 int parent)
1307 {
1308 int line;
1309 struct mfc6_cache *c, *next;
1310
1311 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1312
1313 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1314 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1315 ipv6_addr_equal(&c->mf6c_mcastgrp,
1316 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1317 (parent == -1 || parent == c->mf6c_parent)) {
1318 write_lock_bh(&mrt_lock);
1319 list_del(&c->list);
1320 write_unlock_bh(&mrt_lock);
1321
1322 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1323 ip6mr_cache_free(c);
1324 return 0;
1325 }
1326 }
1327 return -ENOENT;
1328 }
1329
1330 static int ip6mr_device_event(struct notifier_block *this,
1331 unsigned long event, void *ptr)
1332 {
1333 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1334 struct net *net = dev_net(dev);
1335 struct mr6_table *mrt;
1336 struct mif_device *v;
1337 int ct;
1338
1339 if (event != NETDEV_UNREGISTER)
1340 return NOTIFY_DONE;
1341
1342 ip6mr_for_each_table(mrt, net) {
1343 v = &mrt->vif6_table[0];
1344 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1345 if (v->dev == dev)
1346 mif6_delete(mrt, ct, 1, NULL);
1347 }
1348 }
1349
1350 return NOTIFY_DONE;
1351 }
1352
1353 static struct notifier_block ip6_mr_notifier = {
1354 .notifier_call = ip6mr_device_event
1355 };
1356
1357 /*
1358 * Setup for IP multicast routing
1359 */
1360
1361 static int __net_init ip6mr_net_init(struct net *net)
1362 {
1363 int err;
1364
1365 err = ip6mr_rules_init(net);
1366 if (err < 0)
1367 goto fail;
1368
1369 #ifdef CONFIG_PROC_FS
1370 err = -ENOMEM;
1371 if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1372 goto proc_vif_fail;
1373 if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1374 goto proc_cache_fail;
1375 #endif
1376
1377 return 0;
1378
1379 #ifdef CONFIG_PROC_FS
1380 proc_cache_fail:
1381 remove_proc_entry("ip6_mr_vif", net->proc_net);
1382 proc_vif_fail:
1383 ip6mr_rules_exit(net);
1384 #endif
1385 fail:
1386 return err;
1387 }
1388
1389 static void __net_exit ip6mr_net_exit(struct net *net)
1390 {
1391 #ifdef CONFIG_PROC_FS
1392 remove_proc_entry("ip6_mr_cache", net->proc_net);
1393 remove_proc_entry("ip6_mr_vif", net->proc_net);
1394 #endif
1395 ip6mr_rules_exit(net);
1396 }
1397
1398 static struct pernet_operations ip6mr_net_ops = {
1399 .init = ip6mr_net_init,
1400 .exit = ip6mr_net_exit,
1401 };
1402
1403 int __init ip6_mr_init(void)
1404 {
1405 int err;
1406
1407 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1408 sizeof(struct mfc6_cache),
1409 0, SLAB_HWCACHE_ALIGN,
1410 NULL);
1411 if (!mrt_cachep)
1412 return -ENOMEM;
1413
1414 err = register_pernet_subsys(&ip6mr_net_ops);
1415 if (err)
1416 goto reg_pernet_fail;
1417
1418 err = register_netdevice_notifier(&ip6_mr_notifier);
1419 if (err)
1420 goto reg_notif_fail;
1421 #ifdef CONFIG_IPV6_PIMSM_V2
1422 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1423 pr_err("%s: can't add PIM protocol\n", __func__);
1424 err = -EAGAIN;
1425 goto add_proto_fail;
1426 }
1427 #endif
1428 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1429 ip6mr_rtm_dumproute, NULL);
1430 return 0;
1431 #ifdef CONFIG_IPV6_PIMSM_V2
1432 add_proto_fail:
1433 unregister_netdevice_notifier(&ip6_mr_notifier);
1434 #endif
1435 reg_notif_fail:
1436 unregister_pernet_subsys(&ip6mr_net_ops);
1437 reg_pernet_fail:
1438 kmem_cache_destroy(mrt_cachep);
1439 return err;
1440 }
1441
1442 void ip6_mr_cleanup(void)
1443 {
1444 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1445 #ifdef CONFIG_IPV6_PIMSM_V2
1446 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1447 #endif
1448 unregister_netdevice_notifier(&ip6_mr_notifier);
1449 unregister_pernet_subsys(&ip6mr_net_ops);
1450 kmem_cache_destroy(mrt_cachep);
1451 }
1452
1453 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1454 struct mf6cctl *mfc, int mrtsock, int parent)
1455 {
1456 bool found = false;
1457 int line;
1458 struct mfc6_cache *uc, *c;
1459 unsigned char ttls[MAXMIFS];
1460 int i;
1461
1462 if (mfc->mf6cc_parent >= MAXMIFS)
1463 return -ENFILE;
1464
1465 memset(ttls, 255, MAXMIFS);
1466 for (i = 0; i < MAXMIFS; i++) {
1467 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1468 ttls[i] = 1;
1469
1470 }
1471
1472 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1473
1474 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1475 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1476 ipv6_addr_equal(&c->mf6c_mcastgrp,
1477 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1478 (parent == -1 || parent == mfc->mf6cc_parent)) {
1479 found = true;
1480 break;
1481 }
1482 }
1483
1484 if (found) {
1485 write_lock_bh(&mrt_lock);
1486 c->mf6c_parent = mfc->mf6cc_parent;
1487 ip6mr_update_thresholds(mrt, c, ttls);
1488 if (!mrtsock)
1489 c->mfc_flags |= MFC_STATIC;
1490 write_unlock_bh(&mrt_lock);
1491 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1492 return 0;
1493 }
1494
1495 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1496 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1497 return -EINVAL;
1498
1499 c = ip6mr_cache_alloc();
1500 if (!c)
1501 return -ENOMEM;
1502
1503 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1504 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1505 c->mf6c_parent = mfc->mf6cc_parent;
1506 ip6mr_update_thresholds(mrt, c, ttls);
1507 if (!mrtsock)
1508 c->mfc_flags |= MFC_STATIC;
1509
1510 write_lock_bh(&mrt_lock);
1511 list_add(&c->list, &mrt->mfc6_cache_array[line]);
1512 write_unlock_bh(&mrt_lock);
1513
1514 /*
1515 * Check to see if we resolved a queued list. If so we
1516 * need to send on the frames and tidy up.
1517 */
1518 found = false;
1519 spin_lock_bh(&mfc_unres_lock);
1520 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1521 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1522 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1523 list_del(&uc->list);
1524 atomic_dec(&mrt->cache_resolve_queue_len);
1525 found = true;
1526 break;
1527 }
1528 }
1529 if (list_empty(&mrt->mfc6_unres_queue))
1530 del_timer(&mrt->ipmr_expire_timer);
1531 spin_unlock_bh(&mfc_unres_lock);
1532
1533 if (found) {
1534 ip6mr_cache_resolve(net, mrt, uc, c);
1535 ip6mr_cache_free(uc);
1536 }
1537 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1538 return 0;
1539 }
1540
1541 /*
1542 * Close the multicast socket, and clear the vif tables etc
1543 */
1544
1545 static void mroute_clean_tables(struct mr6_table *mrt, bool all)
1546 {
1547 int i;
1548 LIST_HEAD(list);
1549 struct mfc6_cache *c, *next;
1550
1551 /*
1552 * Shut down all active vif entries
1553 */
1554 for (i = 0; i < mrt->maxvif; i++) {
1555 if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
1556 continue;
1557 mif6_delete(mrt, i, 0, &list);
1558 }
1559 unregister_netdevice_many(&list);
1560
1561 /*
1562 * Wipe the cache
1563 */
1564 for (i = 0; i < MFC6_LINES; i++) {
1565 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1566 if (!all && (c->mfc_flags & MFC_STATIC))
1567 continue;
1568 write_lock_bh(&mrt_lock);
1569 list_del(&c->list);
1570 write_unlock_bh(&mrt_lock);
1571
1572 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1573 ip6mr_cache_free(c);
1574 }
1575 }
1576
1577 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1578 spin_lock_bh(&mfc_unres_lock);
1579 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1580 list_del(&c->list);
1581 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1582 ip6mr_destroy_unres(mrt, c);
1583 }
1584 spin_unlock_bh(&mfc_unres_lock);
1585 }
1586 }
1587
1588 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1589 {
1590 int err = 0;
1591 struct net *net = sock_net(sk);
1592
1593 rtnl_lock();
1594 write_lock_bh(&mrt_lock);
1595 if (likely(mrt->mroute6_sk == NULL)) {
1596 mrt->mroute6_sk = sk;
1597 net->ipv6.devconf_all->mc_forwarding++;
1598 } else {
1599 err = -EADDRINUSE;
1600 }
1601 write_unlock_bh(&mrt_lock);
1602
1603 if (!err)
1604 inet6_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
1605 NETCONFA_IFINDEX_ALL,
1606 net->ipv6.devconf_all);
1607 rtnl_unlock();
1608
1609 return err;
1610 }
1611
1612 int ip6mr_sk_done(struct sock *sk)
1613 {
1614 int err = -EACCES;
1615 struct net *net = sock_net(sk);
1616 struct mr6_table *mrt;
1617
1618 rtnl_lock();
1619 ip6mr_for_each_table(mrt, net) {
1620 if (sk == mrt->mroute6_sk) {
1621 write_lock_bh(&mrt_lock);
1622 mrt->mroute6_sk = NULL;
1623 net->ipv6.devconf_all->mc_forwarding--;
1624 write_unlock_bh(&mrt_lock);
1625 inet6_netconf_notify_devconf(net,
1626 NETCONFA_MC_FORWARDING,
1627 NETCONFA_IFINDEX_ALL,
1628 net->ipv6.devconf_all);
1629
1630 mroute_clean_tables(mrt, false);
1631 err = 0;
1632 break;
1633 }
1634 }
1635 rtnl_unlock();
1636
1637 return err;
1638 }
1639
1640 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1641 {
1642 struct mr6_table *mrt;
1643 struct flowi6 fl6 = {
1644 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
1645 .flowi6_oif = skb->dev->ifindex,
1646 .flowi6_mark = skb->mark,
1647 };
1648
1649 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1650 return NULL;
1651
1652 return mrt->mroute6_sk;
1653 }
1654
1655 /*
1656 * Socket options and virtual interface manipulation. The whole
1657 * virtual interface system is a complete heap, but unfortunately
1658 * that's how BSD mrouted happens to think. Maybe one day with a proper
1659 * MOSPF/PIM router set up we can clean this up.
1660 */
1661
1662 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1663 {
1664 int ret, parent = 0;
1665 struct mif6ctl vif;
1666 struct mf6cctl mfc;
1667 mifi_t mifi;
1668 struct net *net = sock_net(sk);
1669 struct mr6_table *mrt;
1670
1671 if (sk->sk_type != SOCK_RAW ||
1672 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1673 return -EOPNOTSUPP;
1674
1675 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1676 if (!mrt)
1677 return -ENOENT;
1678
1679 if (optname != MRT6_INIT) {
1680 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1681 return -EACCES;
1682 }
1683
1684 switch (optname) {
1685 case MRT6_INIT:
1686 if (optlen < sizeof(int))
1687 return -EINVAL;
1688
1689 return ip6mr_sk_init(mrt, sk);
1690
1691 case MRT6_DONE:
1692 return ip6mr_sk_done(sk);
1693
1694 case MRT6_ADD_MIF:
1695 if (optlen < sizeof(vif))
1696 return -EINVAL;
1697 if (copy_from_user(&vif, optval, sizeof(vif)))
1698 return -EFAULT;
1699 if (vif.mif6c_mifi >= MAXMIFS)
1700 return -ENFILE;
1701 rtnl_lock();
1702 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1703 rtnl_unlock();
1704 return ret;
1705
1706 case MRT6_DEL_MIF:
1707 if (optlen < sizeof(mifi_t))
1708 return -EINVAL;
1709 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1710 return -EFAULT;
1711 rtnl_lock();
1712 ret = mif6_delete(mrt, mifi, 0, NULL);
1713 rtnl_unlock();
1714 return ret;
1715
1716 /*
1717 * Manipulate the forwarding caches. These live
1718 * in a sort of kernel/user symbiosis.
1719 */
1720 case MRT6_ADD_MFC:
1721 case MRT6_DEL_MFC:
1722 parent = -1;
1723 case MRT6_ADD_MFC_PROXY:
1724 case MRT6_DEL_MFC_PROXY:
1725 if (optlen < sizeof(mfc))
1726 return -EINVAL;
1727 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1728 return -EFAULT;
1729 if (parent == 0)
1730 parent = mfc.mf6cc_parent;
1731 rtnl_lock();
1732 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1733 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1734 else
1735 ret = ip6mr_mfc_add(net, mrt, &mfc,
1736 sk == mrt->mroute6_sk, parent);
1737 rtnl_unlock();
1738 return ret;
1739
1740 /*
1741 * Control PIM assert (to activate pim will activate assert)
1742 */
1743 case MRT6_ASSERT:
1744 {
1745 int v;
1746
1747 if (optlen != sizeof(v))
1748 return -EINVAL;
1749 if (get_user(v, (int __user *)optval))
1750 return -EFAULT;
1751 mrt->mroute_do_assert = v;
1752 return 0;
1753 }
1754
1755 #ifdef CONFIG_IPV6_PIMSM_V2
1756 case MRT6_PIM:
1757 {
1758 int v;
1759
1760 if (optlen != sizeof(v))
1761 return -EINVAL;
1762 if (get_user(v, (int __user *)optval))
1763 return -EFAULT;
1764 v = !!v;
1765 rtnl_lock();
1766 ret = 0;
1767 if (v != mrt->mroute_do_pim) {
1768 mrt->mroute_do_pim = v;
1769 mrt->mroute_do_assert = v;
1770 }
1771 rtnl_unlock();
1772 return ret;
1773 }
1774
1775 #endif
1776 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1777 case MRT6_TABLE:
1778 {
1779 u32 v;
1780
1781 if (optlen != sizeof(u32))
1782 return -EINVAL;
1783 if (get_user(v, (u32 __user *)optval))
1784 return -EFAULT;
1785 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1786 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1787 return -EINVAL;
1788 if (sk == mrt->mroute6_sk)
1789 return -EBUSY;
1790
1791 rtnl_lock();
1792 ret = 0;
1793 if (!ip6mr_new_table(net, v))
1794 ret = -ENOMEM;
1795 else
1796 raw6_sk(sk)->ip6mr_table = v;
1797 rtnl_unlock();
1798 return ret;
1799 }
1800 #endif
1801 /*
1802 * Spurious command, or MRT6_VERSION which you cannot
1803 * set.
1804 */
1805 default:
1806 return -ENOPROTOOPT;
1807 }
1808 }
1809
1810 /*
1811 * Getsock opt support for the multicast routing system.
1812 */
1813
1814 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1815 int __user *optlen)
1816 {
1817 int olr;
1818 int val;
1819 struct net *net = sock_net(sk);
1820 struct mr6_table *mrt;
1821
1822 if (sk->sk_type != SOCK_RAW ||
1823 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1824 return -EOPNOTSUPP;
1825
1826 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1827 if (!mrt)
1828 return -ENOENT;
1829
1830 switch (optname) {
1831 case MRT6_VERSION:
1832 val = 0x0305;
1833 break;
1834 #ifdef CONFIG_IPV6_PIMSM_V2
1835 case MRT6_PIM:
1836 val = mrt->mroute_do_pim;
1837 break;
1838 #endif
1839 case MRT6_ASSERT:
1840 val = mrt->mroute_do_assert;
1841 break;
1842 default:
1843 return -ENOPROTOOPT;
1844 }
1845
1846 if (get_user(olr, optlen))
1847 return -EFAULT;
1848
1849 olr = min_t(int, olr, sizeof(int));
1850 if (olr < 0)
1851 return -EINVAL;
1852
1853 if (put_user(olr, optlen))
1854 return -EFAULT;
1855 if (copy_to_user(optval, &val, olr))
1856 return -EFAULT;
1857 return 0;
1858 }
1859
1860 /*
1861 * The IP multicast ioctl support routines.
1862 */
1863
1864 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1865 {
1866 struct sioc_sg_req6 sr;
1867 struct sioc_mif_req6 vr;
1868 struct mif_device *vif;
1869 struct mfc6_cache *c;
1870 struct net *net = sock_net(sk);
1871 struct mr6_table *mrt;
1872
1873 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1874 if (!mrt)
1875 return -ENOENT;
1876
1877 switch (cmd) {
1878 case SIOCGETMIFCNT_IN6:
1879 if (copy_from_user(&vr, arg, sizeof(vr)))
1880 return -EFAULT;
1881 if (vr.mifi >= mrt->maxvif)
1882 return -EINVAL;
1883 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1884 read_lock(&mrt_lock);
1885 vif = &mrt->vif6_table[vr.mifi];
1886 if (MIF_EXISTS(mrt, vr.mifi)) {
1887 vr.icount = vif->pkt_in;
1888 vr.ocount = vif->pkt_out;
1889 vr.ibytes = vif->bytes_in;
1890 vr.obytes = vif->bytes_out;
1891 read_unlock(&mrt_lock);
1892
1893 if (copy_to_user(arg, &vr, sizeof(vr)))
1894 return -EFAULT;
1895 return 0;
1896 }
1897 read_unlock(&mrt_lock);
1898 return -EADDRNOTAVAIL;
1899 case SIOCGETSGCNT_IN6:
1900 if (copy_from_user(&sr, arg, sizeof(sr)))
1901 return -EFAULT;
1902
1903 read_lock(&mrt_lock);
1904 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1905 if (c) {
1906 sr.pktcnt = c->mfc_un.res.pkt;
1907 sr.bytecnt = c->mfc_un.res.bytes;
1908 sr.wrong_if = c->mfc_un.res.wrong_if;
1909 read_unlock(&mrt_lock);
1910
1911 if (copy_to_user(arg, &sr, sizeof(sr)))
1912 return -EFAULT;
1913 return 0;
1914 }
1915 read_unlock(&mrt_lock);
1916 return -EADDRNOTAVAIL;
1917 default:
1918 return -ENOIOCTLCMD;
1919 }
1920 }
1921
1922 #ifdef CONFIG_COMPAT
1923 struct compat_sioc_sg_req6 {
1924 struct sockaddr_in6 src;
1925 struct sockaddr_in6 grp;
1926 compat_ulong_t pktcnt;
1927 compat_ulong_t bytecnt;
1928 compat_ulong_t wrong_if;
1929 };
1930
1931 struct compat_sioc_mif_req6 {
1932 mifi_t mifi;
1933 compat_ulong_t icount;
1934 compat_ulong_t ocount;
1935 compat_ulong_t ibytes;
1936 compat_ulong_t obytes;
1937 };
1938
1939 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1940 {
1941 struct compat_sioc_sg_req6 sr;
1942 struct compat_sioc_mif_req6 vr;
1943 struct mif_device *vif;
1944 struct mfc6_cache *c;
1945 struct net *net = sock_net(sk);
1946 struct mr6_table *mrt;
1947
1948 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1949 if (!mrt)
1950 return -ENOENT;
1951
1952 switch (cmd) {
1953 case SIOCGETMIFCNT_IN6:
1954 if (copy_from_user(&vr, arg, sizeof(vr)))
1955 return -EFAULT;
1956 if (vr.mifi >= mrt->maxvif)
1957 return -EINVAL;
1958 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1959 read_lock(&mrt_lock);
1960 vif = &mrt->vif6_table[vr.mifi];
1961 if (MIF_EXISTS(mrt, vr.mifi)) {
1962 vr.icount = vif->pkt_in;
1963 vr.ocount = vif->pkt_out;
1964 vr.ibytes = vif->bytes_in;
1965 vr.obytes = vif->bytes_out;
1966 read_unlock(&mrt_lock);
1967
1968 if (copy_to_user(arg, &vr, sizeof(vr)))
1969 return -EFAULT;
1970 return 0;
1971 }
1972 read_unlock(&mrt_lock);
1973 return -EADDRNOTAVAIL;
1974 case SIOCGETSGCNT_IN6:
1975 if (copy_from_user(&sr, arg, sizeof(sr)))
1976 return -EFAULT;
1977
1978 read_lock(&mrt_lock);
1979 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1980 if (c) {
1981 sr.pktcnt = c->mfc_un.res.pkt;
1982 sr.bytecnt = c->mfc_un.res.bytes;
1983 sr.wrong_if = c->mfc_un.res.wrong_if;
1984 read_unlock(&mrt_lock);
1985
1986 if (copy_to_user(arg, &sr, sizeof(sr)))
1987 return -EFAULT;
1988 return 0;
1989 }
1990 read_unlock(&mrt_lock);
1991 return -EADDRNOTAVAIL;
1992 default:
1993 return -ENOIOCTLCMD;
1994 }
1995 }
1996 #endif
1997
1998 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
1999 {
2000 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2001 IPSTATS_MIB_OUTFORWDATAGRAMS);
2002 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2003 IPSTATS_MIB_OUTOCTETS, skb->len);
2004 return dst_output(net, sk, skb);
2005 }
2006
2007 /*
2008 * Processing handlers for ip6mr_forward
2009 */
2010
2011 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2012 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
2013 {
2014 struct ipv6hdr *ipv6h;
2015 struct mif_device *vif = &mrt->vif6_table[vifi];
2016 struct net_device *dev;
2017 struct dst_entry *dst;
2018 struct flowi6 fl6;
2019
2020 if (!vif->dev)
2021 goto out_free;
2022
2023 #ifdef CONFIG_IPV6_PIMSM_V2
2024 if (vif->flags & MIFF_REGISTER) {
2025 vif->pkt_out++;
2026 vif->bytes_out += skb->len;
2027 vif->dev->stats.tx_bytes += skb->len;
2028 vif->dev->stats.tx_packets++;
2029 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2030 goto out_free;
2031 }
2032 #endif
2033
2034 ipv6h = ipv6_hdr(skb);
2035
2036 fl6 = (struct flowi6) {
2037 .flowi6_oif = vif->link,
2038 .daddr = ipv6h->daddr,
2039 };
2040
2041 dst = ip6_route_output(net, NULL, &fl6);
2042 if (dst->error) {
2043 dst_release(dst);
2044 goto out_free;
2045 }
2046
2047 skb_dst_drop(skb);
2048 skb_dst_set(skb, dst);
2049
2050 /*
2051 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2052 * not only before forwarding, but after forwarding on all output
2053 * interfaces. It is clear, if mrouter runs a multicasting
2054 * program, it should receive packets not depending to what interface
2055 * program is joined.
2056 * If we will not make it, the program will have to join on all
2057 * interfaces. On the other hand, multihoming host (or router, but
2058 * not mrouter) cannot join to more than one interface - it will
2059 * result in receiving multiple packets.
2060 */
2061 dev = vif->dev;
2062 skb->dev = dev;
2063 vif->pkt_out++;
2064 vif->bytes_out += skb->len;
2065
2066 /* We are about to write */
2067 /* XXX: extension headers? */
2068 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2069 goto out_free;
2070
2071 ipv6h = ipv6_hdr(skb);
2072 ipv6h->hop_limit--;
2073
2074 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2075
2076 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2077 net, NULL, skb, skb->dev, dev,
2078 ip6mr_forward2_finish);
2079
2080 out_free:
2081 kfree_skb(skb);
2082 return 0;
2083 }
2084
2085 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2086 {
2087 int ct;
2088
2089 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2090 if (mrt->vif6_table[ct].dev == dev)
2091 break;
2092 }
2093 return ct;
2094 }
2095
2096 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2097 struct sk_buff *skb, struct mfc6_cache *cache)
2098 {
2099 int psend = -1;
2100 int vif, ct;
2101 int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2102
2103 vif = cache->mf6c_parent;
2104 cache->mfc_un.res.pkt++;
2105 cache->mfc_un.res.bytes += skb->len;
2106 cache->mfc_un.res.lastuse = jiffies;
2107
2108 if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2109 struct mfc6_cache *cache_proxy;
2110
2111 /* For an (*,G) entry, we only check that the incoming
2112 * interface is part of the static tree.
2113 */
2114 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2115 if (cache_proxy &&
2116 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2117 goto forward;
2118 }
2119
2120 /*
2121 * Wrong interface: drop packet and (maybe) send PIM assert.
2122 */
2123 if (mrt->vif6_table[vif].dev != skb->dev) {
2124 cache->mfc_un.res.wrong_if++;
2125
2126 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2127 /* pimsm uses asserts, when switching from RPT to SPT,
2128 so that we cannot check that packet arrived on an oif.
2129 It is bad, but otherwise we would need to move pretty
2130 large chunk of pimd to kernel. Ough... --ANK
2131 */
2132 (mrt->mroute_do_pim ||
2133 cache->mfc_un.res.ttls[true_vifi] < 255) &&
2134 time_after(jiffies,
2135 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2136 cache->mfc_un.res.last_assert = jiffies;
2137 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2138 }
2139 goto dont_forward;
2140 }
2141
2142 forward:
2143 mrt->vif6_table[vif].pkt_in++;
2144 mrt->vif6_table[vif].bytes_in += skb->len;
2145
2146 /*
2147 * Forward the frame
2148 */
2149 if (ipv6_addr_any(&cache->mf6c_origin) &&
2150 ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2151 if (true_vifi >= 0 &&
2152 true_vifi != cache->mf6c_parent &&
2153 ipv6_hdr(skb)->hop_limit >
2154 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2155 /* It's an (*,*) entry and the packet is not coming from
2156 * the upstream: forward the packet to the upstream
2157 * only.
2158 */
2159 psend = cache->mf6c_parent;
2160 goto last_forward;
2161 }
2162 goto dont_forward;
2163 }
2164 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2165 /* For (*,G) entry, don't forward to the incoming interface */
2166 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2167 ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2168 if (psend != -1) {
2169 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2170 if (skb2)
2171 ip6mr_forward2(net, mrt, skb2, cache, psend);
2172 }
2173 psend = ct;
2174 }
2175 }
2176 last_forward:
2177 if (psend != -1) {
2178 ip6mr_forward2(net, mrt, skb, cache, psend);
2179 return;
2180 }
2181
2182 dont_forward:
2183 kfree_skb(skb);
2184 }
2185
2186
2187 /*
2188 * Multicast packets for forwarding arrive here
2189 */
2190
2191 int ip6_mr_input(struct sk_buff *skb)
2192 {
2193 struct mfc6_cache *cache;
2194 struct net *net = dev_net(skb->dev);
2195 struct mr6_table *mrt;
2196 struct flowi6 fl6 = {
2197 .flowi6_iif = skb->dev->ifindex,
2198 .flowi6_mark = skb->mark,
2199 };
2200 int err;
2201
2202 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2203 if (err < 0) {
2204 kfree_skb(skb);
2205 return err;
2206 }
2207
2208 read_lock(&mrt_lock);
2209 cache = ip6mr_cache_find(mrt,
2210 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2211 if (!cache) {
2212 int vif = ip6mr_find_vif(mrt, skb->dev);
2213
2214 if (vif >= 0)
2215 cache = ip6mr_cache_find_any(mrt,
2216 &ipv6_hdr(skb)->daddr,
2217 vif);
2218 }
2219
2220 /*
2221 * No usable cache entry
2222 */
2223 if (!cache) {
2224 int vif;
2225
2226 vif = ip6mr_find_vif(mrt, skb->dev);
2227 if (vif >= 0) {
2228 int err = ip6mr_cache_unresolved(mrt, vif, skb);
2229 read_unlock(&mrt_lock);
2230
2231 return err;
2232 }
2233 read_unlock(&mrt_lock);
2234 kfree_skb(skb);
2235 return -ENODEV;
2236 }
2237
2238 ip6_mr_forward(net, mrt, skb, cache);
2239
2240 read_unlock(&mrt_lock);
2241
2242 return 0;
2243 }
2244
2245
2246 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2247 struct mfc6_cache *c, struct rtmsg *rtm)
2248 {
2249 struct rta_mfc_stats mfcs;
2250 struct nlattr *mp_attr;
2251 struct rtnexthop *nhp;
2252 unsigned long lastuse;
2253 int ct;
2254
2255 /* If cache is unresolved, don't try to parse IIF and OIF */
2256 if (c->mf6c_parent >= MAXMIFS)
2257 return -ENOENT;
2258
2259 if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2260 nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2261 return -EMSGSIZE;
2262 mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2263 if (!mp_attr)
2264 return -EMSGSIZE;
2265
2266 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2267 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2268 nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2269 if (!nhp) {
2270 nla_nest_cancel(skb, mp_attr);
2271 return -EMSGSIZE;
2272 }
2273
2274 nhp->rtnh_flags = 0;
2275 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2276 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2277 nhp->rtnh_len = sizeof(*nhp);
2278 }
2279 }
2280
2281 nla_nest_end(skb, mp_attr);
2282
2283 lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2284 lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2285
2286 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2287 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2288 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2289 if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
2290 nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
2291 RTA_PAD))
2292 return -EMSGSIZE;
2293
2294 rtm->rtm_type = RTN_MULTICAST;
2295 return 1;
2296 }
2297
2298 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2299 int nowait, u32 portid)
2300 {
2301 int err;
2302 struct mr6_table *mrt;
2303 struct mfc6_cache *cache;
2304 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2305
2306 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2307 if (!mrt)
2308 return -ENOENT;
2309
2310 read_lock(&mrt_lock);
2311 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2312 if (!cache && skb->dev) {
2313 int vif = ip6mr_find_vif(mrt, skb->dev);
2314
2315 if (vif >= 0)
2316 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2317 vif);
2318 }
2319
2320 if (!cache) {
2321 struct sk_buff *skb2;
2322 struct ipv6hdr *iph;
2323 struct net_device *dev;
2324 int vif;
2325
2326 if (nowait) {
2327 read_unlock(&mrt_lock);
2328 return -EAGAIN;
2329 }
2330
2331 dev = skb->dev;
2332 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2333 read_unlock(&mrt_lock);
2334 return -ENODEV;
2335 }
2336
2337 /* really correct? */
2338 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2339 if (!skb2) {
2340 read_unlock(&mrt_lock);
2341 return -ENOMEM;
2342 }
2343
2344 NETLINK_CB(skb2).portid = portid;
2345 skb_reset_transport_header(skb2);
2346
2347 skb_put(skb2, sizeof(struct ipv6hdr));
2348 skb_reset_network_header(skb2);
2349
2350 iph = ipv6_hdr(skb2);
2351 iph->version = 0;
2352 iph->priority = 0;
2353 iph->flow_lbl[0] = 0;
2354 iph->flow_lbl[1] = 0;
2355 iph->flow_lbl[2] = 0;
2356 iph->payload_len = 0;
2357 iph->nexthdr = IPPROTO_NONE;
2358 iph->hop_limit = 0;
2359 iph->saddr = rt->rt6i_src.addr;
2360 iph->daddr = rt->rt6i_dst.addr;
2361
2362 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2363 read_unlock(&mrt_lock);
2364
2365 return err;
2366 }
2367
2368 if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2369 cache->mfc_flags |= MFC_NOTIFY;
2370
2371 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2372 read_unlock(&mrt_lock);
2373 return err;
2374 }
2375
2376 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2377 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2378 int flags)
2379 {
2380 struct nlmsghdr *nlh;
2381 struct rtmsg *rtm;
2382 int err;
2383
2384 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2385 if (!nlh)
2386 return -EMSGSIZE;
2387
2388 rtm = nlmsg_data(nlh);
2389 rtm->rtm_family = RTNL_FAMILY_IP6MR;
2390 rtm->rtm_dst_len = 128;
2391 rtm->rtm_src_len = 128;
2392 rtm->rtm_tos = 0;
2393 rtm->rtm_table = mrt->id;
2394 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2395 goto nla_put_failure;
2396 rtm->rtm_type = RTN_MULTICAST;
2397 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2398 if (c->mfc_flags & MFC_STATIC)
2399 rtm->rtm_protocol = RTPROT_STATIC;
2400 else
2401 rtm->rtm_protocol = RTPROT_MROUTED;
2402 rtm->rtm_flags = 0;
2403
2404 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2405 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2406 goto nla_put_failure;
2407 err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2408 /* do not break the dump if cache is unresolved */
2409 if (err < 0 && err != -ENOENT)
2410 goto nla_put_failure;
2411
2412 nlmsg_end(skb, nlh);
2413 return 0;
2414
2415 nla_put_failure:
2416 nlmsg_cancel(skb, nlh);
2417 return -EMSGSIZE;
2418 }
2419
2420 static int mr6_msgsize(bool unresolved, int maxvif)
2421 {
2422 size_t len =
2423 NLMSG_ALIGN(sizeof(struct rtmsg))
2424 + nla_total_size(4) /* RTA_TABLE */
2425 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2426 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2427 ;
2428
2429 if (!unresolved)
2430 len = len
2431 + nla_total_size(4) /* RTA_IIF */
2432 + nla_total_size(0) /* RTA_MULTIPATH */
2433 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2434 /* RTA_MFC_STATS */
2435 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2436 ;
2437
2438 return len;
2439 }
2440
2441 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2442 int cmd)
2443 {
2444 struct net *net = read_pnet(&mrt->net);
2445 struct sk_buff *skb;
2446 int err = -ENOBUFS;
2447
2448 skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2449 GFP_ATOMIC);
2450 if (!skb)
2451 goto errout;
2452
2453 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2454 if (err < 0)
2455 goto errout;
2456
2457 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2458 return;
2459
2460 errout:
2461 kfree_skb(skb);
2462 if (err < 0)
2463 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2464 }
2465
2466 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2467 {
2468 struct net *net = sock_net(skb->sk);
2469 struct mr6_table *mrt;
2470 struct mfc6_cache *mfc;
2471 unsigned int t = 0, s_t;
2472 unsigned int h = 0, s_h;
2473 unsigned int e = 0, s_e;
2474
2475 s_t = cb->args[0];
2476 s_h = cb->args[1];
2477 s_e = cb->args[2];
2478
2479 read_lock(&mrt_lock);
2480 ip6mr_for_each_table(mrt, net) {
2481 if (t < s_t)
2482 goto next_table;
2483 if (t > s_t)
2484 s_h = 0;
2485 for (h = s_h; h < MFC6_LINES; h++) {
2486 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2487 if (e < s_e)
2488 goto next_entry;
2489 if (ip6mr_fill_mroute(mrt, skb,
2490 NETLINK_CB(cb->skb).portid,
2491 cb->nlh->nlmsg_seq,
2492 mfc, RTM_NEWROUTE,
2493 NLM_F_MULTI) < 0)
2494 goto done;
2495 next_entry:
2496 e++;
2497 }
2498 e = s_e = 0;
2499 }
2500 spin_lock_bh(&mfc_unres_lock);
2501 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2502 if (e < s_e)
2503 goto next_entry2;
2504 if (ip6mr_fill_mroute(mrt, skb,
2505 NETLINK_CB(cb->skb).portid,
2506 cb->nlh->nlmsg_seq,
2507 mfc, RTM_NEWROUTE,
2508 NLM_F_MULTI) < 0) {
2509 spin_unlock_bh(&mfc_unres_lock);
2510 goto done;
2511 }
2512 next_entry2:
2513 e++;
2514 }
2515 spin_unlock_bh(&mfc_unres_lock);
2516 e = s_e = 0;
2517 s_h = 0;
2518 next_table:
2519 t++;
2520 }
2521 done:
2522 read_unlock(&mrt_lock);
2523
2524 cb->args[2] = e;
2525 cb->args[1] = h;
2526 cb->args[0] = t;
2527
2528 return skb->len;
2529 }
Linux with added FPC-III support