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