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 }
 929
 930 static int mif6_add(struct net *net, struct mr6_table *mrt,
 931                     struct mif6ctl *vifc, int mrtsock)
 932 {
 933         int vifi = vifc->mif6c_mifi;
 934         struct mif_device *v = &mrt->vif6_table[vifi];
 935         struct net_device *dev;
 936         struct inet6_dev *in6_dev;
 937         int err;
 938
 939         /* Is vif busy ? */
 940         if (MIF_EXISTS(mrt, vifi))
 941                 return -EADDRINUSE;
 942
 943         switch (vifc->mif6c_flags) {
 944 #ifdef CONFIG_IPV6_PIMSM_V2
 945         case MIFF_REGISTER:
 946                 /*
 947                  * Special Purpose VIF in PIM
 948                  * All the packets will be sent to the daemon
 949                  */
 950                 if (mrt->mroute_reg_vif_num >= 0)
 951                         return -EADDRINUSE;
 952                 dev = ip6mr_reg_vif(net, mrt);
 953                 if (!dev)
 954                         return -ENOBUFS;
 955                 err = dev_set_allmulti(dev, 1);
 956                 if (err) {
 957                         unregister_netdevice(dev);
 958                         dev_put(dev);
 959                         return err;
 960                 }
 961                 break;
 962 #endif
 963         case 0:
 964                 dev = dev_get_by_index(net, vifc->mif6c_pifi);
 965                 if (!dev)
 966                         return -EADDRNOTAVAIL;
 967                 err = dev_set_allmulti(dev, 1);
 968                 if (err) {
 969                         dev_put(dev);
 970                         return err;
 971                 }
 972                 break;
 973         default:
 974                 return -EINVAL;
 975         }
 976
 977         in6_dev = __in6_dev_get(dev);
 978         if (in6_dev) {
 979                 in6_dev->cnf.mc_forwarding++;
 980                 inet6_netconf_notify_devconf(dev_net(dev),
 981                                              NETCONFA_MC_FORWARDING,
 982                                              dev->ifindex, &in6_dev->cnf);
 983         }
 984
 985         /*
 986          *      Fill in the VIF structures
 987          */
 988         v->rate_limit = vifc->vifc_rate_limit;
 989         v->flags = vifc->mif6c_flags;
 990         if (!mrtsock)
 991                 v->flags |= VIFF_STATIC;
 992         v->threshold = vifc->vifc_threshold;
 993         v->bytes_in = 0;
 994         v->bytes_out = 0;
 995         v->pkt_in = 0;
 996         v->pkt_out = 0;
 997         v->link = dev->ifindex;
 998         if (v->flags & MIFF_REGISTER)
 999                 v->link = dev_get_iflink(dev);
1000
1001         /* And finish update writing critical data */
1002         write_lock_bh(&mrt_lock);
1003         v->dev = dev;
1004 #ifdef CONFIG_IPV6_PIMSM_V2
1005         if (v->flags & MIFF_REGISTER)
1006                 mrt->mroute_reg_vif_num = vifi;
1007 #endif
1008         if (vifi + 1 > mrt->maxvif)
1009                 mrt->maxvif = vifi + 1;
1010         write_unlock_bh(&mrt_lock);
1011         return 0;
1012 }
1013
1014 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1015                                            const struct in6_addr *origin,
1016                                            const struct in6_addr *mcastgrp)
1017 {
1018         int line = MFC6_HASH(mcastgrp, origin);
1019         struct mfc6_cache *c;
1020
1021         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1022                 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1023                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1024                         return c;
1025         }
1026         return NULL;
1027 }
1028
1029 /* Look for a (*,*,oif) entry */
1030 static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1031                                                       mifi_t mifi)
1032 {
1033         int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1034         struct mfc6_cache *c;
1035
1036         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1037                 if (ipv6_addr_any(&c->mf6c_origin) &&
1038                     ipv6_addr_any(&c->mf6c_mcastgrp) &&
1039                     (c->mfc_un.res.ttls[mifi] < 255))
1040                         return c;
1041
1042         return NULL;
1043 }
1044
1045 /* Look for a (*,G) entry */
1046 static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1047                                                struct in6_addr *mcastgrp,
1048                                                mifi_t mifi)
1049 {
1050         int line = MFC6_HASH(mcastgrp, &in6addr_any);
1051         struct mfc6_cache *c, *proxy;
1052
1053         if (ipv6_addr_any(mcastgrp))
1054                 goto skip;
1055
1056         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1057                 if (ipv6_addr_any(&c->mf6c_origin) &&
1058                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1059                         if (c->mfc_un.res.ttls[mifi] < 255)
1060                                 return c;
1061
1062                         /* It's ok if the mifi is part of the static tree */
1063                         proxy = ip6mr_cache_find_any_parent(mrt,
1064                                                             c->mf6c_parent);
1065                         if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1066                                 return c;
1067                 }
1068
1069 skip:
1070         return ip6mr_cache_find_any_parent(mrt, mifi);
1071 }
1072
1073 /*
1074  *      Allocate a multicast cache entry
1075  */
1076 static struct mfc6_cache *ip6mr_cache_alloc(void)
1077 {
1078         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1079         if (!c)
1080                 return NULL;
1081         c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
1082         c->mfc_un.res.minvif = MAXMIFS;
1083         return c;
1084 }
1085
1086 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1087 {
1088         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1089         if (!c)
1090                 return NULL;
1091         skb_queue_head_init(&c->mfc_un.unres.unresolved);
1092         c->mfc_un.unres.expires = jiffies + 10 * HZ;
1093         return c;
1094 }
1095
1096 /*
1097  *      A cache entry has gone into a resolved state from queued
1098  */
1099
1100 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1101                                 struct mfc6_cache *uc, struct mfc6_cache *c)
1102 {
1103         struct sk_buff *skb;
1104
1105         /*
1106          *      Play the pending entries through our router
1107          */
1108
1109         while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1110                 if (ipv6_hdr(skb)->version == 0) {
1111                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
1112
1113                         if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1114                                 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1115                         } else {
1116                                 nlh->nlmsg_type = NLMSG_ERROR;
1117                                 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1118                                 skb_trim(skb, nlh->nlmsg_len);
1119                                 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1120                         }
1121                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1122                 } else
1123                         ip6_mr_forward(net, mrt, skb, c);
1124         }
1125 }
1126
1127 /*
1128  *      Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
1129  *      expects the following bizarre scheme.
1130  *
1131  *      Called under mrt_lock.
1132  */
1133
1134 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1135                               mifi_t mifi, int assert)
1136 {
1137         struct sk_buff *skb;
1138         struct mrt6msg *msg;
1139         int ret;
1140
1141 #ifdef CONFIG_IPV6_PIMSM_V2
1142         if (assert == MRT6MSG_WHOLEPKT)
1143                 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1144                                                 +sizeof(*msg));
1145         else
1146 #endif
1147                 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1148
1149         if (!skb)
1150                 return -ENOBUFS;
1151
1152         /* I suppose that internal messages
1153          * do not require checksums */
1154
1155         skb->ip_summed = CHECKSUM_UNNECESSARY;
1156
1157 #ifdef CONFIG_IPV6_PIMSM_V2
1158         if (assert == MRT6MSG_WHOLEPKT) {
1159                 /* Ugly, but we have no choice with this interface.
1160                    Duplicate old header, fix length etc.
1161                    And all this only to mangle msg->im6_msgtype and
1162                    to set msg->im6_mbz to "mbz" :-)
1163                  */
1164                 skb_push(skb, -skb_network_offset(pkt));
1165
1166                 skb_push(skb, sizeof(*msg));
1167                 skb_reset_transport_header(skb);
1168                 msg = (struct mrt6msg *)skb_transport_header(skb);
1169                 msg->im6_mbz = 0;
1170                 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1171                 msg->im6_mif = mrt->mroute_reg_vif_num;
1172                 msg->im6_pad = 0;
1173                 msg->im6_src = ipv6_hdr(pkt)->saddr;
1174                 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1175
1176                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1177         } else
1178 #endif
1179         {
1180         /*
1181          *      Copy the IP header
1182          */
1183
1184         skb_put(skb, sizeof(struct ipv6hdr));
1185         skb_reset_network_header(skb);
1186         skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1187
1188         /*
1189          *      Add our header
1190          */
1191         skb_put(skb, sizeof(*msg));
1192         skb_reset_transport_header(skb);
1193         msg = (struct mrt6msg *)skb_transport_header(skb);
1194
1195         msg->im6_mbz = 0;
1196         msg->im6_msgtype = assert;
1197         msg->im6_mif = mifi;
1198         msg->im6_pad = 0;
1199         msg->im6_src = ipv6_hdr(pkt)->saddr;
1200         msg->im6_dst = ipv6_hdr(pkt)->daddr;
1201
1202         skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1203         skb->ip_summed = CHECKSUM_UNNECESSARY;
1204         }
1205
1206         if (!mrt->mroute6_sk) {
1207                 kfree_skb(skb);
1208                 return -EINVAL;
1209         }
1210
1211         /*
1212          *      Deliver to user space multicast routing algorithms
1213          */
1214         ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1215         if (ret < 0) {
1216                 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1217                 kfree_skb(skb);
1218         }
1219
1220         return ret;
1221 }
1222
1223 /*
1224  *      Queue a packet for resolution. It gets locked cache entry!
1225  */
1226
1227 static int
1228 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1229 {
1230         bool found = false;
1231         int err;
1232         struct mfc6_cache *c;
1233
1234         spin_lock_bh(&mfc_unres_lock);
1235         list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1236                 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1237                     ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1238                         found = true;
1239                         break;
1240                 }
1241         }
1242
1243         if (!found) {
1244                 /*
1245                  *      Create a new entry if allowable
1246                  */
1247
1248                 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1249                     (c = ip6mr_cache_alloc_unres()) == NULL) {
1250                         spin_unlock_bh(&mfc_unres_lock);
1251
1252                         kfree_skb(skb);
1253                         return -ENOBUFS;
1254                 }
1255
1256                 /*
1257                  *      Fill in the new cache entry
1258                  */
1259                 c->mf6c_parent = -1;
1260                 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1261                 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1262
1263                 /*
1264                  *      Reflect first query at pim6sd
1265                  */
1266                 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1267                 if (err < 0) {
1268                         /* If the report failed throw the cache entry
1269                            out - Brad Parker
1270                          */
1271                         spin_unlock_bh(&mfc_unres_lock);
1272
1273                         ip6mr_cache_free(c);
1274                         kfree_skb(skb);
1275                         return err;
1276                 }
1277
1278                 atomic_inc(&mrt->cache_resolve_queue_len);
1279                 list_add(&c->list, &mrt->mfc6_unres_queue);
1280                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1281
1282                 ipmr_do_expire_process(mrt);
1283         }
1284
1285         /*
1286          *      See if we can append the packet
1287          */
1288         if (c->mfc_un.unres.unresolved.qlen > 3) {
1289                 kfree_skb(skb);
1290                 err = -ENOBUFS;
1291         } else {
1292                 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1293                 err = 0;
1294         }
1295
1296         spin_unlock_bh(&mfc_unres_lock);
1297         return err;
1298 }
1299
1300 /*
1301  *      MFC6 cache manipulation by user space
1302  */
1303
1304 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1305                             int parent)
1306 {
1307         int line;
1308         struct mfc6_cache *c, *next;
1309
1310         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1311
1312         list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1313                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1314                     ipv6_addr_equal(&c->mf6c_mcastgrp,
1315                                     &mfc->mf6cc_mcastgrp.sin6_addr) &&
1316                     (parent == -1 || parent == c->mf6c_parent)) {
1317                         write_lock_bh(&mrt_lock);
1318                         list_del(&c->list);
1319                         write_unlock_bh(&mrt_lock);
1320
1321                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1322                         ip6mr_cache_free(c);
1323                         return 0;
1324                 }
1325         }
1326         return -ENOENT;
1327 }
1328
1329 static int ip6mr_device_event(struct notifier_block *this,
1330                               unsigned long event, void *ptr)
1331 {
1332         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1333         struct net *net = dev_net(dev);
1334         struct mr6_table *mrt;
1335         struct mif_device *v;
1336         int ct;
1337
1338         if (event != NETDEV_UNREGISTER)
1339                 return NOTIFY_DONE;
1340
1341         ip6mr_for_each_table(mrt, net) {
1342                 v = &mrt->vif6_table[0];
1343                 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1344                         if (v->dev == dev)
1345                                 mif6_delete(mrt, ct, 1, NULL);
1346                 }
1347         }
1348
1349         return NOTIFY_DONE;
1350 }
1351
1352 static struct notifier_block ip6_mr_notifier = {
1353         .notifier_call = ip6mr_device_event
1354 };
1355
1356 /*
1357  *      Setup for IP multicast routing
1358  */
1359
1360 static int __net_init ip6mr_net_init(struct net *net)
1361 {
1362         int err;
1363
1364         err = ip6mr_rules_init(net);
1365         if (err < 0)
1366                 goto fail;
1367
1368 #ifdef CONFIG_PROC_FS
1369         err = -ENOMEM;
1370         if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1371                 goto proc_vif_fail;
1372         if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1373                 goto proc_cache_fail;
1374 #endif
1375
1376         return 0;
1377
1378 #ifdef CONFIG_PROC_FS
1379 proc_cache_fail:
1380         remove_proc_entry("ip6_mr_vif", net->proc_net);
1381 proc_vif_fail:
1382         ip6mr_rules_exit(net);
1383 #endif
1384 fail:
1385         return err;
1386 }
1387
1388 static void __net_exit ip6mr_net_exit(struct net *net)
1389 {
1390 #ifdef CONFIG_PROC_FS
1391         remove_proc_entry("ip6_mr_cache", net->proc_net);
1392         remove_proc_entry("ip6_mr_vif", net->proc_net);
1393 #endif
1394         ip6mr_rules_exit(net);
1395 }
1396
1397 static struct pernet_operations ip6mr_net_ops = {
1398         .init = ip6mr_net_init,
1399         .exit = ip6mr_net_exit,
1400 };
1401
1402 int __init ip6_mr_init(void)
1403 {
1404         int err;
1405
1406         mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1407                                        sizeof(struct mfc6_cache),
1408                                        0, SLAB_HWCACHE_ALIGN,
1409                                        NULL);
1410         if (!mrt_cachep)
1411                 return -ENOMEM;
1412
1413         err = register_pernet_subsys(&ip6mr_net_ops);
1414         if (err)
1415                 goto reg_pernet_fail;
1416
1417         err = register_netdevice_notifier(&ip6_mr_notifier);
1418         if (err)
1419                 goto reg_notif_fail;
1420 #ifdef CONFIG_IPV6_PIMSM_V2
1421         if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1422                 pr_err("%s: can't add PIM protocol\n", __func__);
1423                 err = -EAGAIN;
1424                 goto add_proto_fail;
1425         }
1426 #endif
1427         rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1428                       ip6mr_rtm_dumproute, NULL);
1429         return 0;
1430 #ifdef CONFIG_IPV6_PIMSM_V2
1431 add_proto_fail:
1432         unregister_netdevice_notifier(&ip6_mr_notifier);
1433 #endif
1434 reg_notif_fail:
1435         unregister_pernet_subsys(&ip6mr_net_ops);
1436 reg_pernet_fail:
1437         kmem_cache_destroy(mrt_cachep);
1438         return err;
1439 }
1440
1441 void ip6_mr_cleanup(void)
1442 {
1443         rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1444 #ifdef CONFIG_IPV6_PIMSM_V2
1445         inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1446 #endif
1447         unregister_netdevice_notifier(&ip6_mr_notifier);
1448         unregister_pernet_subsys(&ip6mr_net_ops);
1449         kmem_cache_destroy(mrt_cachep);
1450 }
1451
1452 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1453                          struct mf6cctl *mfc, int mrtsock, int parent)
1454 {
1455         bool found = false;
1456         int line;
1457         struct mfc6_cache *uc, *c;
1458         unsigned char ttls[MAXMIFS];
1459         int i;
1460
1461         if (mfc->mf6cc_parent >= MAXMIFS)
1462                 return -ENFILE;
1463
1464         memset(ttls, 255, MAXMIFS);
1465         for (i = 0; i < MAXMIFS; i++) {
1466                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1467                         ttls[i] = 1;
1468
1469         }
1470
1471         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1472
1473         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1474                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1475                     ipv6_addr_equal(&c->mf6c_mcastgrp,
1476                                     &mfc->mf6cc_mcastgrp.sin6_addr) &&
1477                     (parent == -1 || parent == mfc->mf6cc_parent)) {
1478                         found = true;
1479                         break;
1480                 }
1481         }
1482
1483         if (found) {
1484                 write_lock_bh(&mrt_lock);
1485                 c->mf6c_parent = mfc->mf6cc_parent;
1486                 ip6mr_update_thresholds(mrt, c, ttls);
1487                 if (!mrtsock)
1488                         c->mfc_flags |= MFC_STATIC;
1489                 write_unlock_bh(&mrt_lock);
1490                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1491                 return 0;
1492         }
1493
1494         if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1495             !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1496                 return -EINVAL;
1497
1498         c = ip6mr_cache_alloc();
1499         if (!c)
1500                 return -ENOMEM;
1501
1502         c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1503         c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1504         c->mf6c_parent = mfc->mf6cc_parent;
1505         ip6mr_update_thresholds(mrt, c, ttls);
1506         if (!mrtsock)
1507                 c->mfc_flags |= MFC_STATIC;
1508
1509         write_lock_bh(&mrt_lock);
1510         list_add(&c->list, &mrt->mfc6_cache_array[line]);
1511         write_unlock_bh(&mrt_lock);
1512
1513         /*
1514          *      Check to see if we resolved a queued list. If so we
1515          *      need to send on the frames and tidy up.
1516          */
1517         found = false;
1518         spin_lock_bh(&mfc_unres_lock);
1519         list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1520                 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1521                     ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1522                         list_del(&uc->list);
1523                         atomic_dec(&mrt->cache_resolve_queue_len);
1524                         found = true;
1525                         break;
1526                 }
1527         }
1528         if (list_empty(&mrt->mfc6_unres_queue))
1529                 del_timer(&mrt->ipmr_expire_timer);
1530         spin_unlock_bh(&mfc_unres_lock);
1531
1532         if (found) {
1533                 ip6mr_cache_resolve(net, mrt, uc, c);
1534                 ip6mr_cache_free(uc);
1535         }
1536         mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1537         return 0;
1538 }
1539
1540 /*
1541  *      Close the multicast socket, and clear the vif tables etc
1542  */
1543
1544 static void mroute_clean_tables(struct mr6_table *mrt, bool all)
1545 {
1546         int i;
1547         LIST_HEAD(list);
1548         struct mfc6_cache *c, *next;
1549
1550         /*
1551          *      Shut down all active vif entries
1552          */
1553         for (i = 0; i < mrt->maxvif; i++) {
1554                 if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
1555                         continue;
1556                 mif6_delete(mrt, i, 0, &list);
1557         }
1558         unregister_netdevice_many(&list);
1559
1560         /*
1561          *      Wipe the cache
1562          */
1563         for (i = 0; i < MFC6_LINES; i++) {
1564                 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1565                         if (!all && (c->mfc_flags & MFC_STATIC))
1566                                 continue;
1567                         write_lock_bh(&mrt_lock);
1568                         list_del(&c->list);
1569                         write_unlock_bh(&mrt_lock);
1570
1571                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1572                         ip6mr_cache_free(c);
1573                 }
1574         }
1575
1576         if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1577                 spin_lock_bh(&mfc_unres_lock);
1578                 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1579                         list_del(&c->list);
1580                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1581                         ip6mr_destroy_unres(mrt, c);
1582                 }
1583                 spin_unlock_bh(&mfc_unres_lock);
1584         }
1585 }
1586
1587 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1588 {
1589         int err = 0;
1590         struct net *net = sock_net(sk);
1591
1592         rtnl_lock();
1593         write_lock_bh(&mrt_lock);
1594         if (likely(mrt->mroute6_sk == NULL)) {
1595                 mrt->mroute6_sk = sk;
1596                 net->ipv6.devconf_all->mc_forwarding++;
1597         } else {
1598                 err = -EADDRINUSE;
1599         }
1600         write_unlock_bh(&mrt_lock);
1601
1602         if (!err)
1603                 inet6_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
1604                                              NETCONFA_IFINDEX_ALL,
1605                                              net->ipv6.devconf_all);
1606         rtnl_unlock();
1607
1608         return err;
1609 }
1610
1611 int ip6mr_sk_done(struct sock *sk)
1612 {
1613         int err = -EACCES;
1614         struct net *net = sock_net(sk);
1615         struct mr6_table *mrt;
1616
1617         rtnl_lock();
1618         ip6mr_for_each_table(mrt, net) {
1619                 if (sk == mrt->mroute6_sk) {
1620                         write_lock_bh(&mrt_lock);
1621                         mrt->mroute6_sk = NULL;
1622                         net->ipv6.devconf_all->mc_forwarding--;
1623                         write_unlock_bh(&mrt_lock);
1624                         inet6_netconf_notify_devconf(net,
1625                                                      NETCONFA_MC_FORWARDING,
1626                                                      NETCONFA_IFINDEX_ALL,
1627                                                      net->ipv6.devconf_all);
1628
1629                         mroute_clean_tables(mrt, false);
1630                         err = 0;
1631                         break;
1632                 }
1633         }
1634         rtnl_unlock();
1635
1636         return err;
1637 }
1638
1639 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1640 {
1641         struct mr6_table *mrt;
1642         struct flowi6 fl6 = {
1643                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
1644                 .flowi6_oif     = skb->dev->ifindex,
1645                 .flowi6_mark    = skb->mark,
1646         };
1647
1648         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1649                 return NULL;
1650
1651         return mrt->mroute6_sk;
1652 }
1653
1654 /*
1655  *      Socket options and virtual interface manipulation. The whole
1656  *      virtual interface system is a complete heap, but unfortunately
1657  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1658  *      MOSPF/PIM router set up we can clean this up.
1659  */
1660
1661 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1662 {
1663         int ret, parent = 0;
1664         struct mif6ctl vif;
1665         struct mf6cctl mfc;
1666         mifi_t mifi;
1667         struct net *net = sock_net(sk);
1668         struct mr6_table *mrt;
1669
1670         if (sk->sk_type != SOCK_RAW ||
1671             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1672                 return -EOPNOTSUPP;
1673
1674         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1675         if (!mrt)
1676                 return -ENOENT;
1677
1678         if (optname != MRT6_INIT) {
1679                 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1680                         return -EACCES;
1681         }
1682
1683         switch (optname) {
1684         case MRT6_INIT:
1685                 if (optlen < sizeof(int))
1686                         return -EINVAL;
1687
1688                 return ip6mr_sk_init(mrt, sk);
1689
1690         case MRT6_DONE:
1691                 return ip6mr_sk_done(sk);
1692
1693         case MRT6_ADD_MIF:
1694                 if (optlen < sizeof(vif))
1695                         return -EINVAL;
1696                 if (copy_from_user(&vif, optval, sizeof(vif)))
1697                         return -EFAULT;
1698                 if (vif.mif6c_mifi >= MAXMIFS)
1699                         return -ENFILE;
1700                 rtnl_lock();
1701                 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1702                 rtnl_unlock();
1703                 return ret;
1704
1705         case MRT6_DEL_MIF:
1706                 if (optlen < sizeof(mifi_t))
1707                         return -EINVAL;
1708                 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1709                         return -EFAULT;
1710                 rtnl_lock();
1711                 ret = mif6_delete(mrt, mifi, 0, NULL);
1712                 rtnl_unlock();
1713                 return ret;
1714
1715         /*
1716          *      Manipulate the forwarding caches. These live
1717          *      in a sort of kernel/user symbiosis.
1718          */
1719         case MRT6_ADD_MFC:
1720         case MRT6_DEL_MFC:
1721                 parent = -1;
1722         case MRT6_ADD_MFC_PROXY:
1723         case MRT6_DEL_MFC_PROXY:
1724                 if (optlen < sizeof(mfc))
1725                         return -EINVAL;
1726                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1727                         return -EFAULT;
1728                 if (parent == 0)
1729                         parent = mfc.mf6cc_parent;
1730                 rtnl_lock();
1731                 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1732                         ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1733                 else
1734                         ret = ip6mr_mfc_add(net, mrt, &mfc,
1735                                             sk == mrt->mroute6_sk, parent);
1736                 rtnl_unlock();
1737                 return ret;
1738
1739         /*
1740          *      Control PIM assert (to activate pim will activate assert)
1741          */
1742         case MRT6_ASSERT:
1743         {
1744                 int v;
1745
1746                 if (optlen != sizeof(v))
1747                         return -EINVAL;
1748                 if (get_user(v, (int __user *)optval))
1749                         return -EFAULT;
1750                 mrt->mroute_do_assert = v;
1751                 return 0;
1752         }
1753
1754 #ifdef CONFIG_IPV6_PIMSM_V2
1755         case MRT6_PIM:
1756         {
1757                 int v;
1758
1759                 if (optlen != sizeof(v))
1760                         return -EINVAL;
1761                 if (get_user(v, (int __user *)optval))
1762                         return -EFAULT;
1763                 v = !!v;
1764                 rtnl_lock();
1765                 ret = 0;
1766                 if (v != mrt->mroute_do_pim) {
1767                         mrt->mroute_do_pim = v;
1768                         mrt->mroute_do_assert = v;
1769                 }
1770                 rtnl_unlock();
1771                 return ret;
1772         }
1773
1774 #endif
1775 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1776         case MRT6_TABLE:
1777         {
1778                 u32 v;
1779
1780                 if (optlen != sizeof(u32))
1781                         return -EINVAL;
1782                 if (get_user(v, (u32 __user *)optval))
1783                         return -EFAULT;
1784                 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1785                 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1786                         return -EINVAL;
1787                 if (sk == mrt->mroute6_sk)
1788                         return -EBUSY;
1789
1790                 rtnl_lock();
1791                 ret = 0;
1792                 if (!ip6mr_new_table(net, v))
1793                         ret = -ENOMEM;
1794                 else
1795                         raw6_sk(sk)->ip6mr_table = v;
1796                 rtnl_unlock();
1797                 return ret;
1798         }
1799 #endif
1800         /*
1801          *      Spurious command, or MRT6_VERSION which you cannot
1802          *      set.
1803          */
1804         default:
1805                 return -ENOPROTOOPT;
1806         }
1807 }
1808
1809 /*
1810  *      Getsock opt support for the multicast routing system.
1811  */
1812
1813 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1814                           int __user *optlen)
1815 {
1816         int olr;
1817         int val;
1818         struct net *net = sock_net(sk);
1819         struct mr6_table *mrt;
1820
1821         if (sk->sk_type != SOCK_RAW ||
1822             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1823                 return -EOPNOTSUPP;
1824
1825         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1826         if (!mrt)
1827                 return -ENOENT;
1828
1829         switch (optname) {
1830         case MRT6_VERSION:
1831                 val = 0x0305;
1832                 break;
1833 #ifdef CONFIG_IPV6_PIMSM_V2
1834         case MRT6_PIM:
1835                 val = mrt->mroute_do_pim;
1836                 break;
1837 #endif
1838         case MRT6_ASSERT:
1839                 val = mrt->mroute_do_assert;
1840                 break;
1841         default:
1842                 return -ENOPROTOOPT;
1843         }
1844
1845         if (get_user(olr, optlen))
1846                 return -EFAULT;
1847
1848         olr = min_t(int, olr, sizeof(int));
1849         if (olr < 0)
1850                 return -EINVAL;
1851
1852         if (put_user(olr, optlen))
1853                 return -EFAULT;
1854         if (copy_to_user(optval, &val, olr))
1855                 return -EFAULT;
1856         return 0;
1857 }
1858
1859 /*
1860  *      The IP multicast ioctl support routines.
1861  */
1862
1863 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1864 {
1865         struct sioc_sg_req6 sr;
1866         struct sioc_mif_req6 vr;
1867         struct mif_device *vif;
1868         struct mfc6_cache *c;
1869         struct net *net = sock_net(sk);
1870         struct mr6_table *mrt;
1871
1872         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1873         if (!mrt)
1874                 return -ENOENT;
1875
1876         switch (cmd) {
1877         case SIOCGETMIFCNT_IN6:
1878                 if (copy_from_user(&vr, arg, sizeof(vr)))
1879                         return -EFAULT;
1880                 if (vr.mifi >= mrt->maxvif)
1881                         return -EINVAL;
1882                 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1883                 read_lock(&mrt_lock);
1884                 vif = &mrt->vif6_table[vr.mifi];
1885                 if (MIF_EXISTS(mrt, vr.mifi)) {
1886                         vr.icount = vif->pkt_in;
1887                         vr.ocount = vif->pkt_out;
1888                         vr.ibytes = vif->bytes_in;
1889                         vr.obytes = vif->bytes_out;
1890                         read_unlock(&mrt_lock);
1891
1892                         if (copy_to_user(arg, &vr, sizeof(vr)))
1893                                 return -EFAULT;
1894                         return 0;
1895                 }
1896                 read_unlock(&mrt_lock);
1897                 return -EADDRNOTAVAIL;
1898         case SIOCGETSGCNT_IN6:
1899                 if (copy_from_user(&sr, arg, sizeof(sr)))
1900                         return -EFAULT;
1901
1902                 read_lock(&mrt_lock);
1903                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1904                 if (c) {
1905                         sr.pktcnt = c->mfc_un.res.pkt;
1906                         sr.bytecnt = c->mfc_un.res.bytes;
1907                         sr.wrong_if = c->mfc_un.res.wrong_if;
1908                         read_unlock(&mrt_lock);
1909
1910                         if (copy_to_user(arg, &sr, sizeof(sr)))
1911                                 return -EFAULT;
1912                         return 0;
1913                 }
1914                 read_unlock(&mrt_lock);
1915                 return -EADDRNOTAVAIL;
1916         default:
1917                 return -ENOIOCTLCMD;
1918         }
1919 }
1920
1921 #ifdef CONFIG_COMPAT
1922 struct compat_sioc_sg_req6 {
1923         struct sockaddr_in6 src;
1924         struct sockaddr_in6 grp;
1925         compat_ulong_t pktcnt;
1926         compat_ulong_t bytecnt;
1927         compat_ulong_t wrong_if;
1928 };
1929
1930 struct compat_sioc_mif_req6 {
1931         mifi_t  mifi;
1932         compat_ulong_t icount;
1933         compat_ulong_t ocount;
1934         compat_ulong_t ibytes;
1935         compat_ulong_t obytes;
1936 };
1937
1938 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1939 {
1940         struct compat_sioc_sg_req6 sr;
1941         struct compat_sioc_mif_req6 vr;
1942         struct mif_device *vif;
1943         struct mfc6_cache *c;
1944         struct net *net = sock_net(sk);
1945         struct mr6_table *mrt;
1946
1947         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1948         if (!mrt)
1949                 return -ENOENT;
1950
1951         switch (cmd) {
1952         case SIOCGETMIFCNT_IN6:
1953                 if (copy_from_user(&vr, arg, sizeof(vr)))
1954                         return -EFAULT;
1955                 if (vr.mifi >= mrt->maxvif)
1956                         return -EINVAL;
1957                 vr.mifi = array_index_nospec(vr.mifi, mrt->maxvif);
1958                 read_lock(&mrt_lock);
1959                 vif = &mrt->vif6_table[vr.mifi];
1960                 if (MIF_EXISTS(mrt, vr.mifi)) {
1961                         vr.icount = vif->pkt_in;
1962                         vr.ocount = vif->pkt_out;
1963                         vr.ibytes = vif->bytes_in;
1964                         vr.obytes = vif->bytes_out;
1965                         read_unlock(&mrt_lock);
1966
1967                         if (copy_to_user(arg, &vr, sizeof(vr)))
1968                                 return -EFAULT;
1969                         return 0;
1970                 }
1971                 read_unlock(&mrt_lock);
1972                 return -EADDRNOTAVAIL;
1973         case SIOCGETSGCNT_IN6:
1974                 if (copy_from_user(&sr, arg, sizeof(sr)))
1975                         return -EFAULT;
1976
1977                 read_lock(&mrt_lock);
1978                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1979                 if (c) {
1980                         sr.pktcnt = c->mfc_un.res.pkt;
1981                         sr.bytecnt = c->mfc_un.res.bytes;
1982                         sr.wrong_if = c->mfc_un.res.wrong_if;
1983                         read_unlock(&mrt_lock);
1984
1985                         if (copy_to_user(arg, &sr, sizeof(sr)))
1986                                 return -EFAULT;
1987                         return 0;
1988                 }
1989                 read_unlock(&mrt_lock);
1990                 return -EADDRNOTAVAIL;
1991         default:
1992                 return -ENOIOCTLCMD;
1993         }
1994 }
1995 #endif
1996
1997 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
1998 {
1999         IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2000                       IPSTATS_MIB_OUTFORWDATAGRAMS);
2001         IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2002                       IPSTATS_MIB_OUTOCTETS, skb->len);
2003         return dst_output(net, sk, skb);
2004 }
2005
2006 /*
2007  *      Processing handlers for ip6mr_forward
2008  */
2009
2010 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2011                           struct sk_buff *skb, struct mfc6_cache *c, int vifi)
2012 {
2013         struct ipv6hdr *ipv6h;
2014         struct mif_device *vif = &mrt->vif6_table[vifi];
2015         struct net_device *dev;
2016         struct dst_entry *dst;
2017         struct flowi6 fl6;
2018
2019         if (!vif->dev)
2020                 goto out_free;
2021
2022 #ifdef CONFIG_IPV6_PIMSM_V2
2023         if (vif->flags & MIFF_REGISTER) {
2024                 vif->pkt_out++;
2025                 vif->bytes_out += skb->len;
2026                 vif->dev->stats.tx_bytes += skb->len;
2027                 vif->dev->stats.tx_packets++;
2028                 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2029                 goto out_free;
2030         }
2031 #endif
2032
2033         ipv6h = ipv6_hdr(skb);
2034
2035         fl6 = (struct flowi6) {
2036                 .flowi6_oif = vif->link,
2037                 .daddr = ipv6h->daddr,
2038         };
2039
2040         dst = ip6_route_output(net, NULL, &fl6);
2041         if (dst->error) {
2042                 dst_release(dst);
2043                 goto out_free;
2044         }
2045
2046         skb_dst_drop(skb);
2047         skb_dst_set(skb, dst);
2048
2049         /*
2050          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2051          * not only before forwarding, but after forwarding on all output
2052          * interfaces. It is clear, if mrouter runs a multicasting
2053          * program, it should receive packets not depending to what interface
2054          * program is joined.
2055          * If we will not make it, the program will have to join on all
2056          * interfaces. On the other hand, multihoming host (or router, but
2057          * not mrouter) cannot join to more than one interface - it will
2058          * result in receiving multiple packets.
2059          */
2060         dev = vif->dev;
2061         skb->dev = dev;
2062         vif->pkt_out++;
2063         vif->bytes_out += skb->len;
2064
2065         /* We are about to write */
2066         /* XXX: extension headers? */
2067         if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2068                 goto out_free;
2069
2070         ipv6h = ipv6_hdr(skb);
2071         ipv6h->hop_limit--;
2072
2073         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2074
2075         return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2076                        net, NULL, skb, skb->dev, dev,
2077                        ip6mr_forward2_finish);
2078
2079 out_free:
2080         kfree_skb(skb);
2081         return 0;
2082 }
2083
2084 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2085 {
2086         int ct;
2087
2088         for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2089                 if (mrt->vif6_table[ct].dev == dev)
2090                         break;
2091         }
2092         return ct;
2093 }
2094
2095 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2096                            struct sk_buff *skb, struct mfc6_cache *cache)
2097 {
2098         int psend = -1;
2099         int vif, ct;
2100         int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2101
2102         vif = cache->mf6c_parent;
2103         cache->mfc_un.res.pkt++;
2104         cache->mfc_un.res.bytes += skb->len;
2105
2106         if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2107                 struct mfc6_cache *cache_proxy;
2108
2109                 /* For an (*,G) entry, we only check that the incoming
2110                  * interface is part of the static tree.
2111                  */
2112                 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2113                 if (cache_proxy &&
2114                     cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2115                         goto forward;
2116         }
2117
2118         /*
2119          * Wrong interface: drop packet and (maybe) send PIM assert.
2120          */
2121         if (mrt->vif6_table[vif].dev != skb->dev) {
2122                 cache->mfc_un.res.wrong_if++;
2123
2124                 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2125                     /* pimsm uses asserts, when switching from RPT to SPT,
2126                        so that we cannot check that packet arrived on an oif.
2127                        It is bad, but otherwise we would need to move pretty
2128                        large chunk of pimd to kernel. Ough... --ANK
2129                      */
2130                     (mrt->mroute_do_pim ||
2131                      cache->mfc_un.res.ttls[true_vifi] < 255) &&
2132                     time_after(jiffies,
2133                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2134                         cache->mfc_un.res.last_assert = jiffies;
2135                         ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2136                 }
2137                 goto dont_forward;
2138         }
2139
2140 forward:
2141         mrt->vif6_table[vif].pkt_in++;
2142         mrt->vif6_table[vif].bytes_in += skb->len;
2143
2144         /*
2145          *      Forward the frame
2146          */
2147         if (ipv6_addr_any(&cache->mf6c_origin) &&
2148             ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2149                 if (true_vifi >= 0 &&
2150                     true_vifi != cache->mf6c_parent &&
2151                     ipv6_hdr(skb)->hop_limit >
2152                                 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2153                         /* It's an (*,*) entry and the packet is not coming from
2154                          * the upstream: forward the packet to the upstream
2155                          * only.
2156                          */
2157                         psend = cache->mf6c_parent;
2158                         goto last_forward;
2159                 }
2160                 goto dont_forward;
2161         }
2162         for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2163                 /* For (*,G) entry, don't forward to the incoming interface */
2164                 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2165                     ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2166                         if (psend != -1) {
2167                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2168                                 if (skb2)
2169                                         ip6mr_forward2(net, mrt, skb2, cache, psend);
2170                         }
2171                         psend = ct;
2172                 }
2173         }
2174 last_forward:
2175         if (psend != -1) {
2176                 ip6mr_forward2(net, mrt, skb, cache, psend);
2177                 return;
2178         }
2179
2180 dont_forward:
2181         kfree_skb(skb);
2182 }
2183
2184
2185 /*
2186  *      Multicast packets for forwarding arrive here
2187  */
2188
2189 int ip6_mr_input(struct sk_buff *skb)
2190 {
2191         struct mfc6_cache *cache;
2192         struct net *net = dev_net(skb->dev);
2193         struct mr6_table *mrt;
2194         struct flowi6 fl6 = {
2195                 .flowi6_iif     = skb->dev->ifindex,
2196                 .flowi6_mark    = skb->mark,
2197         };
2198         int err;
2199
2200         err = ip6mr_fib_lookup(net, &fl6, &mrt);
2201         if (err < 0) {
2202                 kfree_skb(skb);
2203                 return err;
2204         }
2205
2206         read_lock(&mrt_lock);
2207         cache = ip6mr_cache_find(mrt,
2208                                  &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2209         if (!cache) {
2210                 int vif = ip6mr_find_vif(mrt, skb->dev);
2211
2212                 if (vif >= 0)
2213                         cache = ip6mr_cache_find_any(mrt,
2214                                                      &ipv6_hdr(skb)->daddr,
2215                                                      vif);
2216         }
2217
2218         /*
2219          *      No usable cache entry
2220          */
2221         if (!cache) {
2222                 int vif;
2223
2224                 vif = ip6mr_find_vif(mrt, skb->dev);
2225                 if (vif >= 0) {
2226                         int err = ip6mr_cache_unresolved(mrt, vif, skb);
2227                         read_unlock(&mrt_lock);
2228
2229                         return err;
2230                 }
2231                 read_unlock(&mrt_lock);
2232                 kfree_skb(skb);
2233                 return -ENODEV;
2234         }
2235
2236         ip6_mr_forward(net, mrt, skb, cache);
2237
2238         read_unlock(&mrt_lock);
2239
2240         return 0;
2241 }
2242
2243
2244 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2245                                struct mfc6_cache *c, struct rtmsg *rtm)
2246 {
2247         int ct;
2248         struct rtnexthop *nhp;
2249         struct nlattr *mp_attr;
2250         struct rta_mfc_stats mfcs;
2251
2252         /* If cache is unresolved, don't try to parse IIF and OIF */
2253         if (c->mf6c_parent >= MAXMIFS)
2254                 return -ENOENT;
2255
2256         if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2257             nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2258                 return -EMSGSIZE;
2259         mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2260         if (!mp_attr)
2261                 return -EMSGSIZE;
2262
2263         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2264                 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2265                         nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2266                         if (!nhp) {
2267                                 nla_nest_cancel(skb, mp_attr);
2268                                 return -EMSGSIZE;
2269                         }
2270
2271                         nhp->rtnh_flags = 0;
2272                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2273                         nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2274                         nhp->rtnh_len = sizeof(*nhp);
2275                 }
2276         }
2277
2278         nla_nest_end(skb, mp_attr);
2279
2280         mfcs.mfcs_packets = c->mfc_un.res.pkt;
2281         mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2282         mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2283         if (nla_put(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs) < 0)
2284                 return -EMSGSIZE;
2285
2286         rtm->rtm_type = RTN_MULTICAST;
2287         return 1;
2288 }
2289
2290 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2291                     int nowait, u32 portid)
2292 {
2293         int err;
2294         struct mr6_table *mrt;
2295         struct mfc6_cache *cache;
2296         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2297
2298         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2299         if (!mrt)
2300                 return -ENOENT;
2301
2302         read_lock(&mrt_lock);
2303         cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2304         if (!cache && skb->dev) {
2305                 int vif = ip6mr_find_vif(mrt, skb->dev);
2306
2307                 if (vif >= 0)
2308                         cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2309                                                      vif);
2310         }
2311
2312         if (!cache) {
2313                 struct sk_buff *skb2;
2314                 struct ipv6hdr *iph;
2315                 struct net_device *dev;
2316                 int vif;
2317
2318                 if (nowait) {
2319                         read_unlock(&mrt_lock);
2320                         return -EAGAIN;
2321                 }
2322
2323                 dev = skb->dev;
2324                 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2325                         read_unlock(&mrt_lock);
2326                         return -ENODEV;
2327                 }
2328
2329                 /* really correct? */
2330                 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2331                 if (!skb2) {
2332                         read_unlock(&mrt_lock);
2333                         return -ENOMEM;
2334                 }
2335
2336                 NETLINK_CB(skb2).portid = portid;
2337                 skb_reset_transport_header(skb2);
2338
2339                 skb_put(skb2, sizeof(struct ipv6hdr));
2340                 skb_reset_network_header(skb2);
2341
2342                 iph = ipv6_hdr(skb2);
2343                 iph->version = 0;
2344                 iph->priority = 0;
2345                 iph->flow_lbl[0] = 0;
2346                 iph->flow_lbl[1] = 0;
2347                 iph->flow_lbl[2] = 0;
2348                 iph->payload_len = 0;
2349                 iph->nexthdr = IPPROTO_NONE;
2350                 iph->hop_limit = 0;
2351                 iph->saddr = rt->rt6i_src.addr;
2352                 iph->daddr = rt->rt6i_dst.addr;
2353
2354                 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2355                 read_unlock(&mrt_lock);
2356
2357                 return err;
2358         }
2359
2360         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
2361                 cache->mfc_flags |= MFC_NOTIFY;
2362
2363         err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2364         read_unlock(&mrt_lock);
2365         return err;
2366 }
2367
2368 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2369                              u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2370                              int flags)
2371 {
2372         struct nlmsghdr *nlh;
2373         struct rtmsg *rtm;
2374         int err;
2375
2376         nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2377         if (!nlh)
2378                 return -EMSGSIZE;
2379
2380         rtm = nlmsg_data(nlh);
2381         rtm->rtm_family   = RTNL_FAMILY_IP6MR;
2382         rtm->rtm_dst_len  = 128;
2383         rtm->rtm_src_len  = 128;
2384         rtm->rtm_tos      = 0;
2385         rtm->rtm_table    = mrt->id;
2386         if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2387                 goto nla_put_failure;
2388         rtm->rtm_type = RTN_MULTICAST;
2389         rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
2390         if (c->mfc_flags & MFC_STATIC)
2391                 rtm->rtm_protocol = RTPROT_STATIC;
2392         else
2393                 rtm->rtm_protocol = RTPROT_MROUTED;
2394         rtm->rtm_flags    = 0;
2395
2396         if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2397             nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2398                 goto nla_put_failure;
2399         err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2400         /* do not break the dump if cache is unresolved */
2401         if (err < 0 && err != -ENOENT)
2402                 goto nla_put_failure;
2403
2404         nlmsg_end(skb, nlh);
2405         return 0;
2406
2407 nla_put_failure:
2408         nlmsg_cancel(skb, nlh);
2409         return -EMSGSIZE;
2410 }
2411
2412 static int mr6_msgsize(bool unresolved, int maxvif)
2413 {
2414         size_t len =
2415                 NLMSG_ALIGN(sizeof(struct rtmsg))
2416                 + nla_total_size(4)     /* RTA_TABLE */
2417                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_SRC */
2418                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_DST */
2419                 ;
2420
2421         if (!unresolved)
2422                 len = len
2423                       + nla_total_size(4)       /* RTA_IIF */
2424                       + nla_total_size(0)       /* RTA_MULTIPATH */
2425                       + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2426                                                 /* RTA_MFC_STATS */
2427                       + nla_total_size(sizeof(struct rta_mfc_stats))
2428                 ;
2429
2430         return len;
2431 }
2432
2433 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2434                               int cmd)
2435 {
2436         struct net *net = read_pnet(&mrt->net);
2437         struct sk_buff *skb;
2438         int err = -ENOBUFS;
2439
2440         skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2441                         GFP_ATOMIC);
2442         if (!skb)
2443                 goto errout;
2444
2445         err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2446         if (err < 0)
2447                 goto errout;
2448
2449         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2450         return;
2451
2452 errout:
2453         kfree_skb(skb);
2454         if (err < 0)
2455                 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2456 }
2457
2458 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2459 {
2460         struct net *net = sock_net(skb->sk);
2461         struct mr6_table *mrt;
2462         struct mfc6_cache *mfc;
2463         unsigned int t = 0, s_t;
2464         unsigned int h = 0, s_h;
2465         unsigned int e = 0, s_e;
2466
2467         s_t = cb->args[0];
2468         s_h = cb->args[1];
2469         s_e = cb->args[2];
2470
2471         read_lock(&mrt_lock);
2472         ip6mr_for_each_table(mrt, net) {
2473                 if (t < s_t)
2474                         goto next_table;
2475                 if (t > s_t)
2476                         s_h = 0;
2477                 for (h = s_h; h < MFC6_LINES; h++) {
2478                         list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2479                                 if (e < s_e)
2480                                         goto next_entry;
2481                                 if (ip6mr_fill_mroute(mrt, skb,
2482                                                       NETLINK_CB(cb->skb).portid,
2483                                                       cb->nlh->nlmsg_seq,
2484                                                       mfc, RTM_NEWROUTE,
2485                                                       NLM_F_MULTI) < 0)
2486                                         goto done;
2487 next_entry:
2488                                 e++;
2489                         }
2490                         e = s_e = 0;
2491                 }
2492                 spin_lock_bh(&mfc_unres_lock);
2493                 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2494                         if (e < s_e)
2495                                 goto next_entry2;
2496                         if (ip6mr_fill_mroute(mrt, skb,
2497                                               NETLINK_CB(cb->skb).portid,
2498                                               cb->nlh->nlmsg_seq,
2499                                               mfc, RTM_NEWROUTE,
2500                                               NLM_F_MULTI) < 0) {
2501                                 spin_unlock_bh(&mfc_unres_lock);
2502                                 goto done;
2503                         }
2504 next_entry2:
2505                         e++;
2506                 }
2507                 spin_unlock_bh(&mfc_unres_lock);
2508                 e = s_e = 0;
2509                 s_h = 0;
2510 next_table:
2511                 t++;
2512         }
2513 done:
2514         read_unlock(&mrt_lock);
2515
2516         cb->args[2] = e;
2517         cb->args[1] = h;
2518         cb->args[0] = t;
2519
2520         return skb->len;
2521 }