?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/speculation/mds: Fix documentation typo
[linux/fpc-iii.git] / net / ipv6 / ip6mr.c
blob459f282d90e16591efa92a2c108caf76a9e9e123
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 <linux/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 void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt);
122 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
123 struct netlink_callback *cb);
124 static void mroute_clean_tables(struct mr6_table *mrt, bool all);
125 static void ipmr_expire_process(unsigned long arg);
126
127 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
128 #define ip6mr_for_each_table(mrt, net) \
129 list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
130
131 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
132 {
133 struct mr6_table *mrt;
134
135 ip6mr_for_each_table(mrt, net) {
136 if (mrt->id == id)
137 return mrt;
138 }
139 return NULL;
140 }
141
142 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
143 struct mr6_table **mrt)
144 {
145 int err;
146 struct ip6mr_result res;
147 struct fib_lookup_arg arg = {
148 .result = &res,
149 .flags = FIB_LOOKUP_NOREF,
150 };
151
152 err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
153 flowi6_to_flowi(flp6), 0, &arg);
154 if (err < 0)
155 return err;
156 *mrt = res.mrt;
157 return 0;
158 }
159
160 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
161 int flags, struct fib_lookup_arg *arg)
162 {
163 struct ip6mr_result *res = arg->result;
164 struct mr6_table *mrt;
165
166 switch (rule->action) {
167 case FR_ACT_TO_TBL:
168 break;
169 case FR_ACT_UNREACHABLE:
170 return -ENETUNREACH;
171 case FR_ACT_PROHIBIT:
172 return -EACCES;
173 case FR_ACT_BLACKHOLE:
174 default:
175 return -EINVAL;
176 }
177
178 mrt = ip6mr_get_table(rule->fr_net, rule->table);
179 if (!mrt)
180 return -EAGAIN;
181 res->mrt = mrt;
182 return 0;
183 }
184
185 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
186 {
187 return 1;
188 }
189
190 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
191 FRA_GENERIC_POLICY,
192 };
193
194 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
195 struct fib_rule_hdr *frh, struct nlattr **tb)
196 {
197 return 0;
198 }
199
200 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
201 struct nlattr **tb)
202 {
203 return 1;
204 }
205
206 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
207 struct fib_rule_hdr *frh)
208 {
209 frh->dst_len = 0;
210 frh->src_len = 0;
211 frh->tos = 0;
212 return 0;
213 }
214
215 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
216 .family = RTNL_FAMILY_IP6MR,
217 .rule_size = sizeof(struct ip6mr_rule),
218 .addr_size = sizeof(struct in6_addr),
219 .action = ip6mr_rule_action,
220 .match = ip6mr_rule_match,
221 .configure = ip6mr_rule_configure,
222 .compare = ip6mr_rule_compare,
223 .fill = ip6mr_rule_fill,
224 .nlgroup = RTNLGRP_IPV6_RULE,
225 .policy = ip6mr_rule_policy,
226 .owner = THIS_MODULE,
227 };
228
229 static 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) {
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
254 err2:
255 ip6mr_free_table(mrt);
256 err1:
257 fib_rules_unregister(ops);
258 return err;
259 }
260
261 static 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 fib_rules_unregister(net->ipv6.mr6_rules_ops);
271 rtnl_unlock();
272 }
273 #else
274 #define ip6mr_for_each_table(mrt, net) \
275 for (mrt = net->ipv6.mrt6; mrt; mrt = NULL)
276
277 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
278 {
279 return net->ipv6.mrt6;
280 }
281
282 static 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
289 static 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
295 static 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
304 static 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)
311 return mrt;
312
313 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
314 if (!mrt)
315 return NULL;
316 mrt->id = id;
317 write_pnet(&mrt->net, net);
318
319 /* Forwarding cache */
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
337 static void ip6mr_free_table(struct mr6_table *mrt)
338 {
339 del_timer_sync(&mrt->ipmr_expire_timer);
340 mroute_clean_tables(mrt, true);
341 kfree(mrt);
342 }
343
344 #ifdef CONFIG_PROC_FS
345
346 struct 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
354 static 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 * The /proc interfaces to multicast routing /proc/ip6_mr_cache /proc/ip6_mr_vif
382 */
383
384 struct ipmr_vif_iter {
385 struct seq_net_private p;
386 struct mr6_table *mrt;
387 int ct;
388 };
389
390 static 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
405 static 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)
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
423 static 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
441 static void ip6mr_vif_seq_stop(struct seq_file *seq, void *v)
442 __releases(mrt_lock)
443 {
444 read_unlock(&mrt_lock);
445 }
446
447 static 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
469 static 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
476 static 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
482 static 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
490 static 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)
498 return ERR_PTR(-ENOENT);
499
500 it->mrt = mrt;
501 it->cache = NULL;
502 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
503 : SEQ_START_TOKEN;
504 }
505
506 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
507 {
508 struct mfc6_cache *mfc = v;
509 struct ipmr_mfc_iter *it = seq->private;
510 struct net *net = seq_file_net(seq);
511 struct mr6_table *mrt = it->mrt;
512
513 ++*pos;
514
515 if (v == SEQ_START_TOKEN)
516 return ipmr_mfc_seq_idx(net, seq->private, 0);
517
518 if (mfc->list.next != it->cache)
519 return list_entry(mfc->list.next, struct mfc6_cache, list);
520
521 if (it->cache == &mrt->mfc6_unres_queue)
522 goto end_of_list;
523
524 BUG_ON(it->cache != &mrt->mfc6_cache_array[it->ct]);
525
526 while (++it->ct < MFC6_LINES) {
527 it->cache = &mrt->mfc6_cache_array[it->ct];
528 if (list_empty(it->cache))
529 continue;
530 return list_first_entry(it->cache, struct mfc6_cache, list);
531 }
532
533 /* exhausted cache_array, show unresolved */
534 read_unlock(&mrt_lock);
535 it->cache = &mrt->mfc6_unres_queue;
536 it->ct = 0;
537
538 spin_lock_bh(&mfc_unres_lock);
539 if (!list_empty(it->cache))
540 return list_first_entry(it->cache, struct mfc6_cache, list);
541
542 end_of_list:
543 spin_unlock_bh(&mfc_unres_lock);
544 it->cache = NULL;
545
546 return NULL;
547 }
548
549 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
550 {
551 struct ipmr_mfc_iter *it = seq->private;
552 struct mr6_table *mrt = it->mrt;
553
554 if (it->cache == &mrt->mfc6_unres_queue)
555 spin_unlock_bh(&mfc_unres_lock);
556 else if (it->cache == &mrt->mfc6_cache_array[it->ct])
557 read_unlock(&mrt_lock);
558 }
559
560 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
561 {
562 int n;
563
564 if (v == SEQ_START_TOKEN) {
565 seq_puts(seq,
566 "Group "
567 "Origin "
568 "Iif Pkts Bytes Wrong Oifs\n");
569 } else {
570 const struct mfc6_cache *mfc = v;
571 const struct ipmr_mfc_iter *it = seq->private;
572 struct mr6_table *mrt = it->mrt;
573
574 seq_printf(seq, "%pI6 %pI6 %-3hd",
575 &mfc->mf6c_mcastgrp, &mfc->mf6c_origin,
576 mfc->mf6c_parent);
577
578 if (it->cache != &mrt->mfc6_unres_queue) {
579 seq_printf(seq, " %8lu %8lu %8lu",
580 mfc->mfc_un.res.pkt,
581 mfc->mfc_un.res.bytes,
582 mfc->mfc_un.res.wrong_if);
583 for (n = mfc->mfc_un.res.minvif;
584 n < mfc->mfc_un.res.maxvif; n++) {
585 if (MIF_EXISTS(mrt, n) &&
586 mfc->mfc_un.res.ttls[n] < 255)
587 seq_printf(seq,
588 " %2d:%-3d",
589 n, mfc->mfc_un.res.ttls[n]);
590 }
591 } else {
592 /* unresolved mfc_caches don't contain
593 * pkt, bytes and wrong_if values
594 */
595 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
596 }
597 seq_putc(seq, '\n');
598 }
599 return 0;
600 }
601
602 static const struct seq_operations ipmr_mfc_seq_ops = {
603 .start = ipmr_mfc_seq_start,
604 .next = ipmr_mfc_seq_next,
605 .stop = ipmr_mfc_seq_stop,
606 .show = ipmr_mfc_seq_show,
607 };
608
609 static int ipmr_mfc_open(struct inode *inode, struct file *file)
610 {
611 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
612 sizeof(struct ipmr_mfc_iter));
613 }
614
615 static const struct file_operations ip6mr_mfc_fops = {
616 .owner = THIS_MODULE,
617 .open = ipmr_mfc_open,
618 .read = seq_read,
619 .llseek = seq_lseek,
620 .release = seq_release_net,
621 };
622 #endif
623
624 #ifdef CONFIG_IPV6_PIMSM_V2
625
626 static int pim6_rcv(struct sk_buff *skb)
627 {
628 struct pimreghdr *pim;
629 struct ipv6hdr *encap;
630 struct net_device *reg_dev = NULL;
631 struct net *net = dev_net(skb->dev);
632 struct mr6_table *mrt;
633 struct flowi6 fl6 = {
634 .flowi6_iif = skb->dev->ifindex,
635 .flowi6_mark = skb->mark,
636 };
637 int reg_vif_num;
638
639 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
640 goto drop;
641
642 pim = (struct pimreghdr *)skb_transport_header(skb);
643 if (pim->type != ((PIM_VERSION << 4) | PIM_TYPE_REGISTER) ||
644 (pim->flags & PIM_NULL_REGISTER) ||
645 (csum_ipv6_magic(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
646 sizeof(*pim), IPPROTO_PIM,
647 csum_partial((void *)pim, sizeof(*pim), 0)) &&
648 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
649 goto drop;
650
651 /* check if the inner packet is destined to mcast group */
652 encap = (struct ipv6hdr *)(skb_transport_header(skb) +
653 sizeof(*pim));
654
655 if (!ipv6_addr_is_multicast(&encap->daddr) ||
656 encap->payload_len == 0 ||
657 ntohs(encap->payload_len) + sizeof(*pim) > skb->len)
658 goto drop;
659
660 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
661 goto drop;
662 reg_vif_num = mrt->mroute_reg_vif_num;
663
664 read_lock(&mrt_lock);
665 if (reg_vif_num >= 0)
666 reg_dev = mrt->vif6_table[reg_vif_num].dev;
667 if (reg_dev)
668 dev_hold(reg_dev);
669 read_unlock(&mrt_lock);
670
671 if (!reg_dev)
672 goto drop;
673
674 skb->mac_header = skb->network_header;
675 skb_pull(skb, (u8 *)encap - skb->data);
676 skb_reset_network_header(skb);
677 skb->protocol = htons(ETH_P_IPV6);
678 skb->ip_summed = CHECKSUM_NONE;
679
680 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
681
682 netif_rx(skb);
683
684 dev_put(reg_dev);
685 return 0;
686 drop:
687 kfree_skb(skb);
688 return 0;
689 }
690
691 static const struct inet6_protocol pim6_protocol = {
692 .handler = pim6_rcv,
693 };
694
695 /* Service routines creating virtual interfaces: PIMREG */
696
697 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
698 struct net_device *dev)
699 {
700 struct net *net = dev_net(dev);
701 struct mr6_table *mrt;
702 struct flowi6 fl6 = {
703 .flowi6_oif = dev->ifindex,
704 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
705 .flowi6_mark = skb->mark,
706 };
707 int err;
708
709 err = ip6mr_fib_lookup(net, &fl6, &mrt);
710 if (err < 0) {
711 kfree_skb(skb);
712 return err;
713 }
714
715 read_lock(&mrt_lock);
716 dev->stats.tx_bytes += skb->len;
717 dev->stats.tx_packets++;
718 ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
719 read_unlock(&mrt_lock);
720 kfree_skb(skb);
721 return NETDEV_TX_OK;
722 }
723
724 static int reg_vif_get_iflink(const struct net_device *dev)
725 {
726 return 0;
727 }
728
729 static const struct net_device_ops reg_vif_netdev_ops = {
730 .ndo_start_xmit = reg_vif_xmit,
731 .ndo_get_iflink = reg_vif_get_iflink,
732 };
733
734 static void reg_vif_setup(struct net_device *dev)
735 {
736 dev->type = ARPHRD_PIMREG;
737 dev->mtu = 1500 - sizeof(struct ipv6hdr) - 8;
738 dev->flags = IFF_NOARP;
739 dev->netdev_ops = &reg_vif_netdev_ops;
740 dev->needs_free_netdev = true;
741 dev->features |= NETIF_F_NETNS_LOCAL;
742 }
743
744 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
745 {
746 struct net_device *dev;
747 char name[IFNAMSIZ];
748
749 if (mrt->id == RT6_TABLE_DFLT)
750 sprintf(name, "pim6reg");
751 else
752 sprintf(name, "pim6reg%u", mrt->id);
753
754 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
755 if (!dev)
756 return NULL;
757
758 dev_net_set(dev, net);
759
760 if (register_netdevice(dev)) {
761 free_netdev(dev);
762 return NULL;
763 }
764
765 if (dev_open(dev))
766 goto failure;
767
768 dev_hold(dev);
769 return dev;
770
771 failure:
772 unregister_netdevice(dev);
773 return NULL;
774 }
775 #endif
776
777 /*
778 * Delete a VIF entry
779 */
780
781 static int mif6_delete(struct mr6_table *mrt, int vifi, int notify,
782 struct list_head *head)
783 {
784 struct mif_device *v;
785 struct net_device *dev;
786 struct inet6_dev *in6_dev;
787
788 if (vifi < 0 || vifi >= mrt->maxvif)
789 return -EADDRNOTAVAIL;
790
791 v = &mrt->vif6_table[vifi];
792
793 write_lock_bh(&mrt_lock);
794 dev = v->dev;
795 v->dev = NULL;
796
797 if (!dev) {
798 write_unlock_bh(&mrt_lock);
799 return -EADDRNOTAVAIL;
800 }
801
802 #ifdef CONFIG_IPV6_PIMSM_V2
803 if (vifi == mrt->mroute_reg_vif_num)
804 mrt->mroute_reg_vif_num = -1;
805 #endif
806
807 if (vifi + 1 == mrt->maxvif) {
808 int tmp;
809 for (tmp = vifi - 1; tmp >= 0; tmp--) {
810 if (MIF_EXISTS(mrt, tmp))
811 break;
812 }
813 mrt->maxvif = tmp + 1;
814 }
815
816 write_unlock_bh(&mrt_lock);
817
818 dev_set_allmulti(dev, -1);
819
820 in6_dev = __in6_dev_get(dev);
821 if (in6_dev) {
822 in6_dev->cnf.mc_forwarding--;
823 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
824 NETCONFA_MC_FORWARDING,
825 dev->ifindex, &in6_dev->cnf);
826 }
827
828 if ((v->flags & MIFF_REGISTER) && !notify)
829 unregister_netdevice_queue(dev, head);
830
831 dev_put(dev);
832 return 0;
833 }
834
835 static inline void ip6mr_cache_free(struct mfc6_cache *c)
836 {
837 kmem_cache_free(mrt_cachep, c);
838 }
839
840 /* Destroy an unresolved cache entry, killing queued skbs
841 and reporting error to netlink readers.
842 */
843
844 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
845 {
846 struct net *net = read_pnet(&mrt->net);
847 struct sk_buff *skb;
848
849 atomic_dec(&mrt->cache_resolve_queue_len);
850
851 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
852 if (ipv6_hdr(skb)->version == 0) {
853 struct nlmsghdr *nlh = skb_pull(skb,
854 sizeof(struct ipv6hdr));
855 nlh->nlmsg_type = NLMSG_ERROR;
856 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
857 skb_trim(skb, nlh->nlmsg_len);
858 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
859 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
860 } else
861 kfree_skb(skb);
862 }
863
864 ip6mr_cache_free(c);
865 }
866
867
868 /* Timer process for all the unresolved queue. */
869
870 static void ipmr_do_expire_process(struct mr6_table *mrt)
871 {
872 unsigned long now = jiffies;
873 unsigned long expires = 10 * HZ;
874 struct mfc6_cache *c, *next;
875
876 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
877 if (time_after(c->mfc_un.unres.expires, now)) {
878 /* not yet... */
879 unsigned long interval = c->mfc_un.unres.expires - now;
880 if (interval < expires)
881 expires = interval;
882 continue;
883 }
884
885 list_del(&c->list);
886 mr6_netlink_event(mrt, c, RTM_DELROUTE);
887 ip6mr_destroy_unres(mrt, c);
888 }
889
890 if (!list_empty(&mrt->mfc6_unres_queue))
891 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
892 }
893
894 static void ipmr_expire_process(unsigned long arg)
895 {
896 struct mr6_table *mrt = (struct mr6_table *)arg;
897
898 if (!spin_trylock(&mfc_unres_lock)) {
899 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
900 return;
901 }
902
903 if (!list_empty(&mrt->mfc6_unres_queue))
904 ipmr_do_expire_process(mrt);
905
906 spin_unlock(&mfc_unres_lock);
907 }
908
909 /* Fill oifs list. It is called under write locked mrt_lock. */
910
911 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
912 unsigned char *ttls)
913 {
914 int vifi;
915
916 cache->mfc_un.res.minvif = MAXMIFS;
917 cache->mfc_un.res.maxvif = 0;
918 memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
919
920 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
921 if (MIF_EXISTS(mrt, vifi) &&
922 ttls[vifi] && ttls[vifi] < 255) {
923 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
924 if (cache->mfc_un.res.minvif > vifi)
925 cache->mfc_un.res.minvif = vifi;
926 if (cache->mfc_un.res.maxvif <= vifi)
927 cache->mfc_un.res.maxvif = vifi + 1;
928 }
929 }
930 cache->mfc_un.res.lastuse = jiffies;
931 }
932
933 static int mif6_add(struct net *net, struct mr6_table *mrt,
934 struct mif6ctl *vifc, int mrtsock)
935 {
936 int vifi = vifc->mif6c_mifi;
937 struct mif_device *v = &mrt->vif6_table[vifi];
938 struct net_device *dev;
939 struct inet6_dev *in6_dev;
940 int err;
941
942 /* Is vif busy ? */
943 if (MIF_EXISTS(mrt, vifi))
944 return -EADDRINUSE;
945
946 switch (vifc->mif6c_flags) {
947 #ifdef CONFIG_IPV6_PIMSM_V2
948 case MIFF_REGISTER:
949 /*
950 * Special Purpose VIF in PIM
951 * All the packets will be sent to the daemon
952 */
953 if (mrt->mroute_reg_vif_num >= 0)
954 return -EADDRINUSE;
955 dev = ip6mr_reg_vif(net, mrt);
956 if (!dev)
957 return -ENOBUFS;
958 err = dev_set_allmulti(dev, 1);
959 if (err) {
960 unregister_netdevice(dev);
961 dev_put(dev);
962 return err;
963 }
964 break;
965 #endif
966 case 0:
967 dev = dev_get_by_index(net, vifc->mif6c_pifi);
968 if (!dev)
969 return -EADDRNOTAVAIL;
970 err = dev_set_allmulti(dev, 1);
971 if (err) {
972 dev_put(dev);
973 return err;
974 }
975 break;
976 default:
977 return -EINVAL;
978 }
979
980 in6_dev = __in6_dev_get(dev);
981 if (in6_dev) {
982 in6_dev->cnf.mc_forwarding++;
983 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
984 NETCONFA_MC_FORWARDING,
985 dev->ifindex, &in6_dev->cnf);
986 }
987
988 /*
989 * Fill in the VIF structures
990 */
991 v->rate_limit = vifc->vifc_rate_limit;
992 v->flags = vifc->mif6c_flags;
993 if (!mrtsock)
994 v->flags |= VIFF_STATIC;
995 v->threshold = vifc->vifc_threshold;
996 v->bytes_in = 0;
997 v->bytes_out = 0;
998 v->pkt_in = 0;
999 v->pkt_out = 0;
1000 v->link = dev->ifindex;
1001 if (v->flags & MIFF_REGISTER)
1002 v->link = dev_get_iflink(dev);
1003
1004 /* And finish update writing critical data */
1005 write_lock_bh(&mrt_lock);
1006 v->dev = dev;
1007 #ifdef CONFIG_IPV6_PIMSM_V2
1008 if (v->flags & MIFF_REGISTER)
1009 mrt->mroute_reg_vif_num = vifi;
1010 #endif
1011 if (vifi + 1 > mrt->maxvif)
1012 mrt->maxvif = vifi + 1;
1013 write_unlock_bh(&mrt_lock);
1014 return 0;
1015 }
1016
1017 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1018 const struct in6_addr *origin,
1019 const struct in6_addr *mcastgrp)
1020 {
1021 int line = MFC6_HASH(mcastgrp, origin);
1022 struct mfc6_cache *c;
1023
1024 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1025 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1026 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1027 return c;
1028 }
1029 return NULL;
1030 }
1031
1032 /* Look for a (*,*,oif) entry */
1033 static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1034 mifi_t mifi)
1035 {
1036 int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1037 struct mfc6_cache *c;
1038
1039 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1040 if (ipv6_addr_any(&c->mf6c_origin) &&
1041 ipv6_addr_any(&c->mf6c_mcastgrp) &&
1042 (c->mfc_un.res.ttls[mifi] < 255))
1043 return c;
1044
1045 return NULL;
1046 }
1047
1048 /* Look for a (*,G) entry */
1049 static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1050 struct in6_addr *mcastgrp,
1051 mifi_t mifi)
1052 {
1053 int line = MFC6_HASH(mcastgrp, &in6addr_any);
1054 struct mfc6_cache *c, *proxy;
1055
1056 if (ipv6_addr_any(mcastgrp))
1057 goto skip;
1058
1059 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1060 if (ipv6_addr_any(&c->mf6c_origin) &&
1061 ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1062 if (c->mfc_un.res.ttls[mifi] < 255)
1063 return c;
1064
1065 /* It's ok if the mifi is part of the static tree */
1066 proxy = ip6mr_cache_find_any_parent(mrt,
1067 c->mf6c_parent);
1068 if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1069 return c;
1070 }
1071
1072 skip:
1073 return ip6mr_cache_find_any_parent(mrt, mifi);
1074 }
1075
1076 /*
1077 * Allocate a multicast cache entry
1078 */
1079 static struct mfc6_cache *ip6mr_cache_alloc(void)
1080 {
1081 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1082 if (!c)
1083 return NULL;
1084 c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
1085 c->mfc_un.res.minvif = MAXMIFS;
1086 return c;
1087 }
1088
1089 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1090 {
1091 struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1092 if (!c)
1093 return NULL;
1094 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1095 c->mfc_un.unres.expires = jiffies + 10 * HZ;
1096 return c;
1097 }
1098
1099 /*
1100 * A cache entry has gone into a resolved state from queued
1101 */
1102
1103 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1104 struct mfc6_cache *uc, struct mfc6_cache *c)
1105 {
1106 struct sk_buff *skb;
1107
1108 /*
1109 * Play the pending entries through our router
1110 */
1111
1112 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1113 if (ipv6_hdr(skb)->version == 0) {
1114 struct nlmsghdr *nlh = skb_pull(skb,
1115 sizeof(struct ipv6hdr));
1116
1117 if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1118 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1119 } else {
1120 nlh->nlmsg_type = NLMSG_ERROR;
1121 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1122 skb_trim(skb, nlh->nlmsg_len);
1123 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1124 }
1125 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1126 } else
1127 ip6_mr_forward(net, mrt, skb, c);
1128 }
1129 }
1130
1131 /*
1132 * Bounce a cache query up to pim6sd and netlink.
1133 *
1134 * Called under mrt_lock.
1135 */
1136
1137 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1138 mifi_t mifi, int assert)
1139 {
1140 struct sk_buff *skb;
1141 struct mrt6msg *msg;
1142 int ret;
1143
1144 #ifdef CONFIG_IPV6_PIMSM_V2
1145 if (assert == MRT6MSG_WHOLEPKT)
1146 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1147 +sizeof(*msg));
1148 else
1149 #endif
1150 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1151
1152 if (!skb)
1153 return -ENOBUFS;
1154
1155 /* I suppose that internal messages
1156 * do not require checksums */
1157
1158 skb->ip_summed = CHECKSUM_UNNECESSARY;
1159
1160 #ifdef CONFIG_IPV6_PIMSM_V2
1161 if (assert == MRT6MSG_WHOLEPKT) {
1162 /* Ugly, but we have no choice with this interface.
1163 Duplicate old header, fix length etc.
1164 And all this only to mangle msg->im6_msgtype and
1165 to set msg->im6_mbz to "mbz" :-)
1166 */
1167 skb_push(skb, -skb_network_offset(pkt));
1168
1169 skb_push(skb, sizeof(*msg));
1170 skb_reset_transport_header(skb);
1171 msg = (struct mrt6msg *)skb_transport_header(skb);
1172 msg->im6_mbz = 0;
1173 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1174 msg->im6_mif = mrt->mroute_reg_vif_num;
1175 msg->im6_pad = 0;
1176 msg->im6_src = ipv6_hdr(pkt)->saddr;
1177 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1178
1179 skb->ip_summed = CHECKSUM_UNNECESSARY;
1180 } else
1181 #endif
1182 {
1183 /*
1184 * Copy the IP header
1185 */
1186
1187 skb_put(skb, sizeof(struct ipv6hdr));
1188 skb_reset_network_header(skb);
1189 skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1190
1191 /*
1192 * Add our header
1193 */
1194 skb_put(skb, sizeof(*msg));
1195 skb_reset_transport_header(skb);
1196 msg = (struct mrt6msg *)skb_transport_header(skb);
1197
1198 msg->im6_mbz = 0;
1199 msg->im6_msgtype = assert;
1200 msg->im6_mif = mifi;
1201 msg->im6_pad = 0;
1202 msg->im6_src = ipv6_hdr(pkt)->saddr;
1203 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1204
1205 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1206 skb->ip_summed = CHECKSUM_UNNECESSARY;
1207 }
1208
1209 if (!mrt->mroute6_sk) {
1210 kfree_skb(skb);
1211 return -EINVAL;
1212 }
1213
1214 mrt6msg_netlink_event(mrt, skb);
1215
1216 /*
1217 * Deliver to user space multicast routing algorithms
1218 */
1219 ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1220 if (ret < 0) {
1221 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1222 kfree_skb(skb);
1223 }
1224
1225 return ret;
1226 }
1227
1228 /*
1229 * Queue a packet for resolution. It gets locked cache entry!
1230 */
1231
1232 static int
1233 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1234 {
1235 bool found = false;
1236 int err;
1237 struct mfc6_cache *c;
1238
1239 spin_lock_bh(&mfc_unres_lock);
1240 list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1241 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1242 ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1243 found = true;
1244 break;
1245 }
1246 }
1247
1248 if (!found) {
1249 /*
1250 * Create a new entry if allowable
1251 */
1252
1253 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1254 (c = ip6mr_cache_alloc_unres()) == NULL) {
1255 spin_unlock_bh(&mfc_unres_lock);
1256
1257 kfree_skb(skb);
1258 return -ENOBUFS;
1259 }
1260
1261 /*
1262 * Fill in the new cache entry
1263 */
1264 c->mf6c_parent = -1;
1265 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1266 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1267
1268 /*
1269 * Reflect first query at pim6sd
1270 */
1271 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1272 if (err < 0) {
1273 /* If the report failed throw the cache entry
1274 out - Brad Parker
1275 */
1276 spin_unlock_bh(&mfc_unres_lock);
1277
1278 ip6mr_cache_free(c);
1279 kfree_skb(skb);
1280 return err;
1281 }
1282
1283 atomic_inc(&mrt->cache_resolve_queue_len);
1284 list_add(&c->list, &mrt->mfc6_unres_queue);
1285 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1286
1287 ipmr_do_expire_process(mrt);
1288 }
1289
1290 /*
1291 * See if we can append the packet
1292 */
1293 if (c->mfc_un.unres.unresolved.qlen > 3) {
1294 kfree_skb(skb);
1295 err = -ENOBUFS;
1296 } else {
1297 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1298 err = 0;
1299 }
1300
1301 spin_unlock_bh(&mfc_unres_lock);
1302 return err;
1303 }
1304
1305 /*
1306 * MFC6 cache manipulation by user space
1307 */
1308
1309 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1310 int parent)
1311 {
1312 int line;
1313 struct mfc6_cache *c, *next;
1314
1315 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1316
1317 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1318 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1319 ipv6_addr_equal(&c->mf6c_mcastgrp,
1320 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1321 (parent == -1 || parent == c->mf6c_parent)) {
1322 write_lock_bh(&mrt_lock);
1323 list_del(&c->list);
1324 write_unlock_bh(&mrt_lock);
1325
1326 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1327 ip6mr_cache_free(c);
1328 return 0;
1329 }
1330 }
1331 return -ENOENT;
1332 }
1333
1334 static int ip6mr_device_event(struct notifier_block *this,
1335 unsigned long event, void *ptr)
1336 {
1337 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1338 struct net *net = dev_net(dev);
1339 struct mr6_table *mrt;
1340 struct mif_device *v;
1341 int ct;
1342
1343 if (event != NETDEV_UNREGISTER)
1344 return NOTIFY_DONE;
1345
1346 ip6mr_for_each_table(mrt, net) {
1347 v = &mrt->vif6_table[0];
1348 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1349 if (v->dev == dev)
1350 mif6_delete(mrt, ct, 1, NULL);
1351 }
1352 }
1353
1354 return NOTIFY_DONE;
1355 }
1356
1357 static struct notifier_block ip6_mr_notifier = {
1358 .notifier_call = ip6mr_device_event
1359 };
1360
1361 /*
1362 * Setup for IP multicast routing
1363 */
1364
1365 static int __net_init ip6mr_net_init(struct net *net)
1366 {
1367 int err;
1368
1369 err = ip6mr_rules_init(net);
1370 if (err < 0)
1371 goto fail;
1372
1373 #ifdef CONFIG_PROC_FS
1374 err = -ENOMEM;
1375 if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1376 goto proc_vif_fail;
1377 if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1378 goto proc_cache_fail;
1379 #endif
1380
1381 return 0;
1382
1383 #ifdef CONFIG_PROC_FS
1384 proc_cache_fail:
1385 remove_proc_entry("ip6_mr_vif", net->proc_net);
1386 proc_vif_fail:
1387 ip6mr_rules_exit(net);
1388 #endif
1389 fail:
1390 return err;
1391 }
1392
1393 static void __net_exit ip6mr_net_exit(struct net *net)
1394 {
1395 #ifdef CONFIG_PROC_FS
1396 remove_proc_entry("ip6_mr_cache", net->proc_net);
1397 remove_proc_entry("ip6_mr_vif", net->proc_net);
1398 #endif
1399 ip6mr_rules_exit(net);
1400 }
1401
1402 static struct pernet_operations ip6mr_net_ops = {
1403 .init = ip6mr_net_init,
1404 .exit = ip6mr_net_exit,
1405 };
1406
1407 int __init ip6_mr_init(void)
1408 {
1409 int err;
1410
1411 mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1412 sizeof(struct mfc6_cache),
1413 0, SLAB_HWCACHE_ALIGN,
1414 NULL);
1415 if (!mrt_cachep)
1416 return -ENOMEM;
1417
1418 err = register_pernet_subsys(&ip6mr_net_ops);
1419 if (err)
1420 goto reg_pernet_fail;
1421
1422 err = register_netdevice_notifier(&ip6_mr_notifier);
1423 if (err)
1424 goto reg_notif_fail;
1425 #ifdef CONFIG_IPV6_PIMSM_V2
1426 if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1427 pr_err("%s: can't add PIM protocol\n", __func__);
1428 err = -EAGAIN;
1429 goto add_proto_fail;
1430 }
1431 #endif
1432 rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1433 ip6mr_rtm_dumproute, 0);
1434 return 0;
1435 #ifdef CONFIG_IPV6_PIMSM_V2
1436 add_proto_fail:
1437 unregister_netdevice_notifier(&ip6_mr_notifier);
1438 #endif
1439 reg_notif_fail:
1440 unregister_pernet_subsys(&ip6mr_net_ops);
1441 reg_pernet_fail:
1442 kmem_cache_destroy(mrt_cachep);
1443 return err;
1444 }
1445
1446 void ip6_mr_cleanup(void)
1447 {
1448 rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1449 #ifdef CONFIG_IPV6_PIMSM_V2
1450 inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1451 #endif
1452 unregister_netdevice_notifier(&ip6_mr_notifier);
1453 unregister_pernet_subsys(&ip6mr_net_ops);
1454 kmem_cache_destroy(mrt_cachep);
1455 }
1456
1457 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1458 struct mf6cctl *mfc, int mrtsock, int parent)
1459 {
1460 bool found = false;
1461 int line;
1462 struct mfc6_cache *uc, *c;
1463 unsigned char ttls[MAXMIFS];
1464 int i;
1465
1466 if (mfc->mf6cc_parent >= MAXMIFS)
1467 return -ENFILE;
1468
1469 memset(ttls, 255, MAXMIFS);
1470 for (i = 0; i < MAXMIFS; i++) {
1471 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1472 ttls[i] = 1;
1473
1474 }
1475
1476 line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1477
1478 list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1479 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1480 ipv6_addr_equal(&c->mf6c_mcastgrp,
1481 &mfc->mf6cc_mcastgrp.sin6_addr) &&
1482 (parent == -1 || parent == mfc->mf6cc_parent)) {
1483 found = true;
1484 break;
1485 }
1486 }
1487
1488 if (found) {
1489 write_lock_bh(&mrt_lock);
1490 c->mf6c_parent = mfc->mf6cc_parent;
1491 ip6mr_update_thresholds(mrt, c, ttls);
1492 if (!mrtsock)
1493 c->mfc_flags |= MFC_STATIC;
1494 write_unlock_bh(&mrt_lock);
1495 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1496 return 0;
1497 }
1498
1499 if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1500 !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1501 return -EINVAL;
1502
1503 c = ip6mr_cache_alloc();
1504 if (!c)
1505 return -ENOMEM;
1506
1507 c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1508 c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1509 c->mf6c_parent = mfc->mf6cc_parent;
1510 ip6mr_update_thresholds(mrt, c, ttls);
1511 if (!mrtsock)
1512 c->mfc_flags |= MFC_STATIC;
1513
1514 write_lock_bh(&mrt_lock);
1515 list_add(&c->list, &mrt->mfc6_cache_array[line]);
1516 write_unlock_bh(&mrt_lock);
1517
1518 /*
1519 * Check to see if we resolved a queued list. If so we
1520 * need to send on the frames and tidy up.
1521 */
1522 found = false;
1523 spin_lock_bh(&mfc_unres_lock);
1524 list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1525 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1526 ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1527 list_del(&uc->list);
1528 atomic_dec(&mrt->cache_resolve_queue_len);
1529 found = true;
1530 break;
1531 }
1532 }
1533 if (list_empty(&mrt->mfc6_unres_queue))
1534 del_timer(&mrt->ipmr_expire_timer);
1535 spin_unlock_bh(&mfc_unres_lock);
1536
1537 if (found) {
1538 ip6mr_cache_resolve(net, mrt, uc, c);
1539 ip6mr_cache_free(uc);
1540 }
1541 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1542 return 0;
1543 }
1544
1545 /*
1546 * Close the multicast socket, and clear the vif tables etc
1547 */
1548
1549 static void mroute_clean_tables(struct mr6_table *mrt, bool all)
1550 {
1551 int i;
1552 LIST_HEAD(list);
1553 struct mfc6_cache *c, *next;
1554
1555 /*
1556 * Shut down all active vif entries
1557 */
1558 for (i = 0; i < mrt->maxvif; i++) {
1559 if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
1560 continue;
1561 mif6_delete(mrt, i, 0, &list);
1562 }
1563 unregister_netdevice_many(&list);
1564
1565 /*
1566 * Wipe the cache
1567 */
1568 for (i = 0; i < MFC6_LINES; i++) {
1569 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1570 if (!all && (c->mfc_flags & MFC_STATIC))
1571 continue;
1572 write_lock_bh(&mrt_lock);
1573 list_del(&c->list);
1574 write_unlock_bh(&mrt_lock);
1575
1576 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1577 ip6mr_cache_free(c);
1578 }
1579 }
1580
1581 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1582 spin_lock_bh(&mfc_unres_lock);
1583 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1584 list_del(&c->list);
1585 mr6_netlink_event(mrt, c, RTM_DELROUTE);
1586 ip6mr_destroy_unres(mrt, c);
1587 }
1588 spin_unlock_bh(&mfc_unres_lock);
1589 }
1590 }
1591
1592 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1593 {
1594 int err = 0;
1595 struct net *net = sock_net(sk);
1596
1597 rtnl_lock();
1598 write_lock_bh(&mrt_lock);
1599 if (likely(mrt->mroute6_sk == NULL)) {
1600 mrt->mroute6_sk = sk;
1601 net->ipv6.devconf_all->mc_forwarding++;
1602 } else {
1603 err = -EADDRINUSE;
1604 }
1605 write_unlock_bh(&mrt_lock);
1606
1607 if (!err)
1608 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1609 NETCONFA_MC_FORWARDING,
1610 NETCONFA_IFINDEX_ALL,
1611 net->ipv6.devconf_all);
1612 rtnl_unlock();
1613
1614 return err;
1615 }
1616
1617 int ip6mr_sk_done(struct sock *sk)
1618 {
1619 int err = -EACCES;
1620 struct net *net = sock_net(sk);
1621 struct mr6_table *mrt;
1622
1623 rtnl_lock();
1624 ip6mr_for_each_table(mrt, net) {
1625 if (sk == mrt->mroute6_sk) {
1626 write_lock_bh(&mrt_lock);
1627 mrt->mroute6_sk = NULL;
1628 net->ipv6.devconf_all->mc_forwarding--;
1629 write_unlock_bh(&mrt_lock);
1630 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1631 NETCONFA_MC_FORWARDING,
1632 NETCONFA_IFINDEX_ALL,
1633 net->ipv6.devconf_all);
1634
1635 mroute_clean_tables(mrt, false);
1636 err = 0;
1637 break;
1638 }
1639 }
1640 rtnl_unlock();
1641
1642 return err;
1643 }
1644
1645 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1646 {
1647 struct mr6_table *mrt;
1648 struct flowi6 fl6 = {
1649 .flowi6_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
1650 .flowi6_oif = skb->dev->ifindex,
1651 .flowi6_mark = skb->mark,
1652 };
1653
1654 if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1655 return NULL;
1656
1657 return mrt->mroute6_sk;
1658 }
1659
1660 /*
1661 * Socket options and virtual interface manipulation. The whole
1662 * virtual interface system is a complete heap, but unfortunately
1663 * that's how BSD mrouted happens to think. Maybe one day with a proper
1664 * MOSPF/PIM router set up we can clean this up.
1665 */
1666
1667 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1668 {
1669 int ret, parent = 0;
1670 struct mif6ctl vif;
1671 struct mf6cctl mfc;
1672 mifi_t mifi;
1673 struct net *net = sock_net(sk);
1674 struct mr6_table *mrt;
1675
1676 if (sk->sk_type != SOCK_RAW ||
1677 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1678 return -EOPNOTSUPP;
1679
1680 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1681 if (!mrt)
1682 return -ENOENT;
1683
1684 if (optname != MRT6_INIT) {
1685 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1686 return -EACCES;
1687 }
1688
1689 switch (optname) {
1690 case MRT6_INIT:
1691 if (optlen < sizeof(int))
1692 return -EINVAL;
1693
1694 return ip6mr_sk_init(mrt, sk);
1695
1696 case MRT6_DONE:
1697 return ip6mr_sk_done(sk);
1698
1699 case MRT6_ADD_MIF:
1700 if (optlen < sizeof(vif))
1701 return -EINVAL;
1702 if (copy_from_user(&vif, optval, sizeof(vif)))
1703 return -EFAULT;
1704 if (vif.mif6c_mifi >= MAXMIFS)
1705 return -ENFILE;
1706 rtnl_lock();
1707 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1708 rtnl_unlock();
1709 return ret;
1710
1711 case MRT6_DEL_MIF:
1712 if (optlen < sizeof(mifi_t))
1713 return -EINVAL;
1714 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1715 return -EFAULT;
1716 rtnl_lock();
1717 ret = mif6_delete(mrt, mifi, 0, NULL);
1718 rtnl_unlock();
1719 return ret;
1720
1721 /*
1722 * Manipulate the forwarding caches. These live
1723 * in a sort of kernel/user symbiosis.
1724 */
1725 case MRT6_ADD_MFC:
1726 case MRT6_DEL_MFC:
1727 parent = -1;
1728 case MRT6_ADD_MFC_PROXY:
1729 case MRT6_DEL_MFC_PROXY:
1730 if (optlen < sizeof(mfc))
1731 return -EINVAL;
1732 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1733 return -EFAULT;
1734 if (parent == 0)
1735 parent = mfc.mf6cc_parent;
1736 rtnl_lock();
1737 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1738 ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1739 else
1740 ret = ip6mr_mfc_add(net, mrt, &mfc,
1741 sk == mrt->mroute6_sk, parent);
1742 rtnl_unlock();
1743 return ret;
1744
1745 /*
1746 * Control PIM assert (to activate pim will activate assert)
1747 */
1748 case MRT6_ASSERT:
1749 {
1750 int v;
1751
1752 if (optlen != sizeof(v))
1753 return -EINVAL;
1754 if (get_user(v, (int __user *)optval))
1755 return -EFAULT;
1756 mrt->mroute_do_assert = v;
1757 return 0;
1758 }
1759
1760 #ifdef CONFIG_IPV6_PIMSM_V2
1761 case MRT6_PIM:
1762 {
1763 int v;
1764
1765 if (optlen != sizeof(v))
1766 return -EINVAL;
1767 if (get_user(v, (int __user *)optval))
1768 return -EFAULT;
1769 v = !!v;
1770 rtnl_lock();
1771 ret = 0;
1772 if (v != mrt->mroute_do_pim) {
1773 mrt->mroute_do_pim = v;
1774 mrt->mroute_do_assert = v;
1775 }
1776 rtnl_unlock();
1777 return ret;
1778 }
1779
1780 #endif
1781 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1782 case MRT6_TABLE:
1783 {
1784 u32 v;
1785
1786 if (optlen != sizeof(u32))
1787 return -EINVAL;
1788 if (get_user(v, (u32 __user *)optval))
1789 return -EFAULT;
1790 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1791 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1792 return -EINVAL;
1793 if (sk == mrt->mroute6_sk)
1794 return -EBUSY;
1795
1796 rtnl_lock();
1797 ret = 0;
1798 if (!ip6mr_new_table(net, v))
1799 ret = -ENOMEM;
1800 else
1801 raw6_sk(sk)->ip6mr_table = v;
1802 rtnl_unlock();
1803 return ret;
1804 }
1805 #endif
1806 /*
1807 * Spurious command, or MRT6_VERSION which you cannot
1808 * set.
1809 */
1810 default:
1811 return -ENOPROTOOPT;
1812 }
1813 }
1814
1815 /*
1816 * Getsock opt support for the multicast routing system.
1817 */
1818
1819 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1820 int __user *optlen)
1821 {
1822 int olr;
1823 int val;
1824 struct net *net = sock_net(sk);
1825 struct mr6_table *mrt;
1826
1827 if (sk->sk_type != SOCK_RAW ||
1828 inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1829 return -EOPNOTSUPP;
1830
1831 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1832 if (!mrt)
1833 return -ENOENT;
1834
1835 switch (optname) {
1836 case MRT6_VERSION:
1837 val = 0x0305;
1838 break;
1839 #ifdef CONFIG_IPV6_PIMSM_V2
1840 case MRT6_PIM:
1841 val = mrt->mroute_do_pim;
1842 break;
1843 #endif
1844 case MRT6_ASSERT:
1845 val = mrt->mroute_do_assert;
1846 break;
1847 default:
1848 return -ENOPROTOOPT;
1849 }
1850
1851 if (get_user(olr, optlen))
1852 return -EFAULT;
1853
1854 olr = min_t(int, olr, sizeof(int));
1855 if (olr < 0)
1856 return -EINVAL;
1857
1858 if (put_user(olr, optlen))
1859 return -EFAULT;
1860 if (copy_to_user(optval, &val, olr))
1861 return -EFAULT;
1862 return 0;
1863 }
1864
1865 /*
1866 * The IP multicast ioctl support routines.
1867 */
1868
1869 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1870 {
1871 struct sioc_sg_req6 sr;
1872 struct sioc_mif_req6 vr;
1873 struct mif_device *vif;
1874 struct mfc6_cache *c;
1875 struct net *net = sock_net(sk);
1876 struct mr6_table *mrt;
1877
1878 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1879 if (!mrt)
1880 return -ENOENT;
1881
1882 switch (cmd) {
1883 case SIOCGETMIFCNT_IN6:
1884 if (copy_from_user(&vr, arg, sizeof(vr)))
1885 return -EFAULT;
1886 if (vr.mifi >= mrt->maxvif)
1887 return -EINVAL;
1888 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1889 read_lock(&mrt_lock);
1890 vif = &mrt->vif6_table[vr.mifi];
1891 if (MIF_EXISTS(mrt, vr.mifi)) {
1892 vr.icount = vif->pkt_in;
1893 vr.ocount = vif->pkt_out;
1894 vr.ibytes = vif->bytes_in;
1895 vr.obytes = vif->bytes_out;
1896 read_unlock(&mrt_lock);
1897
1898 if (copy_to_user(arg, &vr, sizeof(vr)))
1899 return -EFAULT;
1900 return 0;
1901 }
1902 read_unlock(&mrt_lock);
1903 return -EADDRNOTAVAIL;
1904 case SIOCGETSGCNT_IN6:
1905 if (copy_from_user(&sr, arg, sizeof(sr)))
1906 return -EFAULT;
1907
1908 read_lock(&mrt_lock);
1909 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1910 if (c) {
1911 sr.pktcnt = c->mfc_un.res.pkt;
1912 sr.bytecnt = c->mfc_un.res.bytes;
1913 sr.wrong_if = c->mfc_un.res.wrong_if;
1914 read_unlock(&mrt_lock);
1915
1916 if (copy_to_user(arg, &sr, sizeof(sr)))
1917 return -EFAULT;
1918 return 0;
1919 }
1920 read_unlock(&mrt_lock);
1921 return -EADDRNOTAVAIL;
1922 default:
1923 return -ENOIOCTLCMD;
1924 }
1925 }
1926
1927 #ifdef CONFIG_COMPAT
1928 struct compat_sioc_sg_req6 {
1929 struct sockaddr_in6 src;
1930 struct sockaddr_in6 grp;
1931 compat_ulong_t pktcnt;
1932 compat_ulong_t bytecnt;
1933 compat_ulong_t wrong_if;
1934 };
1935
1936 struct compat_sioc_mif_req6 {
1937 mifi_t mifi;
1938 compat_ulong_t icount;
1939 compat_ulong_t ocount;
1940 compat_ulong_t ibytes;
1941 compat_ulong_t obytes;
1942 };
1943
1944 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1945 {
1946 struct compat_sioc_sg_req6 sr;
1947 struct compat_sioc_mif_req6 vr;
1948 struct mif_device *vif;
1949 struct mfc6_cache *c;
1950 struct net *net = sock_net(sk);
1951 struct mr6_table *mrt;
1952
1953 mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1954 if (!mrt)
1955 return -ENOENT;
1956
1957 switch (cmd) {
1958 case SIOCGETMIFCNT_IN6:
1959 if (copy_from_user(&vr, arg, sizeof(vr)))
1960 return -EFAULT;
1961 if (vr.mifi >= mrt->maxvif)
1962 return -EINVAL;
1963 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1964 read_lock(&mrt_lock);
1965 vif = &mrt->vif6_table[vr.mifi];
1966 if (MIF_EXISTS(mrt, vr.mifi)) {
1967 vr.icount = vif->pkt_in;
1968 vr.ocount = vif->pkt_out;
1969 vr.ibytes = vif->bytes_in;
1970 vr.obytes = vif->bytes_out;
1971 read_unlock(&mrt_lock);
1972
1973 if (copy_to_user(arg, &vr, sizeof(vr)))
1974 return -EFAULT;
1975 return 0;
1976 }
1977 read_unlock(&mrt_lock);
1978 return -EADDRNOTAVAIL;
1979 case SIOCGETSGCNT_IN6:
1980 if (copy_from_user(&sr, arg, sizeof(sr)))
1981 return -EFAULT;
1982
1983 read_lock(&mrt_lock);
1984 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1985 if (c) {
1986 sr.pktcnt = c->mfc_un.res.pkt;
1987 sr.bytecnt = c->mfc_un.res.bytes;
1988 sr.wrong_if = c->mfc_un.res.wrong_if;
1989 read_unlock(&mrt_lock);
1990
1991 if (copy_to_user(arg, &sr, sizeof(sr)))
1992 return -EFAULT;
1993 return 0;
1994 }
1995 read_unlock(&mrt_lock);
1996 return -EADDRNOTAVAIL;
1997 default:
1998 return -ENOIOCTLCMD;
1999 }
2000 }
2001 #endif
2002
2003 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
2004 {
2005 IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2006 IPSTATS_MIB_OUTFORWDATAGRAMS);
2007 IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2008 IPSTATS_MIB_OUTOCTETS, skb->len);
2009 return dst_output(net, sk, skb);
2010 }
2011
2012 /*
2013 * Processing handlers for ip6mr_forward
2014 */
2015
2016 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2017 struct sk_buff *skb, struct mfc6_cache *c, int vifi)
2018 {
2019 struct ipv6hdr *ipv6h;
2020 struct mif_device *vif = &mrt->vif6_table[vifi];
2021 struct net_device *dev;
2022 struct dst_entry *dst;
2023 struct flowi6 fl6;
2024
2025 if (!vif->dev)
2026 goto out_free;
2027
2028 #ifdef CONFIG_IPV6_PIMSM_V2
2029 if (vif->flags & MIFF_REGISTER) {
2030 vif->pkt_out++;
2031 vif->bytes_out += skb->len;
2032 vif->dev->stats.tx_bytes += skb->len;
2033 vif->dev->stats.tx_packets++;
2034 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2035 goto out_free;
2036 }
2037 #endif
2038
2039 ipv6h = ipv6_hdr(skb);
2040
2041 fl6 = (struct flowi6) {
2042 .flowi6_oif = vif->link,
2043 .daddr = ipv6h->daddr,
2044 };
2045
2046 dst = ip6_route_output(net, NULL, &fl6);
2047 if (dst->error) {
2048 dst_release(dst);
2049 goto out_free;
2050 }
2051
2052 skb_dst_drop(skb);
2053 skb_dst_set(skb, dst);
2054
2055 /*
2056 * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2057 * not only before forwarding, but after forwarding on all output
2058 * interfaces. It is clear, if mrouter runs a multicasting
2059 * program, it should receive packets not depending to what interface
2060 * program is joined.
2061 * If we will not make it, the program will have to join on all
2062 * interfaces. On the other hand, multihoming host (or router, but
2063 * not mrouter) cannot join to more than one interface - it will
2064 * result in receiving multiple packets.
2065 */
2066 dev = vif->dev;
2067 skb->dev = dev;
2068 vif->pkt_out++;
2069 vif->bytes_out += skb->len;
2070
2071 /* We are about to write */
2072 /* XXX: extension headers? */
2073 if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2074 goto out_free;
2075
2076 ipv6h = ipv6_hdr(skb);
2077 ipv6h->hop_limit--;
2078
2079 IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2080
2081 return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2082 net, NULL, skb, skb->dev, dev,
2083 ip6mr_forward2_finish);
2084
2085 out_free:
2086 kfree_skb(skb);
2087 return 0;
2088 }
2089
2090 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2091 {
2092 int ct;
2093
2094 for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2095 if (mrt->vif6_table[ct].dev == dev)
2096 break;
2097 }
2098 return ct;
2099 }
2100
2101 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2102 struct sk_buff *skb, struct mfc6_cache *cache)
2103 {
2104 int psend = -1;
2105 int vif, ct;
2106 int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2107
2108 vif = cache->mf6c_parent;
2109 cache->mfc_un.res.pkt++;
2110 cache->mfc_un.res.bytes += skb->len;
2111 cache->mfc_un.res.lastuse = jiffies;
2112
2113 if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2114 struct mfc6_cache *cache_proxy;
2115
2116 /* For an (*,G) entry, we only check that the incoming
2117 * interface is part of the static tree.
2118 */
2119 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2120 if (cache_proxy &&
2121 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2122 goto forward;
2123 }
2124
2125 /*
2126 * Wrong interface: drop packet and (maybe) send PIM assert.
2127 */
2128 if (mrt->vif6_table[vif].dev != skb->dev) {
2129 cache->mfc_un.res.wrong_if++;
2130
2131 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2132 /* pimsm uses asserts, when switching from RPT to SPT,
2133 so that we cannot check that packet arrived on an oif.
2134 It is bad, but otherwise we would need to move pretty
2135 large chunk of pimd to kernel. Ough... --ANK
2136 */
2137 (mrt->mroute_do_pim ||
2138 cache->mfc_un.res.ttls[true_vifi] < 255) &&
2139 time_after(jiffies,
2140 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2141 cache->mfc_un.res.last_assert = jiffies;
2142 ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2143 }
2144 goto dont_forward;
2145 }
2146
2147 forward:
2148 mrt->vif6_table[vif].pkt_in++;
2149 mrt->vif6_table[vif].bytes_in += skb->len;
2150
2151 /*
2152 * Forward the frame
2153 */
2154 if (ipv6_addr_any(&cache->mf6c_origin) &&
2155 ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2156 if (true_vifi >= 0 &&
2157 true_vifi != cache->mf6c_parent &&
2158 ipv6_hdr(skb)->hop_limit >
2159 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2160 /* It's an (*,*) entry and the packet is not coming from
2161 * the upstream: forward the packet to the upstream
2162 * only.
2163 */
2164 psend = cache->mf6c_parent;
2165 goto last_forward;
2166 }
2167 goto dont_forward;
2168 }
2169 for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2170 /* For (*,G) entry, don't forward to the incoming interface */
2171 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2172 ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2173 if (psend != -1) {
2174 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2175 if (skb2)
2176 ip6mr_forward2(net, mrt, skb2, cache, psend);
2177 }
2178 psend = ct;
2179 }
2180 }
2181 last_forward:
2182 if (psend != -1) {
2183 ip6mr_forward2(net, mrt, skb, cache, psend);
2184 return;
2185 }
2186
2187 dont_forward:
2188 kfree_skb(skb);
2189 }
2190
2191
2192 /*
2193 * Multicast packets for forwarding arrive here
2194 */
2195
2196 int ip6_mr_input(struct sk_buff *skb)
2197 {
2198 struct mfc6_cache *cache;
2199 struct net *net = dev_net(skb->dev);
2200 struct mr6_table *mrt;
2201 struct flowi6 fl6 = {
2202 .flowi6_iif = skb->dev->ifindex,
2203 .flowi6_mark = skb->mark,
2204 };
2205 int err;
2206
2207 err = ip6mr_fib_lookup(net, &fl6, &mrt);
2208 if (err < 0) {
2209 kfree_skb(skb);
2210 return err;
2211 }
2212
2213 read_lock(&mrt_lock);
2214 cache = ip6mr_cache_find(mrt,
2215 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2216 if (!cache) {
2217 int vif = ip6mr_find_vif(mrt, skb->dev);
2218
2219 if (vif >= 0)
2220 cache = ip6mr_cache_find_any(mrt,
2221 &ipv6_hdr(skb)->daddr,
2222 vif);
2223 }
2224
2225 /*
2226 * No usable cache entry
2227 */
2228 if (!cache) {
2229 int vif;
2230
2231 vif = ip6mr_find_vif(mrt, skb->dev);
2232 if (vif >= 0) {
2233 int err = ip6mr_cache_unresolved(mrt, vif, skb);
2234 read_unlock(&mrt_lock);
2235
2236 return err;
2237 }
2238 read_unlock(&mrt_lock);
2239 kfree_skb(skb);
2240 return -ENODEV;
2241 }
2242
2243 ip6_mr_forward(net, mrt, skb, cache);
2244
2245 read_unlock(&mrt_lock);
2246
2247 return 0;
2248 }
2249
2250
2251 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2252 struct mfc6_cache *c, struct rtmsg *rtm)
2253 {
2254 struct rta_mfc_stats mfcs;
2255 struct nlattr *mp_attr;
2256 struct rtnexthop *nhp;
2257 unsigned long lastuse;
2258 int ct;
2259
2260 /* If cache is unresolved, don't try to parse IIF and OIF */
2261 if (c->mf6c_parent >= MAXMIFS) {
2262 rtm->rtm_flags |= RTNH_F_UNRESOLVED;
2263 return -ENOENT;
2264 }
2265
2266 if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2267 nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2268 return -EMSGSIZE;
2269 mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2270 if (!mp_attr)
2271 return -EMSGSIZE;
2272
2273 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2274 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2275 nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2276 if (!nhp) {
2277 nla_nest_cancel(skb, mp_attr);
2278 return -EMSGSIZE;
2279 }
2280
2281 nhp->rtnh_flags = 0;
2282 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2283 nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2284 nhp->rtnh_len = sizeof(*nhp);
2285 }
2286 }
2287
2288 nla_nest_end(skb, mp_attr);
2289
2290 lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2291 lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2292
2293 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2294 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2295 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2296 if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
2297 nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
2298 RTA_PAD))
2299 return -EMSGSIZE;
2300
2301 rtm->rtm_type = RTN_MULTICAST;
2302 return 1;
2303 }
2304
2305 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2306 u32 portid)
2307 {
2308 int err;
2309 struct mr6_table *mrt;
2310 struct mfc6_cache *cache;
2311 struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2312
2313 mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2314 if (!mrt)
2315 return -ENOENT;
2316
2317 read_lock(&mrt_lock);
2318 cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2319 if (!cache && skb->dev) {
2320 int vif = ip6mr_find_vif(mrt, skb->dev);
2321
2322 if (vif >= 0)
2323 cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2324 vif);
2325 }
2326
2327 if (!cache) {
2328 struct sk_buff *skb2;
2329 struct ipv6hdr *iph;
2330 struct net_device *dev;
2331 int vif;
2332
2333 dev = skb->dev;
2334 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2335 read_unlock(&mrt_lock);
2336 return -ENODEV;
2337 }
2338
2339 /* really correct? */
2340 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2341 if (!skb2) {
2342 read_unlock(&mrt_lock);
2343 return -ENOMEM;
2344 }
2345
2346 NETLINK_CB(skb2).portid = portid;
2347 skb_reset_transport_header(skb2);
2348
2349 skb_put(skb2, sizeof(struct ipv6hdr));
2350 skb_reset_network_header(skb2);
2351
2352 iph = ipv6_hdr(skb2);
2353 iph->version = 0;
2354 iph->priority = 0;
2355 iph->flow_lbl[0] = 0;
2356 iph->flow_lbl[1] = 0;
2357 iph->flow_lbl[2] = 0;
2358 iph->payload_len = 0;
2359 iph->nexthdr = IPPROTO_NONE;
2360 iph->hop_limit = 0;
2361 iph->saddr = rt->rt6i_src.addr;
2362 iph->daddr = rt->rt6i_dst.addr;
2363
2364 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2365 read_unlock(&mrt_lock);
2366
2367 return err;
2368 }
2369
2370 if (rtm->rtm_flags & RTM_F_NOTIFY)
2371 cache->mfc_flags |= MFC_NOTIFY;
2372
2373 err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2374 read_unlock(&mrt_lock);
2375 return err;
2376 }
2377
2378 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2379 u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2380 int flags)
2381 {
2382 struct nlmsghdr *nlh;
2383 struct rtmsg *rtm;
2384 int err;
2385
2386 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2387 if (!nlh)
2388 return -EMSGSIZE;
2389
2390 rtm = nlmsg_data(nlh);
2391 rtm->rtm_family = RTNL_FAMILY_IP6MR;
2392 rtm->rtm_dst_len = 128;
2393 rtm->rtm_src_len = 128;
2394 rtm->rtm_tos = 0;
2395 rtm->rtm_table = mrt->id;
2396 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2397 goto nla_put_failure;
2398 rtm->rtm_type = RTN_MULTICAST;
2399 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
2400 if (c->mfc_flags & MFC_STATIC)
2401 rtm->rtm_protocol = RTPROT_STATIC;
2402 else
2403 rtm->rtm_protocol = RTPROT_MROUTED;
2404 rtm->rtm_flags = 0;
2405
2406 if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2407 nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2408 goto nla_put_failure;
2409 err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2410 /* do not break the dump if cache is unresolved */
2411 if (err < 0 && err != -ENOENT)
2412 goto nla_put_failure;
2413
2414 nlmsg_end(skb, nlh);
2415 return 0;
2416
2417 nla_put_failure:
2418 nlmsg_cancel(skb, nlh);
2419 return -EMSGSIZE;
2420 }
2421
2422 static int mr6_msgsize(bool unresolved, int maxvif)
2423 {
2424 size_t len =
2425 NLMSG_ALIGN(sizeof(struct rtmsg))
2426 + nla_total_size(4) /* RTA_TABLE */
2427 + nla_total_size(sizeof(struct in6_addr)) /* RTA_SRC */
2428 + nla_total_size(sizeof(struct in6_addr)) /* RTA_DST */
2429 ;
2430
2431 if (!unresolved)
2432 len = len
2433 + nla_total_size(4) /* RTA_IIF */
2434 + nla_total_size(0) /* RTA_MULTIPATH */
2435 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2436 /* RTA_MFC_STATS */
2437 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2438 ;
2439
2440 return len;
2441 }
2442
2443 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2444 int cmd)
2445 {
2446 struct net *net = read_pnet(&mrt->net);
2447 struct sk_buff *skb;
2448 int err = -ENOBUFS;
2449
2450 skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2451 GFP_ATOMIC);
2452 if (!skb)
2453 goto errout;
2454
2455 err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2456 if (err < 0)
2457 goto errout;
2458
2459 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2460 return;
2461
2462 errout:
2463 kfree_skb(skb);
2464 if (err < 0)
2465 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2466 }
2467
2468 static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2469 {
2470 size_t len =
2471 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2472 + nla_total_size(1) /* IP6MRA_CREPORT_MSGTYPE */
2473 + nla_total_size(4) /* IP6MRA_CREPORT_MIF_ID */
2474 /* IP6MRA_CREPORT_SRC_ADDR */
2475 + nla_total_size(sizeof(struct in6_addr))
2476 /* IP6MRA_CREPORT_DST_ADDR */
2477 + nla_total_size(sizeof(struct in6_addr))
2478 /* IP6MRA_CREPORT_PKT */
2479 + nla_total_size(payloadlen)
2480 ;
2481
2482 return len;
2483 }
2484
2485 static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt)
2486 {
2487 struct net *net = read_pnet(&mrt->net);
2488 struct nlmsghdr *nlh;
2489 struct rtgenmsg *rtgenm;
2490 struct mrt6msg *msg;
2491 struct sk_buff *skb;
2492 struct nlattr *nla;
2493 int payloadlen;
2494
2495 payloadlen = pkt->len - sizeof(struct mrt6msg);
2496 msg = (struct mrt6msg *)skb_transport_header(pkt);
2497
2498 skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2499 if (!skb)
2500 goto errout;
2501
2502 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2503 sizeof(struct rtgenmsg), 0);
2504 if (!nlh)
2505 goto errout;
2506 rtgenm = nlmsg_data(nlh);
2507 rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2508 if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2509 nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2510 nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2511 &msg->im6_src) ||
2512 nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2513 &msg->im6_dst))
2514 goto nla_put_failure;
2515
2516 nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2517 if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2518 nla_data(nla), payloadlen))
2519 goto nla_put_failure;
2520
2521 nlmsg_end(skb, nlh);
2522
2523 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2524 return;
2525
2526 nla_put_failure:
2527 nlmsg_cancel(skb, nlh);
2528 errout:
2529 kfree_skb(skb);
2530 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2531 }
2532
2533 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2534 {
2535 struct net *net = sock_net(skb->sk);
2536 struct mr6_table *mrt;
2537 struct mfc6_cache *mfc;
2538 unsigned int t = 0, s_t;
2539 unsigned int h = 0, s_h;
2540 unsigned int e = 0, s_e;
2541
2542 s_t = cb->args[0];
2543 s_h = cb->args[1];
2544 s_e = cb->args[2];
2545
2546 read_lock(&mrt_lock);
2547 ip6mr_for_each_table(mrt, net) {
2548 if (t < s_t)
2549 goto next_table;
2550 if (t > s_t)
2551 s_h = 0;
2552 for (h = s_h; h < MFC6_LINES; h++) {
2553 list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2554 if (e < s_e)
2555 goto next_entry;
2556 if (ip6mr_fill_mroute(mrt, skb,
2557 NETLINK_CB(cb->skb).portid,
2558 cb->nlh->nlmsg_seq,
2559 mfc, RTM_NEWROUTE,
2560 NLM_F_MULTI) < 0)
2561 goto done;
2562 next_entry:
2563 e++;
2564 }
2565 e = s_e = 0;
2566 }
2567 spin_lock_bh(&mfc_unres_lock);
2568 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2569 if (e < s_e)
2570 goto next_entry2;
2571 if (ip6mr_fill_mroute(mrt, skb,
2572 NETLINK_CB(cb->skb).portid,
2573 cb->nlh->nlmsg_seq,
2574 mfc, RTM_NEWROUTE,
2575 NLM_F_MULTI) < 0) {
2576 spin_unlock_bh(&mfc_unres_lock);
2577 goto done;
2578 }
2579 next_entry2:
2580 e++;
2581 }
2582 spin_unlock_bh(&mfc_unres_lock);
2583 e = s_e = 0;
2584 s_h = 0;
2585 next_table:
2586 t++;
2587 }
2588 done:
2589 read_unlock(&mrt_lock);
2590
2591 cb->args[2] = e;
2592 cb->args[1] = h;
2593 cb->args[0] = t;
2594
2595 return skb->len;
2596 }
Linux with added FPC-III support