]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/ipv4/ipmr.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
skbuff: Add the offload_mr_fwd_mark field
[mirror_ubuntu-bionic-kernel.git] / net / ipv4 / ipmr.c
CommitLineData
1da177e4
LT		 1/*
2 * IP multicast routing support for mrouted 3.6/3.8
3 *
113aa838 4 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
1da177e4
LT		 5 * Linux Consultancy and Custom Driver Development
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
1da177e4
LT		 12 * Fixes:
13 * Michael Chastain : Incorrect size of copying.
14 * Alan Cox : Added the cache manager code
15 * Alan Cox : Fixed the clone/copy bug and device race.
16 * Mike McLagan : Routing by source
17 * Malcolm Beattie : Buffer handling fixes.
18 * Alexey Kuznetsov : Double buffer free and other fixes.
19 * SVR Anand : Fixed several multicast bugs and problems.
20 * Alexey Kuznetsov : Status, optimisations and more.
21 * Brad Parker : Better behaviour on mrouted upcall
22 * overflow.
23 * Carlos Picoto : PIMv1 Support
24 * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
f77f13e2 25 * Relax this requirement to work with older peers.
1da177e4
LT		 26 *
27 */
28
7c0f6ba6 29#include <linux/uaccess.h>
1da177e4 30#include <linux/types.h>
4fc268d2 31#include <linux/capability.h>
1da177e4
LT		 32#include <linux/errno.h>
33#include <linux/timer.h>
34#include <linux/mm.h>
35#include <linux/kernel.h>
36#include <linux/fcntl.h>
37#include <linux/stat.h>
38#include <linux/socket.h>
39#include <linux/in.h>
40#include <linux/inet.h>
41#include <linux/netdevice.h>
42#include <linux/inetdevice.h>
43#include <linux/igmp.h>
44#include <linux/proc_fs.h>
45#include <linux/seq_file.h>
46#include <linux/mroute.h>
47#include <linux/init.h>
46f25dff 48#include <linux/if_ether.h>
5a0e3ad6 49#include <linux/slab.h>
457c4cbc 50#include <net/net_namespace.h>
1da177e4
LT		 51#include <net/ip.h>
52#include <net/protocol.h>
53#include <linux/skbuff.h>
14c85021 54#include <net/route.h>
1da177e4
LT		 55#include <net/sock.h>
56#include <net/icmp.h>
57#include <net/udp.h>
58#include <net/raw.h>
59#include <linux/notifier.h>
60#include <linux/if_arp.h>
61#include <linux/netfilter_ipv4.h>
709b46e8 62#include <linux/compat.h>
bc3b2d7f 63#include <linux/export.h>
c5441932 64#include <net/ip_tunnels.h>
1da177e4 65#include <net/checksum.h>
dc5fc579 66#include <net/netlink.h>
f0ad0860 67#include <net/fib_rules.h>
d67b8c61 68#include <linux/netconf.h>
ccbb0aa6 69#include <net/nexthop.h>
1da177e4 70
f0ad0860
PM		 71struct ipmr_rule {
72 struct fib_rule common;
73};
74
75struct ipmr_result {
76 struct mr_table *mrt;
77};
78
1da177e4 79/* Big lock, protecting vif table, mrt cache and mroute socket state.
a8cb16dd 80 * Note that the changes are semaphored via rtnl_lock.
1da177e4
LT		 81 */
82
83static DEFINE_RWLOCK(mrt_lock);
84
7ef8f65d 85/* Multicast router control variables */
1da177e4 86
1da177e4
LT		 87/* Special spinlock for queue of unresolved entries */
88static DEFINE_SPINLOCK(mfc_unres_lock);
89
90/* We return to original Alan's scheme. Hash table of resolved
a8cb16dd
ED		 91 * entries is changed only in process context and protected
92 * with weak lock mrt_lock. Queue of unresolved entries is protected
93 * with strong spinlock mfc_unres_lock.
94 *
95 * In this case data path is free of exclusive locks at all.
1da177e4
LT		 96 */
97
e18b890b 98static struct kmem_cache *mrt_cachep __read_mostly;
1da177e4 99
f0ad0860 100static struct mr_table *ipmr_new_table(struct net *net, u32 id);
acbb219d
FR		 101static void ipmr_free_table(struct mr_table *mrt);
102
c4854ec8 103static void ip_mr_forward(struct net *net, struct mr_table *mrt,
4b1f0d33
DS		 104 struct net_device *dev, struct sk_buff *skb,
105 struct mfc_cache *cache, int local);
0c12295a 106static int ipmr_cache_report(struct mr_table *mrt,
4feb88e5 107 struct sk_buff *pkt, vifi_t vifi, int assert);
cb6a4e46
PM		 108static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
109 struct mfc_cache *c, struct rtmsg *rtm);
8cd3ac9f
ND		 110static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
111 int cmd);
5a645dd8 112static void igmpmsg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt);
0e615e96 113static void mroute_clean_tables(struct mr_table *mrt, bool all);
f0ad0860
PM		 114static void ipmr_expire_process(unsigned long arg);
115
116#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
117#define ipmr_for_each_table(mrt, net) \
118 list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
119
120static struct mr_table *ipmr_get_table(struct net *net, u32 id)
121{
122 struct mr_table *mrt;
123
124 ipmr_for_each_table(mrt, net) {
125 if (mrt->id == id)
126 return mrt;
127 }
128 return NULL;
129}
130
da91981b 131static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
f0ad0860
PM		 132 struct mr_table **mrt)
133{
f0ad0860 134 int err;
95f4a45d
HFS		 135 struct ipmr_result res;
136 struct fib_lookup_arg arg = {
137 .result = &res,
138 .flags = FIB_LOOKUP_NOREF,
139 };
f0ad0860 140
e58e4159
DA		 141 /* update flow if oif or iif point to device enslaved to l3mdev */
142 l3mdev_update_flow(net, flowi4_to_flowi(flp4));
143
da91981b
DM		 144 err = fib_rules_lookup(net->ipv4.mr_rules_ops,
145 flowi4_to_flowi(flp4), 0, &arg);
f0ad0860
PM		 146 if (err < 0)
147 return err;
148 *mrt = res.mrt;
149 return 0;
150}
151
152static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
153 int flags, struct fib_lookup_arg *arg)
154{
155 struct ipmr_result *res = arg->result;
156 struct mr_table *mrt;
1da177e4 157
f0ad0860
PM		 158 switch (rule->action) {
159 case FR_ACT_TO_TBL:
160 break;
161 case FR_ACT_UNREACHABLE:
162 return -ENETUNREACH;
163 case FR_ACT_PROHIBIT:
164 return -EACCES;
165 case FR_ACT_BLACKHOLE:
166 default:
167 return -EINVAL;
168 }
169
e58e4159
DA		 170 arg->table = fib_rule_get_table(rule, arg);
171
172 mrt = ipmr_get_table(rule->fr_net, arg->table);
51456b29 173 if (!mrt)
f0ad0860
PM		 174 return -EAGAIN;
175 res->mrt = mrt;
176 return 0;
177}
178
179static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
180{
181 return 1;
182}
183
184static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
185 FRA_GENERIC_POLICY,
186};
187
188static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
189 struct fib_rule_hdr *frh, struct nlattr **tb)
190{
191 return 0;
192}
193
194static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
195 struct nlattr **tb)
196{
197 return 1;
198}
199
200static int ipmr_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
04a6f82c 209static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = {
25239cee 210 .family = RTNL_FAMILY_IPMR,
f0ad0860
PM		 211 .rule_size = sizeof(struct ipmr_rule),
212 .addr_size = sizeof(u32),
213 .action = ipmr_rule_action,
214 .match = ipmr_rule_match,
215 .configure = ipmr_rule_configure,
216 .compare = ipmr_rule_compare,
f0ad0860
PM		 217 .fill = ipmr_rule_fill,
218 .nlgroup = RTNLGRP_IPV4_RULE,
219 .policy = ipmr_rule_policy,
220 .owner = THIS_MODULE,
221};
222
223static int __net_init ipmr_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(&ipmr_rules_ops_template, net);
230 if (IS_ERR(ops))
231 return PTR_ERR(ops);
232
233 INIT_LIST_HEAD(&net->ipv4.mr_tables);
234
235 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
1113ebbc
NA		 236 if (IS_ERR(mrt)) {
237 err = PTR_ERR(mrt);
f0ad0860
PM		 238 goto err1;
239 }
240
241 err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
242 if (err < 0)
243 goto err2;
244
245 net->ipv4.mr_rules_ops = ops;
246 return 0;
247
248err2:
f243e5a7 249 ipmr_free_table(mrt);
f0ad0860
PM		 250err1:
251 fib_rules_unregister(ops);
252 return err;
253}
254
255static void __net_exit ipmr_rules_exit(struct net *net)
256{
257 struct mr_table *mrt, *next;
258
ed785309 259 rtnl_lock();
035320d5
ED		 260 list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
261 list_del(&mrt->list);
acbb219d 262 ipmr_free_table(mrt);
035320d5 263 }
f0ad0860 264 fib_rules_unregister(net->ipv4.mr_rules_ops);
419df12f 265 rtnl_unlock();
f0ad0860 266}
4d65b948
YG		 267
268static int ipmr_rules_dump(struct net *net, struct notifier_block *nb)
269{
270 return fib_rules_dump(net, nb, RTNL_FAMILY_IPMR);
271}
272
273static unsigned int ipmr_rules_seq_read(struct net *net)
274{
275 return fib_rules_seq_read(net, RTNL_FAMILY_IPMR);
276}
478e4c2f
YG		 277
278bool ipmr_rule_default(const struct fib_rule *rule)
279{
280 return fib_rule_matchall(rule) && rule->table == RT_TABLE_DEFAULT;
281}
282EXPORT_SYMBOL(ipmr_rule_default);
f0ad0860
PM		 283#else
284#define ipmr_for_each_table(mrt, net) \
285 for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
286
287static struct mr_table *ipmr_get_table(struct net *net, u32 id)
288{
289 return net->ipv4.mrt;
290}
291
da91981b 292static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
f0ad0860
PM		 293 struct mr_table **mrt)
294{
295 *mrt = net->ipv4.mrt;
296 return 0;
297}
298
299static int __net_init ipmr_rules_init(struct net *net)
300{
1113ebbc
NA		 301 struct mr_table *mrt;
302
303 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
304 if (IS_ERR(mrt))
305 return PTR_ERR(mrt);
306 net->ipv4.mrt = mrt;
307 return 0;
f0ad0860
PM		 308}
309
310static void __net_exit ipmr_rules_exit(struct net *net)
311{
ed785309 312 rtnl_lock();
acbb219d 313 ipmr_free_table(net->ipv4.mrt);
ed785309
WC		 314 net->ipv4.mrt = NULL;
315 rtnl_unlock();
f0ad0860 316}
4d65b948
YG		 317
318static int ipmr_rules_dump(struct net *net, struct notifier_block *nb)
319{
320 return 0;
321}
322
323static unsigned int ipmr_rules_seq_read(struct net *net)
324{
325 return 0;
326}
478e4c2f
YG		 327
328bool ipmr_rule_default(const struct fib_rule *rule)
329{
330 return true;
331}
332EXPORT_SYMBOL(ipmr_rule_default);
f0ad0860
PM		 333#endif
334
8fb472c0
NA		 335static inline int ipmr_hash_cmp(struct rhashtable_compare_arg *arg,
336 const void *ptr)
337{
338 const struct mfc_cache_cmp_arg *cmparg = arg->key;
339 struct mfc_cache *c = (struct mfc_cache *)ptr;
340
341 return cmparg->mfc_mcastgrp != c->mfc_mcastgrp ||
342 cmparg->mfc_origin != c->mfc_origin;
343}
344
345static const struct rhashtable_params ipmr_rht_params = {
346 .head_offset = offsetof(struct mfc_cache, mnode),
347 .key_offset = offsetof(struct mfc_cache, cmparg),
348 .key_len = sizeof(struct mfc_cache_cmp_arg),
349 .nelem_hint = 3,
350 .locks_mul = 1,
351 .obj_cmpfn = ipmr_hash_cmp,
352 .automatic_shrinking = true,
353};
354
f0ad0860
PM		 355static struct mr_table *ipmr_new_table(struct net *net, u32 id)
356{
357 struct mr_table *mrt;
1da177e4 358
1113ebbc
NA		 359 /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
360 if (id != RT_TABLE_DEFAULT && id >= 1000000000)
361 return ERR_PTR(-EINVAL);
362
f0ad0860 363 mrt = ipmr_get_table(net, id);
00db4124 364 if (mrt)
f0ad0860
PM		 365 return mrt;
366
367 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
51456b29 368 if (!mrt)
1113ebbc 369 return ERR_PTR(-ENOMEM);
8de53dfb 370 write_pnet(&mrt->net, net);
f0ad0860
PM		 371 mrt->id = id;
372
8fb472c0
NA		 373 rhltable_init(&mrt->mfc_hash, &ipmr_rht_params);
374 INIT_LIST_HEAD(&mrt->mfc_cache_list);
f0ad0860
PM		 375 INIT_LIST_HEAD(&mrt->mfc_unres_queue);
376
377 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
378 (unsigned long)mrt);
379
f0ad0860 380 mrt->mroute_reg_vif_num = -1;
f0ad0860
PM		 381#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
382 list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
383#endif
384 return mrt;
385}
1da177e4 386
acbb219d
FR		 387static void ipmr_free_table(struct mr_table *mrt)
388{
389 del_timer_sync(&mrt->ipmr_expire_timer);
0e615e96 390 mroute_clean_tables(mrt, true);
8fb472c0 391 rhltable_destroy(&mrt->mfc_hash);
acbb219d
FR		 392 kfree(mrt);
393}
394
1da177e4
LT		 395/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
396
d607032d
WC		 397static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
398{
4feb88e5
BT		 399 struct net *net = dev_net(dev);
400
d607032d
WC		 401 dev_close(dev);
402
4feb88e5 403 dev = __dev_get_by_name(net, "tunl0");
d607032d 404 if (dev) {
5bc3eb7e 405 const struct net_device_ops *ops = dev->netdev_ops;
d607032d 406 struct ifreq ifr;
d607032d
WC		 407 struct ip_tunnel_parm p;
408
409 memset(&p, 0, sizeof(p));
410 p.iph.daddr = v->vifc_rmt_addr.s_addr;
411 p.iph.saddr = v->vifc_lcl_addr.s_addr;
412 p.iph.version = 4;
413 p.iph.ihl = 5;
414 p.iph.protocol = IPPROTO_IPIP;
415 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
416 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
417
5bc3eb7e
SH		 418 if (ops->ndo_do_ioctl) {
419 mm_segment_t oldfs = get_fs();
420
421 set_fs(KERNEL_DS);
422 ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
423 set_fs(oldfs);
424 }
d607032d
WC		 425 }
426}
427
a0b47736
NA		 428/* Initialize ipmr pimreg/tunnel in_device */
429static bool ipmr_init_vif_indev(const struct net_device *dev)
430{
431 struct in_device *in_dev;
432
433 ASSERT_RTNL();
434
435 in_dev = __in_dev_get_rtnl(dev);
436 if (!in_dev)
437 return false;
438 ipv4_devconf_setall(in_dev);
439 neigh_parms_data_state_setall(in_dev->arp_parms);
440 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
441
442 return true;
443}
444
7ef8f65d 445static struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
1da177e4
LT		 446{
447 struct net_device *dev;
448
4feb88e5 449 dev = __dev_get_by_name(net, "tunl0");
1da177e4
LT		 450
451 if (dev) {
5bc3eb7e 452 const struct net_device_ops *ops = dev->netdev_ops;
1da177e4
LT		 453 int err;
454 struct ifreq ifr;
1da177e4 455 struct ip_tunnel_parm p;
1da177e4
LT		 456
457 memset(&p, 0, sizeof(p));
458 p.iph.daddr = v->vifc_rmt_addr.s_addr;
459 p.iph.saddr = v->vifc_lcl_addr.s_addr;
460 p.iph.version = 4;
461 p.iph.ihl = 5;
462 p.iph.protocol = IPPROTO_IPIP;
463 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
ba93ef74 464 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
1da177e4 465
5bc3eb7e
SH		 466 if (ops->ndo_do_ioctl) {
467 mm_segment_t oldfs = get_fs();
468
469 set_fs(KERNEL_DS);
470 err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
471 set_fs(oldfs);
a8cb16dd 472 } else {
5bc3eb7e 473 err = -EOPNOTSUPP;
a8cb16dd 474 }
1da177e4
LT		 475 dev = NULL;
476
4feb88e5
BT		 477 if (err == 0 &&
478 (dev = __dev_get_by_name(net, p.name)) != NULL) {
1da177e4 479 dev->flags |= IFF_MULTICAST;
a0b47736 480 if (!ipmr_init_vif_indev(dev))
1da177e4 481 goto failure;
1da177e4
LT		 482 if (dev_open(dev))
483 goto failure;
7dc00c82 484 dev_hold(dev);
1da177e4
LT		 485 }
486 }
487 return dev;
488
489failure:
1da177e4
LT		 490 unregister_netdevice(dev);
491 return NULL;
492}
493
c316c629 494#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
6fef4c0c 495static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
1da177e4 496{
4feb88e5 497 struct net *net = dev_net(dev);
f0ad0860 498 struct mr_table *mrt;
da91981b
DM		 499 struct flowi4 fl4 = {
500 .flowi4_oif = dev->ifindex,
6a662719 501 .flowi4_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
da91981b 502 .flowi4_mark = skb->mark,
f0ad0860
PM		 503 };
504 int err;
505
da91981b 506 err = ipmr_fib_lookup(net, &fl4, &mrt);
e40dbc51
BG		 507 if (err < 0) {
508 kfree_skb(skb);
f0ad0860 509 return err;
e40dbc51 510 }
4feb88e5 511
1da177e4 512 read_lock(&mrt_lock);
cf3677ae
PE		 513 dev->stats.tx_bytes += skb->len;
514 dev->stats.tx_packets++;
0c12295a 515 ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
1da177e4
LT		 516 read_unlock(&mrt_lock);
517 kfree_skb(skb);
6ed10654 518 return NETDEV_TX_OK;
1da177e4
LT		 519}
520
ee9b9596
ND		 521static int reg_vif_get_iflink(const struct net_device *dev)
522{
523 return 0;
524}
525
007c3838
SH		 526static const struct net_device_ops reg_vif_netdev_ops = {
527 .ndo_start_xmit = reg_vif_xmit,
ee9b9596 528 .ndo_get_iflink = reg_vif_get_iflink,
007c3838
SH		 529};
530
1da177e4
LT		 531static void reg_vif_setup(struct net_device *dev)
532{
533 dev->type = ARPHRD_PIMREG;
46f25dff 534 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
1da177e4 535 dev->flags = IFF_NOARP;
70cb4a45 536 dev->netdev_ops = &reg_vif_netdev_ops;
cf124db5 537 dev->needs_free_netdev = true;
403dbb97 538 dev->features |= NETIF_F_NETNS_LOCAL;
1da177e4
LT		 539}
540
f0ad0860 541static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
1da177e4
LT		 542{
543 struct net_device *dev;
f0ad0860 544 char name[IFNAMSIZ];
1da177e4 545
f0ad0860
PM		 546 if (mrt->id == RT_TABLE_DEFAULT)
547 sprintf(name, "pimreg");
548 else
549 sprintf(name, "pimreg%u", mrt->id);
1da177e4 550
c835a677 551 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
1da177e4 552
51456b29 553 if (!dev)
1da177e4
LT		 554 return NULL;
555
403dbb97
TG		 556 dev_net_set(dev, net);
557
1da177e4
LT		 558 if (register_netdevice(dev)) {
559 free_netdev(dev);
560 return NULL;
561 }
1da177e4 562
a0b47736 563 if (!ipmr_init_vif_indev(dev))
1da177e4 564 goto failure;
1da177e4
LT		 565 if (dev_open(dev))
566 goto failure;
567
7dc00c82
WC		 568 dev_hold(dev);
569
1da177e4
LT		 570 return dev;
571
572failure:
1da177e4
LT		 573 unregister_netdevice(dev);
574 return NULL;
575}
c316c629
NA		 576
577/* called with rcu_read_lock() */
578static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
579 unsigned int pimlen)
580{
581 struct net_device *reg_dev = NULL;
582 struct iphdr *encap;
583
584 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
7ef8f65d 585 /* Check that:
c316c629
NA		 586 * a. packet is really sent to a multicast group
587 * b. packet is not a NULL-REGISTER
588 * c. packet is not truncated
589 */
590 if (!ipv4_is_multicast(encap->daddr) ||
591 encap->tot_len == 0 ||
592 ntohs(encap->tot_len) + pimlen > skb->len)
593 return 1;
594
595 read_lock(&mrt_lock);
596 if (mrt->mroute_reg_vif_num >= 0)
597 reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
598 read_unlock(&mrt_lock);
599
600 if (!reg_dev)
601 return 1;
602
603 skb->mac_header = skb->network_header;
604 skb_pull(skb, (u8 *)encap - skb->data);
605 skb_reset_network_header(skb);
606 skb->protocol = htons(ETH_P_IP);
607 skb->ip_summed = CHECKSUM_NONE;
608
609 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
610
611 netif_rx(skb);
612
613 return NET_RX_SUCCESS;
614}
615#else
616static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
617{
618 return NULL;
619}
1da177e4
LT		 620#endif
621
4d65b948
YG		 622static int call_ipmr_vif_entry_notifier(struct notifier_block *nb,
623 struct net *net,
624 enum fib_event_type event_type,
625 struct vif_device *vif,
626 vifi_t vif_index, u32 tb_id)
627{
628 struct vif_entry_notifier_info info = {
629 .info = {
630 .family = RTNL_FAMILY_IPMR,
631 .net = net,
632 },
633 .dev = vif->dev,
634 .vif_index = vif_index,
635 .vif_flags = vif->flags,
636 .tb_id = tb_id,
637 };
638
639 return call_fib_notifier(nb, net, event_type, &info.info);
640}
641
b362053a
YG		 642static int call_ipmr_vif_entry_notifiers(struct net *net,
643 enum fib_event_type event_type,
644 struct vif_device *vif,
645 vifi_t vif_index, u32 tb_id)
646{
647 struct vif_entry_notifier_info info = {
648 .info = {
649 .family = RTNL_FAMILY_IPMR,
650 .net = net,
651 },
652 .dev = vif->dev,
653 .vif_index = vif_index,
654 .vif_flags = vif->flags,
655 .tb_id = tb_id,
656 };
657
658 ASSERT_RTNL();
659 net->ipv4.ipmr_seq++;
660 return call_fib_notifiers(net, event_type, &info.info);
661}
662
4d65b948
YG		 663static int call_ipmr_mfc_entry_notifier(struct notifier_block *nb,
664 struct net *net,
665 enum fib_event_type event_type,
666 struct mfc_cache *mfc, u32 tb_id)
667{
668 struct mfc_entry_notifier_info info = {
669 .info = {
670 .family = RTNL_FAMILY_IPMR,
671 .net = net,
672 },
673 .mfc = mfc,
674 .tb_id = tb_id
675 };
676
677 return call_fib_notifier(nb, net, event_type, &info.info);
678}
679
b362053a
YG		 680static int call_ipmr_mfc_entry_notifiers(struct net *net,
681 enum fib_event_type event_type,
682 struct mfc_cache *mfc, u32 tb_id)
683{
684 struct mfc_entry_notifier_info info = {
685 .info = {
686 .family = RTNL_FAMILY_IPMR,
687 .net = net,
688 },
689 .mfc = mfc,
690 .tb_id = tb_id
691 };
692
693 ASSERT_RTNL();
694 net->ipv4.ipmr_seq++;
695 return call_fib_notifiers(net, event_type, &info.info);
696}
697
2c53040f
BH		 698/**
699 * vif_delete - Delete a VIF entry
7dc00c82 700 * @notify: Set to 1, if the caller is a notifier_call
1da177e4 701 */
0c12295a 702static int vif_delete(struct mr_table *mrt, int vifi, int notify,
d17fa6fa 703 struct list_head *head)
1da177e4 704{
b362053a 705 struct net *net = read_pnet(&mrt->net);
1da177e4
LT		 706 struct vif_device *v;
707 struct net_device *dev;
708 struct in_device *in_dev;
709
0c12295a 710 if (vifi < 0 || vifi >= mrt->maxvif)
1da177e4
LT		 711 return -EADDRNOTAVAIL;
712
0c12295a 713 v = &mrt->vif_table[vifi];
1da177e4 714
b362053a
YG		 715 if (VIF_EXISTS(mrt, vifi))
716 call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_DEL, v, vifi,
717 mrt->id);
718
1da177e4
LT		 719 write_lock_bh(&mrt_lock);
720 dev = v->dev;
721 v->dev = NULL;
722
723 if (!dev) {
724 write_unlock_bh(&mrt_lock);
725 return -EADDRNOTAVAIL;
726 }
727
0c12295a
PM		 728 if (vifi == mrt->mroute_reg_vif_num)
729 mrt->mroute_reg_vif_num = -1;
1da177e4 730
a8cb16dd 731 if (vifi + 1 == mrt->maxvif) {
1da177e4 732 int tmp;
a8cb16dd
ED		 733
734 for (tmp = vifi - 1; tmp >= 0; tmp--) {
0c12295a 735 if (VIF_EXISTS(mrt, tmp))
1da177e4
LT		 736 break;
737 }
0c12295a 738 mrt->maxvif = tmp+1;
1da177e4
LT		 739 }
740
741 write_unlock_bh(&mrt_lock);
742
743 dev_set_allmulti(dev, -1);
744
a8cb16dd
ED		 745 in_dev = __in_dev_get_rtnl(dev);
746 if (in_dev) {
42f811b8 747 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
3b022865 748 inet_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
d67b8c61
ND		 749 NETCONFA_MC_FORWARDING,
750 dev->ifindex, &in_dev->cnf);
1da177e4
LT		 751 ip_rt_multicast_event(in_dev);
752 }
753
a8cb16dd 754 if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
d17fa6fa 755 unregister_netdevice_queue(dev, head);
1da177e4
LT		 756
757 dev_put(dev);
758 return 0;
759}
760
a8c9486b 761static void ipmr_cache_free_rcu(struct rcu_head *head)
5c0a66f5 762{
a8c9486b
ED		 763 struct mfc_cache *c = container_of(head, struct mfc_cache, rcu);
764
5c0a66f5
BT		 765 kmem_cache_free(mrt_cachep, c);
766}
767
310ebbba 768void ipmr_cache_free(struct mfc_cache *c)
a8c9486b
ED		 769{
770 call_rcu(&c->rcu, ipmr_cache_free_rcu);
771}
310ebbba 772EXPORT_SYMBOL(ipmr_cache_free);
a8c9486b 773
1da177e4 774/* Destroy an unresolved cache entry, killing queued skbs
a8cb16dd 775 * and reporting error to netlink readers.
1da177e4 776 */
0c12295a 777static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
1da177e4 778{
8de53dfb 779 struct net *net = read_pnet(&mrt->net);
1da177e4 780 struct sk_buff *skb;
9ef1d4c7 781 struct nlmsgerr *e;
1da177e4 782
0c12295a 783 atomic_dec(&mrt->cache_resolve_queue_len);
1da177e4 784
c354e124 785 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
eddc9ec5 786 if (ip_hdr(skb)->version == 0) {
af72868b
JB		 787 struct nlmsghdr *nlh = skb_pull(skb,
788 sizeof(struct iphdr));
1da177e4 789 nlh->nlmsg_type = NLMSG_ERROR;
573ce260 790 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1da177e4 791 skb_trim(skb, nlh->nlmsg_len);
573ce260 792 e = nlmsg_data(nlh);
9ef1d4c7
PM		 793 e->error = -ETIMEDOUT;
794 memset(&e->msg, 0, sizeof(e->msg));
2942e900 795
15e47304 796 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
a8cb16dd 797 } else {
1da177e4 798 kfree_skb(skb);
a8cb16dd 799 }
1da177e4
LT		 800 }
801
5c0a66f5 802 ipmr_cache_free(c);
1da177e4
LT		 803}
804
e258beb2 805/* Timer process for the unresolved queue. */
e258beb2 806static void ipmr_expire_process(unsigned long arg)
1da177e4 807{
0c12295a 808 struct mr_table *mrt = (struct mr_table *)arg;
1da177e4
LT		 809 unsigned long now;
810 unsigned long expires;
862465f2 811 struct mfc_cache *c, *next;
1da177e4
LT		 812
813 if (!spin_trylock(&mfc_unres_lock)) {
0c12295a 814 mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
1da177e4
LT		 815 return;
816 }
817
0c12295a 818 if (list_empty(&mrt->mfc_unres_queue))
1da177e4
LT		 819 goto out;
820
821 now = jiffies;
822 expires = 10*HZ;
1da177e4 823
0c12295a 824 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
1da177e4
LT		 825 if (time_after(c->mfc_un.unres.expires, now)) {
826 unsigned long interval = c->mfc_un.unres.expires - now;
827 if (interval < expires)
828 expires = interval;
1da177e4
LT		 829 continue;
830 }
831
862465f2 832 list_del(&c->list);
8cd3ac9f 833 mroute_netlink_event(mrt, c, RTM_DELROUTE);
0c12295a 834 ipmr_destroy_unres(mrt, c);
1da177e4
LT		 835 }
836
0c12295a
PM		 837 if (!list_empty(&mrt->mfc_unres_queue))
838 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
1da177e4
LT		 839
840out:
841 spin_unlock(&mfc_unres_lock);
842}
843
844/* Fill oifs list. It is called under write locked mrt_lock. */
0c12295a 845static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
d658f8a0 846 unsigned char *ttls)
1da177e4
LT		 847{
848 int vifi;
849
850 cache->mfc_un.res.minvif = MAXVIFS;
851 cache->mfc_un.res.maxvif = 0;
852 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
853
0c12295a
PM		 854 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
855 if (VIF_EXISTS(mrt, vifi) &&
cf958ae3 856 ttls[vifi] && ttls[vifi] < 255) {
1da177e4
LT		 857 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
858 if (cache->mfc_un.res.minvif > vifi)
859 cache->mfc_un.res.minvif = vifi;
860 if (cache->mfc_un.res.maxvif <= vifi)
861 cache->mfc_un.res.maxvif = vifi + 1;
862 }
863 }
90b5ca17 864 cache->mfc_un.res.lastuse = jiffies;
1da177e4
LT		 865}
866
0c12295a
PM		 867static int vif_add(struct net *net, struct mr_table *mrt,
868 struct vifctl *vifc, int mrtsock)
1da177e4
LT		 869{
870 int vifi = vifc->vifc_vifi;
0c12295a 871 struct vif_device *v = &mrt->vif_table[vifi];
1da177e4
LT		 872 struct net_device *dev;
873 struct in_device *in_dev;
d607032d 874 int err;
1da177e4
LT		 875
876 /* Is vif busy ? */
0c12295a 877 if (VIF_EXISTS(mrt, vifi))
1da177e4
LT		 878 return -EADDRINUSE;
879
880 switch (vifc->vifc_flags) {
1da177e4 881 case VIFF_REGISTER:
1973a4ea 882 if (!ipmr_pimsm_enabled())
c316c629
NA		 883 return -EINVAL;
884 /* Special Purpose VIF in PIM
1da177e4
LT		 885 * All the packets will be sent to the daemon
886 */
0c12295a 887 if (mrt->mroute_reg_vif_num >= 0)
1da177e4 888 return -EADDRINUSE;
f0ad0860 889 dev = ipmr_reg_vif(net, mrt);
1da177e4
LT		 890 if (!dev)
891 return -ENOBUFS;
d607032d
WC		 892 err = dev_set_allmulti(dev, 1);
893 if (err) {
894 unregister_netdevice(dev);
7dc00c82 895 dev_put(dev);
d607032d
WC		 896 return err;
897 }
1da177e4 898 break;
e905a9ed 899 case VIFF_TUNNEL:
4feb88e5 900 dev = ipmr_new_tunnel(net, vifc);
1da177e4
LT		 901 if (!dev)
902 return -ENOBUFS;
d607032d
WC		 903 err = dev_set_allmulti(dev, 1);
904 if (err) {
905 ipmr_del_tunnel(dev, vifc);
7dc00c82 906 dev_put(dev);
d607032d
WC		 907 return err;
908 }
1da177e4 909 break;
ee5e81f0 910 case VIFF_USE_IFINDEX:
1da177e4 911 case 0:
ee5e81f0
I		 912 if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
913 dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
51456b29 914 if (dev && !__in_dev_get_rtnl(dev)) {
ee5e81f0
I		 915 dev_put(dev);
916 return -EADDRNOTAVAIL;
917 }
a8cb16dd 918 } else {
ee5e81f0 919 dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
a8cb16dd 920 }
1da177e4
LT		 921 if (!dev)
922 return -EADDRNOTAVAIL;
d607032d 923 err = dev_set_allmulti(dev, 1);
7dc00c82
WC		 924 if (err) {
925 dev_put(dev);
d607032d 926 return err;
7dc00c82 927 }
1da177e4
LT		 928 break;
929 default:
930 return -EINVAL;
931 }
932
a8cb16dd
ED		 933 in_dev = __in_dev_get_rtnl(dev);
934 if (!in_dev) {
d0490cfd 935 dev_put(dev);
1da177e4 936 return -EADDRNOTAVAIL;
d0490cfd 937 }
42f811b8 938 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
3b022865
DA		 939 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_MC_FORWARDING,
940 dev->ifindex, &in_dev->cnf);
1da177e4
LT		 941 ip_rt_multicast_event(in_dev);
942
a8cb16dd
ED		 943 /* Fill in the VIF structures */
944
c354e124
JK		 945 v->rate_limit = vifc->vifc_rate_limit;
946 v->local = vifc->vifc_lcl_addr.s_addr;
947 v->remote = vifc->vifc_rmt_addr.s_addr;
948 v->flags = vifc->vifc_flags;
1da177e4
LT		 949 if (!mrtsock)
950 v->flags |= VIFF_STATIC;
c354e124 951 v->threshold = vifc->vifc_threshold;
1da177e4
LT		 952 v->bytes_in = 0;
953 v->bytes_out = 0;
954 v->pkt_in = 0;
955 v->pkt_out = 0;
956 v->link = dev->ifindex;
a8cb16dd 957 if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
a54acb3a 958 v->link = dev_get_iflink(dev);
1da177e4
LT		 959
960 /* And finish update writing critical data */
961 write_lock_bh(&mrt_lock);
c354e124 962 v->dev = dev;
a8cb16dd 963 if (v->flags & VIFF_REGISTER)
0c12295a 964 mrt->mroute_reg_vif_num = vifi;
0c12295a
PM		 965 if (vifi+1 > mrt->maxvif)
966 mrt->maxvif = vifi+1;
1da177e4 967 write_unlock_bh(&mrt_lock);
b362053a 968 call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD, v, vifi, mrt->id);
1da177e4
LT		 969 return 0;
970}
971
a8c9486b 972/* called with rcu_read_lock() */
0c12295a 973static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
4feb88e5
BT		 974 __be32 origin,
975 __be32 mcastgrp)
1da177e4 976{
8fb472c0
NA		 977 struct mfc_cache_cmp_arg arg = {
978 .mfc_mcastgrp = mcastgrp,
979 .mfc_origin = origin
980 };
981 struct rhlist_head *tmp, *list;
1da177e4
LT		 982 struct mfc_cache *c;
983
8fb472c0
NA		 984 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
985 rhl_for_each_entry_rcu(c, tmp, list, mnode)
986 return c;
987
862465f2 988 return NULL;
1da177e4
LT		 989}
990
660b26dc
ND		 991/* Look for a (*,*,oif) entry */
992static struct mfc_cache *ipmr_cache_find_any_parent(struct mr_table *mrt,
993 int vifi)
994{
8fb472c0
NA		 995 struct mfc_cache_cmp_arg arg = {
996 .mfc_mcastgrp = htonl(INADDR_ANY),
997 .mfc_origin = htonl(INADDR_ANY)
998 };
999 struct rhlist_head *tmp, *list;
660b26dc
ND		 1000 struct mfc_cache *c;
1001
8fb472c0
NA		 1002 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
1003 rhl_for_each_entry_rcu(c, tmp, list, mnode)
1004 if (c->mfc_un.res.ttls[vifi] < 255)
660b26dc
ND		 1005 return c;
1006
1007 return NULL;
1008}
1009
1010/* Look for a (*,G) entry */
1011static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt,
1012 __be32 mcastgrp, int vifi)
1013{
8fb472c0
NA		 1014 struct mfc_cache_cmp_arg arg = {
1015 .mfc_mcastgrp = mcastgrp,
1016 .mfc_origin = htonl(INADDR_ANY)
1017 };
1018 struct rhlist_head *tmp, *list;
660b26dc
ND		 1019 struct mfc_cache *c, *proxy;
1020
360eb5da 1021 if (mcastgrp == htonl(INADDR_ANY))
660b26dc
ND		 1022 goto skip;
1023
8fb472c0
NA		 1024 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
1025 rhl_for_each_entry_rcu(c, tmp, list, mnode) {
1026 if (c->mfc_un.res.ttls[vifi] < 255)
1027 return c;
1028
1029 /* It's ok if the vifi is part of the static tree */
1030 proxy = ipmr_cache_find_any_parent(mrt, c->mfc_parent);
1031 if (proxy && proxy->mfc_un.res.ttls[vifi] < 255)
1032 return c;
1033 }
660b26dc
ND		 1034
1035skip:
1036 return ipmr_cache_find_any_parent(mrt, vifi);
1037}
1038
8fb472c0
NA		 1039/* Look for a (S,G,iif) entry if parent != -1 */
1040static struct mfc_cache *ipmr_cache_find_parent(struct mr_table *mrt,
1041 __be32 origin, __be32 mcastgrp,
1042 int parent)
1043{
1044 struct mfc_cache_cmp_arg arg = {
1045 .mfc_mcastgrp = mcastgrp,
1046 .mfc_origin = origin,
1047 };
1048 struct rhlist_head *tmp, *list;
1049 struct mfc_cache *c;
1050
1051 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
1052 rhl_for_each_entry_rcu(c, tmp, list, mnode)
1053 if (parent == -1 || parent == c->mfc_parent)
1054 return c;
1055
1056 return NULL;
1057}
1058
7ef8f65d 1059/* Allocate a multicast cache entry */
d658f8a0 1060static struct mfc_cache *ipmr_cache_alloc(void)
1da177e4 1061{
c354e124 1062 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
a8c9486b 1063
70a0dec4
TG		 1064 if (c) {
1065 c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
a8c9486b 1066 c->mfc_un.res.minvif = MAXVIFS;
310ebbba 1067 refcount_set(&c->mfc_un.res.refcount, 1);
70a0dec4 1068 }
1da177e4
LT		 1069 return c;
1070}
1071
d658f8a0 1072static struct mfc_cache *ipmr_cache_alloc_unres(void)
1da177e4 1073{
c354e124 1074 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
a8c9486b
ED		 1075
1076 if (c) {
1077 skb_queue_head_init(&c->mfc_un.unres.unresolved);
1078 c->mfc_un.unres.expires = jiffies + 10*HZ;
1079 }
1da177e4
LT		 1080 return c;
1081}
1082
7ef8f65d 1083/* A cache entry has gone into a resolved state from queued */
0c12295a
PM		 1084static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
1085 struct mfc_cache *uc, struct mfc_cache *c)
1da177e4
LT		 1086{
1087 struct sk_buff *skb;
9ef1d4c7 1088 struct nlmsgerr *e;
1da177e4 1089
a8cb16dd 1090 /* Play the pending entries through our router */
c354e124 1091 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
eddc9ec5 1092 if (ip_hdr(skb)->version == 0) {
af72868b
JB		 1093 struct nlmsghdr *nlh = skb_pull(skb,
1094 sizeof(struct iphdr));
1da177e4 1095
573ce260 1096 if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
a8cb16dd
ED		 1097 nlh->nlmsg_len = skb_tail_pointer(skb) -
1098 (u8 *)nlh;
1da177e4
LT		 1099 } else {
1100 nlh->nlmsg_type = NLMSG_ERROR;
573ce260 1101 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1da177e4 1102 skb_trim(skb, nlh->nlmsg_len);
573ce260 1103 e = nlmsg_data(nlh);
9ef1d4c7
PM		 1104 e->error = -EMSGSIZE;
1105 memset(&e->msg, 0, sizeof(e->msg));
1da177e4 1106 }
2942e900 1107
15e47304 1108 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
a8cb16dd 1109 } else {
4b1f0d33 1110 ip_mr_forward(net, mrt, skb->dev, skb, c, 0);
a8cb16dd 1111 }
1da177e4
LT		 1112 }
1113}
1114
5a645dd8 1115/* Bounce a cache query up to mrouted and netlink.
1da177e4 1116 *
c316c629 1117 * Called under mrt_lock.
1da177e4 1118 */
0c12295a 1119static int ipmr_cache_report(struct mr_table *mrt,
4feb88e5 1120 struct sk_buff *pkt, vifi_t vifi, int assert)
1da177e4 1121{
c9bdd4b5 1122 const int ihl = ip_hdrlen(pkt);
c316c629 1123 struct sock *mroute_sk;
1da177e4
LT		 1124 struct igmphdr *igmp;
1125 struct igmpmsg *msg;
c316c629 1126 struct sk_buff *skb;
1da177e4
LT		 1127 int ret;
1128
1da177e4
LT		 1129 if (assert == IGMPMSG_WHOLEPKT)
1130 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
1131 else
1da177e4
LT		 1132 skb = alloc_skb(128, GFP_ATOMIC);
1133
132adf54 1134 if (!skb)
1da177e4
LT		 1135 return -ENOBUFS;
1136
1da177e4
LT		 1137 if (assert == IGMPMSG_WHOLEPKT) {
1138 /* Ugly, but we have no choice with this interface.
a8cb16dd
ED		 1139 * Duplicate old header, fix ihl, length etc.
1140 * And all this only to mangle msg->im_msgtype and
1141 * to set msg->im_mbz to "mbz" :-)
1da177e4 1142 */
878c8145
ACM		 1143 skb_push(skb, sizeof(struct iphdr));
1144 skb_reset_network_header(skb);
badff6d0 1145 skb_reset_transport_header(skb);
0272ffc4 1146 msg = (struct igmpmsg *)skb_network_header(skb);
d56f90a7 1147 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
1da177e4
LT		 1148 msg->im_msgtype = IGMPMSG_WHOLEPKT;
1149 msg->im_mbz = 0;
0c12295a 1150 msg->im_vif = mrt->mroute_reg_vif_num;
eddc9ec5
ACM		 1151 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
1152 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
1153 sizeof(struct iphdr));
c316c629
NA		 1154 } else {
1155 /* Copy the IP header */
1156 skb_set_network_header(skb, skb->len);
1157 skb_put(skb, ihl);
1158 skb_copy_to_linear_data(skb, pkt->data, ihl);
1159 /* Flag to the kernel this is a route add */
1160 ip_hdr(skb)->protocol = 0;
1161 msg = (struct igmpmsg *)skb_network_header(skb);
1162 msg->im_vif = vifi;
1163 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1164 /* Add our header */
4df864c1 1165 igmp = skb_put(skb, sizeof(struct igmphdr));
c316c629
NA		 1166 igmp->type = assert;
1167 msg->im_msgtype = assert;
1168 igmp->code = 0;
1169 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
1170 skb->transport_header = skb->network_header;
e905a9ed 1171 }
1da177e4 1172
4c968709
ED		 1173 rcu_read_lock();
1174 mroute_sk = rcu_dereference(mrt->mroute_sk);
51456b29 1175 if (!mroute_sk) {
4c968709 1176 rcu_read_unlock();
1da177e4
LT		 1177 kfree_skb(skb);
1178 return -EINVAL;
1179 }
1180
5a645dd8
JG		 1181 igmpmsg_netlink_event(mrt, skb);
1182
a8cb16dd 1183 /* Deliver to mrouted */
4c968709
ED		 1184 ret = sock_queue_rcv_skb(mroute_sk, skb);
1185 rcu_read_unlock();
70a269e6 1186 if (ret < 0) {
e87cc472 1187 net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
1da177e4
LT		 1188 kfree_skb(skb);
1189 }
1190
1191 return ret;
1192}
1193
7ef8f65d
NA		 1194/* Queue a packet for resolution. It gets locked cache entry! */
1195static int ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi,
4b1f0d33 1196 struct sk_buff *skb, struct net_device *dev)
1da177e4 1197{
8fb472c0
NA		 1198 const struct iphdr *iph = ip_hdr(skb);
1199 struct mfc_cache *c;
862465f2 1200 bool found = false;
1da177e4 1201 int err;
1da177e4
LT		 1202
1203 spin_lock_bh(&mfc_unres_lock);
0c12295a 1204 list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
e258beb2 1205 if (c->mfc_mcastgrp == iph->daddr &&
862465f2
PM		 1206 c->mfc_origin == iph->saddr) {
1207 found = true;
1da177e4 1208 break;
862465f2 1209 }
1da177e4
LT		 1210 }
1211
862465f2 1212 if (!found) {
a8cb16dd 1213 /* Create a new entry if allowable */
0c12295a 1214 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
d658f8a0 1215 (c = ipmr_cache_alloc_unres()) == NULL) {
1da177e4
LT		 1216 spin_unlock_bh(&mfc_unres_lock);
1217
1218 kfree_skb(skb);
1219 return -ENOBUFS;
1220 }
1221
a8cb16dd 1222 /* Fill in the new cache entry */
eddc9ec5
ACM		 1223 c->mfc_parent = -1;
1224 c->mfc_origin = iph->saddr;
1225 c->mfc_mcastgrp = iph->daddr;
1da177e4 1226
a8cb16dd 1227 /* Reflect first query at mrouted. */
0c12295a 1228 err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
4feb88e5 1229 if (err < 0) {
e905a9ed 1230 /* If the report failed throw the cache entry
1da177e4
LT		 1231 out - Brad Parker
1232 */
1233 spin_unlock_bh(&mfc_unres_lock);
1234
5c0a66f5 1235 ipmr_cache_free(c);
1da177e4
LT		 1236 kfree_skb(skb);
1237 return err;
1238 }
1239
0c12295a
PM		 1240 atomic_inc(&mrt->cache_resolve_queue_len);
1241 list_add(&c->list, &mrt->mfc_unres_queue);
8cd3ac9f 1242 mroute_netlink_event(mrt, c, RTM_NEWROUTE);
1da177e4 1243
278554bd
DM		 1244 if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
1245 mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
1da177e4
LT		 1246 }
1247
a8cb16dd 1248 /* See if we can append the packet */
a8cb16dd 1249 if (c->mfc_un.unres.unresolved.qlen > 3) {
1da177e4
LT		 1250 kfree_skb(skb);
1251 err = -ENOBUFS;
1252 } else {
4b1f0d33
DS		 1253 if (dev) {
1254 skb->dev = dev;
1255 skb->skb_iif = dev->ifindex;
1256 }
c354e124 1257 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1da177e4
LT		 1258 err = 0;
1259 }
1260
1261 spin_unlock_bh(&mfc_unres_lock);
1262 return err;
1263}
1264
7ef8f65d 1265/* MFC cache manipulation by user space mroute daemon */
1da177e4 1266
660b26dc 1267static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent)
1da177e4 1268{
b362053a 1269 struct net *net = read_pnet(&mrt->net);
8fb472c0 1270 struct mfc_cache *c;
1da177e4 1271
8fb472c0
NA		 1272 /* The entries are added/deleted only under RTNL */
1273 rcu_read_lock();
1274 c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
1275 mfc->mfcc_mcastgrp.s_addr, parent);
1276 rcu_read_unlock();
1277 if (!c)
1278 return -ENOENT;
1279 rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params);
1280 list_del_rcu(&c->list);
b362053a 1281 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, c, mrt->id);
8fb472c0 1282 mroute_netlink_event(mrt, c, RTM_DELROUTE);
310ebbba 1283 ipmr_cache_put(c);
1da177e4 1284
8fb472c0 1285 return 0;
1da177e4
LT		 1286}
1287
0c12295a 1288static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
660b26dc 1289 struct mfcctl *mfc, int mrtsock, int parent)
1da177e4 1290{
862465f2 1291 struct mfc_cache *uc, *c;
8fb472c0
NA		 1292 bool found;
1293 int ret;
1da177e4 1294
a50436f2
PM		 1295 if (mfc->mfcc_parent >= MAXVIFS)
1296 return -ENFILE;
1297
8fb472c0
NA		 1298 /* The entries are added/deleted only under RTNL */
1299 rcu_read_lock();
1300 c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
1301 mfc->mfcc_mcastgrp.s_addr, parent);
1302 rcu_read_unlock();
1303 if (c) {
1da177e4
LT		 1304 write_lock_bh(&mrt_lock);
1305 c->mfc_parent = mfc->mfcc_parent;
0c12295a 1306 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
1da177e4
LT		 1307 if (!mrtsock)
1308 c->mfc_flags |= MFC_STATIC;
1309 write_unlock_bh(&mrt_lock);
b362053a
YG		 1310 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE, c,
1311 mrt->id);
8cd3ac9f 1312 mroute_netlink_event(mrt, c, RTM_NEWROUTE);
1da177e4
LT		 1313 return 0;
1314 }
1315
360eb5da 1316 if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) &&
660b26dc 1317 !ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
1da177e4
LT		 1318 return -EINVAL;
1319
d658f8a0 1320 c = ipmr_cache_alloc();
51456b29 1321 if (!c)
1da177e4
LT		 1322 return -ENOMEM;
1323
c354e124
JK		 1324 c->mfc_origin = mfc->mfcc_origin.s_addr;
1325 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
1326 c->mfc_parent = mfc->mfcc_parent;
0c12295a 1327 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
1da177e4
LT		 1328 if (!mrtsock)
1329 c->mfc_flags |= MFC_STATIC;
1330
8fb472c0
NA		 1331 ret = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->mnode,
1332 ipmr_rht_params);
1333 if (ret) {
1334 pr_err("ipmr: rhtable insert error %d\n", ret);
1335 ipmr_cache_free(c);
1336 return ret;
1337 }
1338 list_add_tail_rcu(&c->list, &mrt->mfc_cache_list);
7ef8f65d
NA		 1339 /* Check to see if we resolved a queued list. If so we
1340 * need to send on the frames and tidy up.
1da177e4 1341 */
b0ebb739 1342 found = false;
1da177e4 1343 spin_lock_bh(&mfc_unres_lock);
0c12295a 1344 list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
e258beb2 1345 if (uc->mfc_origin == c->mfc_origin &&
1da177e4 1346 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
862465f2 1347 list_del(&uc->list);
0c12295a 1348 atomic_dec(&mrt->cache_resolve_queue_len);
b0ebb739 1349 found = true;
1da177e4
LT		 1350 break;
1351 }
1352 }
0c12295a
PM		 1353 if (list_empty(&mrt->mfc_unres_queue))
1354 del_timer(&mrt->ipmr_expire_timer);
1da177e4
LT		 1355 spin_unlock_bh(&mfc_unres_lock);
1356
b0ebb739 1357 if (found) {
0c12295a 1358 ipmr_cache_resolve(net, mrt, uc, c);
5c0a66f5 1359 ipmr_cache_free(uc);
1da177e4 1360 }
b362053a 1361 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD, c, mrt->id);
8cd3ac9f 1362 mroute_netlink_event(mrt, c, RTM_NEWROUTE);
1da177e4
LT		 1363 return 0;
1364}
1365
7ef8f65d 1366/* Close the multicast socket, and clear the vif tables etc */
0e615e96 1367static void mroute_clean_tables(struct mr_table *mrt, bool all)
1da177e4 1368{
b362053a 1369 struct net *net = read_pnet(&mrt->net);
8fb472c0 1370 struct mfc_cache *c, *tmp;
d17fa6fa 1371 LIST_HEAD(list);
8fb472c0 1372 int i;
e905a9ed 1373
a8cb16dd 1374 /* Shut down all active vif entries */
0c12295a 1375 for (i = 0; i < mrt->maxvif; i++) {
0e615e96
NA		 1376 if (!all && (mrt->vif_table[i].flags & VIFF_STATIC))
1377 continue;
1378 vif_delete(mrt, i, 0, &list);
1da177e4 1379 }
d17fa6fa 1380 unregister_netdevice_many(&list);
1da177e4 1381
a8cb16dd 1382 /* Wipe the cache */
8fb472c0
NA		 1383 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1384 if (!all && (c->mfc_flags & MFC_STATIC))
1385 continue;
1386 rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params);
1387 list_del_rcu(&c->list);
b362053a
YG		 1388 call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, c,
1389 mrt->id);
8fb472c0 1390 mroute_netlink_event(mrt, c, RTM_DELROUTE);
310ebbba 1391 ipmr_cache_put(c);
1da177e4
LT		 1392 }
1393
0c12295a 1394 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1da177e4 1395 spin_lock_bh(&mfc_unres_lock);
8fb472c0 1396 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
862465f2 1397 list_del(&c->list);
8cd3ac9f 1398 mroute_netlink_event(mrt, c, RTM_DELROUTE);
0c12295a 1399 ipmr_destroy_unres(mrt, c);
1da177e4
LT		 1400 }
1401 spin_unlock_bh(&mfc_unres_lock);
1402 }
1403}
1404
4c968709
ED		 1405/* called from ip_ra_control(), before an RCU grace period,
1406 * we dont need to call synchronize_rcu() here
1407 */
1da177e4
LT		 1408static void mrtsock_destruct(struct sock *sk)
1409{
4feb88e5 1410 struct net *net = sock_net(sk);
f0ad0860 1411 struct mr_table *mrt;
4feb88e5 1412
1215e51e 1413 ASSERT_RTNL();
f0ad0860 1414 ipmr_for_each_table(mrt, net) {
4c968709 1415 if (sk == rtnl_dereference(mrt->mroute_sk)) {
f0ad0860 1416 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
3b022865
DA		 1417 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
1418 NETCONFA_MC_FORWARDING,
d67b8c61
ND		 1419 NETCONFA_IFINDEX_ALL,
1420 net->ipv4.devconf_all);
a9b3cd7f 1421 RCU_INIT_POINTER(mrt->mroute_sk, NULL);
0e615e96 1422 mroute_clean_tables(mrt, false);
f0ad0860 1423 }
1da177e4 1424 }
1da177e4
LT		 1425}
1426
7ef8f65d
NA		 1427/* Socket options and virtual interface manipulation. The whole
1428 * virtual interface system is a complete heap, but unfortunately
1429 * that's how BSD mrouted happens to think. Maybe one day with a proper
1430 * MOSPF/PIM router set up we can clean this up.
1da177e4 1431 */
e905a9ed 1432
29e97d21
NA		 1433int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval,
1434 unsigned int optlen)
1da177e4 1435{
4feb88e5 1436 struct net *net = sock_net(sk);
29e97d21 1437 int val, ret = 0, parent = 0;
f0ad0860 1438 struct mr_table *mrt;
29e97d21
NA		 1439 struct vifctl vif;
1440 struct mfcctl mfc;
1441 u32 uval;
f0ad0860 1442
29e97d21
NA		 1443 /* There's one exception to the lock - MRT_DONE which needs to unlock */
1444 rtnl_lock();
5e1859fb 1445 if (sk->sk_type != SOCK_RAW ||
29e97d21
NA		 1446 inet_sk(sk)->inet_num != IPPROTO_IGMP) {
1447 ret = -EOPNOTSUPP;
1448 goto out_unlock;
1449 }
5e1859fb 1450
f0ad0860 1451 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
29e97d21
NA		 1452 if (!mrt) {
1453 ret = -ENOENT;
1454 goto out_unlock;
1455 }
132adf54 1456 if (optname != MRT_INIT) {
33d480ce 1457 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
29e97d21
NA		 1458 !ns_capable(net->user_ns, CAP_NET_ADMIN)) {
1459 ret = -EACCES;
1460 goto out_unlock;
1461 }
1da177e4
LT		 1462 }
1463
132adf54
SH		 1464 switch (optname) {
1465 case MRT_INIT:
42e6b89c 1466 if (optlen != sizeof(int)) {
29e97d21 1467 ret = -EINVAL;
42e6b89c
NA		 1468 break;
1469 }
1470 if (rtnl_dereference(mrt->mroute_sk)) {
29e97d21 1471 ret = -EADDRINUSE;
29e97d21 1472 break;
42e6b89c 1473 }
132adf54
SH		 1474
1475 ret = ip_ra_control(sk, 1, mrtsock_destruct);
1476 if (ret == 0) {
cf778b00 1477 rcu_assign_pointer(mrt->mroute_sk, sk);
4feb88e5 1478 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
3b022865
DA		 1479 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
1480 NETCONFA_MC_FORWARDING,
d67b8c61
ND		 1481 NETCONFA_IFINDEX_ALL,
1482 net->ipv4.devconf_all);
132adf54 1483 }
29e97d21 1484 break;
132adf54 1485 case MRT_DONE:
29e97d21
NA		 1486 if (sk != rcu_access_pointer(mrt->mroute_sk)) {
1487 ret = -EACCES;
1488 } else {
29e97d21 1489 ret = ip_ra_control(sk, 0, NULL);
1215e51e 1490 goto out_unlock;
29e97d21
NA		 1491 }
1492 break;
132adf54
SH		 1493 case MRT_ADD_VIF:
1494 case MRT_DEL_VIF:
29e97d21
NA		 1495 if (optlen != sizeof(vif)) {
1496 ret = -EINVAL;
1497 break;
1498 }
1499 if (copy_from_user(&vif, optval, sizeof(vif))) {
1500 ret = -EFAULT;
1501 break;
1502 }
1503 if (vif.vifc_vifi >= MAXVIFS) {
1504 ret = -ENFILE;
1505 break;
1506 }
c354e124 1507 if (optname == MRT_ADD_VIF) {
4c968709
ED		 1508 ret = vif_add(net, mrt, &vif,
1509 sk == rtnl_dereference(mrt->mroute_sk));
132adf54 1510 } else {
0c12295a 1511 ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
132adf54 1512 }
29e97d21 1513 break;
7ef8f65d
NA		 1514 /* Manipulate the forwarding caches. These live
1515 * in a sort of kernel/user symbiosis.
1516 */
132adf54
SH		 1517 case MRT_ADD_MFC:
1518 case MRT_DEL_MFC:
660b26dc
ND		 1519 parent = -1;
1520 case MRT_ADD_MFC_PROXY:
1521 case MRT_DEL_MFC_PROXY:
29e97d21
NA		 1522 if (optlen != sizeof(mfc)) {
1523 ret = -EINVAL;
1524 break;
1525 }
1526 if (copy_from_user(&mfc, optval, sizeof(mfc))) {
1527 ret = -EFAULT;
1528 break;
1529 }
660b26dc
ND		 1530 if (parent == 0)
1531 parent = mfc.mfcc_parent;
660b26dc
ND		 1532 if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY)
1533 ret = ipmr_mfc_delete(mrt, &mfc, parent);
132adf54 1534 else
4c968709 1535 ret = ipmr_mfc_add(net, mrt, &mfc,
660b26dc
ND		 1536 sk == rtnl_dereference(mrt->mroute_sk),
1537 parent);
29e97d21 1538 break;
7ef8f65d 1539 /* Control PIM assert. */
132adf54 1540 case MRT_ASSERT:
29e97d21
NA		 1541 if (optlen != sizeof(val)) {
1542 ret = -EINVAL;
1543 break;
1544 }
1545 if (get_user(val, (int __user *)optval)) {
1546 ret = -EFAULT;
1547 break;
1548 }
1549 mrt->mroute_do_assert = val;
1550 break;
132adf54 1551 case MRT_PIM:
1973a4ea 1552 if (!ipmr_pimsm_enabled()) {
29e97d21
NA		 1553 ret = -ENOPROTOOPT;
1554 break;
1555 }
1556 if (optlen != sizeof(val)) {
1557 ret = -EINVAL;
1558 break;
1559 }
1560 if (get_user(val, (int __user *)optval)) {
1561 ret = -EFAULT;
1562 break;
1563 }
ba93ef74 1564
29e97d21
NA		 1565 val = !!val;
1566 if (val != mrt->mroute_do_pim) {
1567 mrt->mroute_do_pim = val;
1568 mrt->mroute_do_assert = val;
1da177e4 1569 }
29e97d21 1570 break;
f0ad0860 1571 case MRT_TABLE:
29e97d21
NA		 1572 if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES)) {
1573 ret = -ENOPROTOOPT;
1574 break;
1575 }
1576 if (optlen != sizeof(uval)) {
1577 ret = -EINVAL;
1578 break;
1579 }
1580 if (get_user(uval, (u32 __user *)optval)) {
1581 ret = -EFAULT;
1582 break;
1583 }
f0ad0860 1584
4c968709
ED		 1585 if (sk == rtnl_dereference(mrt->mroute_sk)) {
1586 ret = -EBUSY;
1587 } else {
29e97d21 1588 mrt = ipmr_new_table(net, uval);
1113ebbc
NA		 1589 if (IS_ERR(mrt))
1590 ret = PTR_ERR(mrt);
5e1859fb 1591 else
29e97d21 1592 raw_sk(sk)->ipmr_table = uval;
4c968709 1593 }
29e97d21 1594 break;
7ef8f65d 1595 /* Spurious command, or MRT_VERSION which you cannot set. */
132adf54 1596 default:
29e97d21 1597 ret = -ENOPROTOOPT;
1da177e4 1598 }
29e97d21
NA		 1599out_unlock:
1600 rtnl_unlock();
29e97d21 1601 return ret;
1da177e4
LT		 1602}
1603
7ef8f65d 1604/* Getsock opt support for the multicast routing system. */
c354e124 1605int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
1da177e4
LT		 1606{
1607 int olr;
1608 int val;
4feb88e5 1609 struct net *net = sock_net(sk);
f0ad0860
PM		 1610 struct mr_table *mrt;
1611
5e1859fb
ED		 1612 if (sk->sk_type != SOCK_RAW ||
1613 inet_sk(sk)->inet_num != IPPROTO_IGMP)
1614 return -EOPNOTSUPP;
1615
f0ad0860 1616 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
51456b29 1617 if (!mrt)
f0ad0860 1618 return -ENOENT;
1da177e4 1619
fe9ef3ce
NA		 1620 switch (optname) {
1621 case MRT_VERSION:
1622 val = 0x0305;
1623 break;
1624 case MRT_PIM:
1973a4ea 1625 if (!ipmr_pimsm_enabled())
fe9ef3ce
NA		 1626 return -ENOPROTOOPT;
1627 val = mrt->mroute_do_pim;
1628 break;
1629 case MRT_ASSERT:
1630 val = mrt->mroute_do_assert;
1631 break;
1632 default:
1da177e4 1633 return -ENOPROTOOPT;
fe9ef3ce 1634 }
1da177e4
LT		 1635
1636 if (get_user(olr, optlen))
1637 return -EFAULT;
1da177e4
LT		 1638 olr = min_t(unsigned int, olr, sizeof(int));
1639 if (olr < 0)
1640 return -EINVAL;
c354e124 1641 if (put_user(olr, optlen))
1da177e4 1642 return -EFAULT;
c354e124 1643 if (copy_to_user(optval, &val, olr))
1da177e4
LT		 1644 return -EFAULT;
1645 return 0;
1646}
1647
7ef8f65d 1648/* The IP multicast ioctl support routines. */
1da177e4
LT		 1649int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1650{
1651 struct sioc_sg_req sr;
1652 struct sioc_vif_req vr;
1653 struct vif_device *vif;
1654 struct mfc_cache *c;
4feb88e5 1655 struct net *net = sock_net(sk);
f0ad0860
PM		 1656 struct mr_table *mrt;
1657
1658 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
51456b29 1659 if (!mrt)
f0ad0860 1660 return -ENOENT;
e905a9ed 1661
132adf54
SH		 1662 switch (cmd) {
1663 case SIOCGETVIFCNT:
c354e124 1664 if (copy_from_user(&vr, arg, sizeof(vr)))
132adf54 1665 return -EFAULT;
0c12295a 1666 if (vr.vifi >= mrt->maxvif)
132adf54
SH		 1667 return -EINVAL;
1668 read_lock(&mrt_lock);
0c12295a
PM		 1669 vif = &mrt->vif_table[vr.vifi];
1670 if (VIF_EXISTS(mrt, vr.vifi)) {
c354e124
JK		 1671 vr.icount = vif->pkt_in;
1672 vr.ocount = vif->pkt_out;
1673 vr.ibytes = vif->bytes_in;
1674 vr.obytes = vif->bytes_out;
1da177e4 1675 read_unlock(&mrt_lock);
1da177e4 1676
c354e124 1677 if (copy_to_user(arg, &vr, sizeof(vr)))
132adf54
SH		 1678 return -EFAULT;
1679 return 0;
1680 }
1681 read_unlock(&mrt_lock);
1682 return -EADDRNOTAVAIL;
1683 case SIOCGETSGCNT:
c354e124 1684 if (copy_from_user(&sr, arg, sizeof(sr)))
132adf54
SH		 1685 return -EFAULT;
1686
a8c9486b 1687 rcu_read_lock();
0c12295a 1688 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
132adf54
SH		 1689 if (c) {
1690 sr.pktcnt = c->mfc_un.res.pkt;
1691 sr.bytecnt = c->mfc_un.res.bytes;
1692 sr.wrong_if = c->mfc_un.res.wrong_if;
a8c9486b 1693 rcu_read_unlock();
132adf54 1694
c354e124 1695 if (copy_to_user(arg, &sr, sizeof(sr)))
132adf54
SH		 1696 return -EFAULT;
1697 return 0;
1698 }
a8c9486b 1699 rcu_read_unlock();
132adf54
SH		 1700 return -EADDRNOTAVAIL;
1701 default:
1702 return -ENOIOCTLCMD;
1da177e4
LT		 1703 }
1704}
1705
709b46e8
EB		 1706#ifdef CONFIG_COMPAT
1707struct compat_sioc_sg_req {
1708 struct in_addr src;
1709 struct in_addr grp;
1710 compat_ulong_t pktcnt;
1711 compat_ulong_t bytecnt;
1712 compat_ulong_t wrong_if;
1713};
1714
ca6b8bb0
DM		 1715struct compat_sioc_vif_req {
1716 vifi_t vifi; /* Which iface */
1717 compat_ulong_t icount;
1718 compat_ulong_t ocount;
1719 compat_ulong_t ibytes;
1720 compat_ulong_t obytes;
1721};
1722
709b46e8
EB		 1723int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1724{
0033d5ad 1725 struct compat_sioc_sg_req sr;
ca6b8bb0
DM		 1726 struct compat_sioc_vif_req vr;
1727 struct vif_device *vif;
709b46e8
EB		 1728 struct mfc_cache *c;
1729 struct net *net = sock_net(sk);
1730 struct mr_table *mrt;
1731
1732 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
51456b29 1733 if (!mrt)
709b46e8
EB		 1734 return -ENOENT;
1735
1736 switch (cmd) {
ca6b8bb0
DM		 1737 case SIOCGETVIFCNT:
1738 if (copy_from_user(&vr, arg, sizeof(vr)))
1739 return -EFAULT;
1740 if (vr.vifi >= mrt->maxvif)
1741 return -EINVAL;
1742 read_lock(&mrt_lock);
1743 vif = &mrt->vif_table[vr.vifi];
1744 if (VIF_EXISTS(mrt, vr.vifi)) {
1745 vr.icount = vif->pkt_in;
1746 vr.ocount = vif->pkt_out;
1747 vr.ibytes = vif->bytes_in;
1748 vr.obytes = vif->bytes_out;
1749 read_unlock(&mrt_lock);
1750
1751 if (copy_to_user(arg, &vr, sizeof(vr)))
1752 return -EFAULT;
1753 return 0;
1754 }
1755 read_unlock(&mrt_lock);
1756 return -EADDRNOTAVAIL;
709b46e8
EB		 1757 case SIOCGETSGCNT:
1758 if (copy_from_user(&sr, arg, sizeof(sr)))
1759 return -EFAULT;
1760
1761 rcu_read_lock();
1762 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
1763 if (c) {
1764 sr.pktcnt = c->mfc_un.res.pkt;
1765 sr.bytecnt = c->mfc_un.res.bytes;
1766 sr.wrong_if = c->mfc_un.res.wrong_if;
1767 rcu_read_unlock();
1768
1769 if (copy_to_user(arg, &sr, sizeof(sr)))
1770 return -EFAULT;
1771 return 0;
1772 }
1773 rcu_read_unlock();
1774 return -EADDRNOTAVAIL;
1775 default:
1776 return -ENOIOCTLCMD;
1777 }
1778}
1779#endif
1780
1da177e4
LT		 1781static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1782{
351638e7 1783 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
4feb88e5 1784 struct net *net = dev_net(dev);
f0ad0860 1785 struct mr_table *mrt;
1da177e4
LT		 1786 struct vif_device *v;
1787 int ct;
e9dc8653 1788
1da177e4
LT		 1789 if (event != NETDEV_UNREGISTER)
1790 return NOTIFY_DONE;
f0ad0860
PM		 1791
1792 ipmr_for_each_table(mrt, net) {
1793 v = &mrt->vif_table[0];
1794 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1795 if (v->dev == dev)
e92036a6 1796 vif_delete(mrt, ct, 1, NULL);
f0ad0860 1797 }
1da177e4
LT		 1798 }
1799 return NOTIFY_DONE;
1800}
1801
c354e124 1802static struct notifier_block ip_mr_notifier = {
1da177e4
LT		 1803 .notifier_call = ipmr_device_event,
1804};
1805
7ef8f65d
NA		 1806/* Encapsulate a packet by attaching a valid IPIP header to it.
1807 * This avoids tunnel drivers and other mess and gives us the speed so
1808 * important for multicast video.
1da177e4 1809 */
b6a7719a
HFS		 1810static void ip_encap(struct net *net, struct sk_buff *skb,
1811 __be32 saddr, __be32 daddr)
1da177e4 1812{
8856dfa3 1813 struct iphdr *iph;
b71d1d42 1814 const struct iphdr *old_iph = ip_hdr(skb);
8856dfa3
ACM		 1815
1816 skb_push(skb, sizeof(struct iphdr));
b0e380b1 1817 skb->transport_header = skb->network_header;
8856dfa3 1818 skb_reset_network_header(skb);
eddc9ec5 1819 iph = ip_hdr(skb);
1da177e4 1820
a8cb16dd 1821 iph->version = 4;
e023dd64
ACM		 1822 iph->tos = old_iph->tos;
1823 iph->ttl = old_iph->ttl;
1da177e4
LT		 1824 iph->frag_off = 0;
1825 iph->daddr = daddr;
1826 iph->saddr = saddr;
1827 iph->protocol = IPPROTO_IPIP;
1828 iph->ihl = 5;
1829 iph->tot_len = htons(skb->len);
b6a7719a 1830 ip_select_ident(net, skb, NULL);
1da177e4
LT		 1831 ip_send_check(iph);
1832
1da177e4
LT		 1833 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1834 nf_reset(skb);
1835}
1836
0c4b51f0
EB		 1837static inline int ipmr_forward_finish(struct net *net, struct sock *sk,
1838 struct sk_buff *skb)
1da177e4 1839{
a8cb16dd 1840 struct ip_options *opt = &(IPCB(skb)->opt);
1da177e4 1841
73186df8
DM		 1842 IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS);
1843 IP_ADD_STATS(net, IPSTATS_MIB_OUTOCTETS, skb->len);
1da177e4
LT		 1844
1845 if (unlikely(opt->optlen))
1846 ip_forward_options(skb);
1847
13206b6b 1848 return dst_output(net, sk, skb);
1da177e4
LT		 1849}
1850
7ef8f65d 1851/* Processing handlers for ipmr_forward */
1da177e4 1852
0c12295a
PM		 1853static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
1854 struct sk_buff *skb, struct mfc_cache *c, int vifi)
1da177e4 1855{
eddc9ec5 1856 const struct iphdr *iph = ip_hdr(skb);
0c12295a 1857 struct vif_device *vif = &mrt->vif_table[vifi];
1da177e4
LT		 1858 struct net_device *dev;
1859 struct rtable *rt;
31e4543d 1860 struct flowi4 fl4;
1da177e4
LT		 1861 int encap = 0;
1862
51456b29 1863 if (!vif->dev)
1da177e4
LT		 1864 goto out_free;
1865
1da177e4
LT		 1866 if (vif->flags & VIFF_REGISTER) {
1867 vif->pkt_out++;
c354e124 1868 vif->bytes_out += skb->len;
cf3677ae
PE		 1869 vif->dev->stats.tx_bytes += skb->len;
1870 vif->dev->stats.tx_packets++;
0c12295a 1871 ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
69ebbf58 1872 goto out_free;
1da177e4 1873 }
1da177e4 1874
a8cb16dd 1875 if (vif->flags & VIFF_TUNNEL) {
31e4543d 1876 rt = ip_route_output_ports(net, &fl4, NULL,
78fbfd8a
DM		 1877 vif->remote, vif->local,
1878 0, 0,
1879 IPPROTO_IPIP,
1880 RT_TOS(iph->tos), vif->link);
b23dd4fe 1881 if (IS_ERR(rt))
1da177e4
LT		 1882 goto out_free;
1883 encap = sizeof(struct iphdr);
1884 } else {
31e4543d 1885 rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
78fbfd8a
DM		 1886 0, 0,
1887 IPPROTO_IPIP,
1888 RT_TOS(iph->tos), vif->link);
b23dd4fe 1889 if (IS_ERR(rt))
1da177e4
LT		 1890 goto out_free;
1891 }
1892
d8d1f30b 1893 dev = rt->dst.dev;
1da177e4 1894
d8d1f30b 1895 if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
1da177e4 1896 /* Do not fragment multicasts. Alas, IPv4 does not
a8cb16dd
ED		 1897 * allow to send ICMP, so that packets will disappear
1898 * to blackhole.
1da177e4 1899 */
73186df8 1900 IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
1da177e4
LT		 1901 ip_rt_put(rt);
1902 goto out_free;
1903 }
1904
d8d1f30b 1905 encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
1da177e4
LT		 1906
1907 if (skb_cow(skb, encap)) {
e905a9ed 1908 ip_rt_put(rt);
1da177e4
LT		 1909 goto out_free;
1910 }
1911
1912 vif->pkt_out++;
c354e124 1913 vif->bytes_out += skb->len;
1da177e4 1914
adf30907 1915 skb_dst_drop(skb);
d8d1f30b 1916 skb_dst_set(skb, &rt->dst);
eddc9ec5 1917 ip_decrease_ttl(ip_hdr(skb));
1da177e4
LT		 1918
1919 /* FIXME: forward and output firewalls used to be called here.
a8cb16dd
ED		 1920 * What do we do with netfilter? -- RR
1921 */
1da177e4 1922 if (vif->flags & VIFF_TUNNEL) {
b6a7719a 1923 ip_encap(net, skb, vif->local, vif->remote);
1da177e4 1924 /* FIXME: extra output firewall step used to be here. --RR */
2f4c02d4
PE		 1925 vif->dev->stats.tx_packets++;
1926 vif->dev->stats.tx_bytes += skb->len;
1da177e4
LT		 1927 }
1928
9ee6c5dc 1929 IPCB(skb)->flags |= IPSKB_FORWARDED;
1da177e4 1930
7ef8f65d 1931 /* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1da177e4
LT		 1932 * not only before forwarding, but after forwarding on all output
1933 * interfaces. It is clear, if mrouter runs a multicasting
1934 * program, it should receive packets not depending to what interface
1935 * program is joined.
1936 * If we will not make it, the program will have to join on all
1937 * interfaces. On the other hand, multihoming host (or router, but
1938 * not mrouter) cannot join to more than one interface - it will
1939 * result in receiving multiple packets.
1940 */
29a26a56
EB		 1941 NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
1942 net, NULL, skb, skb->dev, dev,
1da177e4
LT		 1943 ipmr_forward_finish);
1944 return;
1945
1946out_free:
1947 kfree_skb(skb);
1da177e4
LT		 1948}
1949
0c12295a 1950static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
1da177e4
LT		 1951{
1952 int ct;
0c12295a
PM		 1953
1954 for (ct = mrt->maxvif-1; ct >= 0; ct--) {
1955 if (mrt->vif_table[ct].dev == dev)
1da177e4
LT		 1956 break;
1957 }
1958 return ct;
1959}
1960
1961/* "local" means that we should preserve one skb (for local delivery) */
c4854ec8 1962static void ip_mr_forward(struct net *net, struct mr_table *mrt,
4b1f0d33
DS		 1963 struct net_device *dev, struct sk_buff *skb,
1964 struct mfc_cache *cache, int local)
1da177e4 1965{
4b1f0d33 1966 int true_vifi = ipmr_find_vif(mrt, dev);
1da177e4
LT		 1967 int psend = -1;
1968 int vif, ct;
1969
1970 vif = cache->mfc_parent;
1971 cache->mfc_un.res.pkt++;
1972 cache->mfc_un.res.bytes += skb->len;
43b9e127 1973 cache->mfc_un.res.lastuse = jiffies;
1da177e4 1974
360eb5da 1975 if (cache->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) {
660b26dc
ND		 1976 struct mfc_cache *cache_proxy;
1977
1978 /* For an (*,G) entry, we only check that the incomming
1979 * interface is part of the static tree.
1980 */
1981 cache_proxy = ipmr_cache_find_any_parent(mrt, vif);
1982 if (cache_proxy &&
1983 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
1984 goto forward;
1985 }
1986
7ef8f65d 1987 /* Wrong interface: drop packet and (maybe) send PIM assert. */
4b1f0d33 1988 if (mrt->vif_table[vif].dev != dev) {
c7537967 1989 if (rt_is_output_route(skb_rtable(skb))) {
1da177e4 1990 /* It is our own packet, looped back.
a8cb16dd
ED		 1991 * Very complicated situation...
1992 *
1993 * The best workaround until routing daemons will be
1994 * fixed is not to redistribute packet, if it was
1995 * send through wrong interface. It means, that
1996 * multicast applications WILL NOT work for
1997 * (S,G), which have default multicast route pointing
1998 * to wrong oif. In any case, it is not a good
1999 * idea to use multicasting applications on router.
1da177e4
LT		 2000 */
2001 goto dont_forward;
2002 }
2003
2004 cache->mfc_un.res.wrong_if++;
1da177e4 2005
0c12295a 2006 if (true_vifi >= 0 && mrt->mroute_do_assert &&
1da177e4 2007 /* pimsm uses asserts, when switching from RPT to SPT,
a8cb16dd
ED		 2008 * so that we cannot check that packet arrived on an oif.
2009 * It is bad, but otherwise we would need to move pretty
2010 * large chunk of pimd to kernel. Ough... --ANK
1da177e4 2011 */
0c12295a 2012 (mrt->mroute_do_pim ||
6f9374a9 2013 cache->mfc_un.res.ttls[true_vifi] < 255) &&
e905a9ed 2014 time_after(jiffies,
1da177e4
LT		 2015 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2016 cache->mfc_un.res.last_assert = jiffies;
0c12295a 2017 ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
1da177e4
LT		 2018 }
2019 goto dont_forward;
2020 }
2021
660b26dc 2022forward:
0c12295a
PM		 2023 mrt->vif_table[vif].pkt_in++;
2024 mrt->vif_table[vif].bytes_in += skb->len;
1da177e4 2025
7ef8f65d 2026 /* Forward the frame */
360eb5da
ND		 2027 if (cache->mfc_origin == htonl(INADDR_ANY) &&
2028 cache->mfc_mcastgrp == htonl(INADDR_ANY)) {
660b26dc
ND		 2029 if (true_vifi >= 0 &&
2030 true_vifi != cache->mfc_parent &&
2031 ip_hdr(skb)->ttl >
2032 cache->mfc_un.res.ttls[cache->mfc_parent]) {
2033 /* It's an (*,*) entry and the packet is not coming from
2034 * the upstream: forward the packet to the upstream
2035 * only.
2036 */
2037 psend = cache->mfc_parent;
2038 goto last_forward;
2039 }
2040 goto dont_forward;
2041 }
a8cb16dd
ED		 2042 for (ct = cache->mfc_un.res.maxvif - 1;
2043 ct >= cache->mfc_un.res.minvif; ct--) {
660b26dc 2044 /* For (*,G) entry, don't forward to the incoming interface */
360eb5da
ND		 2045 if ((cache->mfc_origin != htonl(INADDR_ANY) ||
2046 ct != true_vifi) &&
660b26dc 2047 ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1da177e4
LT		 2048 if (psend != -1) {
2049 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
a8cb16dd 2050
1da177e4 2051 if (skb2)
0c12295a
PM		 2052 ipmr_queue_xmit(net, mrt, skb2, cache,
2053 psend);
1da177e4 2054 }
c354e124 2055 psend = ct;
1da177e4
LT		 2056 }
2057 }
660b26dc 2058last_forward:
1da177e4
LT		 2059 if (psend != -1) {
2060 if (local) {
2061 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
a8cb16dd 2062
1da177e4 2063 if (skb2)
0c12295a 2064 ipmr_queue_xmit(net, mrt, skb2, cache, psend);
1da177e4 2065 } else {
0c12295a 2066 ipmr_queue_xmit(net, mrt, skb, cache, psend);
c4854ec8 2067 return;
1da177e4
LT		 2068 }
2069 }
2070
2071dont_forward:
2072 if (!local)
2073 kfree_skb(skb);
1da177e4
LT		 2074}
2075
417da66f 2076static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
ee3f1aaf 2077{
417da66f
DM		 2078 struct rtable *rt = skb_rtable(skb);
2079 struct iphdr *iph = ip_hdr(skb);
da91981b 2080 struct flowi4 fl4 = {
417da66f
DM		 2081 .daddr = iph->daddr,
2082 .saddr = iph->saddr,
b0fe4a31 2083 .flowi4_tos = RT_TOS(iph->tos),
4fd551d7
DM		 2084 .flowi4_oif = (rt_is_output_route(rt) ?
2085 skb->dev->ifindex : 0),
2086 .flowi4_iif = (rt_is_output_route(rt) ?
1fb9489b 2087 LOOPBACK_IFINDEX :
4fd551d7 2088 skb->dev->ifindex),
b4869889 2089 .flowi4_mark = skb->mark,
ee3f1aaf
DM		 2090 };
2091 struct mr_table *mrt;
2092 int err;
2093
da91981b 2094 err = ipmr_fib_lookup(net, &fl4, &mrt);
ee3f1aaf
DM		 2095 if (err)
2096 return ERR_PTR(err);
2097 return mrt;
2098}
1da177e4 2099
7ef8f65d
NA		 2100/* Multicast packets for forwarding arrive here
2101 * Called with rcu_read_lock();
1da177e4 2102 */
1da177e4
LT		 2103int ip_mr_input(struct sk_buff *skb)
2104{
2105 struct mfc_cache *cache;
4feb88e5 2106 struct net *net = dev_net(skb->dev);
511c3f92 2107 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
f0ad0860 2108 struct mr_table *mrt;
bcfc7d33
TW		 2109 struct net_device *dev;
2110
2111 /* skb->dev passed in is the loX master dev for vrfs.
2112 * As there are no vifs associated with loopback devices,
2113 * get the proper interface that does have a vif associated with it.
2114 */
2115 dev = skb->dev;
2116 if (netif_is_l3_master(skb->dev)) {
2117 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
2118 if (!dev) {
2119 kfree_skb(skb);
2120 return -ENODEV;
2121 }
2122 }
1da177e4
LT		 2123
2124 /* Packet is looped back after forward, it should not be
a8cb16dd 2125 * forwarded second time, but still can be delivered locally.
1da177e4 2126 */
4c968709 2127 if (IPCB(skb)->flags & IPSKB_FORWARDED)
1da177e4
LT		 2128 goto dont_forward;
2129
417da66f 2130 mrt = ipmr_rt_fib_lookup(net, skb);
ee3f1aaf
DM		 2131 if (IS_ERR(mrt)) {
2132 kfree_skb(skb);
2133 return PTR_ERR(mrt);
e40dbc51 2134 }
1da177e4 2135 if (!local) {
4c968709
ED		 2136 if (IPCB(skb)->opt.router_alert) {
2137 if (ip_call_ra_chain(skb))
2138 return 0;
2139 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) {
2140 /* IGMPv1 (and broken IGMPv2 implementations sort of
2141 * Cisco IOS <= 11.2(8)) do not put router alert
2142 * option to IGMP packets destined to routable
2143 * groups. It is very bad, because it means
2144 * that we can forward NO IGMP messages.
2145 */
2146 struct sock *mroute_sk;
2147
2148 mroute_sk = rcu_dereference(mrt->mroute_sk);
2149 if (mroute_sk) {
2150 nf_reset(skb);
2151 raw_rcv(mroute_sk, skb);
2152 return 0;
2153 }
1da177e4
LT		 2154 }
2155 }
2156
a8c9486b 2157 /* already under rcu_read_lock() */
0c12295a 2158 cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
51456b29 2159 if (!cache) {
bcfc7d33 2160 int vif = ipmr_find_vif(mrt, dev);
660b26dc
ND		 2161
2162 if (vif >= 0)
2163 cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr,
2164 vif);
2165 }
1da177e4 2166
7ef8f65d 2167 /* No usable cache entry */
51456b29 2168 if (!cache) {
1da177e4
LT		 2169 int vif;
2170
2171 if (local) {
2172 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2173 ip_local_deliver(skb);
51456b29 2174 if (!skb2)
1da177e4 2175 return -ENOBUFS;
1da177e4
LT		 2176 skb = skb2;
2177 }
2178
a8c9486b 2179 read_lock(&mrt_lock);
bcfc7d33 2180 vif = ipmr_find_vif(mrt, dev);
1da177e4 2181 if (vif >= 0) {
4b1f0d33 2182 int err2 = ipmr_cache_unresolved(mrt, vif, skb, dev);
1da177e4
LT		 2183 read_unlock(&mrt_lock);
2184
0eae88f3 2185 return err2;
1da177e4
LT		 2186 }
2187 read_unlock(&mrt_lock);
2188 kfree_skb(skb);
2189 return -ENODEV;
2190 }
2191
a8c9486b 2192 read_lock(&mrt_lock);
4b1f0d33 2193 ip_mr_forward(net, mrt, dev, skb, cache, local);
1da177e4
LT		 2194 read_unlock(&mrt_lock);
2195
2196 if (local)
2197 return ip_local_deliver(skb);
2198
2199 return 0;
2200
2201dont_forward:
2202 if (local)
2203 return ip_local_deliver(skb);
2204 kfree_skb(skb);
2205 return 0;
2206}
2207
b1879204 2208#ifdef CONFIG_IP_PIMSM_V1
7ef8f65d 2209/* Handle IGMP messages of PIMv1 */
a8cb16dd 2210int pim_rcv_v1(struct sk_buff *skb)
b1879204
IJ		 2211{
2212 struct igmphdr *pim;
4feb88e5 2213 struct net *net = dev_net(skb->dev);
f0ad0860 2214 struct mr_table *mrt;
b1879204
IJ		 2215
2216 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
2217 goto drop;
2218
2219 pim = igmp_hdr(skb);
2220
417da66f 2221 mrt = ipmr_rt_fib_lookup(net, skb);
ee3f1aaf
DM		 2222 if (IS_ERR(mrt))
2223 goto drop;
0c12295a 2224 if (!mrt->mroute_do_pim ||
b1879204
IJ		 2225 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
2226 goto drop;
2227
f0ad0860 2228 if (__pim_rcv(mrt, skb, sizeof(*pim))) {
b1879204
IJ		 2229drop:
2230 kfree_skb(skb);
2231 }
1da177e4
LT		 2232 return 0;
2233}
2234#endif
2235
2236#ifdef CONFIG_IP_PIMSM_V2
a8cb16dd 2237static int pim_rcv(struct sk_buff *skb)
1da177e4
LT		 2238{
2239 struct pimreghdr *pim;
f0ad0860
PM		 2240 struct net *net = dev_net(skb->dev);
2241 struct mr_table *mrt;
1da177e4 2242
b1879204 2243 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1da177e4
LT		 2244 goto drop;
2245
9c70220b 2246 pim = (struct pimreghdr *)skb_transport_header(skb);
56245cae 2247 if (pim->type != ((PIM_VERSION << 4) | (PIM_TYPE_REGISTER)) ||
a8cb16dd 2248 (pim->flags & PIM_NULL_REGISTER) ||
e905a9ed 2249 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
d3bc23e7 2250 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1da177e4
LT		 2251 goto drop;
2252
417da66f 2253 mrt = ipmr_rt_fib_lookup(net, skb);
ee3f1aaf
DM		 2254 if (IS_ERR(mrt))
2255 goto drop;
f0ad0860 2256 if (__pim_rcv(mrt, skb, sizeof(*pim))) {
b1879204
IJ		 2257drop:
2258 kfree_skb(skb);
2259 }
1da177e4
LT		 2260 return 0;
2261}
2262#endif
2263
cb6a4e46
PM		 2264static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2265 struct mfc_cache *c, struct rtmsg *rtm)
1da177e4 2266{
adfa85e4 2267 struct rta_mfc_stats mfcs;
43b9e127
NA		 2268 struct nlattr *mp_attr;
2269 struct rtnexthop *nhp;
b5036cd4 2270 unsigned long lastuse;
43b9e127 2271 int ct;
1da177e4 2272
7438189b 2273 /* If cache is unresolved, don't try to parse IIF and OIF */
1708ebc9
NA		 2274 if (c->mfc_parent >= MAXVIFS) {
2275 rtm->rtm_flags |= RTNH_F_UNRESOLVED;
7438189b 2276 return -ENOENT;
1708ebc9 2277 }
7438189b 2278
92a395e5
TG		 2279 if (VIF_EXISTS(mrt, c->mfc_parent) &&
2280 nla_put_u32(skb, RTA_IIF, mrt->vif_table[c->mfc_parent].dev->ifindex) < 0)
2281 return -EMSGSIZE;
1da177e4 2282
c7c0bbea
YG		 2283 if (c->mfc_flags & MFC_OFFLOAD)
2284 rtm->rtm_flags |= RTNH_F_OFFLOAD;
2285
92a395e5
TG		 2286 if (!(mp_attr = nla_nest_start(skb, RTA_MULTIPATH)))
2287 return -EMSGSIZE;
1da177e4
LT		 2288
2289 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
0c12295a 2290 if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
92a395e5
TG		 2291 if (!(nhp = nla_reserve_nohdr(skb, sizeof(*nhp)))) {
2292 nla_nest_cancel(skb, mp_attr);
2293 return -EMSGSIZE;
2294 }
2295
1da177e4
LT		 2296 nhp->rtnh_flags = 0;
2297 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
0c12295a 2298 nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
1da177e4
LT		 2299 nhp->rtnh_len = sizeof(*nhp);
2300 }
2301 }
92a395e5
TG		 2302
2303 nla_nest_end(skb, mp_attr);
2304
b5036cd4
NA		 2305 lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2306 lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2307
adfa85e4
ND		 2308 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2309 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2310 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
43b9e127 2311 if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
b5036cd4 2312 nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
43b9e127 2313 RTA_PAD))
adfa85e4
ND		 2314 return -EMSGSIZE;
2315
1da177e4
LT		 2316 rtm->rtm_type = RTN_MULTICAST;
2317 return 1;
1da177e4
LT		 2318}
2319
9a1b9496
DM		 2320int ipmr_get_route(struct net *net, struct sk_buff *skb,
2321 __be32 saddr, __be32 daddr,
9f09eaea 2322 struct rtmsg *rtm, u32 portid)
1da177e4 2323{
1da177e4 2324 struct mfc_cache *cache;
9a1b9496
DM		 2325 struct mr_table *mrt;
2326 int err;
1da177e4 2327
f0ad0860 2328 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
51456b29 2329 if (!mrt)
f0ad0860
PM		 2330 return -ENOENT;
2331
a8c9486b 2332 rcu_read_lock();
9a1b9496 2333 cache = ipmr_cache_find(mrt, saddr, daddr);
51456b29 2334 if (!cache && skb->dev) {
660b26dc 2335 int vif = ipmr_find_vif(mrt, skb->dev);
1da177e4 2336
660b26dc
ND		 2337 if (vif >= 0)
2338 cache = ipmr_cache_find_any(mrt, daddr, vif);
2339 }
51456b29 2340 if (!cache) {
72287490 2341 struct sk_buff *skb2;
eddc9ec5 2342 struct iphdr *iph;
1da177e4 2343 struct net_device *dev;
a8cb16dd 2344 int vif = -1;
1da177e4 2345
1da177e4 2346 dev = skb->dev;
a8c9486b 2347 read_lock(&mrt_lock);
a8cb16dd
ED		 2348 if (dev)
2349 vif = ipmr_find_vif(mrt, dev);
2350 if (vif < 0) {
1da177e4 2351 read_unlock(&mrt_lock);
a8c9486b 2352 rcu_read_unlock();
1da177e4
LT		 2353 return -ENODEV;
2354 }
72287490
AK		 2355 skb2 = skb_clone(skb, GFP_ATOMIC);
2356 if (!skb2) {
2357 read_unlock(&mrt_lock);
a8c9486b 2358 rcu_read_unlock();
72287490
AK		 2359 return -ENOMEM;
2360 }
2361
2cf75070 2362 NETLINK_CB(skb2).portid = portid;
e2d1bca7
ACM		 2363 skb_push(skb2, sizeof(struct iphdr));
2364 skb_reset_network_header(skb2);
eddc9ec5
ACM		 2365 iph = ip_hdr(skb2);
2366 iph->ihl = sizeof(struct iphdr) >> 2;
9a1b9496
DM		 2367 iph->saddr = saddr;
2368 iph->daddr = daddr;
eddc9ec5 2369 iph->version = 0;
4b1f0d33 2370 err = ipmr_cache_unresolved(mrt, vif, skb2, dev);
1da177e4 2371 read_unlock(&mrt_lock);
a8c9486b 2372 rcu_read_unlock();
1da177e4
LT		 2373 return err;
2374 }
2375
a8c9486b 2376 read_lock(&mrt_lock);
cb6a4e46 2377 err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
1da177e4 2378 read_unlock(&mrt_lock);
a8c9486b 2379 rcu_read_unlock();
1da177e4
LT		 2380 return err;
2381}
2382
cb6a4e46 2383static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
65886f43
ND		 2384 u32 portid, u32 seq, struct mfc_cache *c, int cmd,
2385 int flags)
cb6a4e46
PM		 2386{
2387 struct nlmsghdr *nlh;
2388 struct rtmsg *rtm;
1eb99af5 2389 int err;
cb6a4e46 2390
65886f43 2391 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
51456b29 2392 if (!nlh)
cb6a4e46
PM		 2393 return -EMSGSIZE;
2394
2395 rtm = nlmsg_data(nlh);
2396 rtm->rtm_family = RTNL_FAMILY_IPMR;
2397 rtm->rtm_dst_len = 32;
2398 rtm->rtm_src_len = 32;
2399 rtm->rtm_tos = 0;
2400 rtm->rtm_table = mrt->id;
f3756b79
DM		 2401 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2402 goto nla_put_failure;
cb6a4e46
PM		 2403 rtm->rtm_type = RTN_MULTICAST;
2404 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
9a68ac72
ND		 2405 if (c->mfc_flags & MFC_STATIC)
2406 rtm->rtm_protocol = RTPROT_STATIC;
2407 else
2408 rtm->rtm_protocol = RTPROT_MROUTED;
cb6a4e46
PM		 2409 rtm->rtm_flags = 0;
2410
930345ea
JB		 2411 if (nla_put_in_addr(skb, RTA_SRC, c->mfc_origin) ||
2412 nla_put_in_addr(skb, RTA_DST, c->mfc_mcastgrp))
f3756b79 2413 goto nla_put_failure;
1eb99af5
ND		 2414 err = __ipmr_fill_mroute(mrt, skb, c, rtm);
2415 /* do not break the dump if cache is unresolved */
2416 if (err < 0 && err != -ENOENT)
cb6a4e46
PM		 2417 goto nla_put_failure;
2418
053c095a
JB		 2419 nlmsg_end(skb, nlh);
2420 return 0;
cb6a4e46
PM		 2421
2422nla_put_failure:
2423 nlmsg_cancel(skb, nlh);
2424 return -EMSGSIZE;
2425}
2426
8cd3ac9f
ND		 2427static size_t mroute_msgsize(bool unresolved, int maxvif)
2428{
2429 size_t len =
2430 NLMSG_ALIGN(sizeof(struct rtmsg))
2431 + nla_total_size(4) /* RTA_TABLE */
2432 + nla_total_size(4) /* RTA_SRC */
2433 + nla_total_size(4) /* RTA_DST */
2434 ;
2435
2436 if (!unresolved)
2437 len = len
2438 + nla_total_size(4) /* RTA_IIF */
2439 + nla_total_size(0) /* RTA_MULTIPATH */
2440 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2441 /* RTA_MFC_STATS */
a9a08042 2442 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
8cd3ac9f
ND		 2443 ;
2444
2445 return len;
2446}
2447
2448static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
2449 int cmd)
2450{
2451 struct net *net = read_pnet(&mrt->net);
2452 struct sk_buff *skb;
2453 int err = -ENOBUFS;
2454
2455 skb = nlmsg_new(mroute_msgsize(mfc->mfc_parent >= MAXVIFS, mrt->maxvif),
2456 GFP_ATOMIC);
51456b29 2457 if (!skb)
8cd3ac9f
ND		 2458 goto errout;
2459
65886f43 2460 err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
8cd3ac9f
ND		 2461 if (err < 0)
2462 goto errout;
2463
2464 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC);
2465 return;
2466
2467errout:
2468 kfree_skb(skb);
2469 if (err < 0)
2470 rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err);
2471}
2472
5a645dd8
JG		 2473static size_t igmpmsg_netlink_msgsize(size_t payloadlen)
2474{
2475 size_t len =
2476 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2477 + nla_total_size(1) /* IPMRA_CREPORT_MSGTYPE */
2478 + nla_total_size(4) /* IPMRA_CREPORT_VIF_ID */
2479 + nla_total_size(4) /* IPMRA_CREPORT_SRC_ADDR */
2480 + nla_total_size(4) /* IPMRA_CREPORT_DST_ADDR */
2481 /* IPMRA_CREPORT_PKT */
2482 + nla_total_size(payloadlen)
2483 ;
2484
2485 return len;
2486}
2487
2488static void igmpmsg_netlink_event(struct mr_table *mrt, struct sk_buff *pkt)
2489{
2490 struct net *net = read_pnet(&mrt->net);
2491 struct nlmsghdr *nlh;
2492 struct rtgenmsg *rtgenm;
2493 struct igmpmsg *msg;
2494 struct sk_buff *skb;
2495 struct nlattr *nla;
2496 int payloadlen;
2497
2498 payloadlen = pkt->len - sizeof(struct igmpmsg);
2499 msg = (struct igmpmsg *)skb_network_header(pkt);
2500
2501 skb = nlmsg_new(igmpmsg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2502 if (!skb)
2503 goto errout;
2504
2505 nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2506 sizeof(struct rtgenmsg), 0);
2507 if (!nlh)
2508 goto errout;
2509 rtgenm = nlmsg_data(nlh);
2510 rtgenm->rtgen_family = RTNL_FAMILY_IPMR;
2511 if (nla_put_u8(skb, IPMRA_CREPORT_MSGTYPE, msg->im_msgtype) ||
2512 nla_put_u32(skb, IPMRA_CREPORT_VIF_ID, msg->im_vif) ||
2513 nla_put_in_addr(skb, IPMRA_CREPORT_SRC_ADDR,
2514 msg->im_src.s_addr) ||
2515 nla_put_in_addr(skb, IPMRA_CREPORT_DST_ADDR,
2516 msg->im_dst.s_addr))
2517 goto nla_put_failure;
2518
2519 nla = nla_reserve(skb, IPMRA_CREPORT_PKT, payloadlen);
2520 if (!nla || skb_copy_bits(pkt, sizeof(struct igmpmsg),
2521 nla_data(nla), payloadlen))
2522 goto nla_put_failure;
2523
2524 nlmsg_end(skb, nlh);
2525
2526 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE_R, NULL, GFP_ATOMIC);
2527 return;
2528
2529nla_put_failure:
2530 nlmsg_cancel(skb, nlh);
2531errout:
2532 kfree_skb(skb);
2533 rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE_R, -ENOBUFS);
2534}
2535
4f75ba69
DS		 2536static int ipmr_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
2537 struct netlink_ext_ack *extack)
2538{
2539 struct net *net = sock_net(in_skb->sk);
2540 struct nlattr *tb[RTA_MAX + 1];
2541 struct sk_buff *skb = NULL;
2542 struct mfc_cache *cache;
2543 struct mr_table *mrt;
2544 struct rtmsg *rtm;
2545 __be32 src, grp;
2546 u32 tableid;
2547 int err;
2548
2549 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX,
2550 rtm_ipv4_policy, extack);
2551 if (err < 0)
2552 goto errout;
2553
2554 rtm = nlmsg_data(nlh);
2555
2556 src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
2557 grp = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
2558 tableid = tb[RTA_TABLE] ? nla_get_u32(tb[RTA_TABLE]) : 0;
2559
2560 mrt = ipmr_get_table(net, tableid ? tableid : RT_TABLE_DEFAULT);
2e3d232e
DC		 2561 if (!mrt) {
2562 err = -ENOENT;
4f75ba69
DS		 2563 goto errout_free;
2564 }
2565
2566 /* entries are added/deleted only under RTNL */
2567 rcu_read_lock();
2568 cache = ipmr_cache_find(mrt, src, grp);
2569 rcu_read_unlock();
2570 if (!cache) {
2571 err = -ENOENT;
2572 goto errout_free;
2573 }
2574
2575 skb = nlmsg_new(mroute_msgsize(false, mrt->maxvif), GFP_KERNEL);
2576 if (!skb) {
2577 err = -ENOBUFS;
2578 goto errout_free;
2579 }
2580
2581 err = ipmr_fill_mroute(mrt, skb, NETLINK_CB(in_skb).portid,
2582 nlh->nlmsg_seq, cache,
2583 RTM_NEWROUTE, 0);
2584 if (err < 0)
2585 goto errout_free;
2586
2587 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
2588
2589errout:
2590 return err;
2591
2592errout_free:
2593 kfree_skb(skb);
2594 goto errout;
2595}
2596
cb6a4e46
PM		 2597static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2598{
2599 struct net *net = sock_net(skb->sk);
2600 struct mr_table *mrt;
2601 struct mfc_cache *mfc;
2602 unsigned int t = 0, s_t;
cb6a4e46
PM		 2603 unsigned int e = 0, s_e;
2604
2605 s_t = cb->args[0];
8fb472c0 2606 s_e = cb->args[1];
cb6a4e46 2607
a8c9486b 2608 rcu_read_lock();
cb6a4e46
PM		 2609 ipmr_for_each_table(mrt, net) {
2610 if (t < s_t)
2611 goto next_table;
8fb472c0
NA		 2612 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) {
2613 if (e < s_e)
2614 goto next_entry;
2615 if (ipmr_fill_mroute(mrt, skb,
2616 NETLINK_CB(cb->skb).portid,
2617 cb->nlh->nlmsg_seq,
2618 mfc, RTM_NEWROUTE,
2619 NLM_F_MULTI) < 0)
2620 goto done;
cb6a4e46 2621next_entry:
8fb472c0 2622 e++;
cb6a4e46 2623 }
8fb472c0
NA		 2624 e = 0;
2625 s_e = 0;
2626
1eb99af5
ND		 2627 spin_lock_bh(&mfc_unres_lock);
2628 list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
2629 if (e < s_e)
2630 goto next_entry2;
2631 if (ipmr_fill_mroute(mrt, skb,
2632 NETLINK_CB(cb->skb).portid,
2633 cb->nlh->nlmsg_seq,
65886f43
ND		 2634 mfc, RTM_NEWROUTE,
2635 NLM_F_MULTI) < 0) {
1eb99af5
ND		 2636 spin_unlock_bh(&mfc_unres_lock);
2637 goto done;
2638 }
2639next_entry2:
2640 e++;
2641 }
2642 spin_unlock_bh(&mfc_unres_lock);
8fb472c0
NA		 2643 e = 0;
2644 s_e = 0;
cb6a4e46
PM		 2645next_table:
2646 t++;
2647 }
2648done:
a8c9486b 2649 rcu_read_unlock();
cb6a4e46 2650
8fb472c0 2651 cb->args[1] = e;
cb6a4e46
PM		 2652 cb->args[0] = t;
2653
2654 return skb->len;
2655}
2656
ccbb0aa6
NA		 2657static const struct nla_policy rtm_ipmr_policy[RTA_MAX + 1] = {
2658 [RTA_SRC] = { .type = NLA_U32 },
2659 [RTA_DST] = { .type = NLA_U32 },
2660 [RTA_IIF] = { .type = NLA_U32 },
2661 [RTA_TABLE] = { .type = NLA_U32 },
2662 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2663};
2664
2665static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol)
2666{
2667 switch (rtm_protocol) {
2668 case RTPROT_STATIC:
2669 case RTPROT_MROUTED:
2670 return true;
2671 }
2672 return false;
2673}
2674
2675static int ipmr_nla_get_ttls(const struct nlattr *nla, struct mfcctl *mfcc)
2676{
2677 struct rtnexthop *rtnh = nla_data(nla);
2678 int remaining = nla_len(nla), vifi = 0;
2679
2680 while (rtnh_ok(rtnh, remaining)) {
2681 mfcc->mfcc_ttls[vifi] = rtnh->rtnh_hops;
2682 if (++vifi == MAXVIFS)
2683 break;
2684 rtnh = rtnh_next(rtnh, &remaining);
2685 }
2686
2687 return remaining > 0 ? -EINVAL : vifi;
2688}
2689
2690/* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */
2691static int rtm_to_ipmr_mfcc(struct net *net, struct nlmsghdr *nlh,
2692 struct mfcctl *mfcc, int *mrtsock,
c21ef3e3
DA		 2693 struct mr_table **mrtret,
2694 struct netlink_ext_ack *extack)
ccbb0aa6
NA		 2695{
2696 struct net_device *dev = NULL;
2697 u32 tblid = RT_TABLE_DEFAULT;
2698 struct mr_table *mrt;
2699 struct nlattr *attr;
2700 struct rtmsg *rtm;
2701 int ret, rem;
2702
fceb6435 2703 ret = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipmr_policy,
c21ef3e3 2704 extack);
ccbb0aa6
NA		 2705 if (ret < 0)
2706 goto out;
2707 rtm = nlmsg_data(nlh);
2708
2709 ret = -EINVAL;
2710 if (rtm->rtm_family != RTNL_FAMILY_IPMR || rtm->rtm_dst_len != 32 ||
2711 rtm->rtm_type != RTN_MULTICAST ||
2712 rtm->rtm_scope != RT_SCOPE_UNIVERSE ||
2713 !ipmr_rtm_validate_proto(rtm->rtm_protocol))
2714 goto out;
2715
2716 memset(mfcc, 0, sizeof(*mfcc));
2717 mfcc->mfcc_parent = -1;
2718 ret = 0;
2719 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), rem) {
2720 switch (nla_type(attr)) {
2721 case RTA_SRC:
2722 mfcc->mfcc_origin.s_addr = nla_get_be32(attr);
2723 break;
2724 case RTA_DST:
2725 mfcc->mfcc_mcastgrp.s_addr = nla_get_be32(attr);
2726 break;
2727 case RTA_IIF:
2728 dev = __dev_get_by_index(net, nla_get_u32(attr));
2729 if (!dev) {
2730 ret = -ENODEV;
2731 goto out;
2732 }
2733 break;
2734 case RTA_MULTIPATH:
2735 if (ipmr_nla_get_ttls(attr, mfcc) < 0) {
2736 ret = -EINVAL;
2737 goto out;
2738 }
2739 break;
2740 case RTA_PREFSRC:
2741 ret = 1;
2742 break;
2743 case RTA_TABLE:
2744 tblid = nla_get_u32(attr);
2745 break;
2746 }
2747 }
2748 mrt = ipmr_get_table(net, tblid);
2749 if (!mrt) {
2750 ret = -ENOENT;
2751 goto out;
2752 }
2753 *mrtret = mrt;
2754 *mrtsock = rtm->rtm_protocol == RTPROT_MROUTED ? 1 : 0;
2755 if (dev)
2756 mfcc->mfcc_parent = ipmr_find_vif(mrt, dev);
2757
2758out:
2759 return ret;
2760}
2761
2762/* takes care of both newroute and delroute */
c21ef3e3
DA		 2763static int ipmr_rtm_route(struct sk_buff *skb, struct nlmsghdr *nlh,
2764 struct netlink_ext_ack *extack)
ccbb0aa6
NA		 2765{
2766 struct net *net = sock_net(skb->sk);
2767 int ret, mrtsock, parent;
2768 struct mr_table *tbl;
2769 struct mfcctl mfcc;
2770
2771 mrtsock = 0;
2772 tbl = NULL;
c21ef3e3 2773 ret = rtm_to_ipmr_mfcc(net, nlh, &mfcc, &mrtsock, &tbl, extack);
ccbb0aa6
NA		 2774 if (ret < 0)
2775 return ret;
2776
2777 parent = ret ? mfcc.mfcc_parent : -1;
2778 if (nlh->nlmsg_type == RTM_NEWROUTE)
2779 return ipmr_mfc_add(net, tbl, &mfcc, mrtsock, parent);
2780 else
2781 return ipmr_mfc_delete(tbl, &mfcc, parent);
2782}
2783
772c344d
NA		 2784static bool ipmr_fill_table(struct mr_table *mrt, struct sk_buff *skb)
2785{
2786 u32 queue_len = atomic_read(&mrt->cache_resolve_queue_len);
2787
2788 if (nla_put_u32(skb, IPMRA_TABLE_ID, mrt->id) ||
2789 nla_put_u32(skb, IPMRA_TABLE_CACHE_RES_QUEUE_LEN, queue_len) ||
2790 nla_put_s32(skb, IPMRA_TABLE_MROUTE_REG_VIF_NUM,
2791 mrt->mroute_reg_vif_num) ||
2792 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_ASSERT,
2793 mrt->mroute_do_assert) ||
2794 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_PIM, mrt->mroute_do_pim))
2795 return false;
2796
2797 return true;
2798}
2799
2800static bool ipmr_fill_vif(struct mr_table *mrt, u32 vifid, struct sk_buff *skb)
2801{
2802 struct nlattr *vif_nest;
2803 struct vif_device *vif;
2804
2805 /* if the VIF doesn't exist just continue */
2806 if (!VIF_EXISTS(mrt, vifid))
2807 return true;
2808
2809 vif = &mrt->vif_table[vifid];
2810 vif_nest = nla_nest_start(skb, IPMRA_VIF);
2811 if (!vif_nest)
2812 return false;
2813 if (nla_put_u32(skb, IPMRA_VIFA_IFINDEX, vif->dev->ifindex) ||
2814 nla_put_u32(skb, IPMRA_VIFA_VIF_ID, vifid) ||
2815 nla_put_u16(skb, IPMRA_VIFA_FLAGS, vif->flags) ||
2816 nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_IN, vif->bytes_in,
2817 IPMRA_VIFA_PAD) ||
2818 nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_OUT, vif->bytes_out,
2819 IPMRA_VIFA_PAD) ||
2820 nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_IN, vif->pkt_in,
2821 IPMRA_VIFA_PAD) ||
2822 nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_OUT, vif->pkt_out,
2823 IPMRA_VIFA_PAD) ||
2824 nla_put_be32(skb, IPMRA_VIFA_LOCAL_ADDR, vif->local) ||
2825 nla_put_be32(skb, IPMRA_VIFA_REMOTE_ADDR, vif->remote)) {
2826 nla_nest_cancel(skb, vif_nest);
2827 return false;
2828 }
2829 nla_nest_end(skb, vif_nest);
2830
2831 return true;
2832}
2833
2834static int ipmr_rtm_dumplink(struct sk_buff *skb, struct netlink_callback *cb)
2835{
2836 struct net *net = sock_net(skb->sk);
2837 struct nlmsghdr *nlh = NULL;
2838 unsigned int t = 0, s_t;
2839 unsigned int e = 0, s_e;
2840 struct mr_table *mrt;
2841
2842 s_t = cb->args[0];
2843 s_e = cb->args[1];
2844
2845 ipmr_for_each_table(mrt, net) {
2846 struct nlattr *vifs, *af;
2847 struct ifinfomsg *hdr;
2848 u32 i;
2849
2850 if (t < s_t)
2851 goto skip_table;
2852 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
2853 cb->nlh->nlmsg_seq, RTM_NEWLINK,
2854 sizeof(*hdr), NLM_F_MULTI);
2855 if (!nlh)
2856 break;
2857
2858 hdr = nlmsg_data(nlh);
2859 memset(hdr, 0, sizeof(*hdr));
2860 hdr->ifi_family = RTNL_FAMILY_IPMR;
2861
2862 af = nla_nest_start(skb, IFLA_AF_SPEC);
2863 if (!af) {
2864 nlmsg_cancel(skb, nlh);
2865 goto out;
2866 }
2867
2868 if (!ipmr_fill_table(mrt, skb)) {
2869 nlmsg_cancel(skb, nlh);
2870 goto out;
2871 }
2872
2873 vifs = nla_nest_start(skb, IPMRA_TABLE_VIFS);
2874 if (!vifs) {
2875 nla_nest_end(skb, af);
2876 nlmsg_end(skb, nlh);
2877 goto out;
2878 }
2879 for (i = 0; i < mrt->maxvif; i++) {
2880 if (e < s_e)
2881 goto skip_entry;
2882 if (!ipmr_fill_vif(mrt, i, skb)) {
2883 nla_nest_end(skb, vifs);
2884 nla_nest_end(skb, af);
2885 nlmsg_end(skb, nlh);
2886 goto out;
2887 }
2888skip_entry:
2889 e++;
2890 }
2891 s_e = 0;
2892 e = 0;
2893 nla_nest_end(skb, vifs);
2894 nla_nest_end(skb, af);
2895 nlmsg_end(skb, nlh);
2896skip_table:
2897 t++;
2898 }
2899
2900out:
2901 cb->args[1] = e;
2902 cb->args[0] = t;
2903
2904 return skb->len;
2905}
2906
e905a9ed 2907#ifdef CONFIG_PROC_FS
7ef8f65d
NA		 2908/* The /proc interfaces to multicast routing :
2909 * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
1da177e4
LT		 2910 */
2911struct ipmr_vif_iter {
f6bb4514 2912 struct seq_net_private p;
f0ad0860 2913 struct mr_table *mrt;
1da177e4
LT		 2914 int ct;
2915};
2916
f6bb4514
BT		 2917static struct vif_device *ipmr_vif_seq_idx(struct net *net,
2918 struct ipmr_vif_iter *iter,
1da177e4
LT		 2919 loff_t pos)
2920{
f0ad0860 2921 struct mr_table *mrt = iter->mrt;
0c12295a
PM		 2922
2923 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
2924 if (!VIF_EXISTS(mrt, iter->ct))
1da177e4 2925 continue;
e905a9ed 2926 if (pos-- == 0)
0c12295a 2927 return &mrt->vif_table[iter->ct];
1da177e4
LT		 2928 }
2929 return NULL;
2930}
2931
2932static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
ba93ef74 2933 __acquires(mrt_lock)
1da177e4 2934{
f0ad0860 2935 struct ipmr_vif_iter *iter = seq->private;
f6bb4514 2936 struct net *net = seq_file_net(seq);
f0ad0860
PM		 2937 struct mr_table *mrt;
2938
2939 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
51456b29 2940 if (!mrt)
f0ad0860
PM		 2941 return ERR_PTR(-ENOENT);
2942
2943 iter->mrt = mrt;
f6bb4514 2944
1da177e4 2945 read_lock(&mrt_lock);
f6bb4514 2946 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
1da177e4
LT		 2947 : SEQ_START_TOKEN;
2948}
2949
2950static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2951{
2952 struct ipmr_vif_iter *iter = seq->private;
f6bb4514 2953 struct net *net = seq_file_net(seq);
f0ad0860 2954 struct mr_table *mrt = iter->mrt;
1da177e4
LT		 2955
2956 ++*pos;
2957 if (v == SEQ_START_TOKEN)
f6bb4514 2958 return ipmr_vif_seq_idx(net, iter, 0);
e905a9ed 2959
0c12295a
PM		 2960 while (++iter->ct < mrt->maxvif) {
2961 if (!VIF_EXISTS(mrt, iter->ct))
1da177e4 2962 continue;
0c12295a 2963 return &mrt->vif_table[iter->ct];
1da177e4
LT		 2964 }
2965 return NULL;
2966}
2967
2968static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
ba93ef74 2969 __releases(mrt_lock)
1da177e4
LT		 2970{
2971 read_unlock(&mrt_lock);
2972}
2973
2974static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
2975{
f0ad0860
PM		 2976 struct ipmr_vif_iter *iter = seq->private;
2977 struct mr_table *mrt = iter->mrt;
f6bb4514 2978
1da177e4 2979 if (v == SEQ_START_TOKEN) {
e905a9ed 2980 seq_puts(seq,
1da177e4
LT		 2981 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
2982 } else {
2983 const struct vif_device *vif = v;
2984 const char *name = vif->dev ? vif->dev->name : "none";
2985
2986 seq_printf(seq,
5b5e0928 2987 "%2zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
0c12295a 2988 vif - mrt->vif_table,
e905a9ed 2989 name, vif->bytes_in, vif->pkt_in,
1da177e4
LT		 2990 vif->bytes_out, vif->pkt_out,
2991 vif->flags, vif->local, vif->remote);
2992 }
2993 return 0;
2994}
2995
f690808e 2996static const struct seq_operations ipmr_vif_seq_ops = {
1da177e4
LT		 2997 .start = ipmr_vif_seq_start,
2998 .next = ipmr_vif_seq_next,
2999 .stop = ipmr_vif_seq_stop,
3000 .show = ipmr_vif_seq_show,
3001};
3002
3003static int ipmr_vif_open(struct inode *inode, struct file *file)
3004{
f6bb4514
BT		 3005 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
3006 sizeof(struct ipmr_vif_iter));
1da177e4
LT		 3007}
3008
9a32144e 3009static const struct file_operations ipmr_vif_fops = {
1da177e4
LT		 3010 .owner = THIS_MODULE,
3011 .open = ipmr_vif_open,
3012 .read = seq_read,
3013 .llseek = seq_lseek,
f6bb4514 3014 .release = seq_release_net,
1da177e4
LT		 3015};
3016
3017struct ipmr_mfc_iter {
f6bb4514 3018 struct seq_net_private p;
f0ad0860 3019 struct mr_table *mrt;
862465f2 3020 struct list_head *cache;
1da177e4
LT		 3021};
3022
f6bb4514
BT		 3023static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
3024 struct ipmr_mfc_iter *it, loff_t pos)
1da177e4 3025{
f0ad0860 3026 struct mr_table *mrt = it->mrt;
1da177e4
LT		 3027 struct mfc_cache *mfc;
3028
a8c9486b 3029 rcu_read_lock();
8fb472c0
NA		 3030 it->cache = &mrt->mfc_cache_list;
3031 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list)
3032 if (pos-- == 0)
3033 return mfc;
a8c9486b 3034 rcu_read_unlock();
1da177e4 3035
1da177e4 3036 spin_lock_bh(&mfc_unres_lock);
0c12295a 3037 it->cache = &mrt->mfc_unres_queue;
862465f2 3038 list_for_each_entry(mfc, it->cache, list)
e258beb2 3039 if (pos-- == 0)
1da177e4
LT		 3040 return mfc;
3041 spin_unlock_bh(&mfc_unres_lock);
3042
3043 it->cache = NULL;
3044 return NULL;
3045}
3046
3047
3048static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
3049{
3050 struct ipmr_mfc_iter *it = seq->private;
f6bb4514 3051 struct net *net = seq_file_net(seq);
f0ad0860 3052 struct mr_table *mrt;
f6bb4514 3053
f0ad0860 3054 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
51456b29 3055 if (!mrt)
f0ad0860 3056 return ERR_PTR(-ENOENT);
f6bb4514 3057
f0ad0860 3058 it->mrt = mrt;
1da177e4 3059 it->cache = NULL;
f6bb4514 3060 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
1da177e4
LT		 3061 : SEQ_START_TOKEN;
3062}
3063
3064static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3065{
1da177e4 3066 struct ipmr_mfc_iter *it = seq->private;
f6bb4514 3067 struct net *net = seq_file_net(seq);
f0ad0860 3068 struct mr_table *mrt = it->mrt;
8fb472c0 3069 struct mfc_cache *mfc = v;
1da177e4
LT		 3070
3071 ++*pos;
3072
3073 if (v == SEQ_START_TOKEN)
f6bb4514 3074 return ipmr_mfc_seq_idx(net, seq->private, 0);
1da177e4 3075
862465f2
PM		 3076 if (mfc->list.next != it->cache)
3077 return list_entry(mfc->list.next, struct mfc_cache, list);
e905a9ed 3078
0c12295a 3079 if (it->cache == &mrt->mfc_unres_queue)
1da177e4
LT		 3080 goto end_of_list;
3081
1da177e4 3082 /* exhausted cache_array, show unresolved */
a8c9486b 3083 rcu_read_unlock();
0c12295a 3084 it->cache = &mrt->mfc_unres_queue;
e905a9ed 3085
1da177e4 3086 spin_lock_bh(&mfc_unres_lock);
862465f2
PM		 3087 if (!list_empty(it->cache))
3088 return list_first_entry(it->cache, struct mfc_cache, list);
1da177e4 3089
a8cb16dd 3090end_of_list:
1da177e4
LT		 3091 spin_unlock_bh(&mfc_unres_lock);
3092 it->cache = NULL;
3093
3094 return NULL;
3095}
3096
3097static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
3098{
3099 struct ipmr_mfc_iter *it = seq->private;
f0ad0860 3100 struct mr_table *mrt = it->mrt;
1da177e4 3101
0c12295a 3102 if (it->cache == &mrt->mfc_unres_queue)
1da177e4 3103 spin_unlock_bh(&mfc_unres_lock);
8fb472c0 3104 else if (it->cache == &mrt->mfc_cache_list)
a8c9486b 3105 rcu_read_unlock();
1da177e4
LT		 3106}
3107
3108static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
3109{
3110 int n;
3111
3112 if (v == SEQ_START_TOKEN) {
e905a9ed 3113 seq_puts(seq,
1da177e4
LT		 3114 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
3115 } else {
3116 const struct mfc_cache *mfc = v;
3117 const struct ipmr_mfc_iter *it = seq->private;
f0ad0860 3118 const struct mr_table *mrt = it->mrt;
e905a9ed 3119
0eae88f3
ED		 3120 seq_printf(seq, "%08X %08X %-3hd",
3121 (__force u32) mfc->mfc_mcastgrp,
3122 (__force u32) mfc->mfc_origin,
1ea472e2 3123 mfc->mfc_parent);
1da177e4 3124
0c12295a 3125 if (it->cache != &mrt->mfc_unres_queue) {
1ea472e2
BT		 3126 seq_printf(seq, " %8lu %8lu %8lu",
3127 mfc->mfc_un.res.pkt,
3128 mfc->mfc_un.res.bytes,
3129 mfc->mfc_un.res.wrong_if);
132adf54 3130 for (n = mfc->mfc_un.res.minvif;
a8cb16dd 3131 n < mfc->mfc_un.res.maxvif; n++) {
0c12295a 3132 if (VIF_EXISTS(mrt, n) &&
cf958ae3
BT		 3133 mfc->mfc_un.res.ttls[n] < 255)
3134 seq_printf(seq,
e905a9ed 3135 " %2d:%-3d",
1da177e4
LT		 3136 n, mfc->mfc_un.res.ttls[n]);
3137 }
1ea472e2
BT		 3138 } else {
3139 /* unresolved mfc_caches don't contain
3140 * pkt, bytes and wrong_if values
3141 */
3142 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
1da177e4
LT		 3143 }
3144 seq_putc(seq, '\n');
3145 }
3146 return 0;
3147}
3148
f690808e 3149static const struct seq_operations ipmr_mfc_seq_ops = {
1da177e4
LT		 3150 .start = ipmr_mfc_seq_start,
3151 .next = ipmr_mfc_seq_next,
3152 .stop = ipmr_mfc_seq_stop,
3153 .show = ipmr_mfc_seq_show,
3154};
3155
3156static int ipmr_mfc_open(struct inode *inode, struct file *file)
3157{
f6bb4514
BT		 3158 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
3159 sizeof(struct ipmr_mfc_iter));
1da177e4
LT		 3160}
3161
9a32144e 3162static const struct file_operations ipmr_mfc_fops = {
1da177e4
LT		 3163 .owner = THIS_MODULE,
3164 .open = ipmr_mfc_open,
3165 .read = seq_read,
3166 .llseek = seq_lseek,
f6bb4514 3167 .release = seq_release_net,
1da177e4 3168};
e905a9ed 3169#endif
1da177e4
LT		 3170
3171#ifdef CONFIG_IP_PIMSM_V2
32613090 3172static const struct net_protocol pim_protocol = {
1da177e4 3173 .handler = pim_rcv,
403dbb97 3174 .netns_ok = 1,
1da177e4
LT		 3175};
3176#endif
3177
4d65b948
YG		 3178static unsigned int ipmr_seq_read(struct net *net)
3179{
3180 ASSERT_RTNL();
3181
3182 return net->ipv4.ipmr_seq + ipmr_rules_seq_read(net);
3183}
3184
3185static int ipmr_dump(struct net *net, struct notifier_block *nb)
3186{
3187 struct mr_table *mrt;
3188 int err;
3189
3190 err = ipmr_rules_dump(net, nb);
3191 if (err)
3192 return err;
3193
3194 ipmr_for_each_table(mrt, net) {
3195 struct vif_device *v = &mrt->vif_table[0];
3196 struct mfc_cache *mfc;
3197 int vifi;
3198
3199 /* Notifiy on table VIF entries */
3200 read_lock(&mrt_lock);
3201 for (vifi = 0; vifi < mrt->maxvif; vifi++, v++) {
3202 if (!v->dev)
3203 continue;
3204
3205 call_ipmr_vif_entry_notifier(nb, net, FIB_EVENT_VIF_ADD,
3206 v, vifi, mrt->id);
3207 }
3208 read_unlock(&mrt_lock);
3209
3210 /* Notify on table MFC entries */
3211 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list)
3212 call_ipmr_mfc_entry_notifier(nb, net,
3213 FIB_EVENT_ENTRY_ADD, mfc,
3214 mrt->id);
3215 }
3216
3217 return 0;
3218}
3219
3220static const struct fib_notifier_ops ipmr_notifier_ops_template = {
3221 .family = RTNL_FAMILY_IPMR,
3222 .fib_seq_read = ipmr_seq_read,
3223 .fib_dump = ipmr_dump,
3224 .owner = THIS_MODULE,
3225};
3226
ef739d8a 3227static int __net_init ipmr_notifier_init(struct net *net)
4d65b948
YG		 3228{
3229 struct fib_notifier_ops *ops;
3230
3231 net->ipv4.ipmr_seq = 0;
3232
3233 ops = fib_notifier_ops_register(&ipmr_notifier_ops_template, net);
3234 if (IS_ERR(ops))
3235 return PTR_ERR(ops);
3236 net->ipv4.ipmr_notifier_ops = ops;
3237
3238 return 0;
3239}
3240
3241static void __net_exit ipmr_notifier_exit(struct net *net)
3242{
3243 fib_notifier_ops_unregister(net->ipv4.ipmr_notifier_ops);
3244 net->ipv4.ipmr_notifier_ops = NULL;
3245}
3246
7ef8f65d 3247/* Setup for IP multicast routing */
cf958ae3
BT		 3248static int __net_init ipmr_net_init(struct net *net)
3249{
f0ad0860 3250 int err;
cf958ae3 3251
4d65b948
YG		 3252 err = ipmr_notifier_init(net);
3253 if (err)
3254 goto ipmr_notifier_fail;
3255
f0ad0860
PM		 3256 err = ipmr_rules_init(net);
3257 if (err < 0)
4d65b948 3258 goto ipmr_rules_fail;
f6bb4514
BT		 3259
3260#ifdef CONFIG_PROC_FS
3261 err = -ENOMEM;
d4beaa66 3262 if (!proc_create("ip_mr_vif", 0, net->proc_net, &ipmr_vif_fops))
f6bb4514 3263 goto proc_vif_fail;
d4beaa66 3264 if (!proc_create("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_fops))
f6bb4514
BT		 3265 goto proc_cache_fail;
3266#endif
2bb8b26c
BT		 3267 return 0;
3268
f6bb4514
BT		 3269#ifdef CONFIG_PROC_FS
3270proc_cache_fail:
ece31ffd 3271 remove_proc_entry("ip_mr_vif", net->proc_net);
f6bb4514 3272proc_vif_fail:
f0ad0860 3273 ipmr_rules_exit(net);
f6bb4514 3274#endif
4d65b948
YG		 3275ipmr_rules_fail:
3276 ipmr_notifier_exit(net);
3277ipmr_notifier_fail:
cf958ae3
BT		 3278 return err;
3279}
3280
3281static void __net_exit ipmr_net_exit(struct net *net)
3282{
f6bb4514 3283#ifdef CONFIG_PROC_FS
ece31ffd
G		 3284 remove_proc_entry("ip_mr_cache", net->proc_net);
3285 remove_proc_entry("ip_mr_vif", net->proc_net);
f6bb4514 3286#endif
4d65b948 3287 ipmr_notifier_exit(net);
f0ad0860 3288 ipmr_rules_exit(net);
cf958ae3
BT		 3289}
3290
3291static struct pernet_operations ipmr_net_ops = {
3292 .init = ipmr_net_init,
3293 .exit = ipmr_net_exit,
3294};
e905a9ed 3295
03d2f897 3296int __init ip_mr_init(void)
1da177e4 3297{
03d2f897
WC		 3298 int err;
3299
1da177e4
LT		 3300 mrt_cachep = kmem_cache_create("ip_mrt_cache",
3301 sizeof(struct mfc_cache),
a8c9486b 3302 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
20c2df83 3303 NULL);
03d2f897 3304
cf958ae3
BT		 3305 err = register_pernet_subsys(&ipmr_net_ops);
3306 if (err)
3307 goto reg_pernet_fail;
3308
03d2f897
WC		 3309 err = register_netdevice_notifier(&ip_mr_notifier);
3310 if (err)
3311 goto reg_notif_fail;
403dbb97
TG		 3312#ifdef CONFIG_IP_PIMSM_V2
3313 if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
058bd4d2 3314 pr_err("%s: can't add PIM protocol\n", __func__);
403dbb97
TG		 3315 err = -EAGAIN;
3316 goto add_proto_fail;
3317 }
3318#endif
c7ac8679 3319 rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
b97bac64 3320 ipmr_rtm_getroute, ipmr_rtm_dumproute, 0);
ccbb0aa6 3321 rtnl_register(RTNL_FAMILY_IPMR, RTM_NEWROUTE,
b97bac64 3322 ipmr_rtm_route, NULL, 0);
ccbb0aa6 3323 rtnl_register(RTNL_FAMILY_IPMR, RTM_DELROUTE,
b97bac64 3324 ipmr_rtm_route, NULL, 0);
772c344d
NA		 3325
3326 rtnl_register(RTNL_FAMILY_IPMR, RTM_GETLINK,
b97bac64 3327 NULL, ipmr_rtm_dumplink, 0);
03d2f897 3328 return 0;
f6bb4514 3329
403dbb97
TG		 3330#ifdef CONFIG_IP_PIMSM_V2
3331add_proto_fail:
3332 unregister_netdevice_notifier(&ip_mr_notifier);
3333#endif
c3e38896 3334reg_notif_fail:
cf958ae3
BT		 3335 unregister_pernet_subsys(&ipmr_net_ops);
3336reg_pernet_fail:
c3e38896 3337 kmem_cache_destroy(mrt_cachep);
03d2f897 3338 return err;
1da177e4 3339}
ubuntu-bionic-kernel mirror