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