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