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