SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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_private,
 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_private,
 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 const struct net_device_ops reg_vif_netdev_ops = {
 420         .ndo_start_xmit = reg_vif_xmit,
 421 };
 422
 423 static void reg_vif_setup(struct net_device *dev)
 424 {
 425         dev->type               = ARPHRD_PIMREG;
 426         dev->mtu                = 1500 - sizeof(struct ipv6hdr) - 8;
 427         dev->flags              = IFF_NOARP;
 428         dev->netdev_ops         = &reg_vif_netdev_ops;
 429         dev->destructor         = free_netdev;
 430 }
 431
 432 static struct net_device *ip6mr_reg_vif(void)
 433 {
 434         struct net_device *dev;
 435
 436         dev = alloc_netdev(0, "pim6reg", reg_vif_setup);
 437         if (dev == NULL)
 438                 return NULL;
 439
 440         if (register_netdevice(dev)) {
 441                 free_netdev(dev);
 442                 return NULL;
 443         }
 444         dev->iflink = 0;
 445
 446         if (dev_open(dev))
 447                 goto failure;
 448
 449         dev_hold(dev);
 450         return dev;
 451
 452 failure:
 453         /* allow the register to be completed before unregistering. */
 454         rtnl_unlock();
 455         rtnl_lock();
 456
 457         unregister_netdevice(dev);
 458         return NULL;
 459 }
 460 #endif
 461
 462 /*
 463  *      Delete a VIF entry
 464  */
 465
 466 static int mif6_delete(int vifi)
 467 {
 468         struct mif_device *v;
 469         struct net_device *dev;
 470         if (vifi < 0 || vifi >= maxvif)
 471                 return -EADDRNOTAVAIL;
 472
 473         v = &vif6_table[vifi];
 474
 475         write_lock_bh(&mrt_lock);
 476         dev = v->dev;
 477         v->dev = NULL;
 478
 479         if (!dev) {
 480                 write_unlock_bh(&mrt_lock);
 481                 return -EADDRNOTAVAIL;
 482         }
 483
 484 #ifdef CONFIG_IPV6_PIMSM_V2
 485         if (vifi == reg_vif_num)
 486                 reg_vif_num = -1;
 487 #endif
 488
 489         if (vifi + 1 == maxvif) {
 490                 int tmp;
 491                 for (tmp = vifi - 1; tmp >= 0; tmp--) {
 492                         if (MIF_EXISTS(tmp))
 493                                 break;
 494                 }
 495                 maxvif = tmp + 1;
 496         }
 497
 498         write_unlock_bh(&mrt_lock);
 499
 500         dev_set_allmulti(dev, -1);
 501
 502         if (v->flags & MIFF_REGISTER)
 503                 unregister_netdevice(dev);
 504
 505         dev_put(dev);
 506         return 0;
 507 }
 508
 509 /* Destroy an unresolved cache entry, killing queued skbs
 510    and reporting error to netlink readers.
 511  */
 512
 513 static void ip6mr_destroy_unres(struct mfc6_cache *c)
 514 {
 515         struct sk_buff *skb;
 516
 517         atomic_dec(&cache_resolve_queue_len);
 518
 519         while((skb = skb_dequeue(&c->mfc_un.unres.unresolved)) != NULL) {
 520                 if (ipv6_hdr(skb)->version == 0) {
 521                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
 522                         nlh->nlmsg_type = NLMSG_ERROR;
 523                         nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 524                         skb_trim(skb, nlh->nlmsg_len);
 525                         ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -ETIMEDOUT;
 526                         rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid);
 527                 } else
 528                         kfree_skb(skb);
 529         }
 530
 531         kmem_cache_free(mrt_cachep, c);
 532 }
 533
 534
 535 /* Single timer process for all the unresolved queue. */
 536
 537 static void ipmr_do_expire_process(unsigned long dummy)
 538 {
 539         unsigned long now = jiffies;
 540         unsigned long expires = 10 * HZ;
 541         struct mfc6_cache *c, **cp;
 542
 543         cp = &mfc_unres_queue;
 544
 545         while ((c = *cp) != NULL) {
 546                 if (time_after(c->mfc_un.unres.expires, now)) {
 547                         /* not yet... */
 548                         unsigned long interval = c->mfc_un.unres.expires - now;
 549                         if (interval < expires)
 550                                 expires = interval;
 551                         cp = &c->next;
 552                         continue;
 553                 }
 554
 555                 *cp = c->next;
 556                 ip6mr_destroy_unres(c);
 557         }
 558
 559         if (atomic_read(&cache_resolve_queue_len))
 560                 mod_timer(&ipmr_expire_timer, jiffies + expires);
 561 }
 562
 563 static void ipmr_expire_process(unsigned long dummy)
 564 {
 565         if (!spin_trylock(&mfc_unres_lock)) {
 566                 mod_timer(&ipmr_expire_timer, jiffies + 1);
 567                 return;
 568         }
 569
 570         if (atomic_read(&cache_resolve_queue_len))
 571                 ipmr_do_expire_process(dummy);
 572
 573         spin_unlock(&mfc_unres_lock);
 574 }
 575
 576 /* Fill oifs list. It is called under write locked mrt_lock. */
 577
 578 static void ip6mr_update_thresholds(struct mfc6_cache *cache, unsigned char *ttls)
 579 {
 580         int vifi;
 581
 582         cache->mfc_un.res.minvif = MAXMIFS;
 583         cache->mfc_un.res.maxvif = 0;
 584         memset(cache->mfc_un.res.ttls, 255, MAXMIFS);
 585
 586         for (vifi = 0; vifi < maxvif; vifi++) {
 587                 if (MIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) {
 588                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
 589                         if (cache->mfc_un.res.minvif > vifi)
 590                                 cache->mfc_un.res.minvif = vifi;
 591                         if (cache->mfc_un.res.maxvif <= vifi)
 592                                 cache->mfc_un.res.maxvif = vifi + 1;
 593                 }
 594         }
 595 }
 596
 597 static int mif6_add(struct mif6ctl *vifc, int mrtsock)
 598 {
 599         int vifi = vifc->mif6c_mifi;
 600         struct mif_device *v = &vif6_table[vifi];
 601         struct net_device *dev;
 602         int err;
 603
 604         /* Is vif busy ? */
 605         if (MIF_EXISTS(vifi))
 606                 return -EADDRINUSE;
 607
 608         switch (vifc->mif6c_flags) {
 609 #ifdef CONFIG_IPV6_PIMSM_V2
 610         case MIFF_REGISTER:
 611                 /*
 612                  * Special Purpose VIF in PIM
 613                  * All the packets will be sent to the daemon
 614                  */
 615                 if (reg_vif_num >= 0)
 616                         return -EADDRINUSE;
 617                 dev = ip6mr_reg_vif();
 618                 if (!dev)
 619                         return -ENOBUFS;
 620                 err = dev_set_allmulti(dev, 1);
 621                 if (err) {
 622                         unregister_netdevice(dev);
 623                         dev_put(dev);
 624                         return err;
 625                 }
 626                 break;
 627 #endif
 628         case 0:
 629                 dev = dev_get_by_index(&init_net, vifc->mif6c_pifi);
 630                 if (!dev)
 631                         return -EADDRNOTAVAIL;
 632                 err = dev_set_allmulti(dev, 1);
 633                 if (err) {
 634                         dev_put(dev);
 635                         return err;
 636                 }
 637                 break;
 638         default:
 639                 return -EINVAL;
 640         }
 641
 642         /*
 643          *      Fill in the VIF structures
 644          */
 645         v->rate_limit = vifc->vifc_rate_limit;
 646         v->flags = vifc->mif6c_flags;
 647         if (!mrtsock)
 648                 v->flags |= VIFF_STATIC;
 649         v->threshold = vifc->vifc_threshold;
 650         v->bytes_in = 0;
 651         v->bytes_out = 0;
 652         v->pkt_in = 0;
 653         v->pkt_out = 0;
 654         v->link = dev->ifindex;
 655         if (v->flags & MIFF_REGISTER)
 656                 v->link = dev->iflink;
 657
 658         /* And finish update writing critical data */
 659         write_lock_bh(&mrt_lock);
 660         v->dev = dev;
 661 #ifdef CONFIG_IPV6_PIMSM_V2
 662         if (v->flags & MIFF_REGISTER)
 663                 reg_vif_num = vifi;
 664 #endif
 665         if (vifi + 1 > maxvif)
 666                 maxvif = vifi + 1;
 667         write_unlock_bh(&mrt_lock);
 668         return 0;
 669 }
 670
 671 static struct mfc6_cache *ip6mr_cache_find(struct in6_addr *origin, struct in6_addr *mcastgrp)
 672 {
 673         int line = MFC6_HASH(mcastgrp, origin);
 674         struct mfc6_cache *c;
 675
 676         for (c = mfc6_cache_array[line]; c; c = c->next) {
 677                 if (ipv6_addr_equal(&c->mf6c_origin, origin) &&
 678                     ipv6_addr_equal(&c->mf6c_mcastgrp, mcastgrp))
 679                         break;
 680         }
 681         return c;
 682 }
 683
 684 /*
 685  *      Allocate a multicast cache entry
 686  */
 687 static struct mfc6_cache *ip6mr_cache_alloc(void)
 688 {
 689         struct mfc6_cache *c = kmem_cache_alloc(mrt_cachep, GFP_KERNEL);
 690         if (c == NULL)
 691                 return NULL;
 692         memset(c, 0, sizeof(*c));
 693         c->mfc_un.res.minvif = MAXMIFS;
 694         return c;
 695 }
 696
 697 static struct mfc6_cache *ip6mr_cache_alloc_unres(void)
 698 {
 699         struct mfc6_cache *c = kmem_cache_alloc(mrt_cachep, GFP_ATOMIC);
 700         if (c == NULL)
 701                 return NULL;
 702         memset(c, 0, sizeof(*c));
 703         skb_queue_head_init(&c->mfc_un.unres.unresolved);
 704         c->mfc_un.unres.expires = jiffies + 10 * HZ;
 705         return c;
 706 }
 707
 708 /*
 709  *      A cache entry has gone into a resolved state from queued
 710  */
 711
 712 static void ip6mr_cache_resolve(struct mfc6_cache *uc, struct mfc6_cache *c)
 713 {
 714         struct sk_buff *skb;
 715
 716         /*
 717          *      Play the pending entries through our router
 718          */
 719
 720         while((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
 721                 if (ipv6_hdr(skb)->version == 0) {
 722                         int err;
 723                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct ipv6hdr));
 724
 725                         if (ip6mr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
 726                                 nlh->nlmsg_len = skb_tail_pointer(skb) - (u8 *)nlh;
 727                         } else {
 728                                 nlh->nlmsg_type = NLMSG_ERROR;
 729                                 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 730                                 skb_trim(skb, nlh->nlmsg_len);
 731                                 ((struct nlmsgerr *)NLMSG_DATA(nlh))->error = -EMSGSIZE;
 732                         }
 733                         err = rtnl_unicast(skb, &init_net, NETLINK_CB(skb).pid);
 734                 } else
 735                         ip6_mr_forward(skb, c);
 736         }
 737 }
 738
 739 /*
 740  *      Bounce a cache query up to pim6sd. We could use netlink for this but pim6sd
 741  *      expects the following bizarre scheme.
 742  *
 743  *      Called under mrt_lock.
 744  */
 745
 746 static int ip6mr_cache_report(struct sk_buff *pkt, mifi_t mifi, int assert)
 747 {
 748         struct sk_buff *skb;
 749         struct mrt6msg *msg;
 750         int ret;
 751
 752 #ifdef CONFIG_IPV6_PIMSM_V2
 753         if (assert == MRT6MSG_WHOLEPKT)
 754                 skb = skb_realloc_headroom(pkt, -skb_network_offset(pkt)
 755                                                 +sizeof(*msg));
 756         else
 757 #endif
 758                 skb = alloc_skb(sizeof(struct ipv6hdr) + sizeof(*msg), GFP_ATOMIC);
 759
 760         if (!skb)
 761                 return -ENOBUFS;
 762
 763         /* I suppose that internal messages
 764          * do not require checksums */
 765
 766         skb->ip_summed = CHECKSUM_UNNECESSARY;
 767
 768 #ifdef CONFIG_IPV6_PIMSM_V2
 769         if (assert == MRT6MSG_WHOLEPKT) {
 770                 /* Ugly, but we have no choice with this interface.
 771                    Duplicate old header, fix length etc.
 772                    And all this only to mangle msg->im6_msgtype and
 773                    to set msg->im6_mbz to "mbz" :-)
 774                  */
 775                 skb_push(skb, -skb_network_offset(pkt));
 776
 777                 skb_push(skb, sizeof(*msg));
 778                 skb_reset_transport_header(skb);
 779                 msg = (struct mrt6msg *)skb_transport_header(skb);
 780                 msg->im6_mbz = 0;
 781                 msg->im6_msgtype = MRT6MSG_WHOLEPKT;
 782                 msg->im6_mif = reg_vif_num;
 783                 msg->im6_pad = 0;
 784                 ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
 785                 ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
 786
 787                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 788         } else
 789 #endif
 790         {
 791         /*
 792          *      Copy the IP header
 793          */
 794
 795         skb_put(skb, sizeof(struct ipv6hdr));
 796         skb_reset_network_header(skb);
 797         skb_copy_to_linear_data(skb, ipv6_hdr(pkt), sizeof(struct ipv6hdr));
 798
 799         /*
 800          *      Add our header
 801          */
 802         skb_put(skb, sizeof(*msg));
 803         skb_reset_transport_header(skb);
 804         msg = (struct mrt6msg *)skb_transport_header(skb);
 805
 806         msg->im6_mbz = 0;
 807         msg->im6_msgtype = assert;
 808         msg->im6_mif = mifi;
 809         msg->im6_pad = 0;
 810         ipv6_addr_copy(&msg->im6_src, &ipv6_hdr(pkt)->saddr);
 811         ipv6_addr_copy(&msg->im6_dst, &ipv6_hdr(pkt)->daddr);
 812
 813         skb->dst = dst_clone(pkt->dst);
 814         skb->ip_summed = CHECKSUM_UNNECESSARY;
 815
 816         skb_pull(skb, sizeof(struct ipv6hdr));
 817         }
 818
 819         if (mroute6_socket == NULL) {
 820                 kfree_skb(skb);
 821                 return -EINVAL;
 822         }
 823
 824         /*
 825          *      Deliver to user space multicast routing algorithms
 826          */
 827         if ((ret = sock_queue_rcv_skb(mroute6_socket, skb)) < 0) {
 828                 if (net_ratelimit())
 829                         printk(KERN_WARNING "mroute6: pending queue full, dropping entries.\n");
 830                 kfree_skb(skb);
 831         }
 832
 833         return ret;
 834 }
 835
 836 /*
 837  *      Queue a packet for resolution. It gets locked cache entry!
 838  */
 839
 840 static int
 841 ip6mr_cache_unresolved(mifi_t mifi, struct sk_buff *skb)
 842 {
 843         int err;
 844         struct mfc6_cache *c;
 845
 846         spin_lock_bh(&mfc_unres_lock);
 847         for (c = mfc_unres_queue; c; c = c->next) {
 848                 if (ipv6_addr_equal(&c->mf6c_mcastgrp, &ipv6_hdr(skb)->daddr) &&
 849                     ipv6_addr_equal(&c->mf6c_origin, &ipv6_hdr(skb)->saddr))
 850                         break;
 851         }
 852
 853         if (c == NULL) {
 854                 /*
 855                  *      Create a new entry if allowable
 856                  */
 857
 858                 if (atomic_read(&cache_resolve_queue_len) >= 10 ||
 859                     (c = ip6mr_cache_alloc_unres()) == NULL) {
 860                         spin_unlock_bh(&mfc_unres_lock);
 861
 862                         kfree_skb(skb);
 863                         return -ENOBUFS;
 864                 }
 865
 866                 /*
 867                  *      Fill in the new cache entry
 868                  */
 869                 c->mf6c_parent = -1;
 870                 c->mf6c_origin = ipv6_hdr(skb)->saddr;
 871                 c->mf6c_mcastgrp = ipv6_hdr(skb)->daddr;
 872
 873                 /*
 874                  *      Reflect first query at pim6sd
 875                  */
 876                 if ((err = ip6mr_cache_report(skb, mifi, MRT6MSG_NOCACHE)) < 0) {
 877                         /* If the report failed throw the cache entry
 878                            out - Brad Parker
 879                          */
 880                         spin_unlock_bh(&mfc_unres_lock);
 881
 882                         kmem_cache_free(mrt_cachep, c);
 883                         kfree_skb(skb);
 884                         return err;
 885                 }
 886
 887                 atomic_inc(&cache_resolve_queue_len);
 888                 c->next = mfc_unres_queue;
 889                 mfc_unres_queue = c;
 890
 891                 ipmr_do_expire_process(1);
 892         }
 893
 894         /*
 895          *      See if we can append the packet
 896          */
 897         if (c->mfc_un.unres.unresolved.qlen > 3) {
 898                 kfree_skb(skb);
 899                 err = -ENOBUFS;
 900         } else {
 901                 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
 902                 err = 0;
 903         }
 904
 905         spin_unlock_bh(&mfc_unres_lock);
 906         return err;
 907 }
 908
 909 /*
 910  *      MFC6 cache manipulation by user space
 911  */
 912
 913 static int ip6mr_mfc_delete(struct mf6cctl *mfc)
 914 {
 915         int line;
 916         struct mfc6_cache *c, **cp;
 917
 918         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
 919
 920         for (cp = &mfc6_cache_array[line]; (c = *cp) != NULL; cp = &c->next) {
 921                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
 922                     ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr)) {
 923                         write_lock_bh(&mrt_lock);
 924                         *cp = c->next;
 925                         write_unlock_bh(&mrt_lock);
 926
 927                         kmem_cache_free(mrt_cachep, c);
 928                         return 0;
 929                 }
 930         }
 931         return -ENOENT;
 932 }
 933
 934 static int ip6mr_device_event(struct notifier_block *this,
 935                               unsigned long event, void *ptr)
 936 {
 937         struct net_device *dev = ptr;
 938         struct mif_device *v;
 939         int ct;
 940
 941         if (!net_eq(dev_net(dev), &init_net))
 942                 return NOTIFY_DONE;
 943
 944         if (event != NETDEV_UNREGISTER)
 945                 return NOTIFY_DONE;
 946
 947         v = &vif6_table[0];
 948         for (ct = 0; ct < maxvif; ct++, v++) {
 949                 if (v->dev == dev)
 950                         mif6_delete(ct);
 951         }
 952         return NOTIFY_DONE;
 953 }
 954
 955 static struct notifier_block ip6_mr_notifier = {
 956         .notifier_call = ip6mr_device_event
 957 };
 958
 959 /*
 960  *      Setup for IP multicast routing
 961  */
 962
 963 int __init ip6_mr_init(void)
 964 {
 965         int err;
 966
 967         mrt_cachep = kmem_cache_create("ip6_mrt_cache",
 968                                        sizeof(struct mfc6_cache),
 969                                        0, SLAB_HWCACHE_ALIGN,
 970                                        NULL);
 971         if (!mrt_cachep)
 972                 return -ENOMEM;
 973
 974         setup_timer(&ipmr_expire_timer, ipmr_expire_process, 0);
 975         err = register_netdevice_notifier(&ip6_mr_notifier);
 976         if (err)
 977                 goto reg_notif_fail;
 978 #ifdef CONFIG_PROC_FS
 979         err = -ENOMEM;
 980         if (!proc_net_fops_create(&init_net, "ip6_mr_vif", 0, &ip6mr_vif_fops))
 981                 goto proc_vif_fail;
 982         if (!proc_net_fops_create(&init_net, "ip6_mr_cache",
 983                                      0, &ip6mr_mfc_fops))
 984                 goto proc_cache_fail;
 985 #endif
 986         return 0;
 987 #ifdef CONFIG_PROC_FS
 988 proc_cache_fail:
 989         proc_net_remove(&init_net, "ip6_mr_vif");
 990 proc_vif_fail:
 991         unregister_netdevice_notifier(&ip6_mr_notifier);
 992 #endif
 993 reg_notif_fail:
 994         del_timer(&ipmr_expire_timer);
 995         kmem_cache_destroy(mrt_cachep);
 996         return err;
 997 }
 998
 999 void ip6_mr_cleanup(void)
1000 {
1001 #ifdef CONFIG_PROC_FS
1002         proc_net_remove(&init_net, "ip6_mr_cache");
1003         proc_net_remove(&init_net, "ip6_mr_vif");
1004 #endif
1005         unregister_netdevice_notifier(&ip6_mr_notifier);
1006         del_timer(&ipmr_expire_timer);
1007         kmem_cache_destroy(mrt_cachep);
1008 }
1009
1010 static int ip6mr_mfc_add(struct mf6cctl *mfc, int mrtsock)
1011 {
1012         int line;
1013         struct mfc6_cache *uc, *c, **cp;
1014         unsigned char ttls[MAXMIFS];
1015         int i;
1016
1017         memset(ttls, 255, MAXMIFS);
1018         for (i = 0; i < MAXMIFS; i++) {
1019                 if (IF_ISSET(i, &mfc->mf6cc_ifset))
1020                         ttls[i] = 1;
1021
1022         }
1023
1024         line = MFC6_HASH(&mfc->mf6cc_mcastgrp.sin6_addr, &mfc->mf6cc_origin.sin6_addr);
1025
1026         for (cp = &mfc6_cache_array[line]; (c = *cp) != NULL; cp = &c->next) {
1027                 if (ipv6_addr_equal(&c->mf6c_origin, &mfc->mf6cc_origin.sin6_addr) &&
1028                     ipv6_addr_equal(&c->mf6c_mcastgrp, &mfc->mf6cc_mcastgrp.sin6_addr))
1029                         break;
1030         }
1031
1032         if (c != NULL) {
1033                 write_lock_bh(&mrt_lock);
1034                 c->mf6c_parent = mfc->mf6cc_parent;
1035                 ip6mr_update_thresholds(c, ttls);
1036                 if (!mrtsock)
1037                         c->mfc_flags |= MFC_STATIC;
1038                 write_unlock_bh(&mrt_lock);
1039                 return 0;
1040         }
1041
1042         if (!ipv6_addr_is_multicast(&mfc->mf6cc_mcastgrp.sin6_addr))
1043                 return -EINVAL;
1044
1045         c = ip6mr_cache_alloc();
1046         if (c == NULL)
1047                 return -ENOMEM;
1048
1049         c->mf6c_origin = mfc->mf6cc_origin.sin6_addr;
1050         c->mf6c_mcastgrp = mfc->mf6cc_mcastgrp.sin6_addr;
1051         c->mf6c_parent = mfc->mf6cc_parent;
1052         ip6mr_update_thresholds(c, ttls);
1053         if (!mrtsock)
1054                 c->mfc_flags |= MFC_STATIC;
1055
1056         write_lock_bh(&mrt_lock);
1057         c->next = mfc6_cache_array[line];
1058         mfc6_cache_array[line] = c;
1059         write_unlock_bh(&mrt_lock);
1060
1061         /*
1062          *      Check to see if we resolved a queued list. If so we
1063          *      need to send on the frames and tidy up.
1064          */
1065         spin_lock_bh(&mfc_unres_lock);
1066         for (cp = &mfc_unres_queue; (uc = *cp) != NULL;
1067              cp = &uc->next) {
1068                 if (ipv6_addr_equal(&uc->mf6c_origin, &c->mf6c_origin) &&
1069                     ipv6_addr_equal(&uc->mf6c_mcastgrp, &c->mf6c_mcastgrp)) {
1070                         *cp = uc->next;
1071                         if (atomic_dec_and_test(&cache_resolve_queue_len))
1072                                 del_timer(&ipmr_expire_timer);
1073                         break;
1074                 }
1075         }
1076         spin_unlock_bh(&mfc_unres_lock);
1077
1078         if (uc) {
1079                 ip6mr_cache_resolve(uc, c);
1080                 kmem_cache_free(mrt_cachep, uc);
1081         }
1082         return 0;
1083 }
1084
1085 /*
1086  *      Close the multicast socket, and clear the vif tables etc
1087  */
1088
1089 static void mroute_clean_tables(struct sock *sk)
1090 {
1091         int i;
1092
1093         /*
1094          *      Shut down all active vif entries
1095          */
1096         for (i = 0; i < maxvif; i++) {
1097                 if (!(vif6_table[i].flags & VIFF_STATIC))
1098                         mif6_delete(i);
1099         }
1100
1101         /*
1102          *      Wipe the cache
1103          */
1104         for (i = 0; i < ARRAY_SIZE(mfc6_cache_array); i++) {
1105                 struct mfc6_cache *c, **cp;
1106
1107                 cp = &mfc6_cache_array[i];
1108                 while ((c = *cp) != NULL) {
1109                         if (c->mfc_flags & MFC_STATIC) {
1110                                 cp = &c->next;
1111                                 continue;
1112                         }
1113                         write_lock_bh(&mrt_lock);
1114                         *cp = c->next;
1115                         write_unlock_bh(&mrt_lock);
1116
1117                         kmem_cache_free(mrt_cachep, c);
1118                 }
1119         }
1120
1121         if (atomic_read(&cache_resolve_queue_len) != 0) {
1122                 struct mfc6_cache *c;
1123
1124                 spin_lock_bh(&mfc_unres_lock);
1125                 while (mfc_unres_queue != NULL) {
1126                         c = mfc_unres_queue;
1127                         mfc_unres_queue = c->next;
1128                         spin_unlock_bh(&mfc_unres_lock);
1129
1130                         ip6mr_destroy_unres(c);
1131
1132                         spin_lock_bh(&mfc_unres_lock);
1133                 }
1134                 spin_unlock_bh(&mfc_unres_lock);
1135         }
1136 }
1137
1138 static int ip6mr_sk_init(struct sock *sk)
1139 {
1140         int err = 0;
1141
1142         rtnl_lock();
1143         write_lock_bh(&mrt_lock);
1144         if (likely(mroute6_socket == NULL))
1145                 mroute6_socket = sk;
1146         else
1147                 err = -EADDRINUSE;
1148         write_unlock_bh(&mrt_lock);
1149
1150         rtnl_unlock();
1151
1152         return err;
1153 }
1154
1155 int ip6mr_sk_done(struct sock *sk)
1156 {
1157         int err = 0;
1158
1159         rtnl_lock();
1160         if (sk == mroute6_socket) {
1161                 write_lock_bh(&mrt_lock);
1162                 mroute6_socket = NULL;
1163                 write_unlock_bh(&mrt_lock);
1164
1165                 mroute_clean_tables(sk);
1166         } else
1167                 err = -EACCES;
1168         rtnl_unlock();
1169
1170         return err;
1171 }
1172
1173 /*
1174  *      Socket options and virtual interface manipulation. The whole
1175  *      virtual interface system is a complete heap, but unfortunately
1176  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1177  *      MOSPF/PIM router set up we can clean this up.
1178  */
1179
1180 int ip6_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, int optlen)
1181 {
1182         int ret;
1183         struct mif6ctl vif;
1184         struct mf6cctl mfc;
1185         mifi_t mifi;
1186
1187         if (optname != MRT6_INIT) {
1188                 if (sk != mroute6_socket && !capable(CAP_NET_ADMIN))
1189                         return -EACCES;
1190         }
1191
1192         switch (optname) {
1193         case MRT6_INIT:
1194                 if (sk->sk_type != SOCK_RAW ||
1195                     inet_sk(sk)->num != IPPROTO_ICMPV6)
1196                         return -EOPNOTSUPP;
1197                 if (optlen < sizeof(int))
1198                         return -EINVAL;
1199
1200                 return ip6mr_sk_init(sk);
1201
1202         case MRT6_DONE:
1203                 return ip6mr_sk_done(sk);
1204
1205         case MRT6_ADD_MIF:
1206                 if (optlen < sizeof(vif))
1207                         return -EINVAL;
1208                 if (copy_from_user(&vif, optval, sizeof(vif)))
1209                         return -EFAULT;
1210                 if (vif.mif6c_mifi >= MAXMIFS)
1211                         return -ENFILE;
1212                 rtnl_lock();
1213                 ret = mif6_add(&vif, sk == mroute6_socket);
1214                 rtnl_unlock();
1215                 return ret;
1216
1217         case MRT6_DEL_MIF:
1218                 if (optlen < sizeof(mifi_t))
1219                         return -EINVAL;
1220                 if (copy_from_user(&mifi, optval, sizeof(mifi_t)))
1221                         return -EFAULT;
1222                 rtnl_lock();
1223                 ret = mif6_delete(mifi);
1224                 rtnl_unlock();
1225                 return ret;
1226
1227         /*
1228          *      Manipulate the forwarding caches. These live
1229          *      in a sort of kernel/user symbiosis.
1230          */
1231         case MRT6_ADD_MFC:
1232         case MRT6_DEL_MFC:
1233                 if (optlen < sizeof(mfc))
1234                         return -EINVAL;
1235                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1236                         return -EFAULT;
1237                 rtnl_lock();
1238                 if (optname == MRT6_DEL_MFC)
1239                         ret = ip6mr_mfc_delete(&mfc);
1240                 else
1241                         ret = ip6mr_mfc_add(&mfc, sk == mroute6_socket);
1242                 rtnl_unlock();
1243                 return ret;
1244
1245         /*
1246          *      Control PIM assert (to activate pim will activate assert)
1247          */
1248         case MRT6_ASSERT:
1249         {
1250                 int v;
1251                 if (get_user(v, (int __user *)optval))
1252                         return -EFAULT;
1253                 mroute_do_assert = !!v;
1254                 return 0;
1255         }
1256
1257 #ifdef CONFIG_IPV6_PIMSM_V2
1258         case MRT6_PIM:
1259         {
1260                 int v;
1261                 if (get_user(v, (int __user *)optval))
1262                         return -EFAULT;
1263                 v = !!v;
1264                 rtnl_lock();
1265                 ret = 0;
1266                 if (v != mroute_do_pim) {
1267                         mroute_do_pim = v;
1268                         mroute_do_assert = v;
1269                         if (mroute_do_pim)
1270                                 ret = inet6_add_protocol(&pim6_protocol,
1271                                                          IPPROTO_PIM);
1272                         else
1273                                 ret = inet6_del_protocol(&pim6_protocol,
1274                                                          IPPROTO_PIM);
1275                         if (ret < 0)
1276                                 ret = -EAGAIN;
1277                 }
1278                 rtnl_unlock();
1279                 return ret;
1280         }
1281
1282 #endif
1283         /*
1284          *      Spurious command, or MRT6_VERSION which you cannot
1285          *      set.
1286          */
1287         default:
1288                 return -ENOPROTOOPT;
1289         }
1290 }
1291
1292 /*
1293  *      Getsock opt support for the multicast routing system.
1294  */
1295
1296 int ip6_mroute_getsockopt(struct sock *sk, int optname, char __user *optval,
1297                           int __user *optlen)
1298 {
1299         int olr;
1300         int val;
1301
1302         switch (optname) {
1303         case MRT6_VERSION:
1304                 val = 0x0305;
1305                 break;
1306 #ifdef CONFIG_IPV6_PIMSM_V2
1307         case MRT6_PIM:
1308                 val = mroute_do_pim;
1309                 break;
1310 #endif
1311         case MRT6_ASSERT:
1312                 val = mroute_do_assert;
1313                 break;
1314         default:
1315                 return -ENOPROTOOPT;
1316         }
1317
1318         if (get_user(olr, optlen))
1319                 return -EFAULT;
1320
1321         olr = min_t(int, olr, sizeof(int));
1322         if (olr < 0)
1323                 return -EINVAL;
1324
1325         if (put_user(olr, optlen))
1326                 return -EFAULT;
1327         if (copy_to_user(optval, &val, olr))
1328                 return -EFAULT;
1329         return 0;
1330 }
1331
1332 /*
1333  *      The IP multicast ioctl support routines.
1334  */
1335
1336 int ip6mr_ioctl(struct sock *sk, int cmd, void __user *arg)
1337 {
1338         struct sioc_sg_req6 sr;
1339         struct sioc_mif_req6 vr;
1340         struct mif_device *vif;
1341         struct mfc6_cache *c;
1342
1343         switch (cmd) {
1344         case SIOCGETMIFCNT_IN6:
1345                 if (copy_from_user(&vr, arg, sizeof(vr)))
1346                         return -EFAULT;
1347                 if (vr.mifi >= maxvif)
1348                         return -EINVAL;
1349                 read_lock(&mrt_lock);
1350                 vif = &vif6_table[vr.mifi];
1351                 if (MIF_EXISTS(vr.mifi)) {
1352                         vr.icount = vif->pkt_in;
1353                         vr.ocount = vif->pkt_out;
1354                         vr.ibytes = vif->bytes_in;
1355                         vr.obytes = vif->bytes_out;
1356                         read_unlock(&mrt_lock);
1357
1358                         if (copy_to_user(arg, &vr, sizeof(vr)))
1359                                 return -EFAULT;
1360                         return 0;
1361                 }
1362                 read_unlock(&mrt_lock);
1363                 return -EADDRNOTAVAIL;
1364         case SIOCGETSGCNT_IN6:
1365                 if (copy_from_user(&sr, arg, sizeof(sr)))
1366                         return -EFAULT;
1367
1368                 read_lock(&mrt_lock);
1369                 c = ip6mr_cache_find(&sr.src.sin6_addr, &sr.grp.sin6_addr);
1370                 if (c) {
1371                         sr.pktcnt = c->mfc_un.res.pkt;
1372                         sr.bytecnt = c->mfc_un.res.bytes;
1373                         sr.wrong_if = c->mfc_un.res.wrong_if;
1374                         read_unlock(&mrt_lock);
1375
1376                         if (copy_to_user(arg, &sr, sizeof(sr)))
1377                                 return -EFAULT;
1378                         return 0;
1379                 }
1380                 read_unlock(&mrt_lock);
1381                 return -EADDRNOTAVAIL;
1382         default:
1383                 return -ENOIOCTLCMD;
1384         }
1385 }
1386
1387
1388 static inline int ip6mr_forward2_finish(struct sk_buff *skb)
1389 {
1390         IP6_INC_STATS_BH(dev_net(skb->dst->dev), ip6_dst_idev(skb->dst),
1391                          IPSTATS_MIB_OUTFORWDATAGRAMS);
1392         return dst_output(skb);
1393 }
1394
1395 /*
1396  *      Processing handlers for ip6mr_forward
1397  */
1398
1399 static int ip6mr_forward2(struct sk_buff *skb, struct mfc6_cache *c, int vifi)
1400 {
1401         struct ipv6hdr *ipv6h;
1402         struct mif_device *vif = &vif6_table[vifi];
1403         struct net_device *dev;
1404         struct dst_entry *dst;
1405         struct flowi fl;
1406
1407         if (vif->dev == NULL)
1408                 goto out_free;
1409
1410 #ifdef CONFIG_IPV6_PIMSM_V2
1411         if (vif->flags & MIFF_REGISTER) {
1412                 vif->pkt_out++;
1413                 vif->bytes_out += skb->len;
1414                 vif->dev->stats.tx_bytes += skb->len;
1415                 vif->dev->stats.tx_packets++;
1416                 ip6mr_cache_report(skb, vifi, MRT6MSG_WHOLEPKT);
1417                 kfree_skb(skb);
1418                 return 0;
1419         }
1420 #endif
1421
1422         ipv6h = ipv6_hdr(skb);
1423
1424         fl = (struct flowi) {
1425                 .oif = vif->link,
1426                 .nl_u = { .ip6_u =
1427                                 { .daddr = ipv6h->daddr, }
1428                 }
1429         };
1430
1431         dst = ip6_route_output(&init_net, NULL, &fl);
1432         if (!dst)
1433                 goto out_free;
1434
1435         dst_release(skb->dst);
1436         skb->dst = dst;
1437
1438         /*
1439          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1440          * not only before forwarding, but after forwarding on all output
1441          * interfaces. It is clear, if mrouter runs a multicasting
1442          * program, it should receive packets not depending to what interface
1443          * program is joined.
1444          * If we will not make it, the program will have to join on all
1445          * interfaces. On the other hand, multihoming host (or router, but
1446          * not mrouter) cannot join to more than one interface - it will
1447          * result in receiving multiple packets.
1448          */
1449         dev = vif->dev;
1450         skb->dev = dev;
1451         vif->pkt_out++;
1452         vif->bytes_out += skb->len;
1453
1454         /* We are about to write */
1455         /* XXX: extension headers? */
1456         if (skb_cow(skb, sizeof(*ipv6h) + LL_RESERVED_SPACE(dev)))
1457                 goto out_free;
1458
1459         ipv6h = ipv6_hdr(skb);
1460         ipv6h->hop_limit--;
1461
1462         IP6CB(skb)->flags |= IP6SKB_FORWARDED;
1463
1464         return NF_HOOK(PF_INET6, NF_INET_FORWARD, skb, skb->dev, dev,
1465                        ip6mr_forward2_finish);
1466
1467 out_free:
1468         kfree_skb(skb);
1469         return 0;
1470 }
1471
1472 static int ip6mr_find_vif(struct net_device *dev)
1473 {
1474         int ct;
1475         for (ct = maxvif - 1; ct >= 0; ct--) {
1476                 if (vif6_table[ct].dev == dev)
1477                         break;
1478         }
1479         return ct;
1480 }
1481
1482 static int ip6_mr_forward(struct sk_buff *skb, struct mfc6_cache *cache)
1483 {
1484         int psend = -1;
1485         int vif, ct;
1486
1487         vif = cache->mf6c_parent;
1488         cache->mfc_un.res.pkt++;
1489         cache->mfc_un.res.bytes += skb->len;
1490
1491         /*
1492          * Wrong interface: drop packet and (maybe) send PIM assert.
1493          */
1494         if (vif6_table[vif].dev != skb->dev) {
1495                 int true_vifi;
1496
1497                 cache->mfc_un.res.wrong_if++;
1498                 true_vifi = ip6mr_find_vif(skb->dev);
1499
1500                 if (true_vifi >= 0 && mroute_do_assert &&
1501                     /* pimsm uses asserts, when switching from RPT to SPT,
1502                        so that we cannot check that packet arrived on an oif.
1503                        It is bad, but otherwise we would need to move pretty
1504                        large chunk of pimd to kernel. Ough... --ANK
1505                      */
1506                     (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1507                     time_after(jiffies,
1508                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1509                         cache->mfc_un.res.last_assert = jiffies;
1510                         ip6mr_cache_report(skb, true_vifi, MRT6MSG_WRONGMIF);
1511                 }
1512                 goto dont_forward;
1513         }
1514
1515         vif6_table[vif].pkt_in++;
1516         vif6_table[vif].bytes_in += skb->len;
1517
1518         /*
1519          *      Forward the frame
1520          */
1521         for (ct = cache->mfc_un.res.maxvif - 1; ct >= cache->mfc_un.res.minvif; ct--) {
1522                 if (ipv6_hdr(skb)->hop_limit > cache->mfc_un.res.ttls[ct]) {
1523                         if (psend != -1) {
1524                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1525                                 if (skb2)
1526                                         ip6mr_forward2(skb2, cache, psend);
1527                         }
1528                         psend = ct;
1529                 }
1530         }
1531         if (psend != -1) {
1532                 ip6mr_forward2(skb, cache, psend);
1533                 return 0;
1534         }
1535
1536 dont_forward:
1537         kfree_skb(skb);
1538         return 0;
1539 }
1540
1541
1542 /*
1543  *      Multicast packets for forwarding arrive here
1544  */
1545
1546 int ip6_mr_input(struct sk_buff *skb)
1547 {
1548         struct mfc6_cache *cache;
1549
1550         read_lock(&mrt_lock);
1551         cache = ip6mr_cache_find(&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr);
1552
1553         /*
1554          *      No usable cache entry
1555          */
1556         if (cache == NULL) {
1557                 int vif;
1558
1559                 vif = ip6mr_find_vif(skb->dev);
1560                 if (vif >= 0) {
1561                         int err = ip6mr_cache_unresolved(vif, skb);
1562                         read_unlock(&mrt_lock);
1563
1564                         return err;
1565                 }
1566                 read_unlock(&mrt_lock);
1567                 kfree_skb(skb);
1568                 return -ENODEV;
1569         }
1570
1571         ip6_mr_forward(skb, cache);
1572
1573         read_unlock(&mrt_lock);
1574
1575         return 0;
1576 }
1577
1578
1579 static int
1580 ip6mr_fill_mroute(struct sk_buff *skb, struct mfc6_cache *c, struct rtmsg *rtm)
1581 {
1582         int ct;
1583         struct rtnexthop *nhp;
1584         struct net_device *dev = vif6_table[c->mf6c_parent].dev;
1585         u8 *b = skb_tail_pointer(skb);
1586         struct rtattr *mp_head;
1587
1588         if (dev)
1589                 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1590
1591         mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1592
1593         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1594                 if (c->mfc_un.res.ttls[ct] < 255) {
1595                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1596                                 goto rtattr_failure;
1597                         nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1598                         nhp->rtnh_flags = 0;
1599                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1600                         nhp->rtnh_ifindex = vif6_table[ct].dev->ifindex;
1601                         nhp->rtnh_len = sizeof(*nhp);
1602                 }
1603         }
1604         mp_head->rta_type = RTA_MULTIPATH;
1605         mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1606         rtm->rtm_type = RTN_MULTICAST;
1607         return 1;
1608
1609 rtattr_failure:
1610         nlmsg_trim(skb, b);
1611         return -EMSGSIZE;
1612 }
1613
1614 int ip6mr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1615 {
1616         int err;
1617         struct mfc6_cache *cache;
1618         struct rt6_info *rt = (struct rt6_info *)skb->dst;
1619
1620         read_lock(&mrt_lock);
1621         cache = ip6mr_cache_find(&rt->rt6i_src.addr, &rt->rt6i_dst.addr);
1622
1623         if (!cache) {
1624                 struct sk_buff *skb2;
1625                 struct ipv6hdr *iph;
1626                 struct net_device *dev;
1627                 int vif;
1628
1629                 if (nowait) {
1630                         read_unlock(&mrt_lock);
1631                         return -EAGAIN;
1632                 }
1633
1634                 dev = skb->dev;
1635                 if (dev == NULL || (vif = ip6mr_find_vif(dev)) < 0) {
1636                         read_unlock(&mrt_lock);
1637                         return -ENODEV;
1638                 }
1639
1640                 /* really correct? */
1641                 skb2 = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
1642                 if (!skb2) {
1643                         read_unlock(&mrt_lock);
1644                         return -ENOMEM;
1645                 }
1646
1647                 skb_reset_transport_header(skb2);
1648
1649                 skb_put(skb2, sizeof(struct ipv6hdr));
1650                 skb_reset_network_header(skb2);
1651
1652                 iph = ipv6_hdr(skb2);
1653                 iph->version = 0;
1654                 iph->priority = 0;
1655                 iph->flow_lbl[0] = 0;
1656                 iph->flow_lbl[1] = 0;
1657                 iph->flow_lbl[2] = 0;
1658                 iph->payload_len = 0;
1659                 iph->nexthdr = IPPROTO_NONE;
1660                 iph->hop_limit = 0;
1661                 ipv6_addr_copy(&iph->saddr, &rt->rt6i_src.addr);
1662                 ipv6_addr_copy(&iph->daddr, &rt->rt6i_dst.addr);
1663
1664                 err = ip6mr_cache_unresolved(vif, skb2);
1665                 read_unlock(&mrt_lock);
1666
1667                 return err;
1668         }
1669
1670         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1671                 cache->mfc_flags |= MFC_NOTIFY;
1672
1673         err = ip6mr_fill_mroute(skb, cache, rtm);
1674         read_unlock(&mrt_lock);
1675         return err;
1676 }
1677