blob: abbd7c992960b7a62b83b0351b2a2f5abb5e160d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * IP multicast routing support for mrouted 3.6/3.8
3 *
Alan Cox113aa832008-10-13 19:01:08 -07004 * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * 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
Gilles Espinassef77f13e2010-03-29 15:41:47 +020025 * Relax this requirement to work with older peers.
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 *
27 */
28
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080029#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/types.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080031#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#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>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080048#include <linux/if_ether.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090049#include <linux/slab.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +020050#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <net/ip.h>
52#include <net/protocol.h>
53#include <linux/skbuff.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020054#include <net/route.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#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>
Eric W. Biederman709b46e2011-01-29 16:15:56 +000062#include <linux/compat.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040063#include <linux/export.h>
Pravin B Shelarc5441932013-03-25 14:49:35 +000064#include <net/ip_tunnels.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#include <net/checksum.h>
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -070066#include <net/netlink.h>
Patrick McHardyf0ad0862010-04-13 05:03:23 +000067#include <net/fib_rules.h>
Nicolas Dichteld67b8c62012-12-04 01:13:35 +000068#include <linux/netconf.h>
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +010069#include <net/nexthop.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Patrick McHardyf0ad0862010-04-13 05:03:23 +000071struct ipmr_rule {
72 struct fib_rule common;
73};
74
75struct ipmr_result {
76 struct mr_table *mrt;
77};
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079/* Big lock, protecting vif table, mrt cache and mroute socket state.
Eric Dumazeta8cb16d2010-10-01 16:15:29 +000080 * Note that the changes are semaphored via rtnl_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 */
82
83static DEFINE_RWLOCK(mrt_lock);
84
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +010085/* Multicast router control variables */
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Linus Torvalds1da177e2005-04-16 15:20:36 -070087/* 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
Eric Dumazeta8cb16d2010-10-01 16:15:29 +000091 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 */
97
Christoph Lametere18b8902006-12-06 20:33:20 -080098static struct kmem_cache *mrt_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000100static struct mr_table *ipmr_new_table(struct net *net, u32 id);
Francesco Ruggeriacbb2192012-08-24 07:38:35 +0000101static void ipmr_free_table(struct mr_table *mrt);
102
Rami Rosenc4854ec2013-07-20 15:09:28 +0300103static void ip_mr_forward(struct net *net, struct mr_table *mrt,
Donald Sharp4b1f0d32017-06-10 16:30:17 -0400104 struct net_device *dev, struct sk_buff *skb,
105 struct mfc_cache *cache, int local);
Patrick McHardy0c122952010-04-13 05:03:22 +0000106static int ipmr_cache_report(struct mr_table *mrt,
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000107 struct sk_buff *pkt, vifi_t vifi, int assert);
Patrick McHardycb6a4e42010-04-26 16:02:08 +0200108static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
109 struct mfc_cache *c, struct rtmsg *rtm);
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +0000110static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
111 int cmd);
Nikolay Aleksandrov0e615e92015-11-20 13:54:19 +0100112static void mroute_clean_tables(struct mr_table *mrt, bool all);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000113static void ipmr_expire_process(unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000115#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
116#define ipmr_for_each_table(mrt, net) \
117 list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
118
119static struct mr_table *ipmr_get_table(struct net *net, u32 id)
120{
121 struct mr_table *mrt;
122
123 ipmr_for_each_table(mrt, net) {
124 if (mrt->id == id)
125 return mrt;
126 }
127 return NULL;
128}
129
David S. Millerda919812011-03-12 02:04:50 -0500130static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000131 struct mr_table **mrt)
132{
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000133 int err;
Hannes Frederic Sowa95f4a452014-01-13 02:45:22 +0100134 struct ipmr_result res;
135 struct fib_lookup_arg arg = {
136 .result = &res,
137 .flags = FIB_LOOKUP_NOREF,
138 };
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000139
David Aherne58e4152016-10-31 15:54:00 -0700140 /* update flow if oif or iif point to device enslaved to l3mdev */
141 l3mdev_update_flow(net, flowi4_to_flowi(flp4));
142
David S. Millerda919812011-03-12 02:04:50 -0500143 err = fib_rules_lookup(net->ipv4.mr_rules_ops,
144 flowi4_to_flowi(flp4), 0, &arg);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000145 if (err < 0)
146 return err;
147 *mrt = res.mrt;
148 return 0;
149}
150
151static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
152 int flags, struct fib_lookup_arg *arg)
153{
154 struct ipmr_result *res = arg->result;
155 struct mr_table *mrt;
156
157 switch (rule->action) {
158 case FR_ACT_TO_TBL:
159 break;
160 case FR_ACT_UNREACHABLE:
161 return -ENETUNREACH;
162 case FR_ACT_PROHIBIT:
163 return -EACCES;
164 case FR_ACT_BLACKHOLE:
165 default:
166 return -EINVAL;
167 }
168
David Aherne58e4152016-10-31 15:54:00 -0700169 arg->table = fib_rule_get_table(rule, arg);
170
171 mrt = ipmr_get_table(rule->fr_net, arg->table);
Ian Morris51456b22015-04-03 09:17:26 +0100172 if (!mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000173 return -EAGAIN;
174 res->mrt = mrt;
175 return 0;
176}
177
178static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
179{
180 return 1;
181}
182
183static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
184 FRA_GENERIC_POLICY,
185};
186
187static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
188 struct fib_rule_hdr *frh, struct nlattr **tb)
189{
190 return 0;
191}
192
193static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
194 struct nlattr **tb)
195{
196 return 1;
197}
198
199static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
200 struct fib_rule_hdr *frh)
201{
202 frh->dst_len = 0;
203 frh->src_len = 0;
204 frh->tos = 0;
205 return 0;
206}
207
Andi Kleen04a6f822012-10-04 17:12:11 -0700208static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = {
Patrick McHardy25239ce2010-04-26 16:02:05 +0200209 .family = RTNL_FAMILY_IPMR,
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000210 .rule_size = sizeof(struct ipmr_rule),
211 .addr_size = sizeof(u32),
212 .action = ipmr_rule_action,
213 .match = ipmr_rule_match,
214 .configure = ipmr_rule_configure,
215 .compare = ipmr_rule_compare,
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000216 .fill = ipmr_rule_fill,
217 .nlgroup = RTNLGRP_IPV4_RULE,
218 .policy = ipmr_rule_policy,
219 .owner = THIS_MODULE,
220};
221
222static int __net_init ipmr_rules_init(struct net *net)
223{
224 struct fib_rules_ops *ops;
225 struct mr_table *mrt;
226 int err;
227
228 ops = fib_rules_register(&ipmr_rules_ops_template, net);
229 if (IS_ERR(ops))
230 return PTR_ERR(ops);
231
232 INIT_LIST_HEAD(&net->ipv4.mr_tables);
233
234 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
Nikolay Aleksandrov1113ebb2015-11-21 15:57:24 +0100235 if (IS_ERR(mrt)) {
236 err = PTR_ERR(mrt);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000237 goto err1;
238 }
239
240 err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
241 if (err < 0)
242 goto err2;
243
244 net->ipv4.mr_rules_ops = ops;
245 return 0;
246
247err2:
WANG Congf243e5a2015-03-25 14:45:03 -0700248 ipmr_free_table(mrt);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000249err1:
250 fib_rules_unregister(ops);
251 return err;
252}
253
254static void __net_exit ipmr_rules_exit(struct net *net)
255{
256 struct mr_table *mrt, *next;
257
WANG Conged785302015-03-31 11:01:45 -0700258 rtnl_lock();
Eric Dumazet035320d2010-06-06 23:48:40 +0000259 list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
260 list_del(&mrt->list);
Francesco Ruggeriacbb2192012-08-24 07:38:35 +0000261 ipmr_free_table(mrt);
Eric Dumazet035320d2010-06-06 23:48:40 +0000262 }
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000263 fib_rules_unregister(net->ipv4.mr_rules_ops);
WANG Cong419df122015-03-31 11:01:46 -0700264 rtnl_unlock();
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000265}
266#else
267#define ipmr_for_each_table(mrt, net) \
268 for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
269
270static struct mr_table *ipmr_get_table(struct net *net, u32 id)
271{
272 return net->ipv4.mrt;
273}
274
David S. Millerda919812011-03-12 02:04:50 -0500275static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000276 struct mr_table **mrt)
277{
278 *mrt = net->ipv4.mrt;
279 return 0;
280}
281
282static int __net_init ipmr_rules_init(struct net *net)
283{
Nikolay Aleksandrov1113ebb2015-11-21 15:57:24 +0100284 struct mr_table *mrt;
285
286 mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
287 if (IS_ERR(mrt))
288 return PTR_ERR(mrt);
289 net->ipv4.mrt = mrt;
290 return 0;
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000291}
292
293static void __net_exit ipmr_rules_exit(struct net *net)
294{
WANG Conged785302015-03-31 11:01:45 -0700295 rtnl_lock();
Francesco Ruggeriacbb2192012-08-24 07:38:35 +0000296 ipmr_free_table(net->ipv4.mrt);
WANG Conged785302015-03-31 11:01:45 -0700297 net->ipv4.mrt = NULL;
298 rtnl_unlock();
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000299}
300#endif
301
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100302static inline int ipmr_hash_cmp(struct rhashtable_compare_arg *arg,
303 const void *ptr)
304{
305 const struct mfc_cache_cmp_arg *cmparg = arg->key;
306 struct mfc_cache *c = (struct mfc_cache *)ptr;
307
308 return cmparg->mfc_mcastgrp != c->mfc_mcastgrp ||
309 cmparg->mfc_origin != c->mfc_origin;
310}
311
312static const struct rhashtable_params ipmr_rht_params = {
313 .head_offset = offsetof(struct mfc_cache, mnode),
314 .key_offset = offsetof(struct mfc_cache, cmparg),
315 .key_len = sizeof(struct mfc_cache_cmp_arg),
316 .nelem_hint = 3,
317 .locks_mul = 1,
318 .obj_cmpfn = ipmr_hash_cmp,
319 .automatic_shrinking = true,
320};
321
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000322static struct mr_table *ipmr_new_table(struct net *net, u32 id)
323{
324 struct mr_table *mrt;
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000325
Nikolay Aleksandrov1113ebb2015-11-21 15:57:24 +0100326 /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
327 if (id != RT_TABLE_DEFAULT && id >= 1000000000)
328 return ERR_PTR(-EINVAL);
329
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000330 mrt = ipmr_get_table(net, id);
Ian Morris00db4122015-04-03 09:17:27 +0100331 if (mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000332 return mrt;
333
334 mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
Ian Morris51456b22015-04-03 09:17:26 +0100335 if (!mrt)
Nikolay Aleksandrov1113ebb2015-11-21 15:57:24 +0100336 return ERR_PTR(-ENOMEM);
Patrick McHardy8de53df2010-04-15 13:29:28 +0200337 write_pnet(&mrt->net, net);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000338 mrt->id = id;
339
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100340 rhltable_init(&mrt->mfc_hash, &ipmr_rht_params);
341 INIT_LIST_HEAD(&mrt->mfc_cache_list);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000342 INIT_LIST_HEAD(&mrt->mfc_unres_queue);
343
344 setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
345 (unsigned long)mrt);
346
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000347 mrt->mroute_reg_vif_num = -1;
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000348#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
349 list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
350#endif
351 return mrt;
352}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Francesco Ruggeriacbb2192012-08-24 07:38:35 +0000354static void ipmr_free_table(struct mr_table *mrt)
355{
356 del_timer_sync(&mrt->ipmr_expire_timer);
Nikolay Aleksandrov0e615e92015-11-20 13:54:19 +0100357 mroute_clean_tables(mrt, true);
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100358 rhltable_destroy(&mrt->mfc_hash);
Francesco Ruggeriacbb2192012-08-24 07:38:35 +0000359 kfree(mrt);
360}
361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
363
Wang Chend6070322008-07-14 20:55:26 -0700364static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
365{
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000366 struct net *net = dev_net(dev);
367
Wang Chend6070322008-07-14 20:55:26 -0700368 dev_close(dev);
369
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000370 dev = __dev_get_by_name(net, "tunl0");
Wang Chend6070322008-07-14 20:55:26 -0700371 if (dev) {
Stephen Hemminger5bc3eb72008-11-19 21:52:05 -0800372 const struct net_device_ops *ops = dev->netdev_ops;
Wang Chend6070322008-07-14 20:55:26 -0700373 struct ifreq ifr;
Wang Chend6070322008-07-14 20:55:26 -0700374 struct ip_tunnel_parm p;
375
376 memset(&p, 0, sizeof(p));
377 p.iph.daddr = v->vifc_rmt_addr.s_addr;
378 p.iph.saddr = v->vifc_lcl_addr.s_addr;
379 p.iph.version = 4;
380 p.iph.ihl = 5;
381 p.iph.protocol = IPPROTO_IPIP;
382 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
383 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
384
Stephen Hemminger5bc3eb72008-11-19 21:52:05 -0800385 if (ops->ndo_do_ioctl) {
386 mm_segment_t oldfs = get_fs();
387
388 set_fs(KERNEL_DS);
389 ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
390 set_fs(oldfs);
391 }
Wang Chend6070322008-07-14 20:55:26 -0700392 }
393}
394
Nikolay Aleksandrova0b47732015-11-21 15:57:32 +0100395/* Initialize ipmr pimreg/tunnel in_device */
396static bool ipmr_init_vif_indev(const struct net_device *dev)
397{
398 struct in_device *in_dev;
399
400 ASSERT_RTNL();
401
402 in_dev = __in_dev_get_rtnl(dev);
403 if (!in_dev)
404 return false;
405 ipv4_devconf_setall(in_dev);
406 neigh_parms_data_state_setall(in_dev->arp_parms);
407 IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
408
409 return true;
410}
411
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +0100412static struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
414 struct net_device *dev;
415
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000416 dev = __dev_get_by_name(net, "tunl0");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
418 if (dev) {
Stephen Hemminger5bc3eb72008-11-19 21:52:05 -0800419 const struct net_device_ops *ops = dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 int err;
421 struct ifreq ifr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 struct ip_tunnel_parm p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 memset(&p, 0, sizeof(p));
425 p.iph.daddr = v->vifc_rmt_addr.s_addr;
426 p.iph.saddr = v->vifc_lcl_addr.s_addr;
427 p.iph.version = 4;
428 p.iph.ihl = 5;
429 p.iph.protocol = IPPROTO_IPIP;
430 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
Stephen Hemmingerba93ef72008-01-21 17:28:59 -0800431 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Stephen Hemminger5bc3eb72008-11-19 21:52:05 -0800433 if (ops->ndo_do_ioctl) {
434 mm_segment_t oldfs = get_fs();
435
436 set_fs(KERNEL_DS);
437 err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
438 set_fs(oldfs);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000439 } else {
Stephen Hemminger5bc3eb72008-11-19 21:52:05 -0800440 err = -EOPNOTSUPP;
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000441 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 dev = NULL;
443
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000444 if (err == 0 &&
445 (dev = __dev_get_by_name(net, p.name)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 dev->flags |= IFF_MULTICAST;
Nikolay Aleksandrova0b47732015-11-21 15:57:32 +0100447 if (!ipmr_init_vif_indev(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (dev_open(dev))
450 goto failure;
Wang Chen7dc00c82008-07-14 20:56:34 -0700451 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
453 }
454 return dev;
455
456failure:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 unregister_netdevice(dev);
458 return NULL;
459}
460
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +0100461#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000462static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000464 struct net *net = dev_net(dev);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000465 struct mr_table *mrt;
David S. Millerda919812011-03-12 02:04:50 -0500466 struct flowi4 fl4 = {
467 .flowi4_oif = dev->ifindex,
Cong Wang6a662712014-04-15 16:25:34 -0700468 .flowi4_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
David S. Millerda919812011-03-12 02:04:50 -0500469 .flowi4_mark = skb->mark,
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000470 };
471 int err;
472
David S. Millerda919812011-03-12 02:04:50 -0500473 err = ipmr_fib_lookup(net, &fl4, &mrt);
Ben Greeare40dbc52010-07-15 13:22:33 +0000474 if (err < 0) {
475 kfree_skb(skb);
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000476 return err;
Ben Greeare40dbc52010-07-15 13:22:33 +0000477 }
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 read_lock(&mrt_lock);
Pavel Emelyanovcf3677a2008-05-21 14:17:33 -0700480 dev->stats.tx_bytes += skb->len;
481 dev->stats.tx_packets++;
Patrick McHardy0c122952010-04-13 05:03:22 +0000482 ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 read_unlock(&mrt_lock);
484 kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000485 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486}
487
Nicolas Dichtelee9b9592015-04-02 17:07:03 +0200488static int reg_vif_get_iflink(const struct net_device *dev)
489{
490 return 0;
491}
492
Stephen Hemminger007c3832008-11-20 20:28:35 -0800493static const struct net_device_ops reg_vif_netdev_ops = {
494 .ndo_start_xmit = reg_vif_xmit,
Nicolas Dichtelee9b9592015-04-02 17:07:03 +0200495 .ndo_get_iflink = reg_vif_get_iflink,
Stephen Hemminger007c3832008-11-20 20:28:35 -0800496};
497
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498static void reg_vif_setup(struct net_device *dev)
499{
500 dev->type = ARPHRD_PIMREG;
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800501 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 dev->flags = IFF_NOARP;
Himangi Saraogi70cb4a42014-05-30 21:10:48 +0530503 dev->netdev_ops = &reg_vif_netdev_ops;
David S. Millercf124db2017-05-08 12:52:56 -0400504 dev->needs_free_netdev = true;
Tom Goff403dbb92009-06-14 03:16:13 -0700505 dev->features |= NETIF_F_NETNS_LOCAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506}
507
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000508static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509{
510 struct net_device *dev;
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000511 char name[IFNAMSIZ];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000513 if (mrt->id == RT_TABLE_DEFAULT)
514 sprintf(name, "pimreg");
515 else
516 sprintf(name, "pimreg%u", mrt->id);
517
Tom Gundersenc835a672014-07-14 16:37:24 +0200518 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Ian Morris51456b22015-04-03 09:17:26 +0100520 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 return NULL;
522
Tom Goff403dbb92009-06-14 03:16:13 -0700523 dev_net_set(dev, net);
524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (register_netdevice(dev)) {
526 free_netdev(dev);
527 return NULL;
528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
Nikolay Aleksandrova0b47732015-11-21 15:57:32 +0100530 if (!ipmr_init_vif_indev(dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 goto failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (dev_open(dev))
533 goto failure;
534
Wang Chen7dc00c82008-07-14 20:56:34 -0700535 dev_hold(dev);
536
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return dev;
538
539failure:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 unregister_netdevice(dev);
541 return NULL;
542}
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +0100543
544/* called with rcu_read_lock() */
545static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
546 unsigned int pimlen)
547{
548 struct net_device *reg_dev = NULL;
549 struct iphdr *encap;
550
551 encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +0100552 /* Check that:
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +0100553 * a. packet is really sent to a multicast group
554 * b. packet is not a NULL-REGISTER
555 * c. packet is not truncated
556 */
557 if (!ipv4_is_multicast(encap->daddr) ||
558 encap->tot_len == 0 ||
559 ntohs(encap->tot_len) + pimlen > skb->len)
560 return 1;
561
562 read_lock(&mrt_lock);
563 if (mrt->mroute_reg_vif_num >= 0)
564 reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
565 read_unlock(&mrt_lock);
566
567 if (!reg_dev)
568 return 1;
569
570 skb->mac_header = skb->network_header;
571 skb_pull(skb, (u8 *)encap - skb->data);
572 skb_reset_network_header(skb);
573 skb->protocol = htons(ETH_P_IP);
574 skb->ip_summed = CHECKSUM_NONE;
575
576 skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
577
578 netif_rx(skb);
579
580 return NET_RX_SUCCESS;
581}
582#else
583static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
584{
585 return NULL;
586}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587#endif
588
Ben Hutchings2c530402012-07-10 10:55:09 +0000589/**
590 * vif_delete - Delete a VIF entry
Wang Chen7dc00c82008-07-14 20:56:34 -0700591 * @notify: Set to 1, if the caller is a notifier_call
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 */
Patrick McHardy0c122952010-04-13 05:03:22 +0000593static int vif_delete(struct mr_table *mrt, int vifi, int notify,
Eric Dumazetd17fa6f2009-10-28 05:21:38 +0000594 struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
596 struct vif_device *v;
597 struct net_device *dev;
598 struct in_device *in_dev;
599
Patrick McHardy0c122952010-04-13 05:03:22 +0000600 if (vifi < 0 || vifi >= mrt->maxvif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return -EADDRNOTAVAIL;
602
Patrick McHardy0c122952010-04-13 05:03:22 +0000603 v = &mrt->vif_table[vifi];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 write_lock_bh(&mrt_lock);
606 dev = v->dev;
607 v->dev = NULL;
608
609 if (!dev) {
610 write_unlock_bh(&mrt_lock);
611 return -EADDRNOTAVAIL;
612 }
613
Patrick McHardy0c122952010-04-13 05:03:22 +0000614 if (vifi == mrt->mroute_reg_vif_num)
615 mrt->mroute_reg_vif_num = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000617 if (vifi + 1 == mrt->maxvif) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 int tmp;
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000619
620 for (tmp = vifi - 1; tmp >= 0; tmp--) {
Patrick McHardy0c122952010-04-13 05:03:22 +0000621 if (VIF_EXISTS(mrt, tmp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 break;
623 }
Patrick McHardy0c122952010-04-13 05:03:22 +0000624 mrt->maxvif = tmp+1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 }
626
627 write_unlock_bh(&mrt_lock);
628
629 dev_set_allmulti(dev, -1);
630
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000631 in_dev = __in_dev_get_rtnl(dev);
632 if (in_dev) {
Herbert Xu42f811b2007-06-04 23:34:44 -0700633 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
David Ahern3b022862017-03-28 14:28:02 -0700634 inet_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
Nicolas Dichteld67b8c62012-12-04 01:13:35 +0000635 NETCONFA_MC_FORWARDING,
636 dev->ifindex, &in_dev->cnf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 ip_rt_multicast_event(in_dev);
638 }
639
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000640 if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
Eric Dumazetd17fa6f2009-10-28 05:21:38 +0000641 unregister_netdevice_queue(dev, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 dev_put(dev);
644 return 0;
645}
646
Eric Dumazeta8c94862010-10-01 16:15:08 +0000647static void ipmr_cache_free_rcu(struct rcu_head *head)
648{
649 struct mfc_cache *c = container_of(head, struct mfc_cache, rcu);
650
651 kmem_cache_free(mrt_cachep, c);
652}
653
Benjamin Thery5c0a66f2009-01-22 04:56:17 +0000654static inline void ipmr_cache_free(struct mfc_cache *c)
655{
Eric Dumazeta8c94862010-10-01 16:15:08 +0000656 call_rcu(&c->rcu, ipmr_cache_free_rcu);
Benjamin Thery5c0a66f2009-01-22 04:56:17 +0000657}
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659/* Destroy an unresolved cache entry, killing queued skbs
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000660 * and reporting error to netlink readers.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 */
Patrick McHardy0c122952010-04-13 05:03:22 +0000662static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663{
Patrick McHardy8de53df2010-04-15 13:29:28 +0200664 struct net *net = read_pnet(&mrt->net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 struct sk_buff *skb;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700666 struct nlmsgerr *e;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Patrick McHardy0c122952010-04-13 05:03:22 +0000668 atomic_dec(&mrt->cache_resolve_queue_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Jianjun Kongc354e122008-11-03 00:28:02 -0800670 while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700671 if (ip_hdr(skb)->version == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
673 nlh->nlmsg_type = NLMSG_ERROR;
Hong zhi guo573ce262013-03-27 06:47:04 +0000674 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 skb_trim(skb, nlh->nlmsg_len);
Hong zhi guo573ce262013-03-27 06:47:04 +0000676 e = nlmsg_data(nlh);
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700677 e->error = -ETIMEDOUT;
678 memset(&e->msg, 0, sizeof(e->msg));
Thomas Graf2942e902006-08-15 00:30:25 -0700679
Eric W. Biederman15e47302012-09-07 20:12:54 +0000680 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000681 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 kfree_skb(skb);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000683 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
685
Benjamin Thery5c0a66f2009-01-22 04:56:17 +0000686 ipmr_cache_free(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
Patrick McHardye258beb2010-04-13 05:03:19 +0000689/* Timer process for the unresolved queue. */
Patrick McHardye258beb2010-04-13 05:03:19 +0000690static void ipmr_expire_process(unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691{
Patrick McHardy0c122952010-04-13 05:03:22 +0000692 struct mr_table *mrt = (struct mr_table *)arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 unsigned long now;
694 unsigned long expires;
Patrick McHardy862465f2010-04-13 05:03:21 +0000695 struct mfc_cache *c, *next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 if (!spin_trylock(&mfc_unres_lock)) {
Patrick McHardy0c122952010-04-13 05:03:22 +0000698 mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 return;
700 }
701
Patrick McHardy0c122952010-04-13 05:03:22 +0000702 if (list_empty(&mrt->mfc_unres_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 goto out;
704
705 now = jiffies;
706 expires = 10*HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Patrick McHardy0c122952010-04-13 05:03:22 +0000708 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 if (time_after(c->mfc_un.unres.expires, now)) {
710 unsigned long interval = c->mfc_un.unres.expires - now;
711 if (interval < expires)
712 expires = interval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 continue;
714 }
715
Patrick McHardy862465f2010-04-13 05:03:21 +0000716 list_del(&c->list);
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +0000717 mroute_netlink_event(mrt, c, RTM_DELROUTE);
Patrick McHardy0c122952010-04-13 05:03:22 +0000718 ipmr_destroy_unres(mrt, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 }
720
Patrick McHardy0c122952010-04-13 05:03:22 +0000721 if (!list_empty(&mrt->mfc_unres_queue))
722 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724out:
725 spin_unlock(&mfc_unres_lock);
726}
727
728/* Fill oifs list. It is called under write locked mrt_lock. */
Patrick McHardy0c122952010-04-13 05:03:22 +0000729static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
Patrick McHardyd658f8a2010-04-13 05:03:20 +0000730 unsigned char *ttls)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731{
732 int vifi;
733
734 cache->mfc_un.res.minvif = MAXVIFS;
735 cache->mfc_un.res.maxvif = 0;
736 memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
737
Patrick McHardy0c122952010-04-13 05:03:22 +0000738 for (vifi = 0; vifi < mrt->maxvif; vifi++) {
739 if (VIF_EXISTS(mrt, vifi) &&
Benjamin Therycf958ae32009-01-22 04:56:16 +0000740 ttls[vifi] && ttls[vifi] < 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 cache->mfc_un.res.ttls[vifi] = ttls[vifi];
742 if (cache->mfc_un.res.minvif > vifi)
743 cache->mfc_un.res.minvif = vifi;
744 if (cache->mfc_un.res.maxvif <= vifi)
745 cache->mfc_un.res.maxvif = vifi + 1;
746 }
747 }
Nikolay Aleksandrov90b5ca12016-07-26 18:54:52 +0200748 cache->mfc_un.res.lastuse = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749}
750
Patrick McHardy0c122952010-04-13 05:03:22 +0000751static int vif_add(struct net *net, struct mr_table *mrt,
752 struct vifctl *vifc, int mrtsock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
754 int vifi = vifc->vifc_vifi;
Patrick McHardy0c122952010-04-13 05:03:22 +0000755 struct vif_device *v = &mrt->vif_table[vifi];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 struct net_device *dev;
757 struct in_device *in_dev;
Wang Chend6070322008-07-14 20:55:26 -0700758 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759
760 /* Is vif busy ? */
Patrick McHardy0c122952010-04-13 05:03:22 +0000761 if (VIF_EXISTS(mrt, vifi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 return -EADDRINUSE;
763
764 switch (vifc->vifc_flags) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 case VIFF_REGISTER:
Nikolay Aleksandrov1973a4e2015-11-26 15:23:48 +0100766 if (!ipmr_pimsm_enabled())
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +0100767 return -EINVAL;
768 /* Special Purpose VIF in PIM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 * All the packets will be sent to the daemon
770 */
Patrick McHardy0c122952010-04-13 05:03:22 +0000771 if (mrt->mroute_reg_vif_num >= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 return -EADDRINUSE;
Patrick McHardyf0ad0862010-04-13 05:03:23 +0000773 dev = ipmr_reg_vif(net, mrt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 if (!dev)
775 return -ENOBUFS;
Wang Chend6070322008-07-14 20:55:26 -0700776 err = dev_set_allmulti(dev, 1);
777 if (err) {
778 unregister_netdevice(dev);
Wang Chen7dc00c82008-07-14 20:56:34 -0700779 dev_put(dev);
Wang Chend6070322008-07-14 20:55:26 -0700780 return err;
781 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 break;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900783 case VIFF_TUNNEL:
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000784 dev = ipmr_new_tunnel(net, vifc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (!dev)
786 return -ENOBUFS;
Wang Chend6070322008-07-14 20:55:26 -0700787 err = dev_set_allmulti(dev, 1);
788 if (err) {
789 ipmr_del_tunnel(dev, vifc);
Wang Chen7dc00c82008-07-14 20:56:34 -0700790 dev_put(dev);
Wang Chend6070322008-07-14 20:55:26 -0700791 return err;
792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 break;
Ilia Kee5e81f2009-09-16 05:53:07 +0000794 case VIFF_USE_IFINDEX:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 case 0:
Ilia Kee5e81f2009-09-16 05:53:07 +0000796 if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
797 dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
Ian Morris51456b22015-04-03 09:17:26 +0100798 if (dev && !__in_dev_get_rtnl(dev)) {
Ilia Kee5e81f2009-09-16 05:53:07 +0000799 dev_put(dev);
800 return -EADDRNOTAVAIL;
801 }
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000802 } else {
Ilia Kee5e81f2009-09-16 05:53:07 +0000803 dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000804 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 if (!dev)
806 return -EADDRNOTAVAIL;
Wang Chend6070322008-07-14 20:55:26 -0700807 err = dev_set_allmulti(dev, 1);
Wang Chen7dc00c82008-07-14 20:56:34 -0700808 if (err) {
809 dev_put(dev);
Wang Chend6070322008-07-14 20:55:26 -0700810 return err;
Wang Chen7dc00c82008-07-14 20:56:34 -0700811 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 break;
813 default:
814 return -EINVAL;
815 }
816
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000817 in_dev = __in_dev_get_rtnl(dev);
818 if (!in_dev) {
Dan Carpenterd0490cf2009-11-11 02:03:54 +0000819 dev_put(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 return -EADDRNOTAVAIL;
Dan Carpenterd0490cf2009-11-11 02:03:54 +0000821 }
Herbert Xu42f811b2007-06-04 23:34:44 -0700822 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
David Ahern3b022862017-03-28 14:28:02 -0700823 inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_MC_FORWARDING,
824 dev->ifindex, &in_dev->cnf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 ip_rt_multicast_event(in_dev);
826
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000827 /* Fill in the VIF structures */
828
Jianjun Kongc354e122008-11-03 00:28:02 -0800829 v->rate_limit = vifc->vifc_rate_limit;
830 v->local = vifc->vifc_lcl_addr.s_addr;
831 v->remote = vifc->vifc_rmt_addr.s_addr;
832 v->flags = vifc->vifc_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 if (!mrtsock)
834 v->flags |= VIFF_STATIC;
Jianjun Kongc354e122008-11-03 00:28:02 -0800835 v->threshold = vifc->vifc_threshold;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 v->bytes_in = 0;
837 v->bytes_out = 0;
838 v->pkt_in = 0;
839 v->pkt_out = 0;
840 v->link = dev->ifindex;
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000841 if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
Nicolas Dichtela54acb32015-04-02 17:07:00 +0200842 v->link = dev_get_iflink(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
844 /* And finish update writing critical data */
845 write_lock_bh(&mrt_lock);
Jianjun Kongc354e122008-11-03 00:28:02 -0800846 v->dev = dev;
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000847 if (v->flags & VIFF_REGISTER)
Patrick McHardy0c122952010-04-13 05:03:22 +0000848 mrt->mroute_reg_vif_num = vifi;
Patrick McHardy0c122952010-04-13 05:03:22 +0000849 if (vifi+1 > mrt->maxvif)
850 mrt->maxvif = vifi+1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 write_unlock_bh(&mrt_lock);
852 return 0;
853}
854
Eric Dumazeta8c94862010-10-01 16:15:08 +0000855/* called with rcu_read_lock() */
Patrick McHardy0c122952010-04-13 05:03:22 +0000856static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
Benjamin Thery4feb88e2009-01-22 04:56:23 +0000857 __be32 origin,
858 __be32 mcastgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100860 struct mfc_cache_cmp_arg arg = {
861 .mfc_mcastgrp = mcastgrp,
862 .mfc_origin = origin
863 };
864 struct rhlist_head *tmp, *list;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 struct mfc_cache *c;
866
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100867 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
868 rhl_for_each_entry_rcu(c, tmp, list, mnode)
869 return c;
870
Patrick McHardy862465f2010-04-13 05:03:21 +0000871 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}
873
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000874/* Look for a (*,*,oif) entry */
875static struct mfc_cache *ipmr_cache_find_any_parent(struct mr_table *mrt,
876 int vifi)
877{
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100878 struct mfc_cache_cmp_arg arg = {
879 .mfc_mcastgrp = htonl(INADDR_ANY),
880 .mfc_origin = htonl(INADDR_ANY)
881 };
882 struct rhlist_head *tmp, *list;
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000883 struct mfc_cache *c;
884
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100885 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
886 rhl_for_each_entry_rcu(c, tmp, list, mnode)
887 if (c->mfc_un.res.ttls[vifi] < 255)
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000888 return c;
889
890 return NULL;
891}
892
893/* Look for a (*,G) entry */
894static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt,
895 __be32 mcastgrp, int vifi)
896{
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100897 struct mfc_cache_cmp_arg arg = {
898 .mfc_mcastgrp = mcastgrp,
899 .mfc_origin = htonl(INADDR_ANY)
900 };
901 struct rhlist_head *tmp, *list;
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000902 struct mfc_cache *c, *proxy;
903
Nicolas Dichtel360eb5d2013-01-22 11:18:03 +0100904 if (mcastgrp == htonl(INADDR_ANY))
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000905 goto skip;
906
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100907 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
908 rhl_for_each_entry_rcu(c, tmp, list, mnode) {
909 if (c->mfc_un.res.ttls[vifi] < 255)
910 return c;
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000911
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100912 /* It's ok if the vifi is part of the static tree */
913 proxy = ipmr_cache_find_any_parent(mrt, c->mfc_parent);
914 if (proxy && proxy->mfc_un.res.ttls[vifi] < 255)
915 return c;
916 }
Nicolas Dichtel660b26d2013-01-21 06:00:26 +0000917
918skip:
919 return ipmr_cache_find_any_parent(mrt, vifi);
920}
921
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +0100922/* Look for a (S,G,iif) entry if parent != -1 */
923static struct mfc_cache *ipmr_cache_find_parent(struct mr_table *mrt,
924 __be32 origin, __be32 mcastgrp,
925 int parent)
926{
927 struct mfc_cache_cmp_arg arg = {
928 .mfc_mcastgrp = mcastgrp,
929 .mfc_origin = origin,
930 };
931 struct rhlist_head *tmp, *list;
932 struct mfc_cache *c;
933
934 list = rhltable_lookup(&mrt->mfc_hash, &arg, ipmr_rht_params);
935 rhl_for_each_entry_rcu(c, tmp, list, mnode)
936 if (parent == -1 || parent == c->mfc_parent)
937 return c;
938
939 return NULL;
940}
941
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +0100942/* Allocate a multicast cache entry */
Patrick McHardyd658f8a2010-04-13 05:03:20 +0000943static struct mfc_cache *ipmr_cache_alloc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944{
Jianjun Kongc354e122008-11-03 00:28:02 -0800945 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
Eric Dumazeta8c94862010-10-01 16:15:08 +0000946
Tom Goff70a0dec2016-06-23 16:11:57 -0400947 if (c) {
948 c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
Eric Dumazeta8c94862010-10-01 16:15:08 +0000949 c->mfc_un.res.minvif = MAXVIFS;
Tom Goff70a0dec2016-06-23 16:11:57 -0400950 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 return c;
952}
953
Patrick McHardyd658f8a2010-04-13 05:03:20 +0000954static struct mfc_cache *ipmr_cache_alloc_unres(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955{
Jianjun Kongc354e122008-11-03 00:28:02 -0800956 struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
Eric Dumazeta8c94862010-10-01 16:15:08 +0000957
958 if (c) {
959 skb_queue_head_init(&c->mfc_un.unres.unresolved);
960 c->mfc_un.unres.expires = jiffies + 10*HZ;
961 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 return c;
963}
964
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +0100965/* A cache entry has gone into a resolved state from queued */
Patrick McHardy0c122952010-04-13 05:03:22 +0000966static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
967 struct mfc_cache *uc, struct mfc_cache *c)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968{
969 struct sk_buff *skb;
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700970 struct nlmsgerr *e;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000972 /* Play the pending entries through our router */
Jianjun Kongc354e122008-11-03 00:28:02 -0800973 while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700974 if (ip_hdr(skb)->version == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
976
Hong zhi guo573ce262013-03-27 06:47:04 +0000977 if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000978 nlh->nlmsg_len = skb_tail_pointer(skb) -
979 (u8 *)nlh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 } else {
981 nlh->nlmsg_type = NLMSG_ERROR;
Hong zhi guo573ce262013-03-27 06:47:04 +0000982 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 skb_trim(skb, nlh->nlmsg_len);
Hong zhi guo573ce262013-03-27 06:47:04 +0000984 e = nlmsg_data(nlh);
Patrick McHardy9ef1d4c2005-06-28 12:55:30 -0700985 e->error = -EMSGSIZE;
986 memset(&e->msg, 0, sizeof(e->msg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 }
Thomas Graf2942e902006-08-15 00:30:25 -0700988
Eric W. Biederman15e47302012-09-07 20:12:54 +0000989 rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000990 } else {
Donald Sharp4b1f0d32017-06-10 16:30:17 -0400991 ip_mr_forward(net, mrt, skb->dev, skb, c, 0);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +0000992 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
994}
995
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +0100996/* Bounce a cache query up to mrouted. We could use netlink for this but mrouted
997 * expects the following bizarre scheme.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 *
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +0100999 * Called under mrt_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 */
Patrick McHardy0c122952010-04-13 05:03:22 +00001001static int ipmr_cache_report(struct mr_table *mrt,
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001002 struct sk_buff *pkt, vifi_t vifi, int assert)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003{
Arnaldo Carvalho de Meloc9bdd4b2007-03-12 20:09:15 -03001004 const int ihl = ip_hdrlen(pkt);
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +01001005 struct sock *mroute_sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 struct igmphdr *igmp;
1007 struct igmpmsg *msg;
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +01001008 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 int ret;
1010
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (assert == IGMPMSG_WHOLEPKT)
1012 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
1013 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 skb = alloc_skb(128, GFP_ATOMIC);
1015
Stephen Hemminger132adf52007-03-08 20:44:43 -08001016 if (!skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 return -ENOBUFS;
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 if (assert == IGMPMSG_WHOLEPKT) {
1020 /* Ugly, but we have no choice with this interface.
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001021 * Duplicate old header, fix ihl, length etc.
1022 * And all this only to mangle msg->im_msgtype and
1023 * to set msg->im_mbz to "mbz" :-)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 */
Arnaldo Carvalho de Melo878c8142007-03-11 22:38:29 -03001025 skb_push(skb, sizeof(struct iphdr));
1026 skb_reset_network_header(skb);
Arnaldo Carvalho de Melobadff6d2007-03-13 13:06:52 -03001027 skb_reset_transport_header(skb);
Arnaldo Carvalho de Melo0272ffc2007-03-12 20:05:39 -03001028 msg = (struct igmpmsg *)skb_network_header(skb);
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -07001029 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 msg->im_msgtype = IGMPMSG_WHOLEPKT;
1031 msg->im_mbz = 0;
Patrick McHardy0c122952010-04-13 05:03:22 +00001032 msg->im_vif = mrt->mroute_reg_vif_num;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001033 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
1034 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
1035 sizeof(struct iphdr));
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +01001036 } else {
1037 /* Copy the IP header */
1038 skb_set_network_header(skb, skb->len);
1039 skb_put(skb, ihl);
1040 skb_copy_to_linear_data(skb, pkt->data, ihl);
1041 /* Flag to the kernel this is a route add */
1042 ip_hdr(skb)->protocol = 0;
1043 msg = (struct igmpmsg *)skb_network_header(skb);
1044 msg->im_vif = vifi;
1045 skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1046 /* Add our header */
Johannes Berg4df864c2017-06-16 14:29:21 +02001047 igmp = skb_put(skb, sizeof(struct igmphdr));
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +01001048 igmp->type = assert;
1049 msg->im_msgtype = assert;
1050 igmp->code = 0;
1051 ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
1052 skb->transport_header = skb->network_header;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001053 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
Eric Dumazet4c968702010-10-01 16:15:01 +00001055 rcu_read_lock();
1056 mroute_sk = rcu_dereference(mrt->mroute_sk);
Ian Morris51456b22015-04-03 09:17:26 +01001057 if (!mroute_sk) {
Eric Dumazet4c968702010-10-01 16:15:01 +00001058 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 kfree_skb(skb);
1060 return -EINVAL;
1061 }
1062
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001063 /* Deliver to mrouted */
Eric Dumazet4c968702010-10-01 16:15:01 +00001064 ret = sock_queue_rcv_skb(mroute_sk, skb);
1065 rcu_read_unlock();
Benjamin Thery70a269e2009-01-22 04:56:15 +00001066 if (ret < 0) {
Joe Perchese87cc472012-05-13 21:56:26 +00001067 net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 kfree_skb(skb);
1069 }
1070
1071 return ret;
1072}
1073
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001074/* Queue a packet for resolution. It gets locked cache entry! */
1075static int ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi,
Donald Sharp4b1f0d32017-06-10 16:30:17 -04001076 struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077{
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001078 const struct iphdr *iph = ip_hdr(skb);
1079 struct mfc_cache *c;
Patrick McHardy862465f2010-04-13 05:03:21 +00001080 bool found = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
1083 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy0c122952010-04-13 05:03:22 +00001084 list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
Patrick McHardye258beb2010-04-13 05:03:19 +00001085 if (c->mfc_mcastgrp == iph->daddr &&
Patrick McHardy862465f2010-04-13 05:03:21 +00001086 c->mfc_origin == iph->saddr) {
1087 found = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 break;
Patrick McHardy862465f2010-04-13 05:03:21 +00001089 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 }
1091
Patrick McHardy862465f2010-04-13 05:03:21 +00001092 if (!found) {
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001093 /* Create a new entry if allowable */
Patrick McHardy0c122952010-04-13 05:03:22 +00001094 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
Patrick McHardyd658f8a2010-04-13 05:03:20 +00001095 (c = ipmr_cache_alloc_unres()) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 spin_unlock_bh(&mfc_unres_lock);
1097
1098 kfree_skb(skb);
1099 return -ENOBUFS;
1100 }
1101
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001102 /* Fill in the new cache entry */
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001103 c->mfc_parent = -1;
1104 c->mfc_origin = iph->saddr;
1105 c->mfc_mcastgrp = iph->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001107 /* Reflect first query at mrouted. */
Patrick McHardy0c122952010-04-13 05:03:22 +00001108 err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001109 if (err < 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001110 /* If the report failed throw the cache entry
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 out - Brad Parker
1112 */
1113 spin_unlock_bh(&mfc_unres_lock);
1114
Benjamin Thery5c0a66f2009-01-22 04:56:17 +00001115 ipmr_cache_free(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 kfree_skb(skb);
1117 return err;
1118 }
1119
Patrick McHardy0c122952010-04-13 05:03:22 +00001120 atomic_inc(&mrt->cache_resolve_queue_len);
1121 list_add(&c->list, &mrt->mfc_unres_queue);
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00001122 mroute_netlink_event(mrt, c, RTM_NEWROUTE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
David S. Miller278554b2010-05-12 00:05:35 -07001124 if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
1125 mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 }
1127
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001128 /* See if we can append the packet */
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001129 if (c->mfc_un.unres.unresolved.qlen > 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 kfree_skb(skb);
1131 err = -ENOBUFS;
1132 } else {
Donald Sharp4b1f0d32017-06-10 16:30:17 -04001133 if (dev) {
1134 skb->dev = dev;
1135 skb->skb_iif = dev->ifindex;
1136 }
Jianjun Kongc354e122008-11-03 00:28:02 -08001137 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 err = 0;
1139 }
1140
1141 spin_unlock_bh(&mfc_unres_lock);
1142 return err;
1143}
1144
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001145/* MFC cache manipulation by user space mroute daemon */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001147static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001149 struct mfc_cache *c;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001151 /* The entries are added/deleted only under RTNL */
1152 rcu_read_lock();
1153 c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
1154 mfc->mfcc_mcastgrp.s_addr, parent);
1155 rcu_read_unlock();
1156 if (!c)
1157 return -ENOENT;
1158 rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params);
1159 list_del_rcu(&c->list);
1160 mroute_netlink_event(mrt, c, RTM_DELROUTE);
1161 ipmr_cache_free(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001163 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164}
1165
Patrick McHardy0c122952010-04-13 05:03:22 +00001166static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001167 struct mfcctl *mfc, int mrtsock, int parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168{
Patrick McHardy862465f2010-04-13 05:03:21 +00001169 struct mfc_cache *uc, *c;
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001170 bool found;
1171 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
Patrick McHardya50436f22010-03-17 06:04:14 +00001173 if (mfc->mfcc_parent >= MAXVIFS)
1174 return -ENFILE;
1175
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001176 /* The entries are added/deleted only under RTNL */
1177 rcu_read_lock();
1178 c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
1179 mfc->mfcc_mcastgrp.s_addr, parent);
1180 rcu_read_unlock();
1181 if (c) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 write_lock_bh(&mrt_lock);
1183 c->mfc_parent = mfc->mfcc_parent;
Patrick McHardy0c122952010-04-13 05:03:22 +00001184 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 if (!mrtsock)
1186 c->mfc_flags |= MFC_STATIC;
1187 write_unlock_bh(&mrt_lock);
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00001188 mroute_netlink_event(mrt, c, RTM_NEWROUTE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 return 0;
1190 }
1191
Nicolas Dichtel360eb5d2013-01-22 11:18:03 +01001192 if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) &&
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001193 !ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 return -EINVAL;
1195
Patrick McHardyd658f8a2010-04-13 05:03:20 +00001196 c = ipmr_cache_alloc();
Ian Morris51456b22015-04-03 09:17:26 +01001197 if (!c)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 return -ENOMEM;
1199
Jianjun Kongc354e122008-11-03 00:28:02 -08001200 c->mfc_origin = mfc->mfcc_origin.s_addr;
1201 c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
1202 c->mfc_parent = mfc->mfcc_parent;
Patrick McHardy0c122952010-04-13 05:03:22 +00001203 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 if (!mrtsock)
1205 c->mfc_flags |= MFC_STATIC;
1206
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001207 ret = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->mnode,
1208 ipmr_rht_params);
1209 if (ret) {
1210 pr_err("ipmr: rhtable insert error %d\n", ret);
1211 ipmr_cache_free(c);
1212 return ret;
1213 }
1214 list_add_tail_rcu(&c->list, &mrt->mfc_cache_list);
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001215 /* Check to see if we resolved a queued list. If so we
1216 * need to send on the frames and tidy up.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 */
Patrick McHardyb0ebb732010-04-15 13:29:28 +02001218 found = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy0c122952010-04-13 05:03:22 +00001220 list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
Patrick McHardye258beb2010-04-13 05:03:19 +00001221 if (uc->mfc_origin == c->mfc_origin &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 uc->mfc_mcastgrp == c->mfc_mcastgrp) {
Patrick McHardy862465f2010-04-13 05:03:21 +00001223 list_del(&uc->list);
Patrick McHardy0c122952010-04-13 05:03:22 +00001224 atomic_dec(&mrt->cache_resolve_queue_len);
Patrick McHardyb0ebb732010-04-15 13:29:28 +02001225 found = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 break;
1227 }
1228 }
Patrick McHardy0c122952010-04-13 05:03:22 +00001229 if (list_empty(&mrt->mfc_unres_queue))
1230 del_timer(&mrt->ipmr_expire_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 spin_unlock_bh(&mfc_unres_lock);
1232
Patrick McHardyb0ebb732010-04-15 13:29:28 +02001233 if (found) {
Patrick McHardy0c122952010-04-13 05:03:22 +00001234 ipmr_cache_resolve(net, mrt, uc, c);
Benjamin Thery5c0a66f2009-01-22 04:56:17 +00001235 ipmr_cache_free(uc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 }
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00001237 mroute_netlink_event(mrt, c, RTM_NEWROUTE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 return 0;
1239}
1240
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001241/* Close the multicast socket, and clear the vif tables etc */
Nikolay Aleksandrov0e615e92015-11-20 13:54:19 +01001242static void mroute_clean_tables(struct mr_table *mrt, bool all)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243{
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001244 struct mfc_cache *c, *tmp;
Eric Dumazetd17fa6f2009-10-28 05:21:38 +00001245 LIST_HEAD(list);
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001246 int i;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001247
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001248 /* Shut down all active vif entries */
Patrick McHardy0c122952010-04-13 05:03:22 +00001249 for (i = 0; i < mrt->maxvif; i++) {
Nikolay Aleksandrov0e615e92015-11-20 13:54:19 +01001250 if (!all && (mrt->vif_table[i].flags & VIFF_STATIC))
1251 continue;
1252 vif_delete(mrt, i, 0, &list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 }
Eric Dumazetd17fa6f2009-10-28 05:21:38 +00001254 unregister_netdevice_many(&list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001256 /* Wipe the cache */
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001257 list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
1258 if (!all && (c->mfc_flags & MFC_STATIC))
1259 continue;
1260 rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params);
1261 list_del_rcu(&c->list);
1262 mroute_netlink_event(mrt, c, RTM_DELROUTE);
1263 ipmr_cache_free(c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 }
1265
Patrick McHardy0c122952010-04-13 05:03:22 +00001266 if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 spin_lock_bh(&mfc_unres_lock);
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01001268 list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
Patrick McHardy862465f2010-04-13 05:03:21 +00001269 list_del(&c->list);
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00001270 mroute_netlink_event(mrt, c, RTM_DELROUTE);
Patrick McHardy0c122952010-04-13 05:03:22 +00001271 ipmr_destroy_unres(mrt, c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 }
1273 spin_unlock_bh(&mfc_unres_lock);
1274 }
1275}
1276
Eric Dumazet4c968702010-10-01 16:15:01 +00001277/* called from ip_ra_control(), before an RCU grace period,
1278 * we dont need to call synchronize_rcu() here
1279 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280static void mrtsock_destruct(struct sock *sk)
1281{
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001282 struct net *net = sock_net(sk);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001283 struct mr_table *mrt;
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001284
WANG Cong1215e512017-04-12 12:32:13 -07001285 ASSERT_RTNL();
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001286 ipmr_for_each_table(mrt, net) {
Eric Dumazet4c968702010-10-01 16:15:01 +00001287 if (sk == rtnl_dereference(mrt->mroute_sk)) {
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001288 IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
David Ahern3b022862017-03-28 14:28:02 -07001289 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
1290 NETCONFA_MC_FORWARDING,
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001291 NETCONFA_IFINDEX_ALL,
1292 net->ipv4.devconf_all);
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +00001293 RCU_INIT_POINTER(mrt->mroute_sk, NULL);
Nikolay Aleksandrov0e615e92015-11-20 13:54:19 +01001294 mroute_clean_tables(mrt, false);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001295 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297}
1298
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001299/* Socket options and virtual interface manipulation. The whole
1300 * virtual interface system is a complete heap, but unfortunately
1301 * that's how BSD mrouted happens to think. Maybe one day with a proper
1302 * MOSPF/PIM router set up we can clean this up.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001304
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001305int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval,
1306 unsigned int optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307{
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001308 struct net *net = sock_net(sk);
1309 int val, ret = 0, parent = 0;
1310 struct mr_table *mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 struct vifctl vif;
1312 struct mfcctl mfc;
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001313 u32 uval;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001314
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001315 /* There's one exception to the lock - MRT_DONE which needs to unlock */
1316 rtnl_lock();
Eric Dumazet5e1859f2012-11-25 06:41:45 +00001317 if (sk->sk_type != SOCK_RAW ||
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001318 inet_sk(sk)->inet_num != IPPROTO_IGMP) {
1319 ret = -EOPNOTSUPP;
1320 goto out_unlock;
1321 }
Eric Dumazet5e1859f2012-11-25 06:41:45 +00001322
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001323 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001324 if (!mrt) {
1325 ret = -ENOENT;
1326 goto out_unlock;
1327 }
Stephen Hemminger132adf52007-03-08 20:44:43 -08001328 if (optname != MRT_INIT) {
Eric Dumazet33d480c2011-08-11 19:30:52 +00001329 if (sk != rcu_access_pointer(mrt->mroute_sk) &&
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001330 !ns_capable(net->user_ns, CAP_NET_ADMIN)) {
1331 ret = -EACCES;
1332 goto out_unlock;
1333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 }
1335
Stephen Hemminger132adf52007-03-08 20:44:43 -08001336 switch (optname) {
1337 case MRT_INIT:
Nikolay Aleksandrov42e6b892015-11-26 15:23:49 +01001338 if (optlen != sizeof(int)) {
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001339 ret = -EINVAL;
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001340 break;
Nikolay Aleksandrov42e6b892015-11-26 15:23:49 +01001341 }
1342 if (rtnl_dereference(mrt->mroute_sk)) {
1343 ret = -EADDRINUSE;
1344 break;
1345 }
Stephen Hemminger132adf52007-03-08 20:44:43 -08001346
1347 ret = ip_ra_control(sk, 1, mrtsock_destruct);
1348 if (ret == 0) {
Eric Dumazetcf778b02012-01-12 04:41:32 +00001349 rcu_assign_pointer(mrt->mroute_sk, sk);
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001350 IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
David Ahern3b022862017-03-28 14:28:02 -07001351 inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
1352 NETCONFA_MC_FORWARDING,
Nicolas Dichteld67b8c62012-12-04 01:13:35 +00001353 NETCONFA_IFINDEX_ALL,
1354 net->ipv4.devconf_all);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001355 }
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001356 break;
Stephen Hemminger132adf52007-03-08 20:44:43 -08001357 case MRT_DONE:
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001358 if (sk != rcu_access_pointer(mrt->mroute_sk)) {
1359 ret = -EACCES;
1360 } else {
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001361 ret = ip_ra_control(sk, 0, NULL);
WANG Cong1215e512017-04-12 12:32:13 -07001362 goto out_unlock;
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001363 }
1364 break;
Stephen Hemminger132adf52007-03-08 20:44:43 -08001365 case MRT_ADD_VIF:
1366 case MRT_DEL_VIF:
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001367 if (optlen != sizeof(vif)) {
1368 ret = -EINVAL;
1369 break;
1370 }
1371 if (copy_from_user(&vif, optval, sizeof(vif))) {
1372 ret = -EFAULT;
1373 break;
1374 }
1375 if (vif.vifc_vifi >= MAXVIFS) {
1376 ret = -ENFILE;
1377 break;
1378 }
Jianjun Kongc354e122008-11-03 00:28:02 -08001379 if (optname == MRT_ADD_VIF) {
Eric Dumazet4c968702010-10-01 16:15:01 +00001380 ret = vif_add(net, mrt, &vif,
1381 sk == rtnl_dereference(mrt->mroute_sk));
Stephen Hemminger132adf52007-03-08 20:44:43 -08001382 } else {
Patrick McHardy0c122952010-04-13 05:03:22 +00001383 ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001384 }
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001385 break;
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001386 /* Manipulate the forwarding caches. These live
1387 * in a sort of kernel/user symbiosis.
1388 */
Stephen Hemminger132adf52007-03-08 20:44:43 -08001389 case MRT_ADD_MFC:
1390 case MRT_DEL_MFC:
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001391 parent = -1;
1392 case MRT_ADD_MFC_PROXY:
1393 case MRT_DEL_MFC_PROXY:
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001394 if (optlen != sizeof(mfc)) {
1395 ret = -EINVAL;
1396 break;
1397 }
1398 if (copy_from_user(&mfc, optval, sizeof(mfc))) {
1399 ret = -EFAULT;
1400 break;
1401 }
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001402 if (parent == 0)
1403 parent = mfc.mfcc_parent;
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001404 if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY)
1405 ret = ipmr_mfc_delete(mrt, &mfc, parent);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001406 else
Eric Dumazet4c968702010-10-01 16:15:01 +00001407 ret = ipmr_mfc_add(net, mrt, &mfc,
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001408 sk == rtnl_dereference(mrt->mroute_sk),
1409 parent);
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001410 break;
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001411 /* Control PIM assert. */
Stephen Hemminger132adf52007-03-08 20:44:43 -08001412 case MRT_ASSERT:
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001413 if (optlen != sizeof(val)) {
1414 ret = -EINVAL;
1415 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 }
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001417 if (get_user(val, (int __user *)optval)) {
1418 ret = -EFAULT;
1419 break;
1420 }
1421 mrt->mroute_do_assert = val;
1422 break;
1423 case MRT_PIM:
Nikolay Aleksandrov1973a4e2015-11-26 15:23:48 +01001424 if (!ipmr_pimsm_enabled()) {
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001425 ret = -ENOPROTOOPT;
1426 break;
1427 }
1428 if (optlen != sizeof(val)) {
1429 ret = -EINVAL;
1430 break;
1431 }
1432 if (get_user(val, (int __user *)optval)) {
1433 ret = -EFAULT;
1434 break;
1435 }
1436
1437 val = !!val;
1438 if (val != mrt->mroute_do_pim) {
1439 mrt->mroute_do_pim = val;
1440 mrt->mroute_do_assert = val;
1441 }
1442 break;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001443 case MRT_TABLE:
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001444 if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES)) {
1445 ret = -ENOPROTOOPT;
1446 break;
1447 }
1448 if (optlen != sizeof(uval)) {
1449 ret = -EINVAL;
1450 break;
1451 }
1452 if (get_user(uval, (u32 __user *)optval)) {
1453 ret = -EFAULT;
1454 break;
1455 }
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001456
Eric Dumazet4c968702010-10-01 16:15:01 +00001457 if (sk == rtnl_dereference(mrt->mroute_sk)) {
1458 ret = -EBUSY;
1459 } else {
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001460 mrt = ipmr_new_table(net, uval);
Nikolay Aleksandrov1113ebb2015-11-21 15:57:24 +01001461 if (IS_ERR(mrt))
1462 ret = PTR_ERR(mrt);
Eric Dumazet5e1859f2012-11-25 06:41:45 +00001463 else
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001464 raw_sk(sk)->ipmr_table = uval;
Eric Dumazet4c968702010-10-01 16:15:01 +00001465 }
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001466 break;
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001467 /* Spurious command, or MRT_VERSION which you cannot set. */
Stephen Hemminger132adf52007-03-08 20:44:43 -08001468 default:
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001469 ret = -ENOPROTOOPT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 }
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001471out_unlock:
1472 rtnl_unlock();
Nikolay Aleksandrov29e97d22015-11-21 15:57:31 +01001473 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474}
1475
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001476/* Getsock opt support for the multicast routing system. */
Jianjun Kongc354e122008-11-03 00:28:02 -08001477int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478{
1479 int olr;
1480 int val;
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001481 struct net *net = sock_net(sk);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001482 struct mr_table *mrt;
1483
Eric Dumazet5e1859f2012-11-25 06:41:45 +00001484 if (sk->sk_type != SOCK_RAW ||
1485 inet_sk(sk)->inet_num != IPPROTO_IGMP)
1486 return -EOPNOTSUPP;
1487
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001488 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
Ian Morris51456b22015-04-03 09:17:26 +01001489 if (!mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001490 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
Nikolay Aleksandrovfe9ef3c2015-11-21 15:57:28 +01001492 switch (optname) {
1493 case MRT_VERSION:
Jianjun Kongc354e122008-11-03 00:28:02 -08001494 val = 0x0305;
Nikolay Aleksandrovfe9ef3c2015-11-21 15:57:28 +01001495 break;
1496 case MRT_PIM:
Nikolay Aleksandrov1973a4e2015-11-26 15:23:48 +01001497 if (!ipmr_pimsm_enabled())
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +01001498 return -ENOPROTOOPT;
Patrick McHardy0c122952010-04-13 05:03:22 +00001499 val = mrt->mroute_do_pim;
Nikolay Aleksandrovfe9ef3c2015-11-21 15:57:28 +01001500 break;
1501 case MRT_ASSERT:
Patrick McHardy0c122952010-04-13 05:03:22 +00001502 val = mrt->mroute_do_assert;
Nikolay Aleksandrovfe9ef3c2015-11-21 15:57:28 +01001503 break;
1504 default:
1505 return -ENOPROTOOPT;
Nikolay Aleksandrovc316c622015-11-21 15:57:26 +01001506 }
Nikolay Aleksandrovfe9ef3c2015-11-21 15:57:28 +01001507
1508 if (get_user(olr, optlen))
1509 return -EFAULT;
1510 olr = min_t(unsigned int, olr, sizeof(int));
1511 if (olr < 0)
1512 return -EINVAL;
1513 if (put_user(olr, optlen))
1514 return -EFAULT;
Jianjun Kongc354e122008-11-03 00:28:02 -08001515 if (copy_to_user(optval, &val, olr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 return -EFAULT;
1517 return 0;
1518}
1519
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001520/* The IP multicast ioctl support routines. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1522{
1523 struct sioc_sg_req sr;
1524 struct sioc_vif_req vr;
1525 struct vif_device *vif;
1526 struct mfc_cache *c;
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001527 struct net *net = sock_net(sk);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001528 struct mr_table *mrt;
1529
1530 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
Ian Morris51456b22015-04-03 09:17:26 +01001531 if (!mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001532 return -ENOENT;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001533
Stephen Hemminger132adf52007-03-08 20:44:43 -08001534 switch (cmd) {
1535 case SIOCGETVIFCNT:
Jianjun Kongc354e122008-11-03 00:28:02 -08001536 if (copy_from_user(&vr, arg, sizeof(vr)))
Stephen Hemminger132adf52007-03-08 20:44:43 -08001537 return -EFAULT;
Patrick McHardy0c122952010-04-13 05:03:22 +00001538 if (vr.vifi >= mrt->maxvif)
Stephen Hemminger132adf52007-03-08 20:44:43 -08001539 return -EINVAL;
1540 read_lock(&mrt_lock);
Patrick McHardy0c122952010-04-13 05:03:22 +00001541 vif = &mrt->vif_table[vr.vifi];
1542 if (VIF_EXISTS(mrt, vr.vifi)) {
Jianjun Kongc354e122008-11-03 00:28:02 -08001543 vr.icount = vif->pkt_in;
1544 vr.ocount = vif->pkt_out;
1545 vr.ibytes = vif->bytes_in;
1546 vr.obytes = vif->bytes_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 read_unlock(&mrt_lock);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001548
Jianjun Kongc354e122008-11-03 00:28:02 -08001549 if (copy_to_user(arg, &vr, sizeof(vr)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 return -EFAULT;
Stephen Hemminger132adf52007-03-08 20:44:43 -08001551 return 0;
1552 }
1553 read_unlock(&mrt_lock);
1554 return -EADDRNOTAVAIL;
1555 case SIOCGETSGCNT:
Jianjun Kongc354e122008-11-03 00:28:02 -08001556 if (copy_from_user(&sr, arg, sizeof(sr)))
Stephen Hemminger132adf52007-03-08 20:44:43 -08001557 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
Eric Dumazeta8c94862010-10-01 16:15:08 +00001559 rcu_read_lock();
Patrick McHardy0c122952010-04-13 05:03:22 +00001560 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
Stephen Hemminger132adf52007-03-08 20:44:43 -08001561 if (c) {
1562 sr.pktcnt = c->mfc_un.res.pkt;
1563 sr.bytecnt = c->mfc_un.res.bytes;
1564 sr.wrong_if = c->mfc_un.res.wrong_if;
Eric Dumazeta8c94862010-10-01 16:15:08 +00001565 rcu_read_unlock();
Stephen Hemminger132adf52007-03-08 20:44:43 -08001566
Jianjun Kongc354e122008-11-03 00:28:02 -08001567 if (copy_to_user(arg, &sr, sizeof(sr)))
Stephen Hemminger132adf52007-03-08 20:44:43 -08001568 return -EFAULT;
1569 return 0;
1570 }
Eric Dumazeta8c94862010-10-01 16:15:08 +00001571 rcu_read_unlock();
Stephen Hemminger132adf52007-03-08 20:44:43 -08001572 return -EADDRNOTAVAIL;
1573 default:
1574 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 }
1576}
1577
Eric W. Biederman709b46e2011-01-29 16:15:56 +00001578#ifdef CONFIG_COMPAT
1579struct compat_sioc_sg_req {
1580 struct in_addr src;
1581 struct in_addr grp;
1582 compat_ulong_t pktcnt;
1583 compat_ulong_t bytecnt;
1584 compat_ulong_t wrong_if;
1585};
1586
David S. Millerca6b8bb02011-02-03 17:24:28 -08001587struct compat_sioc_vif_req {
1588 vifi_t vifi; /* Which iface */
1589 compat_ulong_t icount;
1590 compat_ulong_t ocount;
1591 compat_ulong_t ibytes;
1592 compat_ulong_t obytes;
1593};
1594
Eric W. Biederman709b46e2011-01-29 16:15:56 +00001595int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1596{
David S. Miller0033d5a2011-02-03 17:21:31 -08001597 struct compat_sioc_sg_req sr;
David S. Millerca6b8bb02011-02-03 17:24:28 -08001598 struct compat_sioc_vif_req vr;
1599 struct vif_device *vif;
Eric W. Biederman709b46e2011-01-29 16:15:56 +00001600 struct mfc_cache *c;
1601 struct net *net = sock_net(sk);
1602 struct mr_table *mrt;
1603
1604 mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
Ian Morris51456b22015-04-03 09:17:26 +01001605 if (!mrt)
Eric W. Biederman709b46e2011-01-29 16:15:56 +00001606 return -ENOENT;
1607
1608 switch (cmd) {
David S. Millerca6b8bb02011-02-03 17:24:28 -08001609 case SIOCGETVIFCNT:
1610 if (copy_from_user(&vr, arg, sizeof(vr)))
1611 return -EFAULT;
1612 if (vr.vifi >= mrt->maxvif)
1613 return -EINVAL;
1614 read_lock(&mrt_lock);
1615 vif = &mrt->vif_table[vr.vifi];
1616 if (VIF_EXISTS(mrt, vr.vifi)) {
1617 vr.icount = vif->pkt_in;
1618 vr.ocount = vif->pkt_out;
1619 vr.ibytes = vif->bytes_in;
1620 vr.obytes = vif->bytes_out;
1621 read_unlock(&mrt_lock);
1622
1623 if (copy_to_user(arg, &vr, sizeof(vr)))
1624 return -EFAULT;
1625 return 0;
1626 }
1627 read_unlock(&mrt_lock);
1628 return -EADDRNOTAVAIL;
Eric W. Biederman709b46e2011-01-29 16:15:56 +00001629 case SIOCGETSGCNT:
1630 if (copy_from_user(&sr, arg, sizeof(sr)))
1631 return -EFAULT;
1632
1633 rcu_read_lock();
1634 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
1635 if (c) {
1636 sr.pktcnt = c->mfc_un.res.pkt;
1637 sr.bytecnt = c->mfc_un.res.bytes;
1638 sr.wrong_if = c->mfc_un.res.wrong_if;
1639 rcu_read_unlock();
1640
1641 if (copy_to_user(arg, &sr, sizeof(sr)))
1642 return -EFAULT;
1643 return 0;
1644 }
1645 rcu_read_unlock();
1646 return -EADDRNOTAVAIL;
1647 default:
1648 return -ENOIOCTLCMD;
1649 }
1650}
1651#endif
1652
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1654{
Jiri Pirko351638e2013-05-28 01:30:21 +00001655 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001656 struct net *net = dev_net(dev);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001657 struct mr_table *mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 struct vif_device *v;
1659 int ct;
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001660
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 if (event != NETDEV_UNREGISTER)
1662 return NOTIFY_DONE;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001663
1664 ipmr_for_each_table(mrt, net) {
1665 v = &mrt->vif_table[0];
1666 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1667 if (v->dev == dev)
RongQing.Lie92036a2011-11-23 23:10:52 +00001668 vif_delete(mrt, ct, 1, NULL);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001669 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 }
1671 return NOTIFY_DONE;
1672}
1673
Jianjun Kongc354e122008-11-03 00:28:02 -08001674static struct notifier_block ip_mr_notifier = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 .notifier_call = ipmr_device_event,
1676};
1677
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001678/* Encapsulate a packet by attaching a valid IPIP header to it.
1679 * This avoids tunnel drivers and other mess and gives us the speed so
1680 * important for multicast video.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 */
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +01001682static void ip_encap(struct net *net, struct sk_buff *skb,
1683 __be32 saddr, __be32 daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684{
Arnaldo Carvalho de Melo8856dfa2007-03-10 19:40:39 -03001685 struct iphdr *iph;
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001686 const struct iphdr *old_iph = ip_hdr(skb);
Arnaldo Carvalho de Melo8856dfa2007-03-10 19:40:39 -03001687
1688 skb_push(skb, sizeof(struct iphdr));
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -07001689 skb->transport_header = skb->network_header;
Arnaldo Carvalho de Melo8856dfa2007-03-10 19:40:39 -03001690 skb_reset_network_header(skb);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001691 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001693 iph->version = 4;
Arnaldo Carvalho de Meloe023dd62007-03-12 20:09:36 -03001694 iph->tos = old_iph->tos;
1695 iph->ttl = old_iph->ttl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 iph->frag_off = 0;
1697 iph->daddr = daddr;
1698 iph->saddr = saddr;
1699 iph->protocol = IPPROTO_IPIP;
1700 iph->ihl = 5;
1701 iph->tot_len = htons(skb->len);
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +01001702 ip_select_ident(net, skb, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 ip_send_check(iph);
1704
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1706 nf_reset(skb);
1707}
1708
Eric W. Biederman0c4b51f2015-09-15 20:04:18 -05001709static inline int ipmr_forward_finish(struct net *net, struct sock *sk,
1710 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711{
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001712 struct ip_options *opt = &(IPCB(skb)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
David S. Miller73186df2015-11-03 13:41:45 -05001714 IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS);
1715 IP_ADD_STATS(net, IPSTATS_MIB_OUTOCTETS, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
1717 if (unlikely(opt->optlen))
1718 ip_forward_options(skb);
1719
Eric W. Biederman13206b62015-10-07 16:48:35 -05001720 return dst_output(net, sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721}
1722
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001723/* Processing handlers for ipmr_forward */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Patrick McHardy0c122952010-04-13 05:03:22 +00001725static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
1726 struct sk_buff *skb, struct mfc_cache *c, int vifi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001728 const struct iphdr *iph = ip_hdr(skb);
Patrick McHardy0c122952010-04-13 05:03:22 +00001729 struct vif_device *vif = &mrt->vif_table[vifi];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 struct net_device *dev;
1731 struct rtable *rt;
David S. Miller31e4543d2011-05-03 20:25:42 -07001732 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 int encap = 0;
1734
Ian Morris51456b22015-04-03 09:17:26 +01001735 if (!vif->dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 goto out_free;
1737
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 if (vif->flags & VIFF_REGISTER) {
1739 vif->pkt_out++;
Jianjun Kongc354e122008-11-03 00:28:02 -08001740 vif->bytes_out += skb->len;
Pavel Emelyanovcf3677a2008-05-21 14:17:33 -07001741 vif->dev->stats.tx_bytes += skb->len;
1742 vif->dev->stats.tx_packets++;
Patrick McHardy0c122952010-04-13 05:03:22 +00001743 ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
Ilpo Järvinen69ebbf52009-02-06 23:46:51 -08001744 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001747 if (vif->flags & VIFF_TUNNEL) {
David S. Miller31e4543d2011-05-03 20:25:42 -07001748 rt = ip_route_output_ports(net, &fl4, NULL,
David S. Miller78fbfd82011-03-12 00:00:52 -05001749 vif->remote, vif->local,
1750 0, 0,
1751 IPPROTO_IPIP,
1752 RT_TOS(iph->tos), vif->link);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001753 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 goto out_free;
1755 encap = sizeof(struct iphdr);
1756 } else {
David S. Miller31e4543d2011-05-03 20:25:42 -07001757 rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
David S. Miller78fbfd82011-03-12 00:00:52 -05001758 0, 0,
1759 IPPROTO_IPIP,
1760 RT_TOS(iph->tos), vif->link);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001761 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 goto out_free;
1763 }
1764
Changli Gaod8d1f302010-06-10 23:31:35 -07001765 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
Changli Gaod8d1f302010-06-10 23:31:35 -07001767 if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 /* Do not fragment multicasts. Alas, IPv4 does not
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001769 * allow to send ICMP, so that packets will disappear
1770 * to blackhole.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 */
David S. Miller73186df2015-11-03 13:41:45 -05001772 IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 ip_rt_put(rt);
1774 goto out_free;
1775 }
1776
Changli Gaod8d1f302010-06-10 23:31:35 -07001777 encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778
1779 if (skb_cow(skb, encap)) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001780 ip_rt_put(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 goto out_free;
1782 }
1783
1784 vif->pkt_out++;
Jianjun Kongc354e122008-11-03 00:28:02 -08001785 vif->bytes_out += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
Eric Dumazetadf30902009-06-02 05:19:30 +00001787 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -07001788 skb_dst_set(skb, &rt->dst);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07001789 ip_decrease_ttl(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790
1791 /* FIXME: forward and output firewalls used to be called here.
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001792 * What do we do with netfilter? -- RR
1793 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 if (vif->flags & VIFF_TUNNEL) {
Hannes Frederic Sowab6a77192015-03-25 17:07:44 +01001795 ip_encap(net, skb, vif->local, vif->remote);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 /* FIXME: extra output firewall step used to be here. --RR */
Pavel Emelyanov2f4c02d2008-05-21 14:16:14 -07001797 vif->dev->stats.tx_packets++;
1798 vif->dev->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 }
1800
Lance Richardson9ee6c5d2016-11-02 16:36:17 -04001801 IPCB(skb)->flags |= IPSKB_FORWARDED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001803 /* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 * not only before forwarding, but after forwarding on all output
1805 * interfaces. It is clear, if mrouter runs a multicasting
1806 * program, it should receive packets not depending to what interface
1807 * program is joined.
1808 * If we will not make it, the program will have to join on all
1809 * interfaces. On the other hand, multihoming host (or router, but
1810 * not mrouter) cannot join to more than one interface - it will
1811 * result in receiving multiple packets.
1812 */
Eric W. Biederman29a26a52015-09-15 20:04:16 -05001813 NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
1814 net, NULL, skb, skb->dev, dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 ipmr_forward_finish);
1816 return;
1817
1818out_free:
1819 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820}
1821
Patrick McHardy0c122952010-04-13 05:03:22 +00001822static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823{
1824 int ct;
Patrick McHardy0c122952010-04-13 05:03:22 +00001825
1826 for (ct = mrt->maxvif-1; ct >= 0; ct--) {
1827 if (mrt->vif_table[ct].dev == dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 break;
1829 }
1830 return ct;
1831}
1832
1833/* "local" means that we should preserve one skb (for local delivery) */
Rami Rosenc4854ec2013-07-20 15:09:28 +03001834static void ip_mr_forward(struct net *net, struct mr_table *mrt,
Donald Sharp4b1f0d32017-06-10 16:30:17 -04001835 struct net_device *dev, struct sk_buff *skb,
1836 struct mfc_cache *cache, int local)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837{
Donald Sharp4b1f0d32017-06-10 16:30:17 -04001838 int true_vifi = ipmr_find_vif(mrt, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 int psend = -1;
1840 int vif, ct;
1841
1842 vif = cache->mfc_parent;
1843 cache->mfc_un.res.pkt++;
1844 cache->mfc_un.res.bytes += skb->len;
Nikolay Aleksandrov43b9e122016-07-14 19:28:27 +03001845 cache->mfc_un.res.lastuse = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846
Nicolas Dichtel360eb5d2013-01-22 11:18:03 +01001847 if (cache->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) {
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001848 struct mfc_cache *cache_proxy;
1849
1850 /* For an (*,G) entry, we only check that the incomming
1851 * interface is part of the static tree.
1852 */
1853 cache_proxy = ipmr_cache_find_any_parent(mrt, vif);
1854 if (cache_proxy &&
1855 cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
1856 goto forward;
1857 }
1858
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001859 /* Wrong interface: drop packet and (maybe) send PIM assert. */
Donald Sharp4b1f0d32017-06-10 16:30:17 -04001860 if (mrt->vif_table[vif].dev != dev) {
David S. Millerc7537962010-11-11 17:07:48 -08001861 if (rt_is_output_route(skb_rtable(skb))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 /* It is our own packet, looped back.
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001863 * Very complicated situation...
1864 *
1865 * The best workaround until routing daemons will be
1866 * fixed is not to redistribute packet, if it was
1867 * send through wrong interface. It means, that
1868 * multicast applications WILL NOT work for
1869 * (S,G), which have default multicast route pointing
1870 * to wrong oif. In any case, it is not a good
1871 * idea to use multicasting applications on router.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 */
1873 goto dont_forward;
1874 }
1875
1876 cache->mfc_un.res.wrong_if++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
Patrick McHardy0c122952010-04-13 05:03:22 +00001878 if (true_vifi >= 0 && mrt->mroute_do_assert &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 /* pimsm uses asserts, when switching from RPT to SPT,
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001880 * so that we cannot check that packet arrived on an oif.
1881 * It is bad, but otherwise we would need to move pretty
1882 * large chunk of pimd to kernel. Ough... --ANK
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 */
Patrick McHardy0c122952010-04-13 05:03:22 +00001884 (mrt->mroute_do_pim ||
Benjamin Thery6f9374a2009-01-22 04:56:20 +00001885 cache->mfc_un.res.ttls[true_vifi] < 255) &&
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001886 time_after(jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1888 cache->mfc_un.res.last_assert = jiffies;
Patrick McHardy0c122952010-04-13 05:03:22 +00001889 ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 }
1891 goto dont_forward;
1892 }
1893
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001894forward:
Patrick McHardy0c122952010-04-13 05:03:22 +00001895 mrt->vif_table[vif].pkt_in++;
1896 mrt->vif_table[vif].bytes_in += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001898 /* Forward the frame */
Nicolas Dichtel360eb5d2013-01-22 11:18:03 +01001899 if (cache->mfc_origin == htonl(INADDR_ANY) &&
1900 cache->mfc_mcastgrp == htonl(INADDR_ANY)) {
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001901 if (true_vifi >= 0 &&
1902 true_vifi != cache->mfc_parent &&
1903 ip_hdr(skb)->ttl >
1904 cache->mfc_un.res.ttls[cache->mfc_parent]) {
1905 /* It's an (*,*) entry and the packet is not coming from
1906 * the upstream: forward the packet to the upstream
1907 * only.
1908 */
1909 psend = cache->mfc_parent;
1910 goto last_forward;
1911 }
1912 goto dont_forward;
1913 }
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001914 for (ct = cache->mfc_un.res.maxvif - 1;
1915 ct >= cache->mfc_un.res.minvif; ct--) {
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001916 /* For (*,G) entry, don't forward to the incoming interface */
Nicolas Dichtel360eb5d2013-01-22 11:18:03 +01001917 if ((cache->mfc_origin != htonl(INADDR_ANY) ||
1918 ct != true_vifi) &&
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001919 ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 if (psend != -1) {
1921 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001922
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 if (skb2)
Patrick McHardy0c122952010-04-13 05:03:22 +00001924 ipmr_queue_xmit(net, mrt, skb2, cache,
1925 psend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 }
Jianjun Kongc354e122008-11-03 00:28:02 -08001927 psend = ct;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 }
1929 }
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00001930last_forward:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 if (psend != -1) {
1932 if (local) {
1933 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001934
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 if (skb2)
Patrick McHardy0c122952010-04-13 05:03:22 +00001936 ipmr_queue_xmit(net, mrt, skb2, cache, psend);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 } else {
Patrick McHardy0c122952010-04-13 05:03:22 +00001938 ipmr_queue_xmit(net, mrt, skb, cache, psend);
Rami Rosenc4854ec2013-07-20 15:09:28 +03001939 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 }
1941 }
1942
1943dont_forward:
1944 if (!local)
1945 kfree_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946}
1947
David S. Miller417da662011-05-03 19:42:43 -07001948static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
David S. Milleree3f1aa2011-03-09 14:06:20 -08001949{
David S. Miller417da662011-05-03 19:42:43 -07001950 struct rtable *rt = skb_rtable(skb);
1951 struct iphdr *iph = ip_hdr(skb);
David S. Millerda919812011-03-12 02:04:50 -05001952 struct flowi4 fl4 = {
David S. Miller417da662011-05-03 19:42:43 -07001953 .daddr = iph->daddr,
1954 .saddr = iph->saddr,
Julian Anastasovb0fe4a32011-07-23 02:00:41 +00001955 .flowi4_tos = RT_TOS(iph->tos),
David S. Miller4fd551d2012-07-17 14:39:44 -07001956 .flowi4_oif = (rt_is_output_route(rt) ?
1957 skb->dev->ifindex : 0),
1958 .flowi4_iif = (rt_is_output_route(rt) ?
Pavel Emelyanov1fb94892012-08-08 21:53:36 +00001959 LOOPBACK_IFINDEX :
David S. Miller4fd551d2012-07-17 14:39:44 -07001960 skb->dev->ifindex),
David Millerb4869882012-07-01 02:03:01 +00001961 .flowi4_mark = skb->mark,
David S. Milleree3f1aa2011-03-09 14:06:20 -08001962 };
1963 struct mr_table *mrt;
1964 int err;
1965
David S. Millerda919812011-03-12 02:04:50 -05001966 err = ipmr_fib_lookup(net, &fl4, &mrt);
David S. Milleree3f1aa2011-03-09 14:06:20 -08001967 if (err)
1968 return ERR_PTR(err);
1969 return mrt;
1970}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01001972/* Multicast packets for forwarding arrive here
1973 * Called with rcu_read_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975int ip_mr_input(struct sk_buff *skb)
1976{
1977 struct mfc_cache *cache;
Benjamin Thery4feb88e2009-01-22 04:56:23 +00001978 struct net *net = dev_net(skb->dev);
Eric Dumazet511c3f92009-06-02 05:14:27 +00001979 int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00001980 struct mr_table *mrt;
Thomas Winterbcfc7d32017-05-16 10:14:44 +12001981 struct net_device *dev;
1982
1983 /* skb->dev passed in is the loX master dev for vrfs.
1984 * As there are no vifs associated with loopback devices,
1985 * get the proper interface that does have a vif associated with it.
1986 */
1987 dev = skb->dev;
1988 if (netif_is_l3_master(skb->dev)) {
1989 dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
1990 if (!dev) {
1991 kfree_skb(skb);
1992 return -ENODEV;
1993 }
1994 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995
1996 /* Packet is looped back after forward, it should not be
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00001997 * forwarded second time, but still can be delivered locally.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 */
Eric Dumazet4c968702010-10-01 16:15:01 +00001999 if (IPCB(skb)->flags & IPSKB_FORWARDED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 goto dont_forward;
2001
David S. Miller417da662011-05-03 19:42:43 -07002002 mrt = ipmr_rt_fib_lookup(net, skb);
David S. Milleree3f1aa2011-03-09 14:06:20 -08002003 if (IS_ERR(mrt)) {
2004 kfree_skb(skb);
2005 return PTR_ERR(mrt);
Ben Greeare40dbc52010-07-15 13:22:33 +00002006 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 if (!local) {
Eric Dumazet4c968702010-10-01 16:15:01 +00002008 if (IPCB(skb)->opt.router_alert) {
2009 if (ip_call_ra_chain(skb))
2010 return 0;
2011 } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) {
2012 /* IGMPv1 (and broken IGMPv2 implementations sort of
2013 * Cisco IOS <= 11.2(8)) do not put router alert
2014 * option to IGMP packets destined to routable
2015 * groups. It is very bad, because it means
2016 * that we can forward NO IGMP messages.
2017 */
2018 struct sock *mroute_sk;
2019
2020 mroute_sk = rcu_dereference(mrt->mroute_sk);
2021 if (mroute_sk) {
2022 nf_reset(skb);
2023 raw_rcv(mroute_sk, skb);
2024 return 0;
2025 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 }
2027 }
2028
Eric Dumazeta8c94862010-10-01 16:15:08 +00002029 /* already under rcu_read_lock() */
Patrick McHardy0c122952010-04-13 05:03:22 +00002030 cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
Ian Morris51456b22015-04-03 09:17:26 +01002031 if (!cache) {
Thomas Winterbcfc7d32017-05-16 10:14:44 +12002032 int vif = ipmr_find_vif(mrt, dev);
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002033
2034 if (vif >= 0)
2035 cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr,
2036 vif);
2037 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01002039 /* No usable cache entry */
Ian Morris51456b22015-04-03 09:17:26 +01002040 if (!cache) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 int vif;
2042
2043 if (local) {
2044 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2045 ip_local_deliver(skb);
Ian Morris51456b22015-04-03 09:17:26 +01002046 if (!skb2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 skb = skb2;
2049 }
2050
Eric Dumazeta8c94862010-10-01 16:15:08 +00002051 read_lock(&mrt_lock);
Thomas Winterbcfc7d32017-05-16 10:14:44 +12002052 vif = ipmr_find_vif(mrt, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 if (vif >= 0) {
Donald Sharp4b1f0d32017-06-10 16:30:17 -04002054 int err2 = ipmr_cache_unresolved(mrt, vif, skb, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 read_unlock(&mrt_lock);
2056
Eric Dumazet0eae88f2010-04-20 19:06:52 -07002057 return err2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 }
2059 read_unlock(&mrt_lock);
2060 kfree_skb(skb);
2061 return -ENODEV;
2062 }
2063
Eric Dumazeta8c94862010-10-01 16:15:08 +00002064 read_lock(&mrt_lock);
Donald Sharp4b1f0d32017-06-10 16:30:17 -04002065 ip_mr_forward(net, mrt, dev, skb, cache, local);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 read_unlock(&mrt_lock);
2067
2068 if (local)
2069 return ip_local_deliver(skb);
2070
2071 return 0;
2072
2073dont_forward:
2074 if (local)
2075 return ip_local_deliver(skb);
2076 kfree_skb(skb);
2077 return 0;
2078}
2079
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002080#ifdef CONFIG_IP_PIMSM_V1
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01002081/* Handle IGMP messages of PIMv1 */
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002082int pim_rcv_v1(struct sk_buff *skb)
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002083{
2084 struct igmphdr *pim;
Benjamin Thery4feb88e2009-01-22 04:56:23 +00002085 struct net *net = dev_net(skb->dev);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002086 struct mr_table *mrt;
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002087
2088 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
2089 goto drop;
2090
2091 pim = igmp_hdr(skb);
2092
David S. Miller417da662011-05-03 19:42:43 -07002093 mrt = ipmr_rt_fib_lookup(net, skb);
David S. Milleree3f1aa2011-03-09 14:06:20 -08002094 if (IS_ERR(mrt))
2095 goto drop;
Patrick McHardy0c122952010-04-13 05:03:22 +00002096 if (!mrt->mroute_do_pim ||
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002097 pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
2098 goto drop;
2099
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002100 if (__pim_rcv(mrt, skb, sizeof(*pim))) {
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002101drop:
2102 kfree_skb(skb);
2103 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 return 0;
2105}
2106#endif
2107
2108#ifdef CONFIG_IP_PIMSM_V2
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002109static int pim_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110{
2111 struct pimreghdr *pim;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002112 struct net *net = dev_net(skb->dev);
2113 struct mr_table *mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002115 if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 goto drop;
2117
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07002118 pim = (struct pimreghdr *)skb_transport_header(skb);
Nikolay Aleksandrov56245ca2016-10-31 13:21:04 +01002119 if (pim->type != ((PIM_VERSION << 4) | (PIM_TYPE_REGISTER)) ||
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002120 (pim->flags & PIM_NULL_REGISTER) ||
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002121 (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
Al Virod3bc23e2006-11-14 21:24:49 -08002122 csum_fold(skb_checksum(skb, 0, skb->len, 0))))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123 goto drop;
2124
David S. Miller417da662011-05-03 19:42:43 -07002125 mrt = ipmr_rt_fib_lookup(net, skb);
David S. Milleree3f1aa2011-03-09 14:06:20 -08002126 if (IS_ERR(mrt))
2127 goto drop;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002128 if (__pim_rcv(mrt, skb, sizeof(*pim))) {
Ilpo Järvinenb1879202008-12-16 01:15:11 -08002129drop:
2130 kfree_skb(skb);
2131 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 return 0;
2133}
2134#endif
2135
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002136static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2137 struct mfc_cache *c, struct rtmsg *rtm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138{
Nicolas Dichteladfa85e2012-12-04 01:13:37 +00002139 struct rta_mfc_stats mfcs;
Nikolay Aleksandrov43b9e122016-07-14 19:28:27 +03002140 struct nlattr *mp_attr;
2141 struct rtnexthop *nhp;
Nikolay Aleksandrovb5036cd2016-09-20 16:17:22 +02002142 unsigned long lastuse;
Nikolay Aleksandrov43b9e122016-07-14 19:28:27 +03002143 int ct;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144
Nicolas Dichtel74381892010-03-25 23:45:35 +00002145 /* If cache is unresolved, don't try to parse IIF and OIF */
Nikolay Aleksandrov1708ebc2017-01-03 12:13:39 +01002146 if (c->mfc_parent >= MAXVIFS) {
2147 rtm->rtm_flags |= RTNH_F_UNRESOLVED;
Nicolas Dichtel74381892010-03-25 23:45:35 +00002148 return -ENOENT;
Nikolay Aleksandrov1708ebc2017-01-03 12:13:39 +01002149 }
Nicolas Dichtel74381892010-03-25 23:45:35 +00002150
Thomas Graf92a395e2012-06-26 23:36:13 +00002151 if (VIF_EXISTS(mrt, c->mfc_parent) &&
2152 nla_put_u32(skb, RTA_IIF, mrt->vif_table[c->mfc_parent].dev->ifindex) < 0)
2153 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154
Thomas Graf92a395e2012-06-26 23:36:13 +00002155 if (!(mp_attr = nla_nest_start(skb, RTA_MULTIPATH)))
2156 return -EMSGSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157
2158 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
Patrick McHardy0c122952010-04-13 05:03:22 +00002159 if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
Thomas Graf92a395e2012-06-26 23:36:13 +00002160 if (!(nhp = nla_reserve_nohdr(skb, sizeof(*nhp)))) {
2161 nla_nest_cancel(skb, mp_attr);
2162 return -EMSGSIZE;
2163 }
2164
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165 nhp->rtnh_flags = 0;
2166 nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
Patrick McHardy0c122952010-04-13 05:03:22 +00002167 nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 nhp->rtnh_len = sizeof(*nhp);
2169 }
2170 }
Thomas Graf92a395e2012-06-26 23:36:13 +00002171
2172 nla_nest_end(skb, mp_attr);
2173
Nikolay Aleksandrovb5036cd2016-09-20 16:17:22 +02002174 lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2175 lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2176
Nicolas Dichteladfa85e2012-12-04 01:13:37 +00002177 mfcs.mfcs_packets = c->mfc_un.res.pkt;
2178 mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2179 mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
Nikolay Aleksandrov43b9e122016-07-14 19:28:27 +03002180 if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
Nikolay Aleksandrovb5036cd2016-09-20 16:17:22 +02002181 nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
Nikolay Aleksandrov43b9e122016-07-14 19:28:27 +03002182 RTA_PAD))
Nicolas Dichteladfa85e2012-12-04 01:13:37 +00002183 return -EMSGSIZE;
2184
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 rtm->rtm_type = RTN_MULTICAST;
2186 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187}
2188
David S. Miller9a1b9492011-05-04 12:18:54 -07002189int ipmr_get_route(struct net *net, struct sk_buff *skb,
2190 __be32 saddr, __be32 daddr,
David Ahern9f09eae2017-01-06 17:39:06 -08002191 struct rtmsg *rtm, u32 portid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 struct mfc_cache *cache;
David S. Miller9a1b9492011-05-04 12:18:54 -07002194 struct mr_table *mrt;
2195 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002197 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
Ian Morris51456b22015-04-03 09:17:26 +01002198 if (!mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002199 return -ENOENT;
2200
Eric Dumazeta8c94862010-10-01 16:15:08 +00002201 rcu_read_lock();
David S. Miller9a1b9492011-05-04 12:18:54 -07002202 cache = ipmr_cache_find(mrt, saddr, daddr);
Ian Morris51456b22015-04-03 09:17:26 +01002203 if (!cache && skb->dev) {
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002204 int vif = ipmr_find_vif(mrt, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205
Nicolas Dichtel660b26d2013-01-21 06:00:26 +00002206 if (vif >= 0)
2207 cache = ipmr_cache_find_any(mrt, daddr, vif);
2208 }
Ian Morris51456b22015-04-03 09:17:26 +01002209 if (!cache) {
Alexey Kuznetsov72287492006-07-25 16:45:12 -07002210 struct sk_buff *skb2;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002211 struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212 struct net_device *dev;
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002213 int vif = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 dev = skb->dev;
Eric Dumazeta8c94862010-10-01 16:15:08 +00002216 read_lock(&mrt_lock);
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002217 if (dev)
2218 vif = ipmr_find_vif(mrt, dev);
2219 if (vif < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 read_unlock(&mrt_lock);
Eric Dumazeta8c94862010-10-01 16:15:08 +00002221 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 return -ENODEV;
2223 }
Alexey Kuznetsov72287492006-07-25 16:45:12 -07002224 skb2 = skb_clone(skb, GFP_ATOMIC);
2225 if (!skb2) {
2226 read_unlock(&mrt_lock);
Eric Dumazeta8c94862010-10-01 16:15:08 +00002227 rcu_read_unlock();
Alexey Kuznetsov72287492006-07-25 16:45:12 -07002228 return -ENOMEM;
2229 }
2230
Nikolay Aleksandrov2cf75072016-09-25 23:08:31 +02002231 NETLINK_CB(skb2).portid = portid;
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -07002232 skb_push(skb2, sizeof(struct iphdr));
2233 skb_reset_network_header(skb2);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002234 iph = ip_hdr(skb2);
2235 iph->ihl = sizeof(struct iphdr) >> 2;
David S. Miller9a1b9492011-05-04 12:18:54 -07002236 iph->saddr = saddr;
2237 iph->daddr = daddr;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -07002238 iph->version = 0;
Donald Sharp4b1f0d32017-06-10 16:30:17 -04002239 err = ipmr_cache_unresolved(mrt, vif, skb2, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 read_unlock(&mrt_lock);
Eric Dumazeta8c94862010-10-01 16:15:08 +00002241 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 return err;
2243 }
2244
Eric Dumazeta8c94862010-10-01 16:15:08 +00002245 read_lock(&mrt_lock);
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002246 err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 read_unlock(&mrt_lock);
Eric Dumazeta8c94862010-10-01 16:15:08 +00002248 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 return err;
2250}
2251
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002252static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
Nicolas Dichtel65886f42014-03-19 17:47:50 +01002253 u32 portid, u32 seq, struct mfc_cache *c, int cmd,
2254 int flags)
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002255{
2256 struct nlmsghdr *nlh;
2257 struct rtmsg *rtm;
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002258 int err;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002259
Nicolas Dichtel65886f42014-03-19 17:47:50 +01002260 nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
Ian Morris51456b22015-04-03 09:17:26 +01002261 if (!nlh)
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002262 return -EMSGSIZE;
2263
2264 rtm = nlmsg_data(nlh);
2265 rtm->rtm_family = RTNL_FAMILY_IPMR;
2266 rtm->rtm_dst_len = 32;
2267 rtm->rtm_src_len = 32;
2268 rtm->rtm_tos = 0;
2269 rtm->rtm_table = mrt->id;
David S. Millerf3756b72012-04-01 20:39:02 -04002270 if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2271 goto nla_put_failure;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002272 rtm->rtm_type = RTN_MULTICAST;
2273 rtm->rtm_scope = RT_SCOPE_UNIVERSE;
Nicolas Dichtel9a68ac72012-12-04 01:13:38 +00002274 if (c->mfc_flags & MFC_STATIC)
2275 rtm->rtm_protocol = RTPROT_STATIC;
2276 else
2277 rtm->rtm_protocol = RTPROT_MROUTED;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002278 rtm->rtm_flags = 0;
2279
Jiri Benc930345e2015-03-29 16:59:25 +02002280 if (nla_put_in_addr(skb, RTA_SRC, c->mfc_origin) ||
2281 nla_put_in_addr(skb, RTA_DST, c->mfc_mcastgrp))
David S. Millerf3756b72012-04-01 20:39:02 -04002282 goto nla_put_failure;
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002283 err = __ipmr_fill_mroute(mrt, skb, c, rtm);
2284 /* do not break the dump if cache is unresolved */
2285 if (err < 0 && err != -ENOENT)
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002286 goto nla_put_failure;
2287
Johannes Berg053c0952015-01-16 22:09:00 +01002288 nlmsg_end(skb, nlh);
2289 return 0;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002290
2291nla_put_failure:
2292 nlmsg_cancel(skb, nlh);
2293 return -EMSGSIZE;
2294}
2295
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00002296static size_t mroute_msgsize(bool unresolved, int maxvif)
2297{
2298 size_t len =
2299 NLMSG_ALIGN(sizeof(struct rtmsg))
2300 + nla_total_size(4) /* RTA_TABLE */
2301 + nla_total_size(4) /* RTA_SRC */
2302 + nla_total_size(4) /* RTA_DST */
2303 ;
2304
2305 if (!unresolved)
2306 len = len
2307 + nla_total_size(4) /* RTA_IIF */
2308 + nla_total_size(0) /* RTA_MULTIPATH */
2309 + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2310 /* RTA_MFC_STATS */
Nicolas Dichtela9a08042016-04-21 18:58:26 +02002311 + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00002312 ;
2313
2314 return len;
2315}
2316
2317static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
2318 int cmd)
2319{
2320 struct net *net = read_pnet(&mrt->net);
2321 struct sk_buff *skb;
2322 int err = -ENOBUFS;
2323
2324 skb = nlmsg_new(mroute_msgsize(mfc->mfc_parent >= MAXVIFS, mrt->maxvif),
2325 GFP_ATOMIC);
Ian Morris51456b22015-04-03 09:17:26 +01002326 if (!skb)
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00002327 goto errout;
2328
Nicolas Dichtel65886f42014-03-19 17:47:50 +01002329 err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
Nicolas Dichtel8cd3ac92012-12-04 01:13:40 +00002330 if (err < 0)
2331 goto errout;
2332
2333 rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC);
2334 return;
2335
2336errout:
2337 kfree_skb(skb);
2338 if (err < 0)
2339 rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err);
2340}
2341
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002342static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2343{
2344 struct net *net = sock_net(skb->sk);
2345 struct mr_table *mrt;
2346 struct mfc_cache *mfc;
2347 unsigned int t = 0, s_t;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002348 unsigned int e = 0, s_e;
2349
2350 s_t = cb->args[0];
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002351 s_e = cb->args[1];
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002352
Eric Dumazeta8c94862010-10-01 16:15:08 +00002353 rcu_read_lock();
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002354 ipmr_for_each_table(mrt, net) {
2355 if (t < s_t)
2356 goto next_table;
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002357 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) {
2358 if (e < s_e)
2359 goto next_entry;
2360 if (ipmr_fill_mroute(mrt, skb,
2361 NETLINK_CB(cb->skb).portid,
2362 cb->nlh->nlmsg_seq,
2363 mfc, RTM_NEWROUTE,
2364 NLM_F_MULTI) < 0)
2365 goto done;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002366next_entry:
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002367 e++;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002368 }
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002369 e = 0;
2370 s_e = 0;
2371
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002372 spin_lock_bh(&mfc_unres_lock);
2373 list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
2374 if (e < s_e)
2375 goto next_entry2;
2376 if (ipmr_fill_mroute(mrt, skb,
2377 NETLINK_CB(cb->skb).portid,
2378 cb->nlh->nlmsg_seq,
Nicolas Dichtel65886f42014-03-19 17:47:50 +01002379 mfc, RTM_NEWROUTE,
2380 NLM_F_MULTI) < 0) {
Nicolas Dichtel1eb99af2012-12-04 01:13:39 +00002381 spin_unlock_bh(&mfc_unres_lock);
2382 goto done;
2383 }
2384next_entry2:
2385 e++;
2386 }
2387 spin_unlock_bh(&mfc_unres_lock);
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002388 e = 0;
2389 s_e = 0;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002390next_table:
2391 t++;
2392 }
2393done:
Eric Dumazeta8c94862010-10-01 16:15:08 +00002394 rcu_read_unlock();
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002395
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002396 cb->args[1] = e;
Patrick McHardycb6a4e42010-04-26 16:02:08 +02002397 cb->args[0] = t;
2398
2399 return skb->len;
2400}
2401
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +01002402static const struct nla_policy rtm_ipmr_policy[RTA_MAX + 1] = {
2403 [RTA_SRC] = { .type = NLA_U32 },
2404 [RTA_DST] = { .type = NLA_U32 },
2405 [RTA_IIF] = { .type = NLA_U32 },
2406 [RTA_TABLE] = { .type = NLA_U32 },
2407 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
2408};
2409
2410static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol)
2411{
2412 switch (rtm_protocol) {
2413 case RTPROT_STATIC:
2414 case RTPROT_MROUTED:
2415 return true;
2416 }
2417 return false;
2418}
2419
2420static int ipmr_nla_get_ttls(const struct nlattr *nla, struct mfcctl *mfcc)
2421{
2422 struct rtnexthop *rtnh = nla_data(nla);
2423 int remaining = nla_len(nla), vifi = 0;
2424
2425 while (rtnh_ok(rtnh, remaining)) {
2426 mfcc->mfcc_ttls[vifi] = rtnh->rtnh_hops;
2427 if (++vifi == MAXVIFS)
2428 break;
2429 rtnh = rtnh_next(rtnh, &remaining);
2430 }
2431
2432 return remaining > 0 ? -EINVAL : vifi;
2433}
2434
2435/* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */
2436static int rtm_to_ipmr_mfcc(struct net *net, struct nlmsghdr *nlh,
2437 struct mfcctl *mfcc, int *mrtsock,
David Ahernc21ef3e2017-04-16 09:48:24 -07002438 struct mr_table **mrtret,
2439 struct netlink_ext_ack *extack)
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +01002440{
2441 struct net_device *dev = NULL;
2442 u32 tblid = RT_TABLE_DEFAULT;
2443 struct mr_table *mrt;
2444 struct nlattr *attr;
2445 struct rtmsg *rtm;
2446 int ret, rem;
2447
Johannes Bergfceb6432017-04-12 14:34:07 +02002448 ret = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipmr_policy,
David Ahernc21ef3e2017-04-16 09:48:24 -07002449 extack);
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +01002450 if (ret < 0)
2451 goto out;
2452 rtm = nlmsg_data(nlh);
2453
2454 ret = -EINVAL;
2455 if (rtm->rtm_family != RTNL_FAMILY_IPMR || rtm->rtm_dst_len != 32 ||
2456 rtm->rtm_type != RTN_MULTICAST ||
2457 rtm->rtm_scope != RT_SCOPE_UNIVERSE ||
2458 !ipmr_rtm_validate_proto(rtm->rtm_protocol))
2459 goto out;
2460
2461 memset(mfcc, 0, sizeof(*mfcc));
2462 mfcc->mfcc_parent = -1;
2463 ret = 0;
2464 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), rem) {
2465 switch (nla_type(attr)) {
2466 case RTA_SRC:
2467 mfcc->mfcc_origin.s_addr = nla_get_be32(attr);
2468 break;
2469 case RTA_DST:
2470 mfcc->mfcc_mcastgrp.s_addr = nla_get_be32(attr);
2471 break;
2472 case RTA_IIF:
2473 dev = __dev_get_by_index(net, nla_get_u32(attr));
2474 if (!dev) {
2475 ret = -ENODEV;
2476 goto out;
2477 }
2478 break;
2479 case RTA_MULTIPATH:
2480 if (ipmr_nla_get_ttls(attr, mfcc) < 0) {
2481 ret = -EINVAL;
2482 goto out;
2483 }
2484 break;
2485 case RTA_PREFSRC:
2486 ret = 1;
2487 break;
2488 case RTA_TABLE:
2489 tblid = nla_get_u32(attr);
2490 break;
2491 }
2492 }
2493 mrt = ipmr_get_table(net, tblid);
2494 if (!mrt) {
2495 ret = -ENOENT;
2496 goto out;
2497 }
2498 *mrtret = mrt;
2499 *mrtsock = rtm->rtm_protocol == RTPROT_MROUTED ? 1 : 0;
2500 if (dev)
2501 mfcc->mfcc_parent = ipmr_find_vif(mrt, dev);
2502
2503out:
2504 return ret;
2505}
2506
2507/* takes care of both newroute and delroute */
David Ahernc21ef3e2017-04-16 09:48:24 -07002508static int ipmr_rtm_route(struct sk_buff *skb, struct nlmsghdr *nlh,
2509 struct netlink_ext_ack *extack)
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +01002510{
2511 struct net *net = sock_net(skb->sk);
2512 int ret, mrtsock, parent;
2513 struct mr_table *tbl;
2514 struct mfcctl mfcc;
2515
2516 mrtsock = 0;
2517 tbl = NULL;
David Ahernc21ef3e2017-04-16 09:48:24 -07002518 ret = rtm_to_ipmr_mfcc(net, nlh, &mfcc, &mrtsock, &tbl, extack);
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +01002519 if (ret < 0)
2520 return ret;
2521
2522 parent = ret ? mfcc.mfcc_parent : -1;
2523 if (nlh->nlmsg_type == RTM_NEWROUTE)
2524 return ipmr_mfc_add(net, tbl, &mfcc, mrtsock, parent);
2525 else
2526 return ipmr_mfc_delete(tbl, &mfcc, parent);
2527}
2528
Nikolay Aleksandrov772c3442017-06-07 18:02:32 +03002529static bool ipmr_fill_table(struct mr_table *mrt, struct sk_buff *skb)
2530{
2531 u32 queue_len = atomic_read(&mrt->cache_resolve_queue_len);
2532
2533 if (nla_put_u32(skb, IPMRA_TABLE_ID, mrt->id) ||
2534 nla_put_u32(skb, IPMRA_TABLE_CACHE_RES_QUEUE_LEN, queue_len) ||
2535 nla_put_s32(skb, IPMRA_TABLE_MROUTE_REG_VIF_NUM,
2536 mrt->mroute_reg_vif_num) ||
2537 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_ASSERT,
2538 mrt->mroute_do_assert) ||
2539 nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_PIM, mrt->mroute_do_pim))
2540 return false;
2541
2542 return true;
2543}
2544
2545static bool ipmr_fill_vif(struct mr_table *mrt, u32 vifid, struct sk_buff *skb)
2546{
2547 struct nlattr *vif_nest;
2548 struct vif_device *vif;
2549
2550 /* if the VIF doesn't exist just continue */
2551 if (!VIF_EXISTS(mrt, vifid))
2552 return true;
2553
2554 vif = &mrt->vif_table[vifid];
2555 vif_nest = nla_nest_start(skb, IPMRA_VIF);
2556 if (!vif_nest)
2557 return false;
2558 if (nla_put_u32(skb, IPMRA_VIFA_IFINDEX, vif->dev->ifindex) ||
2559 nla_put_u32(skb, IPMRA_VIFA_VIF_ID, vifid) ||
2560 nla_put_u16(skb, IPMRA_VIFA_FLAGS, vif->flags) ||
2561 nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_IN, vif->bytes_in,
2562 IPMRA_VIFA_PAD) ||
2563 nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_OUT, vif->bytes_out,
2564 IPMRA_VIFA_PAD) ||
2565 nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_IN, vif->pkt_in,
2566 IPMRA_VIFA_PAD) ||
2567 nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_OUT, vif->pkt_out,
2568 IPMRA_VIFA_PAD) ||
2569 nla_put_be32(skb, IPMRA_VIFA_LOCAL_ADDR, vif->local) ||
2570 nla_put_be32(skb, IPMRA_VIFA_REMOTE_ADDR, vif->remote)) {
2571 nla_nest_cancel(skb, vif_nest);
2572 return false;
2573 }
2574 nla_nest_end(skb, vif_nest);
2575
2576 return true;
2577}
2578
2579static int ipmr_rtm_dumplink(struct sk_buff *skb, struct netlink_callback *cb)
2580{
2581 struct net *net = sock_net(skb->sk);
2582 struct nlmsghdr *nlh = NULL;
2583 unsigned int t = 0, s_t;
2584 unsigned int e = 0, s_e;
2585 struct mr_table *mrt;
2586
2587 s_t = cb->args[0];
2588 s_e = cb->args[1];
2589
2590 ipmr_for_each_table(mrt, net) {
2591 struct nlattr *vifs, *af;
2592 struct ifinfomsg *hdr;
2593 u32 i;
2594
2595 if (t < s_t)
2596 goto skip_table;
2597 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
2598 cb->nlh->nlmsg_seq, RTM_NEWLINK,
2599 sizeof(*hdr), NLM_F_MULTI);
2600 if (!nlh)
2601 break;
2602
2603 hdr = nlmsg_data(nlh);
2604 memset(hdr, 0, sizeof(*hdr));
2605 hdr->ifi_family = RTNL_FAMILY_IPMR;
2606
2607 af = nla_nest_start(skb, IFLA_AF_SPEC);
2608 if (!af) {
2609 nlmsg_cancel(skb, nlh);
2610 goto out;
2611 }
2612
2613 if (!ipmr_fill_table(mrt, skb)) {
2614 nlmsg_cancel(skb, nlh);
2615 goto out;
2616 }
2617
2618 vifs = nla_nest_start(skb, IPMRA_TABLE_VIFS);
2619 if (!vifs) {
2620 nla_nest_end(skb, af);
2621 nlmsg_end(skb, nlh);
2622 goto out;
2623 }
2624 for (i = 0; i < mrt->maxvif; i++) {
2625 if (e < s_e)
2626 goto skip_entry;
2627 if (!ipmr_fill_vif(mrt, i, skb)) {
2628 nla_nest_end(skb, vifs);
2629 nla_nest_end(skb, af);
2630 nlmsg_end(skb, nlh);
2631 goto out;
2632 }
2633skip_entry:
2634 e++;
2635 }
2636 s_e = 0;
2637 e = 0;
2638 nla_nest_end(skb, vifs);
2639 nla_nest_end(skb, af);
2640 nlmsg_end(skb, nlh);
2641skip_table:
2642 t++;
2643 }
2644
2645out:
2646 cb->args[1] = e;
2647 cb->args[0] = t;
2648
2649 return skb->len;
2650}
2651
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002652#ifdef CONFIG_PROC_FS
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01002653/* The /proc interfaces to multicast routing :
2654 * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 */
2656struct ipmr_vif_iter {
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002657 struct seq_net_private p;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002658 struct mr_table *mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 int ct;
2660};
2661
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002662static struct vif_device *ipmr_vif_seq_idx(struct net *net,
2663 struct ipmr_vif_iter *iter,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 loff_t pos)
2665{
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002666 struct mr_table *mrt = iter->mrt;
Patrick McHardy0c122952010-04-13 05:03:22 +00002667
2668 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
2669 if (!VIF_EXISTS(mrt, iter->ct))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 continue;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002671 if (pos-- == 0)
Patrick McHardy0c122952010-04-13 05:03:22 +00002672 return &mrt->vif_table[iter->ct];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 }
2674 return NULL;
2675}
2676
2677static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
Stephen Hemmingerba93ef72008-01-21 17:28:59 -08002678 __acquires(mrt_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679{
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002680 struct ipmr_vif_iter *iter = seq->private;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002681 struct net *net = seq_file_net(seq);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002682 struct mr_table *mrt;
2683
2684 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
Ian Morris51456b22015-04-03 09:17:26 +01002685 if (!mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002686 return ERR_PTR(-ENOENT);
2687
2688 iter->mrt = mrt;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002689
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 read_lock(&mrt_lock);
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002691 return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 : SEQ_START_TOKEN;
2693}
2694
2695static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2696{
2697 struct ipmr_vif_iter *iter = seq->private;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002698 struct net *net = seq_file_net(seq);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002699 struct mr_table *mrt = iter->mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700
2701 ++*pos;
2702 if (v == SEQ_START_TOKEN)
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002703 return ipmr_vif_seq_idx(net, iter, 0);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002704
Patrick McHardy0c122952010-04-13 05:03:22 +00002705 while (++iter->ct < mrt->maxvif) {
2706 if (!VIF_EXISTS(mrt, iter->ct))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 continue;
Patrick McHardy0c122952010-04-13 05:03:22 +00002708 return &mrt->vif_table[iter->ct];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709 }
2710 return NULL;
2711}
2712
2713static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
Stephen Hemmingerba93ef72008-01-21 17:28:59 -08002714 __releases(mrt_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715{
2716 read_unlock(&mrt_lock);
2717}
2718
2719static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
2720{
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002721 struct ipmr_vif_iter *iter = seq->private;
2722 struct mr_table *mrt = iter->mrt;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002723
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724 if (v == SEQ_START_TOKEN) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002725 seq_puts(seq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
2727 } else {
2728 const struct vif_device *vif = v;
2729 const char *name = vif->dev ? vif->dev->name : "none";
2730
2731 seq_printf(seq,
Alexey Dobriyan5b5e0922017-02-27 14:30:02 -08002732 "%2zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
Patrick McHardy0c122952010-04-13 05:03:22 +00002733 vif - mrt->vif_table,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002734 name, vif->bytes_in, vif->pkt_in,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 vif->bytes_out, vif->pkt_out,
2736 vif->flags, vif->local, vif->remote);
2737 }
2738 return 0;
2739}
2740
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002741static const struct seq_operations ipmr_vif_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742 .start = ipmr_vif_seq_start,
2743 .next = ipmr_vif_seq_next,
2744 .stop = ipmr_vif_seq_stop,
2745 .show = ipmr_vif_seq_show,
2746};
2747
2748static int ipmr_vif_open(struct inode *inode, struct file *file)
2749{
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002750 return seq_open_net(inode, file, &ipmr_vif_seq_ops,
2751 sizeof(struct ipmr_vif_iter));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752}
2753
Arjan van de Ven9a321442007-02-12 00:55:35 -08002754static const struct file_operations ipmr_vif_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 .owner = THIS_MODULE,
2756 .open = ipmr_vif_open,
2757 .read = seq_read,
2758 .llseek = seq_lseek,
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002759 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760};
2761
2762struct ipmr_mfc_iter {
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002763 struct seq_net_private p;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002764 struct mr_table *mrt;
Patrick McHardy862465f2010-04-13 05:03:21 +00002765 struct list_head *cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766};
2767
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002768static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
2769 struct ipmr_mfc_iter *it, loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770{
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002771 struct mr_table *mrt = it->mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 struct mfc_cache *mfc;
2773
Eric Dumazeta8c94862010-10-01 16:15:08 +00002774 rcu_read_lock();
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002775 it->cache = &mrt->mfc_cache_list;
2776 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list)
2777 if (pos-- == 0)
2778 return mfc;
Eric Dumazeta8c94862010-10-01 16:15:08 +00002779 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780
Linus Torvalds1da177e2005-04-16 15:20:36 -07002781 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy0c122952010-04-13 05:03:22 +00002782 it->cache = &mrt->mfc_unres_queue;
Patrick McHardy862465f2010-04-13 05:03:21 +00002783 list_for_each_entry(mfc, it->cache, list)
Patrick McHardye258beb2010-04-13 05:03:19 +00002784 if (pos-- == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785 return mfc;
2786 spin_unlock_bh(&mfc_unres_lock);
2787
2788 it->cache = NULL;
2789 return NULL;
2790}
2791
2792
2793static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
2794{
2795 struct ipmr_mfc_iter *it = seq->private;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002796 struct net *net = seq_file_net(seq);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002797 struct mr_table *mrt;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002798
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002799 mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
Ian Morris51456b22015-04-03 09:17:26 +01002800 if (!mrt)
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002801 return ERR_PTR(-ENOENT);
2802
2803 it->mrt = mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 it->cache = NULL;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002805 return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 : SEQ_START_TOKEN;
2807}
2808
2809static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2810{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 struct ipmr_mfc_iter *it = seq->private;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002812 struct net *net = seq_file_net(seq);
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002813 struct mr_table *mrt = it->mrt;
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002814 struct mfc_cache *mfc = v;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
2816 ++*pos;
2817
2818 if (v == SEQ_START_TOKEN)
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002819 return ipmr_mfc_seq_idx(net, seq->private, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820
Patrick McHardy862465f2010-04-13 05:03:21 +00002821 if (mfc->list.next != it->cache)
2822 return list_entry(mfc->list.next, struct mfc_cache, list);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002823
Patrick McHardy0c122952010-04-13 05:03:22 +00002824 if (it->cache == &mrt->mfc_unres_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002825 goto end_of_list;
2826
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 /* exhausted cache_array, show unresolved */
Eric Dumazeta8c94862010-10-01 16:15:08 +00002828 rcu_read_unlock();
Patrick McHardy0c122952010-04-13 05:03:22 +00002829 it->cache = &mrt->mfc_unres_queue;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002830
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831 spin_lock_bh(&mfc_unres_lock);
Patrick McHardy862465f2010-04-13 05:03:21 +00002832 if (!list_empty(it->cache))
2833 return list_first_entry(it->cache, struct mfc_cache, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002835end_of_list:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836 spin_unlock_bh(&mfc_unres_lock);
2837 it->cache = NULL;
2838
2839 return NULL;
2840}
2841
2842static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
2843{
2844 struct ipmr_mfc_iter *it = seq->private;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002845 struct mr_table *mrt = it->mrt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846
Patrick McHardy0c122952010-04-13 05:03:22 +00002847 if (it->cache == &mrt->mfc_unres_queue)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 spin_unlock_bh(&mfc_unres_lock);
Nikolay Aleksandrov8fb472c2017-01-12 15:53:33 +01002849 else if (it->cache == &mrt->mfc_cache_list)
Eric Dumazeta8c94862010-10-01 16:15:08 +00002850 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851}
2852
2853static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
2854{
2855 int n;
2856
2857 if (v == SEQ_START_TOKEN) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002858 seq_puts(seq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002859 "Group Origin Iif Pkts Bytes Wrong Oifs\n");
2860 } else {
2861 const struct mfc_cache *mfc = v;
2862 const struct ipmr_mfc_iter *it = seq->private;
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002863 const struct mr_table *mrt = it->mrt;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002864
Eric Dumazet0eae88f2010-04-20 19:06:52 -07002865 seq_printf(seq, "%08X %08X %-3hd",
2866 (__force u32) mfc->mfc_mcastgrp,
2867 (__force u32) mfc->mfc_origin,
Benjamin Thery1ea472e2008-12-03 22:21:47 -08002868 mfc->mfc_parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869
Patrick McHardy0c122952010-04-13 05:03:22 +00002870 if (it->cache != &mrt->mfc_unres_queue) {
Benjamin Thery1ea472e2008-12-03 22:21:47 -08002871 seq_printf(seq, " %8lu %8lu %8lu",
2872 mfc->mfc_un.res.pkt,
2873 mfc->mfc_un.res.bytes,
2874 mfc->mfc_un.res.wrong_if);
Stephen Hemminger132adf52007-03-08 20:44:43 -08002875 for (n = mfc->mfc_un.res.minvif;
Eric Dumazeta8cb16d2010-10-01 16:15:29 +00002876 n < mfc->mfc_un.res.maxvif; n++) {
Patrick McHardy0c122952010-04-13 05:03:22 +00002877 if (VIF_EXISTS(mrt, n) &&
Benjamin Therycf958ae32009-01-22 04:56:16 +00002878 mfc->mfc_un.res.ttls[n] < 255)
2879 seq_printf(seq,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002880 " %2d:%-3d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 n, mfc->mfc_un.res.ttls[n]);
2882 }
Benjamin Thery1ea472e2008-12-03 22:21:47 -08002883 } else {
2884 /* unresolved mfc_caches don't contain
2885 * pkt, bytes and wrong_if values
2886 */
2887 seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888 }
2889 seq_putc(seq, '\n');
2890 }
2891 return 0;
2892}
2893
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002894static const struct seq_operations ipmr_mfc_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 .start = ipmr_mfc_seq_start,
2896 .next = ipmr_mfc_seq_next,
2897 .stop = ipmr_mfc_seq_stop,
2898 .show = ipmr_mfc_seq_show,
2899};
2900
2901static int ipmr_mfc_open(struct inode *inode, struct file *file)
2902{
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002903 return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
2904 sizeof(struct ipmr_mfc_iter));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905}
2906
Arjan van de Ven9a321442007-02-12 00:55:35 -08002907static const struct file_operations ipmr_mfc_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 .owner = THIS_MODULE,
2909 .open = ipmr_mfc_open,
2910 .read = seq_read,
2911 .llseek = seq_lseek,
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002912 .release = seq_release_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913};
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002914#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915
2916#ifdef CONFIG_IP_PIMSM_V2
Alexey Dobriyan32613092009-09-14 12:21:47 +00002917static const struct net_protocol pim_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 .handler = pim_rcv,
Tom Goff403dbb92009-06-14 03:16:13 -07002919 .netns_ok = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920};
2921#endif
2922
Nikolay Aleksandrov7ef8f652015-11-21 15:57:27 +01002923/* Setup for IP multicast routing */
Benjamin Therycf958ae32009-01-22 04:56:16 +00002924static int __net_init ipmr_net_init(struct net *net)
2925{
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002926 int err;
Benjamin Therycf958ae32009-01-22 04:56:16 +00002927
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002928 err = ipmr_rules_init(net);
2929 if (err < 0)
Benjamin Therycf958ae32009-01-22 04:56:16 +00002930 goto fail;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002931
2932#ifdef CONFIG_PROC_FS
2933 err = -ENOMEM;
Gao fengd4beaa62013-02-18 01:34:54 +00002934 if (!proc_create("ip_mr_vif", 0, net->proc_net, &ipmr_vif_fops))
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002935 goto proc_vif_fail;
Gao fengd4beaa62013-02-18 01:34:54 +00002936 if (!proc_create("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_fops))
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002937 goto proc_cache_fail;
2938#endif
Benjamin Thery2bb8b262009-01-22 04:56:18 +00002939 return 0;
2940
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002941#ifdef CONFIG_PROC_FS
2942proc_cache_fail:
Gao fengece31ff2013-02-18 01:34:56 +00002943 remove_proc_entry("ip_mr_vif", net->proc_net);
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002944proc_vif_fail:
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002945 ipmr_rules_exit(net);
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002946#endif
Benjamin Therycf958ae32009-01-22 04:56:16 +00002947fail:
2948 return err;
2949}
2950
2951static void __net_exit ipmr_net_exit(struct net *net)
2952{
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002953#ifdef CONFIG_PROC_FS
Gao fengece31ff2013-02-18 01:34:56 +00002954 remove_proc_entry("ip_mr_cache", net->proc_net);
2955 remove_proc_entry("ip_mr_vif", net->proc_net);
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002956#endif
Patrick McHardyf0ad0862010-04-13 05:03:23 +00002957 ipmr_rules_exit(net);
Benjamin Therycf958ae32009-01-22 04:56:16 +00002958}
2959
2960static struct pernet_operations ipmr_net_ops = {
2961 .init = ipmr_net_init,
2962 .exit = ipmr_net_exit,
2963};
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002964
Wang Chen03d2f892008-07-03 12:13:36 +08002965int __init ip_mr_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966{
Wang Chen03d2f892008-07-03 12:13:36 +08002967 int err;
2968
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969 mrt_cachep = kmem_cache_create("ip_mrt_cache",
2970 sizeof(struct mfc_cache),
Eric Dumazeta8c94862010-10-01 16:15:08 +00002971 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
Paul Mundt20c2df82007-07-20 10:11:58 +09002972 NULL);
Wang Chen03d2f892008-07-03 12:13:36 +08002973
Benjamin Therycf958ae32009-01-22 04:56:16 +00002974 err = register_pernet_subsys(&ipmr_net_ops);
2975 if (err)
2976 goto reg_pernet_fail;
2977
Wang Chen03d2f892008-07-03 12:13:36 +08002978 err = register_netdevice_notifier(&ip_mr_notifier);
2979 if (err)
2980 goto reg_notif_fail;
Tom Goff403dbb92009-06-14 03:16:13 -07002981#ifdef CONFIG_IP_PIMSM_V2
2982 if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +00002983 pr_err("%s: can't add PIM protocol\n", __func__);
Tom Goff403dbb92009-06-14 03:16:13 -07002984 err = -EAGAIN;
2985 goto add_proto_fail;
2986 }
2987#endif
Greg Rosec7ac8672011-06-10 01:27:09 +00002988 rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
2989 NULL, ipmr_rtm_dumproute, NULL);
Nikolay Aleksandrovccbb0aa2015-11-26 15:23:50 +01002990 rtnl_register(RTNL_FAMILY_IPMR, RTM_NEWROUTE,
2991 ipmr_rtm_route, NULL, NULL);
2992 rtnl_register(RTNL_FAMILY_IPMR, RTM_DELROUTE,
2993 ipmr_rtm_route, NULL, NULL);
Nikolay Aleksandrov772c3442017-06-07 18:02:32 +03002994
2995 rtnl_register(RTNL_FAMILY_IPMR, RTM_GETLINK,
2996 NULL, ipmr_rtm_dumplink, NULL);
Wang Chen03d2f892008-07-03 12:13:36 +08002997 return 0;
Benjamin Theryf6bb4512009-01-22 04:56:22 +00002998
Tom Goff403dbb92009-06-14 03:16:13 -07002999#ifdef CONFIG_IP_PIMSM_V2
3000add_proto_fail:
3001 unregister_netdevice_notifier(&ip_mr_notifier);
3002#endif
Benjamin Theryc3e38892008-11-19 14:07:41 -08003003reg_notif_fail:
Benjamin Therycf958ae32009-01-22 04:56:16 +00003004 unregister_pernet_subsys(&ipmr_net_ops);
3005reg_pernet_fail:
Benjamin Theryc3e38892008-11-19 14:07:41 -08003006 kmem_cache_destroy(mrt_cachep);
Wang Chen03d2f892008-07-03 12:13:36 +08003007 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008}