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