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