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