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