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