net/ipv6/ip6mr.c

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