~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv4/ipmr.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp