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