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