net/ipv6/ip6mr.c

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