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