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 <linux/uaccess.h>
  20 #include <linux/types.h>
  21 #include <linux/sched.h>
  22 #include <linux/errno.h>
  23 #include <linux/timer.h>
  24 #include <linux/mm.h>
  25 #include <linux/kernel.h>
  26 #include <linux/fcntl.h>
  27 #include <linux/stat.h>
  28 #include <linux/socket.h>
  29 #include <linux/inet.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/inetdevice.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/seq_file.h>
  34 #include <linux/init.h>
  35 #include <linux/slab.h>
  36 #include <linux/compat.h>
  37 #include <net/protocol.h>
  38 #include <linux/skbuff.h>
  39 #include <net/sock.h>
  40 #include <net/raw.h>
  41 #include <linux/notifier.h>
  42 #include <linux/if_arp.h>
  43 #include <net/checksum.h>
  44 #include <net/netlink.h>
  45 #include <net/fib_rules.h>
  46
  47 #include <net/ipv6.h>
  48 #include <net/ip6_route.h>
  49 #include <linux/mroute6.h>
  50 #include <linux/pim.h>
  51 #include <net/addrconf.h>
  52 #include <linux/netfilter_ipv6.h>
  53 #include <linux/export.h>
  54 #include <net/ip6_checksum.h>
  55 #include <linux/netconf.h>
  56
  57 struct mr6_table {
  58         struct list_head        list;
  59         possible_net_t          net;
  60         u32                     id;
  61         struct sock             *mroute6_sk;
  62         struct timer_list       ipmr_expire_timer;
  63         struct list_head        mfc6_unres_queue;
  64         struct list_head        mfc6_cache_array[MFC6_LINES];
  65         struct mif_device       vif6_table[MAXMIFS];
  66         int                     maxvif;
  67         atomic_t                cache_resolve_queue_len;
  68         bool                    mroute_do_assert;
  69         bool                    mroute_do_pim;
  70 #ifdef CONFIG_IPV6_PIMSM_V2
  71         int                     mroute_reg_vif_num;
  72 #endif
  73 };
  74
  75 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 void 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 void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
 118                               int cmd);
 119 static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt);
 120 static int ip6mr_rtm_dumproute(struct sk_buff *skb,
 121                                struct netlink_callback *cb);
 122 static void mroute_clean_tables(struct mr6_table *mrt, bool all);
 123 static void ipmr_expire_process(unsigned long arg);
 124
 125 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
 126 #define ip6mr_for_each_table(mrt, net) \
 127         list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list)
 128
 129 static struct mr6_table *ip6mr_get_table(struct net *net, u32 id)
 130 {
 131         struct mr6_table *mrt;
 132
 133         ip6mr_for_each_table(mrt, net) {
 134                 if (mrt->id == id)
 135                         return mrt;
 136         }
 137         return NULL;
 138 }
 139
 140 static int ip6mr_fib_lookup(struct net *net, struct flowi6 *flp6,
 141                             struct mr6_table **mrt)
 142 {
 143         int err;
 144         struct ip6mr_result res;
 145         struct fib_lookup_arg arg = {
 146                 .result = &res,
 147                 .flags = FIB_LOOKUP_NOREF,
 148         };
 149
 150         err = fib_rules_lookup(net->ipv6.mr6_rules_ops,
 151                                flowi6_to_flowi(flp6), 0, &arg);
 152         if (err < 0)
 153                 return err;
 154         *mrt = res.mrt;
 155         return 0;
 156 }
 157
 158 static int ip6mr_rule_action(struct fib_rule *rule, struct flowi *flp,
 159                              int flags, struct fib_lookup_arg *arg)
 160 {
 161         struct ip6mr_result *res = arg->result;
 162         struct mr6_table *mrt;
 163
 164         switch (rule->action) {
 165         case FR_ACT_TO_TBL:
 166                 break;
 167         case FR_ACT_UNREACHABLE:
 168                 return -ENETUNREACH;
 169         case FR_ACT_PROHIBIT:
 170                 return -EACCES;
 171         case FR_ACT_BLACKHOLE:
 172         default:
 173                 return -EINVAL;
 174         }
 175
 176         mrt = ip6mr_get_table(rule->fr_net, rule->table);
 177         if (!mrt)
 178                 return -EAGAIN;
 179         res->mrt = mrt;
 180         return 0;
 181 }
 182
 183 static int ip6mr_rule_match(struct fib_rule *rule, struct flowi *flp, int flags)
 184 {
 185         return 1;
 186 }
 187
 188 static const struct nla_policy ip6mr_rule_policy[FRA_MAX + 1] = {
 189         FRA_GENERIC_POLICY,
 190 };
 191
 192 static int ip6mr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
 193                                 struct fib_rule_hdr *frh, struct nlattr **tb)
 194 {
 195         return 0;
 196 }
 197
 198 static int ip6mr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
 199                               struct nlattr **tb)
 200 {
 201         return 1;
 202 }
 203
 204 static int ip6mr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 205                            struct fib_rule_hdr *frh)
 206 {
 207         frh->dst_len = 0;
 208         frh->src_len = 0;
 209         frh->tos     = 0;
 210         return 0;
 211 }
 212
 213 static const struct fib_rules_ops __net_initconst ip6mr_rules_ops_template = {
 214         .family         = RTNL_FAMILY_IP6MR,
 215         .rule_size      = sizeof(struct ip6mr_rule),
 216         .addr_size      = sizeof(struct in6_addr),
 217         .action         = ip6mr_rule_action,
 218         .match          = ip6mr_rule_match,
 219         .configure      = ip6mr_rule_configure,
 220         .compare        = ip6mr_rule_compare,
 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) {
 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         ip6mr_free_table(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         fib_rules_unregister(net->ipv6.mr6_rules_ops);
 269         rtnl_unlock();
 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)
 309                 return mrt;
 310
 311         mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
 312         if (!mrt)
 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)
 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)
 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_TYPE_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)
 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
 677         skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
 678
 679         netif_rx(skb);
 680
 681         dev_put(reg_dev);
 682         return 0;
 683  drop:
 684         kfree_skb(skb);
 685         return 0;
 686 }
 687
 688 static const struct inet6_protocol pim6_protocol = {
 689         .handler        =       pim6_rcv,
 690 };
 691
 692 /* Service routines creating virtual interfaces: PIMREG */
 693
 694 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb,
 695                                       struct net_device *dev)
 696 {
 697         struct net *net = dev_net(dev);
 698         struct mr6_table *mrt;
 699         struct flowi6 fl6 = {
 700                 .flowi6_oif     = dev->ifindex,
 701                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
 702                 .flowi6_mark    = skb->mark,
 703         };
 704         int err;
 705
 706         err = ip6mr_fib_lookup(net, &fl6, &mrt);
 707         if (err < 0) {
 708                 kfree_skb(skb);
 709                 return err;
 710         }
 711
 712         read_lock(&mrt_lock);
 713         dev->stats.tx_bytes += skb->len;
 714         dev->stats.tx_packets++;
 715         ip6mr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, MRT6MSG_WHOLEPKT);
 716         read_unlock(&mrt_lock);
 717         kfree_skb(skb);
 718         return NETDEV_TX_OK;
 719 }
 720
 721 static int reg_vif_get_iflink(const struct net_device *dev)
 722 {
 723         return 0;
 724 }
 725
 726 static const struct net_device_ops reg_vif_netdev_ops = {
 727         .ndo_start_xmit = reg_vif_xmit,
 728         .ndo_get_iflink = reg_vif_get_iflink,
 729 };
 730
 731 static void reg_vif_setup(struct net_device *dev)
 732 {
 733         dev->type               = ARPHRD_PIMREG;
 734         dev->mtu                = 1500 - sizeof(struct ipv6hdr) - 8;
 735         dev->flags              = IFF_NOARP;
 736         dev->netdev_ops         = &reg_vif_netdev_ops;
 737         dev->needs_free_netdev  = true;
 738         dev->features           |= NETIF_F_NETNS_LOCAL;
 739 }
 740
 741 static struct net_device *ip6mr_reg_vif(struct net *net, struct mr6_table *mrt)
 742 {
 743         struct net_device *dev;
 744         char name[IFNAMSIZ];
 745
 746         if (mrt->id == RT6_TABLE_DFLT)
 747                 sprintf(name, "pim6reg");
 748         else
 749                 sprintf(name, "pim6reg%u", mrt->id);
 750
 751         dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
 752         if (!dev)
 753                 return NULL;
 754
 755         dev_net_set(dev, net);
 756
 757         if (register_netdevice(dev)) {
 758                 free_netdev(dev);
 759                 return NULL;
 760         }
 761
 762         if (dev_open(dev))
 763                 goto failure;
 764
 765         dev_hold(dev);
 766         return dev;
 767
 768 failure:
 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, int notify,
 779                        struct list_head *head)
 780 {
 781         struct mif_device *v;
 782         struct net_device *dev;
 783         struct inet6_dev *in6_dev;
 784
 785         if (vifi < 0 || vifi >= mrt->maxvif)
 786                 return -EADDRNOTAVAIL;
 787
 788         v = &mrt->vif6_table[vifi];
 789
 790         write_lock_bh(&mrt_lock);
 791         dev = v->dev;
 792         v->dev = NULL;
 793
 794         if (!dev) {
 795                 write_unlock_bh(&mrt_lock);
 796                 return -EADDRNOTAVAIL;
 797         }
 798
 799 #ifdef CONFIG_IPV6_PIMSM_V2
 800         if (vifi == mrt->mroute_reg_vif_num)
 801                 mrt->mroute_reg_vif_num = -1;
 802 #endif
 803
 804         if (vifi + 1 == mrt->maxvif) {
 805                 int tmp;
 806                 for (tmp = vifi - 1; tmp >= 0; tmp--) {
 807                         if (MIF_EXISTS(mrt, tmp))
 808                                 break;
 809                 }
 810                 mrt->maxvif = tmp + 1;
 811         }
 812
 813         write_unlock_bh(&mrt_lock);
 814
 815         dev_set_allmulti(dev, -1);
 816
 817         in6_dev = __in6_dev_get(dev);
 818         if (in6_dev) {
 819                 in6_dev->cnf.mc_forwarding--;
 820                 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
 821                                              NETCONFA_MC_FORWARDING,
 822                                              dev->ifindex, &in6_dev->cnf);
 823         }
 824
 825         if ((v->flags & MIFF_REGISTER) && !notify)
 826                 unregister_netdevice_queue(dev, head);
 827
 828         dev_put(dev);
 829         return 0;
 830 }
 831
 832 static inline void ip6mr_cache_free(struct mfc6_cache *c)
 833 {
 834         kmem_cache_free(mrt_cachep, c);
 835 }
 836
 837 /* Destroy an unresolved cache entry, killing queued skbs
 838    and reporting error to netlink readers.
 839  */
 840
 841 static void ip6mr_destroy_unres(struct mr6_table *mrt, struct mfc6_cache *c)
 842 {
 843         struct net *net = read_pnet(&mrt->net);
 844         struct sk_buff *skb;
 845
 846         atomic_dec(&mrt->cache_resolve_queue_len);
 847
 848         while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
 849                 if (ipv6_hdr(skb)->version == 0) {
 850                         struct nlmsghdr *nlh = skb_pull(skb,
 851                                                         sizeof(struct ipv6hdr));
 852                         nlh->nlmsg_type = NLMSG_ERROR;
 853                         nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
 854                         skb_trim(skb, nlh->nlmsg_len);
 855                         ((struct nlmsgerr *)nlmsg_data(nlh))->error = -ETIMEDOUT;
 856                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
 857                 } else
 858                         kfree_skb(skb);
 859         }
 860
 861         ip6mr_cache_free(c);
 862 }
 863
 864
 865 /* Timer process for all the unresolved queue. */
 866
 867 static void ipmr_do_expire_process(struct mr6_table *mrt)
 868 {
 869         unsigned long now = jiffies;
 870         unsigned long expires = 10 * HZ;
 871         struct mfc6_cache *c, *next;
 872
 873         list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
 874                 if (time_after(c->mfc_un.unres.expires, now)) {
 875                         /* not yet... */
 876                         unsigned long interval = c->mfc_un.unres.expires - now;
 877                         if (interval < expires)
 878                                 expires = interval;
 879                         continue;
 880                 }
 881
 882                 list_del(&c->list);
 883                 mr6_netlink_event(mrt, c, RTM_DELROUTE);
 884                 ip6mr_destroy_unres(mrt, c);
 885         }
 886
 887         if (!list_empty(&mrt->mfc6_unres_queue))
 888                 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
 889 }
 890
 891 static void ipmr_expire_process(unsigned long arg)
 892 {
 893         struct mr6_table *mrt = (struct mr6_table *)arg;
 894
 895         if (!spin_trylock(&mfc_unres_lock)) {
 896                 mod_timer(&mrt->ipmr_expire_timer, jiffies + 1);
 897                 return;
 898         }
 899
 900         if (!list_empty(&mrt->mfc6_unres_queue))
 901                 ipmr_do_expire_process(mrt);
 902
 903         spin_unlock(&mfc_unres_lock);
 904 }
 905
 906 /* Fill oifs list. It is called under write locked mrt_lock. */
 907
 908 static void ip6mr_update_thresholds(struct mr6_table *mrt, struct mfc6_cache *cache,
 909                                     unsigned char *ttls)
 910 {
 911         int vifi;
 912
 913         cache->mfc_un.res.minvif = MAXMIFS;
 914         cache->mfc_un.res.maxvif = 0;
 915         memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
 916
 917         for (vifi = 0; vifi < mrt->maxvif; vifi++) {
 918                 if (MIF_EXISTS(mrt, vifi) &&
 919                     ttls[vifi] && ttls[vifi] < 255) {
 920                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
 921                         if (cache->mfc_un.res.minvif > vifi)
 922                                 cache->mfc_un.res.minvif = vifi;
 923                         if (cache->mfc_un.res.maxvif <= vifi)
 924                                 cache->mfc_un.res.maxvif = vifi + 1;
 925                 }
 926         }
 927         cache->mfc_un.res.lastuse = jiffies;
 928 }
 929
 930 static int mif6_add(struct net *net, struct mr6_table *mrt,
 931                     struct mif6ctl *vifc, int mrtsock)
 932 {
 933         int vifi = vifc->mif6c_mifi;
 934         struct mif_device *v = &mrt->vif6_table[vifi];
 935         struct net_device *dev;
 936         struct inet6_dev *in6_dev;
 937         int err;
 938
 939         /* Is vif busy ? */
 940         if (MIF_EXISTS(mrt, vifi))
 941                 return -EADDRINUSE;
 942
 943         switch (vifc->mif6c_flags) {
 944 #ifdef CONFIG_IPV6_PIMSM_V2
 945         case MIFF_REGISTER:
 946                 /*
 947                  * Special Purpose VIF in PIM
 948                  * All the packets will be sent to the daemon
 949                  */
 950                 if (mrt->mroute_reg_vif_num >= 0)
 951                         return -EADDRINUSE;
 952                 dev = ip6mr_reg_vif(net, mrt);
 953                 if (!dev)
 954                         return -ENOBUFS;
 955                 err = dev_set_allmulti(dev, 1);
 956                 if (err) {
 957                         unregister_netdevice(dev);
 958                         dev_put(dev);
 959                         return err;
 960                 }
 961                 break;
 962 #endif
 963         case 0:
 964                 dev = dev_get_by_index(net, vifc->mif6c_pifi);
 965                 if (!dev)
 966                         return -EADDRNOTAVAIL;
 967                 err = dev_set_allmulti(dev, 1);
 968                 if (err) {
 969                         dev_put(dev);
 970                         return err;
 971                 }
 972                 break;
 973         default:
 974                 return -EINVAL;
 975         }
 976
 977         in6_dev = __in6_dev_get(dev);
 978         if (in6_dev) {
 979                 in6_dev->cnf.mc_forwarding++;
 980                 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
 981                                              NETCONFA_MC_FORWARDING,
 982                                              dev->ifindex, &in6_dev->cnf);
 983         }
 984
 985         /*
 986          *      Fill in the VIF structures
 987          */
 988         v->rate_limit = vifc->vifc_rate_limit;
 989         v->flags = vifc->mif6c_flags;
 990         if (!mrtsock)
 991                 v->flags |= VIFF_STATIC;
 992         v->threshold = vifc->vifc_threshold;
 993         v->bytes_in = 0;
 994         v->bytes_out = 0;
 995         v->pkt_in = 0;
 996         v->pkt_out = 0;
 997         v->link = dev->ifindex;
 998         if (v->flags & MIFF_REGISTER)
 999                 v->link = dev_get_iflink(dev);
1000
1001         /* And finish update writing critical data */
1002         write_lock_bh(&mrt_lock);
1003         v->dev = dev;
1004 #ifdef CONFIG_IPV6_PIMSM_V2
1005         if (v->flags & MIFF_REGISTER)
1006                 mrt->mroute_reg_vif_num = vifi;
1007 #endif
1008         if (vifi + 1 > mrt->maxvif)
1009                 mrt->maxvif = vifi + 1;
1010         write_unlock_bh(&mrt_lock);
1011         return 0;
1012 }
1013
1014 static struct mfc6_cache *ip6mr_cache_find(struct mr6_table *mrt,
1015                                            const struct in6_addr *origin,
1016                                            const struct in6_addr *mcastgrp)
1017 {
1018         int line = MFC6_HASH(mcastgrp, origin);
1019         struct mfc6_cache *c;
1020
1021         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1022                 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
1023                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
1024                         return c;
1025         }
1026         return NULL;
1027 }
1028
1029 /* Look for a (*,*,oif) entry */
1030 static struct mfc6_cache *ip6mr_cache_find_any_parent(struct mr6_table *mrt,
1031                                                       mifi_t mifi)
1032 {
1033         int line = MFC6_HASH(&in6addr_any, &in6addr_any);
1034         struct mfc6_cache *c;
1035
1036         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1037                 if (ipv6_addr_any(&c->mf6c_origin) &&
1038                     ipv6_addr_any(&c->mf6c_mcastgrp) &&
1039                     (c->mfc_un.res.ttls[mifi] < 255))
1040                         return c;
1041
1042         return NULL;
1043 }
1044
1045 /* Look for a (*,G) entry */
1046 static struct mfc6_cache *ip6mr_cache_find_any(struct mr6_table *mrt,
1047                                                struct in6_addr *mcastgrp,
1048                                                mifi_t mifi)
1049 {
1050         int line = MFC6_HASH(mcastgrp, &in6addr_any);
1051         struct mfc6_cache *c, *proxy;
1052
1053         if (ipv6_addr_any(mcastgrp))
1054                 goto skip;
1055
1056         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list)
1057                 if (ipv6_addr_any(&c->mf6c_origin) &&
1058                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp)) {
1059                         if (c->mfc_un.res.ttls[mifi] < 255)
1060                                 return c;
1061
1062                         /* It's ok if the mifi is part of the static tree */
1063                         proxy = ip6mr_cache_find_any_parent(mrt,
1064                                                             c->mf6c_parent);
1065                         if (proxy && proxy->mfc_un.res.ttls[mifi] < 255)
1066                                 return c;
1067                 }
1068
1069 skip:
1070         return ip6mr_cache_find_any_parent(mrt, mifi);
1071 }
1072
1073 /*
1074  *      Allocate a multicast cache entry
1075  */
1076 static struct mfc6_cache *ip6mr_cache_alloc(void)
1077 {
1078         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
1079         if (!c)
1080                 return NULL;
1081         c->mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
1082         c->mfc_un.res.minvif = MAXMIFS;
1083         return c;
1084 }
1085
1086 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
1087 {
1088         struct mfc6_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
1089         if (!c)
1090                 return NULL;
1091         skb_queue_head_init(&c->mfc_un.unres.unresolved);
1092         c->mfc_un.unres.expires = jiffies + 10 * HZ;
1093         return c;
1094 }
1095
1096 /*
1097  *      A cache entry has gone into a resolved state from queued
1098  */
1099
1100 static void ip6mr_cache_resolve(struct net *net, struct mr6_table *mrt,
1101                                 struct mfc6_cache *uc, struct mfc6_cache *c)
1102 {
1103         struct sk_buff *skb;
1104
1105         /*
1106          *      Play the pending entries through our router
1107          */
1108
1109         while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
1110                 if (ipv6_hdr(skb)->version == 0) {
1111                         struct nlmsghdr *nlh = skb_pull(skb,
1112                                                         sizeof(struct ipv6hdr));
1113
1114                         if (__ip6mr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
1115                                 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
1116                         } else {
1117                                 nlh->nlmsg_type = NLMSG_ERROR;
1118                                 nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
1119                                 skb_trim(skb, nlh->nlmsg_len);
1120                                 ((struct nlmsgerr *)nlmsg_data(nlh))->error = -EMSGSIZE;
1121                         }
1122                         rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
1123                 } else
1124                         ip6_mr_forward(net, mrt, skb, c);
1125         }
1126 }
1127
1128 /*
1129  *      Bounce a cache query up to pim6sd and netlink.
1130  *
1131  *      Called under mrt_lock.
1132  */
1133
1134 static int ip6mr_cache_report(struct mr6_table *mrt, struct sk_buff *pkt,
1135                               mifi_t mifi, int assert)
1136 {
1137         struct sk_buff *skb;
1138         struct mrt6msg *msg;
1139         int ret;
1140
1141 #ifdef CONFIG_IPV6_PIMSM_V2
1142         if (assert == MRT6MSG_WHOLEPKT)
1143                 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
1144                                                 +sizeof(*msg));
1145         else
1146 #endif
1147                 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
1148
1149         if (!skb)
1150                 return -ENOBUFS;
1151
1152         /* I suppose that internal messages
1153          * do not require checksums */
1154
1155         skb->ip_summed = CHECKSUM_UNNECESSARY;
1156
1157 #ifdef CONFIG_IPV6_PIMSM_V2
1158         if (assert == MRT6MSG_WHOLEPKT) {
1159                 /* Ugly, but we have no choice with this interface.
1160                    Duplicate old header, fix length etc.
1161                    And all this only to mangle msg->im6_msgtype and
1162                    to set msg->im6_mbz to "mbz" :-)
1163                  */
1164                 skb_push(skb, -skb_network_offset(pkt));
1165
1166                 skb_push(skb, sizeof(*msg));
1167                 skb_reset_transport_header(skb);
1168                 msg = (struct mrt6msg *)skb_transport_header(skb);
1169                 msg->im6_mbz = 0;
1170                 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
1171                 msg->im6_mif = mrt->mroute_reg_vif_num;
1172                 msg->im6_pad = 0;
1173                 msg->im6_src = ipv6_hdr(pkt)->saddr;
1174                 msg->im6_dst = ipv6_hdr(pkt)->daddr;
1175
1176                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1177         } else
1178 #endif
1179         {
1180         /*
1181          *      Copy the IP header
1182          */
1183
1184         skb_put(skb, sizeof(struct ipv6hdr));
1185         skb_reset_network_header(skb);
1186         skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
1187
1188         /*
1189          *      Add our header
1190          */
1191         skb_put(skb, sizeof(*msg));
1192         skb_reset_transport_header(skb);
1193         msg = (struct mrt6msg *)skb_transport_header(skb);
1194
1195         msg->im6_mbz = 0;
1196         msg->im6_msgtype = assert;
1197         msg->im6_mif = mifi;
1198         msg->im6_pad = 0;
1199         msg->im6_src = ipv6_hdr(pkt)->saddr;
1200         msg->im6_dst = ipv6_hdr(pkt)->daddr;
1201
1202         skb_dst_set(skb, dst_clone(skb_dst(pkt)));
1203         skb->ip_summed = CHECKSUM_UNNECESSARY;
1204         }
1205
1206         if (!mrt->mroute6_sk) {
1207                 kfree_skb(skb);
1208                 return -EINVAL;
1209         }
1210
1211         mrt6msg_netlink_event(mrt, skb);
1212
1213         /*
1214          *      Deliver to user space multicast routing algorithms
1215          */
1216         ret = sock_queue_rcv_skb(mrt->mroute6_sk, skb);
1217         if (ret < 0) {
1218                 net_warn_ratelimited("mroute6: pending queue full, dropping entries\n");
1219                 kfree_skb(skb);
1220         }
1221
1222         return ret;
1223 }
1224
1225 /*
1226  *      Queue a packet for resolution. It gets locked cache entry!
1227  */
1228
1229 static int
1230 ip6mr_cache_unresolved(struct mr6_table *mrt, mifi_t mifi, struct sk_buff *skb)
1231 {
1232         bool found = false;
1233         int err;
1234         struct mfc6_cache *c;
1235
1236         spin_lock_bh(&mfc_unres_lock);
1237         list_for_each_entry(c, &mrt->mfc6_unres_queue, list) {
1238                 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
1239                     ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr)) {
1240                         found = true;
1241                         break;
1242                 }
1243         }
1244
1245         if (!found) {
1246                 /*
1247                  *      Create a new entry if allowable
1248                  */
1249
1250                 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
1251                     (c = ip6mr_cache_alloc_unres()) == NULL) {
1252                         spin_unlock_bh(&mfc_unres_lock);
1253
1254                         kfree_skb(skb);
1255                         return -ENOBUFS;
1256                 }
1257
1258                 /*
1259                  *      Fill in the new cache entry
1260                  */
1261                 c->mf6c_parent = -1;
1262                 c->mf6c_origin = ipv6_hdr(skb)->saddr;
1263                 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
1264
1265                 /*
1266                  *      Reflect first query at pim6sd
1267                  */
1268                 err = ip6mr_cache_report(mrt, skb, mifi, MRT6MSG_NOCACHE);
1269                 if (err < 0) {
1270                         /* If the report failed throw the cache entry
1271                            out - Brad Parker
1272                          */
1273                         spin_unlock_bh(&mfc_unres_lock);
1274
1275                         ip6mr_cache_free(c);
1276                         kfree_skb(skb);
1277                         return err;
1278                 }
1279
1280                 atomic_inc(&mrt->cache_resolve_queue_len);
1281                 list_add(&c->list, &mrt->mfc6_unres_queue);
1282                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1283
1284                 ipmr_do_expire_process(mrt);
1285         }
1286
1287         /*
1288          *      See if we can append the packet
1289          */
1290         if (c->mfc_un.unres.unresolved.qlen > 3) {
1291                 kfree_skb(skb);
1292                 err = -ENOBUFS;
1293         } else {
1294                 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1295                 err = 0;
1296         }
1297
1298         spin_unlock_bh(&mfc_unres_lock);
1299         return err;
1300 }
1301
1302 /*
1303  *      MFC6 cache manipulation by user space
1304  */
1305
1306 static int ip6mr_mfc_delete(struct mr6_table *mrt, struct mf6cctl *mfc,
1307                             int parent)
1308 {
1309         int line;
1310         struct mfc6_cache *c, *next;
1311
1312         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1313
1314         list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[line], list) {
1315                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1316                     ipv6_addr_equal(&c->mf6c_mcastgrp,
1317                                     &mfc->mf6cc_mcastgrp.sin6_addr) &&
1318                     (parent == -1 || parent == c->mf6c_parent)) {
1319                         write_lock_bh(&mrt_lock);
1320                         list_del(&c->list);
1321                         write_unlock_bh(&mrt_lock);
1322
1323                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1324                         ip6mr_cache_free(c);
1325                         return 0;
1326                 }
1327         }
1328         return -ENOENT;
1329 }
1330
1331 static int ip6mr_device_event(struct notifier_block *this,
1332                               unsigned long event, void *ptr)
1333 {
1334         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1335         struct net *net = dev_net(dev);
1336         struct mr6_table *mrt;
1337         struct mif_device *v;
1338         int ct;
1339
1340         if (event != NETDEV_UNREGISTER)
1341                 return NOTIFY_DONE;
1342
1343         ip6mr_for_each_table(mrt, net) {
1344                 v = &mrt->vif6_table[0];
1345                 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1346                         if (v->dev == dev)
1347                                 mif6_delete(mrt, ct, 1, NULL);
1348                 }
1349         }
1350
1351         return NOTIFY_DONE;
1352 }
1353
1354 static struct notifier_block ip6_mr_notifier = {
1355         .notifier_call = ip6mr_device_event
1356 };
1357
1358 /*
1359  *      Setup for IP multicast routing
1360  */
1361
1362 static int __net_init ip6mr_net_init(struct net *net)
1363 {
1364         int err;
1365
1366         err = ip6mr_rules_init(net);
1367         if (err < 0)
1368                 goto fail;
1369
1370 #ifdef CONFIG_PROC_FS
1371         err = -ENOMEM;
1372         if (!proc_create("ip6_mr_vif", 0, net->proc_net, &ip6mr_vif_fops))
1373                 goto proc_vif_fail;
1374         if (!proc_create("ip6_mr_cache", 0, net->proc_net, &ip6mr_mfc_fops))
1375                 goto proc_cache_fail;
1376 #endif
1377
1378         return 0;
1379
1380 #ifdef CONFIG_PROC_FS
1381 proc_cache_fail:
1382         remove_proc_entry("ip6_mr_vif", net->proc_net);
1383 proc_vif_fail:
1384         ip6mr_rules_exit(net);
1385 #endif
1386 fail:
1387         return err;
1388 }
1389
1390 static void __net_exit ip6mr_net_exit(struct net *net)
1391 {
1392 #ifdef CONFIG_PROC_FS
1393         remove_proc_entry("ip6_mr_cache", net->proc_net);
1394         remove_proc_entry("ip6_mr_vif", net->proc_net);
1395 #endif
1396         ip6mr_rules_exit(net);
1397 }
1398
1399 static struct pernet_operations ip6mr_net_ops = {
1400         .init = ip6mr_net_init,
1401         .exit = ip6mr_net_exit,
1402 };
1403
1404 int __init ip6_mr_init(void)
1405 {
1406         int err;
1407
1408         mrt_cachep = kmem_cache_create("ip6_mrt_cache",
1409                                        sizeof(struct mfc6_cache),
1410                                        0, SLAB_HWCACHE_ALIGN,
1411                                        NULL);
1412         if (!mrt_cachep)
1413                 return -ENOMEM;
1414
1415         err = register_pernet_subsys(&ip6mr_net_ops);
1416         if (err)
1417                 goto reg_pernet_fail;
1418
1419         err = register_netdevice_notifier(&ip6_mr_notifier);
1420         if (err)
1421                 goto reg_notif_fail;
1422 #ifdef CONFIG_IPV6_PIMSM_V2
1423         if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
1424                 pr_err("%s: can't add PIM protocol\n", __func__);
1425                 err = -EAGAIN;
1426                 goto add_proto_fail;
1427         }
1428 #endif
1429         rtnl_register(RTNL_FAMILY_IP6MR, RTM_GETROUTE, NULL,
1430                       ip6mr_rtm_dumproute, NULL);
1431         return 0;
1432 #ifdef CONFIG_IPV6_PIMSM_V2
1433 add_proto_fail:
1434         unregister_netdevice_notifier(&ip6_mr_notifier);
1435 #endif
1436 reg_notif_fail:
1437         unregister_pernet_subsys(&ip6mr_net_ops);
1438 reg_pernet_fail:
1439         kmem_cache_destroy(mrt_cachep);
1440         return err;
1441 }
1442
1443 void ip6_mr_cleanup(void)
1444 {
1445         rtnl_unregister(RTNL_FAMILY_IP6MR, RTM_GETROUTE);
1446 #ifdef CONFIG_IPV6_PIMSM_V2
1447         inet6_del_protocol(&pim6_protocol, IPPROTO_PIM);
1448 #endif
1449         unregister_netdevice_notifier(&ip6_mr_notifier);
1450         unregister_pernet_subsys(&ip6mr_net_ops);
1451         kmem_cache_destroy(mrt_cachep);
1452 }
1453
1454 static int ip6mr_mfc_add(struct net *net, struct mr6_table *mrt,
1455                          struct mf6cctl *mfc, int mrtsock, int parent)
1456 {
1457         bool found = false;
1458         int line;
1459         struct mfc6_cache *uc, *c;
1460         unsigned char ttls[MAXMIFS];
1461         int i;
1462
1463         if (mfc->mf6cc_parent >= MAXMIFS)
1464                 return -ENFILE;
1465
1466         memset(ttls, 255, MAXMIFS);
1467         for (i = 0; i < MAXMIFS; i++) {
1468                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1469                         ttls[i] = 1;
1470
1471         }
1472
1473         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1474
1475         list_for_each_entry(c, &mrt->mfc6_cache_array[line], list) {
1476                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1477                     ipv6_addr_equal(&c->mf6c_mcastgrp,
1478                                     &mfc->mf6cc_mcastgrp.sin6_addr) &&
1479                     (parent == -1 || parent == mfc->mf6cc_parent)) {
1480                         found = true;
1481                         break;
1482                 }
1483         }
1484
1485         if (found) {
1486                 write_lock_bh(&mrt_lock);
1487                 c->mf6c_parent = mfc->mf6cc_parent;
1488                 ip6mr_update_thresholds(mrt, c, ttls);
1489                 if (!mrtsock)
1490                         c->mfc_flags |= MFC_STATIC;
1491                 write_unlock_bh(&mrt_lock);
1492                 mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1493                 return 0;
1494         }
1495
1496         if (!ipv6_addr_any(&mfc->mf6cc_mcastgrp.sin6_addr) &&
1497             !ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1498                 return -EINVAL;
1499
1500         c = ip6mr_cache_alloc();
1501         if (!c)
1502                 return -ENOMEM;
1503
1504         c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1505         c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1506         c->mf6c_parent = mfc->mf6cc_parent;
1507         ip6mr_update_thresholds(mrt, c, ttls);
1508         if (!mrtsock)
1509                 c->mfc_flags |= MFC_STATIC;
1510
1511         write_lock_bh(&mrt_lock);
1512         list_add(&c->list, &mrt->mfc6_cache_array[line]);
1513         write_unlock_bh(&mrt_lock);
1514
1515         /*
1516          *      Check to see if we resolved a queued list. If so we
1517          *      need to send on the frames and tidy up.
1518          */
1519         found = false;
1520         spin_lock_bh(&mfc_unres_lock);
1521         list_for_each_entry(uc, &mrt->mfc6_unres_queue, list) {
1522                 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1523                     ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1524                         list_del(&uc->list);
1525                         atomic_dec(&mrt->cache_resolve_queue_len);
1526                         found = true;
1527                         break;
1528                 }
1529         }
1530         if (list_empty(&mrt->mfc6_unres_queue))
1531                 del_timer(&mrt->ipmr_expire_timer);
1532         spin_unlock_bh(&mfc_unres_lock);
1533
1534         if (found) {
1535                 ip6mr_cache_resolve(net, mrt, uc, c);
1536                 ip6mr_cache_free(uc);
1537         }
1538         mr6_netlink_event(mrt, c, RTM_NEWROUTE);
1539         return 0;
1540 }
1541
1542 /*
1543  *      Close the multicast socket, and clear the vif tables etc
1544  */
1545
1546 static void mroute_clean_tables(struct mr6_table *mrt, bool all)
1547 {
1548         int i;
1549         LIST_HEAD(list);
1550         struct mfc6_cache *c, *next;
1551
1552         /*
1553          *      Shut down all active vif entries
1554          */
1555         for (i = 0; i < mrt->maxvif; i++) {
1556                 if (!all && (mrt->vif6_table[i].flags & VIFF_STATIC))
1557                         continue;
1558                 mif6_delete(mrt, i, 0, &list);
1559         }
1560         unregister_netdevice_many(&list);
1561
1562         /*
1563          *      Wipe the cache
1564          */
1565         for (i = 0; i < MFC6_LINES; i++) {
1566                 list_for_each_entry_safe(c, next, &mrt->mfc6_cache_array[i], list) {
1567                         if (!all && (c->mfc_flags & MFC_STATIC))
1568                                 continue;
1569                         write_lock_bh(&mrt_lock);
1570                         list_del(&c->list);
1571                         write_unlock_bh(&mrt_lock);
1572
1573                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1574                         ip6mr_cache_free(c);
1575                 }
1576         }
1577
1578         if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1579                 spin_lock_bh(&mfc_unres_lock);
1580                 list_for_each_entry_safe(c, next, &mrt->mfc6_unres_queue, list) {
1581                         list_del(&c->list);
1582                         mr6_netlink_event(mrt, c, RTM_DELROUTE);
1583                         ip6mr_destroy_unres(mrt, c);
1584                 }
1585                 spin_unlock_bh(&mfc_unres_lock);
1586         }
1587 }
1588
1589 static int ip6mr_sk_init(struct mr6_table *mrt, struct sock *sk)
1590 {
1591         int err = 0;
1592         struct net *net = sock_net(sk);
1593
1594         rtnl_lock();
1595         write_lock_bh(&mrt_lock);
1596         if (likely(mrt->mroute6_sk == NULL)) {
1597                 mrt->mroute6_sk = sk;
1598                 net->ipv6.devconf_all->mc_forwarding++;
1599         } else {
1600                 err = -EADDRINUSE;
1601         }
1602         write_unlock_bh(&mrt_lock);
1603
1604         if (!err)
1605                 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1606                                              NETCONFA_MC_FORWARDING,
1607                                              NETCONFA_IFINDEX_ALL,
1608                                              net->ipv6.devconf_all);
1609         rtnl_unlock();
1610
1611         return err;
1612 }
1613
1614 int ip6mr_sk_done(struct sock *sk)
1615 {
1616         int err = -EACCES;
1617         struct net *net = sock_net(sk);
1618         struct mr6_table *mrt;
1619
1620         rtnl_lock();
1621         ip6mr_for_each_table(mrt, net) {
1622                 if (sk == mrt->mroute6_sk) {
1623                         write_lock_bh(&mrt_lock);
1624                         mrt->mroute6_sk = NULL;
1625                         net->ipv6.devconf_all->mc_forwarding--;
1626                         write_unlock_bh(&mrt_lock);
1627                         inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
1628                                                      NETCONFA_MC_FORWARDING,
1629                                                      NETCONFA_IFINDEX_ALL,
1630                                                      net->ipv6.devconf_all);
1631
1632                         mroute_clean_tables(mrt, false);
1633                         err = 0;
1634                         break;
1635                 }
1636         }
1637         rtnl_unlock();
1638
1639         return err;
1640 }
1641
1642 struct sock *mroute6_socket(struct net *net, struct sk_buff *skb)
1643 {
1644         struct mr6_table *mrt;
1645         struct flowi6 fl6 = {
1646                 .flowi6_iif     = skb->skb_iif ? : LOOPBACK_IFINDEX,
1647                 .flowi6_oif     = skb->dev->ifindex,
1648                 .flowi6_mark    = skb->mark,
1649         };
1650
1651         if (ip6mr_fib_lookup(net, &fl6, &mrt) < 0)
1652                 return NULL;
1653
1654         return mrt->mroute6_sk;
1655 }
1656
1657 /*
1658  *      Socket options and virtual interface manipulation. The whole
1659  *      virtual interface system is a complete heap, but unfortunately
1660  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1661  *      MOSPF/PIM router set up we can clean this up.
1662  */
1663
1664 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1665 {
1666         int ret, parent = 0;
1667         struct mif6ctl vif;
1668         struct mf6cctl mfc;
1669         mifi_t mifi;
1670         struct net *net = sock_net(sk);
1671         struct mr6_table *mrt;
1672
1673         if (sk->sk_type != SOCK_RAW ||
1674             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1675                 return -EOPNOTSUPP;
1676
1677         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1678         if (!mrt)
1679                 return -ENOENT;
1680
1681         if (optname != MRT6_INIT) {
1682                 if (sk != mrt->mroute6_sk && !ns_capable(net->user_ns, CAP_NET_ADMIN))
1683                         return -EACCES;
1684         }
1685
1686         switch (optname) {
1687         case MRT6_INIT:
1688                 if (optlen < sizeof(int))
1689                         return -EINVAL;
1690
1691                 return ip6mr_sk_init(mrt, sk);
1692
1693         case MRT6_DONE:
1694                 return ip6mr_sk_done(sk);
1695
1696         case MRT6_ADD_MIF:
1697                 if (optlen < sizeof(vif))
1698                         return -EINVAL;
1699                 if (copy_from_user(&vif, optval, sizeof(vif)))
1700                         return -EFAULT;
1701                 if (vif.mif6c_mifi >= MAXMIFS)
1702                         return -ENFILE;
1703                 rtnl_lock();
1704                 ret = mif6_add(net, mrt, &vif, sk == mrt->mroute6_sk);
1705                 rtnl_unlock();
1706                 return ret;
1707
1708         case MRT6_DEL_MIF:
1709                 if (optlen < sizeof(mifi_t))
1710                         return -EINVAL;
1711                 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1712                         return -EFAULT;
1713                 rtnl_lock();
1714                 ret = mif6_delete(mrt, mifi, 0, NULL);
1715                 rtnl_unlock();
1716                 return ret;
1717
1718         /*
1719          *      Manipulate the forwarding caches. These live
1720          *      in a sort of kernel/user symbiosis.
1721          */
1722         case MRT6_ADD_MFC:
1723         case MRT6_DEL_MFC:
1724                 parent = -1;
1725         case MRT6_ADD_MFC_PROXY:
1726         case MRT6_DEL_MFC_PROXY:
1727                 if (optlen < sizeof(mfc))
1728                         return -EINVAL;
1729                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1730                         return -EFAULT;
1731                 if (parent == 0)
1732                         parent = mfc.mf6cc_parent;
1733                 rtnl_lock();
1734                 if (optname == MRT6_DEL_MFC || optname == MRT6_DEL_MFC_PROXY)
1735                         ret = ip6mr_mfc_delete(mrt, &mfc, parent);
1736                 else
1737                         ret = ip6mr_mfc_add(net, mrt, &mfc,
1738                                             sk == mrt->mroute6_sk, parent);
1739                 rtnl_unlock();
1740                 return ret;
1741
1742         /*
1743          *      Control PIM assert (to activate pim will activate assert)
1744          */
1745         case MRT6_ASSERT:
1746         {
1747                 int v;
1748
1749                 if (optlen != sizeof(v))
1750                         return -EINVAL;
1751                 if (get_user(v, (int __user *)optval))
1752                         return -EFAULT;
1753                 mrt->mroute_do_assert = v;
1754                 return 0;
1755         }
1756
1757 #ifdef CONFIG_IPV6_PIMSM_V2
1758         case MRT6_PIM:
1759         {
1760                 int v;
1761
1762                 if (optlen != sizeof(v))
1763                         return -EINVAL;
1764                 if (get_user(v, (int __user *)optval))
1765                         return -EFAULT;
1766                 v = !!v;
1767                 rtnl_lock();
1768                 ret = 0;
1769                 if (v != mrt->mroute_do_pim) {
1770                         mrt->mroute_do_pim = v;
1771                         mrt->mroute_do_assert = v;
1772                 }
1773                 rtnl_unlock();
1774                 return ret;
1775         }
1776
1777 #endif
1778 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
1779         case MRT6_TABLE:
1780         {
1781                 u32 v;
1782
1783                 if (optlen != sizeof(u32))
1784                         return -EINVAL;
1785                 if (get_user(v, (u32 __user *)optval))
1786                         return -EFAULT;
1787                 /* "pim6reg%u" should not exceed 16 bytes (IFNAMSIZ) */
1788                 if (v != RT_TABLE_DEFAULT && v >= 100000000)
1789                         return -EINVAL;
1790                 if (sk == mrt->mroute6_sk)
1791                         return -EBUSY;
1792
1793                 rtnl_lock();
1794                 ret = 0;
1795                 if (!ip6mr_new_table(net, v))
1796                         ret = -ENOMEM;
1797                 raw6_sk(sk)->ip6mr_table = v;
1798                 rtnl_unlock();
1799                 return ret;
1800         }
1801 #endif
1802         /*
1803          *      Spurious command, or MRT6_VERSION which you cannot
1804          *      set.
1805          */
1806         default:
1807                 return -ENOPROTOOPT;
1808         }
1809 }
1810
1811 /*
1812  *      Getsock opt support for the multicast routing system.
1813  */
1814
1815 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1816                           int __user *optlen)
1817 {
1818         int olr;
1819         int val;
1820         struct net *net = sock_net(sk);
1821         struct mr6_table *mrt;
1822
1823         if (sk->sk_type != SOCK_RAW ||
1824             inet_sk(sk)->inet_num != IPPROTO_ICMPV6)
1825                 return -EOPNOTSUPP;
1826
1827         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1828         if (!mrt)
1829                 return -ENOENT;
1830
1831         switch (optname) {
1832         case MRT6_VERSION:
1833                 val = 0x0305;
1834                 break;
1835 #ifdef CONFIG_IPV6_PIMSM_V2
1836         case MRT6_PIM:
1837                 val = mrt->mroute_do_pim;
1838                 break;
1839 #endif
1840         case MRT6_ASSERT:
1841                 val = mrt->mroute_do_assert;
1842                 break;
1843         default:
1844                 return -ENOPROTOOPT;
1845         }
1846
1847         if (get_user(olr, optlen))
1848                 return -EFAULT;
1849
1850         olr = min_t(int, olr, sizeof(int));
1851         if (olr < 0)
1852                 return -EINVAL;
1853
1854         if (put_user(olr, optlen))
1855                 return -EFAULT;
1856         if (copy_to_user(optval, &val, olr))
1857                 return -EFAULT;
1858         return 0;
1859 }
1860
1861 /*
1862  *      The IP multicast ioctl support routines.
1863  */
1864
1865 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1866 {
1867         struct sioc_sg_req6 sr;
1868         struct sioc_mif_req6 vr;
1869         struct mif_device *vif;
1870         struct mfc6_cache *c;
1871         struct net *net = sock_net(sk);
1872         struct mr6_table *mrt;
1873
1874         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1875         if (!mrt)
1876                 return -ENOENT;
1877
1878         switch (cmd) {
1879         case SIOCGETMIFCNT_IN6:
1880                 if (copy_from_user(&vr, arg, sizeof(vr)))
1881                         return -EFAULT;
1882                 if (vr.mifi >= mrt->maxvif)
1883                         return -EINVAL;
1884                 read_lock(&mrt_lock);
1885                 vif = &mrt->vif6_table[vr.mifi];
1886                 if (MIF_EXISTS(mrt, vr.mifi)) {
1887                         vr.icount = vif->pkt_in;
1888                         vr.ocount = vif->pkt_out;
1889                         vr.ibytes = vif->bytes_in;
1890                         vr.obytes = vif->bytes_out;
1891                         read_unlock(&mrt_lock);
1892
1893                         if (copy_to_user(arg, &vr, sizeof(vr)))
1894                                 return -EFAULT;
1895                         return 0;
1896                 }
1897                 read_unlock(&mrt_lock);
1898                 return -EADDRNOTAVAIL;
1899         case SIOCGETSGCNT_IN6:
1900                 if (copy_from_user(&sr, arg, sizeof(sr)))
1901                         return -EFAULT;
1902
1903                 read_lock(&mrt_lock);
1904                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1905                 if (c) {
1906                         sr.pktcnt = c->mfc_un.res.pkt;
1907                         sr.bytecnt = c->mfc_un.res.bytes;
1908                         sr.wrong_if = c->mfc_un.res.wrong_if;
1909                         read_unlock(&mrt_lock);
1910
1911                         if (copy_to_user(arg, &sr, sizeof(sr)))
1912                                 return -EFAULT;
1913                         return 0;
1914                 }
1915                 read_unlock(&mrt_lock);
1916                 return -EADDRNOTAVAIL;
1917         default:
1918                 return -ENOIOCTLCMD;
1919         }
1920 }
1921
1922 #ifdef CONFIG_COMPAT
1923 struct compat_sioc_sg_req6 {
1924         struct sockaddr_in6 src;
1925         struct sockaddr_in6 grp;
1926         compat_ulong_t pktcnt;
1927         compat_ulong_t bytecnt;
1928         compat_ulong_t wrong_if;
1929 };
1930
1931 struct compat_sioc_mif_req6 {
1932         mifi_t  mifi;
1933         compat_ulong_t icount;
1934         compat_ulong_t ocount;
1935         compat_ulong_t ibytes;
1936         compat_ulong_t obytes;
1937 };
1938
1939 int ip6mr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
1940 {
1941         struct compat_sioc_sg_req6 sr;
1942         struct compat_sioc_mif_req6 vr;
1943         struct mif_device *vif;
1944         struct mfc6_cache *c;
1945         struct net *net = sock_net(sk);
1946         struct mr6_table *mrt;
1947
1948         mrt = ip6mr_get_table(net, raw6_sk(sk)->ip6mr_table ? : RT6_TABLE_DFLT);
1949         if (!mrt)
1950                 return -ENOENT;
1951
1952         switch (cmd) {
1953         case SIOCGETMIFCNT_IN6:
1954                 if (copy_from_user(&vr, arg, sizeof(vr)))
1955                         return -EFAULT;
1956                 if (vr.mifi >= mrt->maxvif)
1957                         return -EINVAL;
1958                 read_lock(&mrt_lock);
1959                 vif = &mrt->vif6_table[vr.mifi];
1960                 if (MIF_EXISTS(mrt, vr.mifi)) {
1961                         vr.icount = vif->pkt_in;
1962                         vr.ocount = vif->pkt_out;
1963                         vr.ibytes = vif->bytes_in;
1964                         vr.obytes = vif->bytes_out;
1965                         read_unlock(&mrt_lock);
1966
1967                         if (copy_to_user(arg, &vr, sizeof(vr)))
1968                                 return -EFAULT;
1969                         return 0;
1970                 }
1971                 read_unlock(&mrt_lock);
1972                 return -EADDRNOTAVAIL;
1973         case SIOCGETSGCNT_IN6:
1974                 if (copy_from_user(&sr, arg, sizeof(sr)))
1975                         return -EFAULT;
1976
1977                 read_lock(&mrt_lock);
1978                 c = ip6mr_cache_find(mrt, &sr.src.sin6_addr, &sr.grp.sin6_addr);
1979                 if (c) {
1980                         sr.pktcnt = c->mfc_un.res.pkt;
1981                         sr.bytecnt = c->mfc_un.res.bytes;
1982                         sr.wrong_if = c->mfc_un.res.wrong_if;
1983                         read_unlock(&mrt_lock);
1984
1985                         if (copy_to_user(arg, &sr, sizeof(sr)))
1986                                 return -EFAULT;
1987                         return 0;
1988                 }
1989                 read_unlock(&mrt_lock);
1990                 return -EADDRNOTAVAIL;
1991         default:
1992                 return -ENOIOCTLCMD;
1993         }
1994 }
1995 #endif
1996
1997 static inline int ip6mr_forward2_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
1998 {
1999         __IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
2000                         IPSTATS_MIB_OUTFORWDATAGRAMS);
2001         __IP6_ADD_STATS(net, ip6_dst_idev(skb_dst(skb)),
2002                         IPSTATS_MIB_OUTOCTETS, skb->len);
2003         return dst_output(net, sk, skb);
2004 }
2005
2006 /*
2007  *      Processing handlers for ip6mr_forward
2008  */
2009
2010 static int ip6mr_forward2(struct net *net, struct mr6_table *mrt,
2011                           struct sk_buff *skb, struct mfc6_cache *c, int vifi)
2012 {
2013         struct ipv6hdr *ipv6h;
2014         struct mif_device *vif = &mrt->vif6_table[vifi];
2015         struct net_device *dev;
2016         struct dst_entry *dst;
2017         struct flowi6 fl6;
2018
2019         if (!vif->dev)
2020                 goto out_free;
2021
2022 #ifdef CONFIG_IPV6_PIMSM_V2
2023         if (vif->flags & MIFF_REGISTER) {
2024                 vif->pkt_out++;
2025                 vif->bytes_out += skb->len;
2026                 vif->dev->stats.tx_bytes += skb->len;
2027                 vif->dev->stats.tx_packets++;
2028                 ip6mr_cache_report(mrt, skb, vifi, MRT6MSG_WHOLEPKT);
2029                 goto out_free;
2030         }
2031 #endif
2032
2033         ipv6h = ipv6_hdr(skb);
2034
2035         fl6 = (struct flowi6) {
2036                 .flowi6_oif = vif->link,
2037                 .daddr = ipv6h->daddr,
2038         };
2039
2040         dst = ip6_route_output(net, NULL, &fl6);
2041         if (dst->error) {
2042                 dst_release(dst);
2043                 goto out_free;
2044         }
2045
2046         skb_dst_drop(skb);
2047         skb_dst_set(skb, dst);
2048
2049         /*
2050          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
2051          * not only before forwarding, but after forwarding on all output
2052          * interfaces. It is clear, if mrouter runs a multicasting
2053          * program, it should receive packets not depending to what interface
2054          * program is joined.
2055          * If we will not make it, the program will have to join on all
2056          * interfaces. On the other hand, multihoming host (or router, but
2057          * not mrouter) cannot join to more than one interface - it will
2058          * result in receiving multiple packets.
2059          */
2060         dev = vif->dev;
2061         skb->dev = dev;
2062         vif->pkt_out++;
2063         vif->bytes_out += skb->len;
2064
2065         /* We are about to write */
2066         /* XXX: extension headers? */
2067         if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
2068                 goto out_free;
2069
2070         ipv6h = ipv6_hdr(skb);
2071         ipv6h->hop_limit--;
2072
2073         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
2074
2075         return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
2076                        net, NULL, skb, skb->dev, dev,
2077                        ip6mr_forward2_finish);
2078
2079 out_free:
2080         kfree_skb(skb);
2081         return 0;
2082 }
2083
2084 static int ip6mr_find_vif(struct mr6_table *mrt, struct net_device *dev)
2085 {
2086         int ct;
2087
2088         for (ct = mrt->maxvif - 1; ct >= 0; ct--) {
2089                 if (mrt->vif6_table[ct].dev == dev)
2090                         break;
2091         }
2092         return ct;
2093 }
2094
2095 static void ip6_mr_forward(struct net *net, struct mr6_table *mrt,
2096                            struct sk_buff *skb, struct mfc6_cache *cache)
2097 {
2098         int psend = -1;
2099         int vif, ct;
2100         int true_vifi = ip6mr_find_vif(mrt, skb->dev);
2101
2102         vif = cache->mf6c_parent;
2103         cache->mfc_un.res.pkt++;
2104         cache->mfc_un.res.bytes += skb->len;
2105         cache->mfc_un.res.lastuse = jiffies;
2106
2107         if (ipv6_addr_any(&cache->mf6c_origin) && true_vifi >= 0) {
2108                 struct mfc6_cache *cache_proxy;
2109
2110                 /* For an (*,G) entry, we only check that the incoming
2111                  * interface is part of the static tree.
2112                  */
2113                 cache_proxy = ip6mr_cache_find_any_parent(mrt, vif);
2114                 if (cache_proxy &&
2115                     cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
2116                         goto forward;
2117         }
2118
2119         /*
2120          * Wrong interface: drop packet and (maybe) send PIM assert.
2121          */
2122         if (mrt->vif6_table[vif].dev != skb->dev) {
2123                 cache->mfc_un.res.wrong_if++;
2124
2125                 if (true_vifi >= 0 && mrt->mroute_do_assert &&
2126                     /* pimsm uses asserts, when switching from RPT to SPT,
2127                        so that we cannot check that packet arrived on an oif.
2128                        It is bad, but otherwise we would need to move pretty
2129                        large chunk of pimd to kernel. Ough... --ANK
2130                      */
2131                     (mrt->mroute_do_pim ||
2132                      cache->mfc_un.res.ttls[true_vifi] < 255) &&
2133                     time_after(jiffies,
2134                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
2135                         cache->mfc_un.res.last_assert = jiffies;
2136                         ip6mr_cache_report(mrt, skb, true_vifi, MRT6MSG_WRONGMIF);
2137                 }
2138                 goto dont_forward;
2139         }
2140
2141 forward:
2142         mrt->vif6_table[vif].pkt_in++;
2143         mrt->vif6_table[vif].bytes_in += skb->len;
2144
2145         /*
2146          *      Forward the frame
2147          */
2148         if (ipv6_addr_any(&cache->mf6c_origin) &&
2149             ipv6_addr_any(&cache->mf6c_mcastgrp)) {
2150                 if (true_vifi >= 0 &&
2151                     true_vifi != cache->mf6c_parent &&
2152                     ipv6_hdr(skb)->hop_limit >
2153                                 cache->mfc_un.res.ttls[cache->mf6c_parent]) {
2154                         /* It's an (*,*) entry and the packet is not coming from
2155                          * the upstream: forward the packet to the upstream
2156                          * only.
2157                          */
2158                         psend = cache->mf6c_parent;
2159                         goto last_forward;
2160                 }
2161                 goto dont_forward;
2162         }
2163         for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
2164                 /* For (*,G) entry, don't forward to the incoming interface */
2165                 if ((!ipv6_addr_any(&cache->mf6c_origin) || ct != true_vifi) &&
2166                     ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
2167                         if (psend != -1) {
2168                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
2169                                 if (skb2)
2170                                         ip6mr_forward2(net, mrt, skb2, cache, psend);
2171                         }
2172                         psend = ct;
2173                 }
2174         }
2175 last_forward:
2176         if (psend != -1) {
2177                 ip6mr_forward2(net, mrt, skb, cache, psend);
2178                 return;
2179         }
2180
2181 dont_forward:
2182         kfree_skb(skb);
2183 }
2184
2185
2186 /*
2187  *      Multicast packets for forwarding arrive here
2188  */
2189
2190 int ip6_mr_input(struct sk_buff *skb)
2191 {
2192         struct mfc6_cache *cache;
2193         struct net *net = dev_net(skb->dev);
2194         struct mr6_table *mrt;
2195         struct flowi6 fl6 = {
2196                 .flowi6_iif     = skb->dev->ifindex,
2197                 .flowi6_mark    = skb->mark,
2198         };
2199         int err;
2200
2201         err = ip6mr_fib_lookup(net, &fl6, &mrt);
2202         if (err < 0) {
2203                 kfree_skb(skb);
2204                 return err;
2205         }
2206
2207         read_lock(&mrt_lock);
2208         cache = ip6mr_cache_find(mrt,
2209                                  &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
2210         if (!cache) {
2211                 int vif = ip6mr_find_vif(mrt, skb->dev);
2212
2213                 if (vif >= 0)
2214                         cache = ip6mr_cache_find_any(mrt,
2215                                                      &ipv6_hdr(skb)->daddr,
2216                                                      vif);
2217         }
2218
2219         /*
2220          *      No usable cache entry
2221          */
2222         if (!cache) {
2223                 int vif;
2224
2225                 vif = ip6mr_find_vif(mrt, skb->dev);
2226                 if (vif >= 0) {
2227                         int err = ip6mr_cache_unresolved(mrt, vif, skb);
2228                         read_unlock(&mrt_lock);
2229
2230                         return err;
2231                 }
2232                 read_unlock(&mrt_lock);
2233                 kfree_skb(skb);
2234                 return -ENODEV;
2235         }
2236
2237         ip6_mr_forward(net, mrt, skb, cache);
2238
2239         read_unlock(&mrt_lock);
2240
2241         return 0;
2242 }
2243
2244
2245 static int __ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2246                                struct mfc6_cache *c, struct rtmsg *rtm)
2247 {
2248         struct rta_mfc_stats mfcs;
2249         struct nlattr *mp_attr;
2250         struct rtnexthop *nhp;
2251         unsigned long lastuse;
2252         int ct;
2253
2254         /* If cache is unresolved, don't try to parse IIF and OIF */
2255         if (c->mf6c_parent >= MAXMIFS) {
2256                 rtm->rtm_flags |= RTNH_F_UNRESOLVED;
2257                 return -ENOENT;
2258         }
2259
2260         if (MIF_EXISTS(mrt, c->mf6c_parent) &&
2261             nla_put_u32(skb, RTA_IIF, mrt->vif6_table[c->mf6c_parent].dev->ifindex) < 0)
2262                 return -EMSGSIZE;
2263         mp_attr = nla_nest_start(skb, RTA_MULTIPATH);
2264         if (!mp_attr)
2265                 return -EMSGSIZE;
2266
2267         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
2268                 if (MIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
2269                         nhp = nla_reserve_nohdr(skb, sizeof(*nhp));
2270                         if (!nhp) {
2271                                 nla_nest_cancel(skb, mp_attr);
2272                                 return -EMSGSIZE;
2273                         }
2274
2275                         nhp->rtnh_flags = 0;
2276                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
2277                         nhp->rtnh_ifindex = mrt->vif6_table[ct].dev->ifindex;
2278                         nhp->rtnh_len = sizeof(*nhp);
2279                 }
2280         }
2281
2282         nla_nest_end(skb, mp_attr);
2283
2284         lastuse = READ_ONCE(c->mfc_un.res.lastuse);
2285         lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0;
2286
2287         mfcs.mfcs_packets = c->mfc_un.res.pkt;
2288         mfcs.mfcs_bytes = c->mfc_un.res.bytes;
2289         mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
2290         if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) ||
2291             nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse),
2292                               RTA_PAD))
2293                 return -EMSGSIZE;
2294
2295         rtm->rtm_type = RTN_MULTICAST;
2296         return 1;
2297 }
2298
2299 int ip6mr_get_route(struct net *net, struct sk_buff *skb, struct rtmsg *rtm,
2300                     u32 portid)
2301 {
2302         int err;
2303         struct mr6_table *mrt;
2304         struct mfc6_cache *cache;
2305         struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
2306
2307         mrt = ip6mr_get_table(net, RT6_TABLE_DFLT);
2308         if (!mrt)
2309                 return -ENOENT;
2310
2311         read_lock(&mrt_lock);
2312         cache = ip6mr_cache_find(mrt, &rt->rt6i_src.addr, &rt->rt6i_dst.addr);
2313         if (!cache && skb->dev) {
2314                 int vif = ip6mr_find_vif(mrt, skb->dev);
2315
2316                 if (vif >= 0)
2317                         cache = ip6mr_cache_find_any(mrt, &rt->rt6i_dst.addr,
2318                                                      vif);
2319         }
2320
2321         if (!cache) {
2322                 struct sk_buff *skb2;
2323                 struct ipv6hdr *iph;
2324                 struct net_device *dev;
2325                 int vif;
2326
2327                 dev = skb->dev;
2328                 if (!dev || (vif = ip6mr_find_vif(mrt, dev)) < 0) {
2329                         read_unlock(&mrt_lock);
2330                         return -ENODEV;
2331                 }
2332
2333                 /* really correct? */
2334                 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
2335                 if (!skb2) {
2336                         read_unlock(&mrt_lock);
2337                         return -ENOMEM;
2338                 }
2339
2340                 NETLINK_CB(skb2).portid = portid;
2341                 skb_reset_transport_header(skb2);
2342
2343                 skb_put(skb2, sizeof(struct ipv6hdr));
2344                 skb_reset_network_header(skb2);
2345
2346                 iph = ipv6_hdr(skb2);
2347                 iph->version = 0;
2348                 iph->priority = 0;
2349                 iph->flow_lbl[0] = 0;
2350                 iph->flow_lbl[1] = 0;
2351                 iph->flow_lbl[2] = 0;
2352                 iph->payload_len = 0;
2353                 iph->nexthdr = IPPROTO_NONE;
2354                 iph->hop_limit = 0;
2355                 iph->saddr = rt->rt6i_src.addr;
2356                 iph->daddr = rt->rt6i_dst.addr;
2357
2358                 err = ip6mr_cache_unresolved(mrt, vif, skb2);
2359                 read_unlock(&mrt_lock);
2360
2361                 return err;
2362         }
2363
2364         if (rtm->rtm_flags & RTM_F_NOTIFY)
2365                 cache->mfc_flags |= MFC_NOTIFY;
2366
2367         err = __ip6mr_fill_mroute(mrt, skb, cache, rtm);
2368         read_unlock(&mrt_lock);
2369         return err;
2370 }
2371
2372 static int ip6mr_fill_mroute(struct mr6_table *mrt, struct sk_buff *skb,
2373                              u32 portid, u32 seq, struct mfc6_cache *c, int cmd,
2374                              int flags)
2375 {
2376         struct nlmsghdr *nlh;
2377         struct rtmsg *rtm;
2378         int err;
2379
2380         nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
2381         if (!nlh)
2382                 return -EMSGSIZE;
2383
2384         rtm = nlmsg_data(nlh);
2385         rtm->rtm_family   = RTNL_FAMILY_IP6MR;
2386         rtm->rtm_dst_len  = 128;
2387         rtm->rtm_src_len  = 128;
2388         rtm->rtm_tos      = 0;
2389         rtm->rtm_table    = mrt->id;
2390         if (nla_put_u32(skb, RTA_TABLE, mrt->id))
2391                 goto nla_put_failure;
2392         rtm->rtm_type = RTN_MULTICAST;
2393         rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
2394         if (c->mfc_flags & MFC_STATIC)
2395                 rtm->rtm_protocol = RTPROT_STATIC;
2396         else
2397                 rtm->rtm_protocol = RTPROT_MROUTED;
2398         rtm->rtm_flags    = 0;
2399
2400         if (nla_put_in6_addr(skb, RTA_SRC, &c->mf6c_origin) ||
2401             nla_put_in6_addr(skb, RTA_DST, &c->mf6c_mcastgrp))
2402                 goto nla_put_failure;
2403         err = __ip6mr_fill_mroute(mrt, skb, c, rtm);
2404         /* do not break the dump if cache is unresolved */
2405         if (err < 0 && err != -ENOENT)
2406                 goto nla_put_failure;
2407
2408         nlmsg_end(skb, nlh);
2409         return 0;
2410
2411 nla_put_failure:
2412         nlmsg_cancel(skb, nlh);
2413         return -EMSGSIZE;
2414 }
2415
2416 static int mr6_msgsize(bool unresolved, int maxvif)
2417 {
2418         size_t len =
2419                 NLMSG_ALIGN(sizeof(struct rtmsg))
2420                 + nla_total_size(4)     /* RTA_TABLE */
2421                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_SRC */
2422                 + nla_total_size(sizeof(struct in6_addr))       /* RTA_DST */
2423                 ;
2424
2425         if (!unresolved)
2426                 len = len
2427                       + nla_total_size(4)       /* RTA_IIF */
2428                       + nla_total_size(0)       /* RTA_MULTIPATH */
2429                       + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
2430                                                 /* RTA_MFC_STATS */
2431                       + nla_total_size_64bit(sizeof(struct rta_mfc_stats))
2432                 ;
2433
2434         return len;
2435 }
2436
2437 static void mr6_netlink_event(struct mr6_table *mrt, struct mfc6_cache *mfc,
2438                               int cmd)
2439 {
2440         struct net *net = read_pnet(&mrt->net);
2441         struct sk_buff *skb;
2442         int err = -ENOBUFS;
2443
2444         skb = nlmsg_new(mr6_msgsize(mfc->mf6c_parent >= MAXMIFS, mrt->maxvif),
2445                         GFP_ATOMIC);
2446         if (!skb)
2447                 goto errout;
2448
2449         err = ip6mr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
2450         if (err < 0)
2451                 goto errout;
2452
2453         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE, NULL, GFP_ATOMIC);
2454         return;
2455
2456 errout:
2457         kfree_skb(skb);
2458         if (err < 0)
2459                 rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE, err);
2460 }
2461
2462 static size_t mrt6msg_netlink_msgsize(size_t payloadlen)
2463 {
2464         size_t len =
2465                 NLMSG_ALIGN(sizeof(struct rtgenmsg))
2466                 + nla_total_size(1)     /* IP6MRA_CREPORT_MSGTYPE */
2467                 + nla_total_size(4)     /* IP6MRA_CREPORT_MIF_ID */
2468                                         /* IP6MRA_CREPORT_SRC_ADDR */
2469                 + nla_total_size(sizeof(struct in6_addr))
2470                                         /* IP6MRA_CREPORT_DST_ADDR */
2471                 + nla_total_size(sizeof(struct in6_addr))
2472                                         /* IP6MRA_CREPORT_PKT */
2473                 + nla_total_size(payloadlen)
2474                 ;
2475
2476         return len;
2477 }
2478
2479 static void mrt6msg_netlink_event(struct mr6_table *mrt, struct sk_buff *pkt)
2480 {
2481         struct net *net = read_pnet(&mrt->net);
2482         struct nlmsghdr *nlh;
2483         struct rtgenmsg *rtgenm;
2484         struct mrt6msg *msg;
2485         struct sk_buff *skb;
2486         struct nlattr *nla;
2487         int payloadlen;
2488
2489         payloadlen = pkt->len - sizeof(struct mrt6msg);
2490         msg = (struct mrt6msg *)skb_transport_header(pkt);
2491
2492         skb = nlmsg_new(mrt6msg_netlink_msgsize(payloadlen), GFP_ATOMIC);
2493         if (!skb)
2494                 goto errout;
2495
2496         nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
2497                         sizeof(struct rtgenmsg), 0);
2498         if (!nlh)
2499                 goto errout;
2500         rtgenm = nlmsg_data(nlh);
2501         rtgenm->rtgen_family = RTNL_FAMILY_IP6MR;
2502         if (nla_put_u8(skb, IP6MRA_CREPORT_MSGTYPE, msg->im6_msgtype) ||
2503             nla_put_u32(skb, IP6MRA_CREPORT_MIF_ID, msg->im6_mif) ||
2504             nla_put_in6_addr(skb, IP6MRA_CREPORT_SRC_ADDR,
2505                              &msg->im6_src) ||
2506             nla_put_in6_addr(skb, IP6MRA_CREPORT_DST_ADDR,
2507                              &msg->im6_dst))
2508                 goto nla_put_failure;
2509
2510         nla = nla_reserve(skb, IP6MRA_CREPORT_PKT, payloadlen);
2511         if (!nla || skb_copy_bits(pkt, sizeof(struct mrt6msg),
2512                                   nla_data(nla), payloadlen))
2513                 goto nla_put_failure;
2514
2515         nlmsg_end(skb, nlh);
2516
2517         rtnl_notify(skb, net, 0, RTNLGRP_IPV6_MROUTE_R, NULL, GFP_ATOMIC);
2518         return;
2519
2520 nla_put_failure:
2521         nlmsg_cancel(skb, nlh);
2522 errout:
2523         kfree_skb(skb);
2524         rtnl_set_sk_err(net, RTNLGRP_IPV6_MROUTE_R, -ENOBUFS);
2525 }
2526
2527 static int ip6mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2528 {
2529         struct net *net = sock_net(skb->sk);
2530         struct mr6_table *mrt;
2531         struct mfc6_cache *mfc;
2532         unsigned int t = 0, s_t;
2533         unsigned int h = 0, s_h;
2534         unsigned int e = 0, s_e;
2535
2536         s_t = cb->args[0];
2537         s_h = cb->args[1];
2538         s_e = cb->args[2];
2539
2540         read_lock(&mrt_lock);
2541         ip6mr_for_each_table(mrt, net) {
2542                 if (t < s_t)
2543                         goto next_table;
2544                 if (t > s_t)
2545                         s_h = 0;
2546                 for (h = s_h; h < MFC6_LINES; h++) {
2547                         list_for_each_entry(mfc, &mrt->mfc6_cache_array[h], list) {
2548                                 if (e < s_e)
2549                                         goto next_entry;
2550                                 if (ip6mr_fill_mroute(mrt, skb,
2551                                                       NETLINK_CB(cb->skb).portid,
2552                                                       cb->nlh->nlmsg_seq,
2553                                                       mfc, RTM_NEWROUTE,
2554                                                       NLM_F_MULTI) < 0)
2555                                         goto done;
2556 next_entry:
2557                                 e++;
2558                         }
2559                         e = s_e = 0;
2560                 }
2561                 spin_lock_bh(&mfc_unres_lock);
2562                 list_for_each_entry(mfc, &mrt->mfc6_unres_queue, list) {
2563                         if (e < s_e)
2564                                 goto next_entry2;
2565                         if (ip6mr_fill_mroute(mrt, skb,
2566                                               NETLINK_CB(cb->skb).portid,
2567                                               cb->nlh->nlmsg_seq,
2568                                               mfc, RTM_NEWROUTE,
2569                                               NLM_F_MULTI) < 0) {
2570                                 spin_unlock_bh(&mfc_unres_lock);
2571                                 goto done;
2572                         }
2573 next_entry2:
2574                         e++;
2575                 }
2576                 spin_unlock_bh(&mfc_unres_lock);
2577                 e = s_e = 0;
2578                 s_h = 0;
2579 next_table:
2580                 t++;
2581         }
2582 done:
2583         read_unlock(&mrt_lock);
2584
2585         cb->args[2] = e;
2586         cb->args[1] = h;
2587         cb->args[0] = t;
2588
2589         return skb->len;
2590 }