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