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