net/ipv6/ip6mr.c

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