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