git.oblomov.eu Git - linux-2.6/blob - net/ipv4/ipmr.c

   1 /*
   2  *      IP multicast routing support for mrouted 3.6/3.8
   3  *
   4  *              (c) 1995 Alan Cox, <alan@redhat.com>
   5  *        Linux Consultancy and Custom Driver Development
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version
  10  *      2 of the License, or (at your option) any later version.
  11  *
  12  *      Version: $Id: ipmr.c,v 1.65 2001/10/31 21:55:54 davem Exp $
  13  *
  14  *      Fixes:
  15  *      Michael Chastain        :       Incorrect size of copying.
  16  *      Alan Cox                :       Added the cache manager code
  17  *      Alan Cox                :       Fixed the clone/copy bug and device race.
  18  *      Mike McLagan            :       Routing by source
  19  *      Malcolm Beattie         :       Buffer handling fixes.
  20  *      Alexey Kuznetsov        :       Double buffer free and other fixes.
  21  *      SVR Anand               :       Fixed several multicast bugs and problems.
  22  *      Alexey Kuznetsov        :       Status, optimisations and more.
  23  *      Brad Parker             :       Better behaviour on mrouted upcall
  24  *                                      overflow.
  25  *      Carlos Picoto           :       PIMv1 Support
  26  *      Pavlin Ivanov Radoslavov:       PIMv2 Registers must checksum only PIM header
  27  *                                      Relax this requrement to work with older peers.
  28  *
  29  */
  30
  31 #include <asm/system.h>
  32 #include <asm/uaccess.h>
  33 #include <linux/types.h>
  34 #include <linux/capability.h>
  35 #include <linux/errno.h>
  36 #include <linux/timer.h>
  37 #include <linux/mm.h>
  38 #include <linux/kernel.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/stat.h>
  41 #include <linux/socket.h>
  42 #include <linux/in.h>
  43 #include <linux/inet.h>
  44 #include <linux/netdevice.h>
  45 #include <linux/inetdevice.h>
  46 #include <linux/igmp.h>
  47 #include <linux/proc_fs.h>
  48 #include <linux/seq_file.h>
  49 #include <linux/mroute.h>
  50 #include <linux/init.h>
  51 #include <linux/if_ether.h>
  52 #include <net/ip.h>
  53 #include <net/protocol.h>
  54 #include <linux/skbuff.h>
  55 #include <net/route.h>
  56 #include <net/sock.h>
  57 #include <net/icmp.h>
  58 #include <net/udp.h>
  59 #include <net/raw.h>
  60 #include <linux/notifier.h>
  61 #include <linux/if_arp.h>
  62 #include <linux/netfilter_ipv4.h>
  63 #include <net/ipip.h>
  64 #include <net/checksum.h>
  65
  66 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
  67 #define CONFIG_IP_PIMSM 1
  68 #endif
  69
  70 static struct sock *mroute_socket;
  71
  72
  73 /* Big lock, protecting vif table, mrt cache and mroute socket state.
  74    Note that the changes are semaphored via rtnl_lock.
  75  */
  76
  77 static DEFINE_RWLOCK(mrt_lock);
  78
  79 /*
  80  *      Multicast router control variables
  81  */
  82
  83 static struct vif_device vif_table[MAXVIFS];            /* Devices              */
  84 static int maxvif;
  85
  86 #define VIF_EXISTS(idx) (vif_table[idx].dev != NULL)
  87
  88 static int mroute_do_assert;                            /* Set in PIM assert    */
  89 static int mroute_do_pim;
  90
  91 static struct mfc_cache *mfc_cache_array[MFC_LINES];    /* Forwarding cache     */
  92
  93 static struct mfc_cache *mfc_unres_queue;               /* Queue of unresolved entries */
  94 static atomic_t cache_resolve_queue_len;                /* Size of unresolved   */
  95
  96 /* Special spinlock for queue of unresolved entries */
  97 static DEFINE_SPINLOCK(mfc_unres_lock);
  98
  99 /* We return to original Alan's scheme. Hash table of resolved
 100    entries is changed only in process context and protected
 101    with weak lock mrt_lock. Queue of unresolved entries is protected
 102    with strong spinlock mfc_unres_lock.
 103
 104    In this case data path is free of exclusive locks at all.
 105  */
 106
 107 static struct kmem_cache *mrt_cachep __read_mostly;
 108
 109 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local);
 110 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert);
 111 static int ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm);
 112
 113 #ifdef CONFIG_IP_PIMSM_V2
 114 static struct net_protocol pim_protocol;
 115 #endif
 116
 117 static struct timer_list ipmr_expire_timer;
 118
 119 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
 120
 121 static
 122 struct net_device *ipmr_new_tunnel(struct vifctl *v)
 123 {
 124         struct net_device  *dev;
 125
 126         dev = __dev_get_by_name("tunl0");
 127
 128         if (dev) {
 129                 int err;
 130                 struct ifreq ifr;
 131                 mm_segment_t    oldfs;
 132                 struct ip_tunnel_parm p;
 133                 struct in_device  *in_dev;
 134
 135                 memset(&p, 0, sizeof(p));
 136                 p.iph.daddr = v->vifc_rmt_addr.s_addr;
 137                 p.iph.saddr = v->vifc_lcl_addr.s_addr;
 138                 p.iph.version = 4;
 139                 p.iph.ihl = 5;
 140                 p.iph.protocol = IPPROTO_IPIP;
 141                 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
 142                 ifr.ifr_ifru.ifru_data = (void*)&p;
 143
 144                 oldfs = get_fs(); set_fs(KERNEL_DS);
 145                 err = dev->do_ioctl(dev, &ifr, SIOCADDTUNNEL);
 146                 set_fs(oldfs);
 147
 148                 dev = NULL;
 149
 150                 if (err == 0 && (dev = __dev_get_by_name(p.name)) != NULL) {
 151                         dev->flags |= IFF_MULTICAST;
 152
 153                         in_dev = __in_dev_get_rtnl(dev);
 154                         if (in_dev == NULL && (in_dev = inetdev_init(dev)) == NULL)
 155                                 goto failure;
 156                         in_dev->cnf.rp_filter = 0;
 157
 158                         if (dev_open(dev))
 159                                 goto failure;
 160                 }
 161         }
 162         return dev;
 163
 164 failure:
 165         /* allow the register to be completed before unregistering. */
 166         rtnl_unlock();
 167         rtnl_lock();
 168
 169         unregister_netdevice(dev);
 170         return NULL;
 171 }
 172
 173 #ifdef CONFIG_IP_PIMSM
 174
 175 static int reg_vif_num = -1;
 176
 177 static int reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
 178 {
 179         read_lock(&mrt_lock);
 180         ((struct net_device_stats*)netdev_priv(dev))->tx_bytes += skb->len;
 181         ((struct net_device_stats*)netdev_priv(dev))->tx_packets++;
 182         ipmr_cache_report(skb, reg_vif_num, IGMPMSG_WHOLEPKT);
 183         read_unlock(&mrt_lock);
 184         kfree_skb(skb);
 185         return 0;
 186 }
 187
 188 static struct net_device_stats *reg_vif_get_stats(struct net_device *dev)
 189 {
 190         return (struct net_device_stats*)netdev_priv(dev);
 191 }
 192
 193 static void reg_vif_setup(struct net_device *dev)
 194 {
 195         dev->type               = ARPHRD_PIMREG;
 196         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
 197         dev->flags              = IFF_NOARP;
 198         dev->hard_start_xmit    = reg_vif_xmit;
 199         dev->get_stats          = reg_vif_get_stats;
 200         dev->destructor         = free_netdev;
 201 }
 202
 203 static struct net_device *ipmr_reg_vif(void)
 204 {
 205         struct net_device *dev;
 206         struct in_device *in_dev;
 207
 208         dev = alloc_netdev(sizeof(struct net_device_stats), "pimreg",
 209                            reg_vif_setup);
 210
 211         if (dev == NULL)
 212                 return NULL;
 213
 214         if (register_netdevice(dev)) {
 215                 free_netdev(dev);
 216                 return NULL;
 217         }
 218         dev->iflink = 0;
 219
 220         if ((in_dev = inetdev_init(dev)) == NULL)
 221                 goto failure;
 222
 223         in_dev->cnf.rp_filter = 0;
 224
 225         if (dev_open(dev))
 226                 goto failure;
 227
 228         return dev;
 229
 230 failure:
 231         /* allow the register to be completed before unregistering. */
 232         rtnl_unlock();
 233         rtnl_lock();
 234
 235         unregister_netdevice(dev);
 236         return NULL;
 237 }
 238 #endif
 239
 240 /*
 241  *      Delete a VIF entry
 242  */
 243
 244 static int vif_delete(int vifi)
 245 {
 246         struct vif_device *v;
 247         struct net_device *dev;
 248         struct in_device *in_dev;
 249
 250         if (vifi < 0 || vifi >= maxvif)
 251                 return -EADDRNOTAVAIL;
 252
 253         v = &vif_table[vifi];
 254
 255         write_lock_bh(&mrt_lock);
 256         dev = v->dev;
 257         v->dev = NULL;
 258
 259         if (!dev) {
 260                 write_unlock_bh(&mrt_lock);
 261                 return -EADDRNOTAVAIL;
 262         }
 263
 264 #ifdef CONFIG_IP_PIMSM
 265         if (vifi == reg_vif_num)
 266                 reg_vif_num = -1;
 267 #endif
 268
 269         if (vifi+1 == maxvif) {
 270                 int tmp;
 271                 for (tmp=vifi-1; tmp>=0; tmp--) {
 272                         if (VIF_EXISTS(tmp))
 273                                 break;
 274                 }
 275                 maxvif = tmp+1;
 276         }
 277
 278         write_unlock_bh(&mrt_lock);
 279
 280         dev_set_allmulti(dev, -1);
 281
 282         if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
 283                 in_dev->cnf.mc_forwarding--;
 284                 ip_rt_multicast_event(in_dev);
 285         }
 286
 287         if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
 288                 unregister_netdevice(dev);
 289
 290         dev_put(dev);
 291         return 0;
 292 }
 293
 294 /* Destroy an unresolved cache entry, killing queued skbs
 295    and reporting error to netlink readers.
 296  */
 297
 298 static void ipmr_destroy_unres(struct mfc_cache *c)
 299 {
 300         struct sk_buff *skb;
 301         struct nlmsgerr *e;
 302
 303         atomic_dec(&cache_resolve_queue_len);
 304
 305         while((skb=skb_dequeue(&c->mfc_un.unres.unresolved))) {
 306                 if (skb->nh.iph->version == 0) {
 307                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 308                         nlh->nlmsg_type = NLMSG_ERROR;
 309                         nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 310                         skb_trim(skb, nlh->nlmsg_len);
 311                         e = NLMSG_DATA(nlh);
 312                         e->error = -ETIMEDOUT;
 313                         memset(&e->msg, 0, sizeof(e->msg));
 314
 315                         rtnl_unicast(skb, NETLINK_CB(skb).pid);
 316                 } else
 317                         kfree_skb(skb);
 318         }
 319
 320         kmem_cache_free(mrt_cachep, c);
 321 }
 322
 323
 324 /* Single timer process for all the unresolved queue. */
 325
 326 static void ipmr_expire_process(unsigned long dummy)
 327 {
 328         unsigned long now;
 329         unsigned long expires;
 330         struct mfc_cache *c, **cp;
 331
 332         if (!spin_trylock(&mfc_unres_lock)) {
 333                 mod_timer(&ipmr_expire_timer, jiffies+HZ/10);
 334                 return;
 335         }
 336
 337         if (atomic_read(&cache_resolve_queue_len) == 0)
 338                 goto out;
 339
 340         now = jiffies;
 341         expires = 10*HZ;
 342         cp = &mfc_unres_queue;
 343
 344         while ((c=*cp) != NULL) {
 345                 if (time_after(c->mfc_un.unres.expires, now)) {
 346                         unsigned long interval = c->mfc_un.unres.expires - now;
 347                         if (interval < expires)
 348                                 expires = interval;
 349                         cp = &c->next;
 350                         continue;
 351                 }
 352
 353                 *cp = c->next;
 354
 355                 ipmr_destroy_unres(c);
 356         }
 357
 358         if (atomic_read(&cache_resolve_queue_len))
 359                 mod_timer(&ipmr_expire_timer, jiffies + expires);
 360
 361 out:
 362         spin_unlock(&mfc_unres_lock);
 363 }
 364
 365 /* Fill oifs list. It is called under write locked mrt_lock. */
 366
 367 static void ipmr_update_thresholds(struct mfc_cache *cache, unsigned char *ttls)
 368 {
 369         int vifi;
 370
 371         cache->mfc_un.res.minvif = MAXVIFS;
 372         cache->mfc_un.res.maxvif = 0;
 373         memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
 374
 375         for (vifi=0; vifi<maxvif; vifi++) {
 376                 if (VIF_EXISTS(vifi) && ttls[vifi] && ttls[vifi] < 255) {
 377                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
 378                         if (cache->mfc_un.res.minvif > vifi)
 379                                 cache->mfc_un.res.minvif = vifi;
 380                         if (cache->mfc_un.res.maxvif <= vifi)
 381                                 cache->mfc_un.res.maxvif = vifi + 1;
 382                 }
 383         }
 384 }
 385
 386 static int vif_add(struct vifctl *vifc, int mrtsock)
 387 {
 388         int vifi = vifc->vifc_vifi;
 389         struct vif_device *v = &vif_table[vifi];
 390         struct net_device *dev;
 391         struct in_device *in_dev;
 392
 393         /* Is vif busy ? */
 394         if (VIF_EXISTS(vifi))
 395                 return -EADDRINUSE;
 396
 397         switch (vifc->vifc_flags) {
 398 #ifdef CONFIG_IP_PIMSM
 399         case VIFF_REGISTER:
 400                 /*
 401                  * Special Purpose VIF in PIM
 402                  * All the packets will be sent to the daemon
 403                  */
 404                 if (reg_vif_num >= 0)
 405                         return -EADDRINUSE;
 406                 dev = ipmr_reg_vif();
 407                 if (!dev)
 408                         return -ENOBUFS;
 409                 break;
 410 #endif
 411         case VIFF_TUNNEL:
 412                 dev = ipmr_new_tunnel(vifc);
 413                 if (!dev)
 414                         return -ENOBUFS;
 415                 break;
 416         case 0:
 417                 dev = ip_dev_find(vifc->vifc_lcl_addr.s_addr);
 418                 if (!dev)
 419                         return -EADDRNOTAVAIL;
 420                 dev_put(dev);
 421                 break;
 422         default:
 423                 return -EINVAL;
 424         }
 425
 426         if ((in_dev = __in_dev_get_rtnl(dev)) == NULL)
 427                 return -EADDRNOTAVAIL;
 428         in_dev->cnf.mc_forwarding++;
 429         dev_set_allmulti(dev, +1);
 430         ip_rt_multicast_event(in_dev);
 431
 432         /*
 433          *      Fill in the VIF structures
 434          */
 435         v->rate_limit=vifc->vifc_rate_limit;
 436         v->local=vifc->vifc_lcl_addr.s_addr;
 437         v->remote=vifc->vifc_rmt_addr.s_addr;
 438         v->flags=vifc->vifc_flags;
 439         if (!mrtsock)
 440                 v->flags |= VIFF_STATIC;
 441         v->threshold=vifc->vifc_threshold;
 442         v->bytes_in = 0;
 443         v->bytes_out = 0;
 444         v->pkt_in = 0;
 445         v->pkt_out = 0;
 446         v->link = dev->ifindex;
 447         if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
 448                 v->link = dev->iflink;
 449
 450         /* And finish update writing critical data */
 451         write_lock_bh(&mrt_lock);
 452         dev_hold(dev);
 453         v->dev=dev;
 454 #ifdef CONFIG_IP_PIMSM
 455         if (v->flags&VIFF_REGISTER)
 456                 reg_vif_num = vifi;
 457 #endif
 458         if (vifi+1 > maxvif)
 459                 maxvif = vifi+1;
 460         write_unlock_bh(&mrt_lock);
 461         return 0;
 462 }
 463
 464 static struct mfc_cache *ipmr_cache_find(__be32 origin, __be32 mcastgrp)
 465 {
 466         int line=MFC_HASH(mcastgrp,origin);
 467         struct mfc_cache *c;
 468
 469         for (c=mfc_cache_array[line]; c; c = c->next) {
 470                 if (c->mfc_origin==origin && c->mfc_mcastgrp==mcastgrp)
 471                         break;
 472         }
 473         return c;
 474 }
 475
 476 /*
 477  *      Allocate a multicast cache entry
 478  */
 479 static struct mfc_cache *ipmr_cache_alloc(void)
 480 {
 481         struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
 482         if(c==NULL)
 483                 return NULL;
 484         c->mfc_un.res.minvif = MAXVIFS;
 485         return c;
 486 }
 487
 488 static struct mfc_cache *ipmr_cache_alloc_unres(void)
 489 {
 490         struct mfc_cache *c=kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
 491         if(c==NULL)
 492                 return NULL;
 493         skb_queue_head_init(&c->mfc_un.unres.unresolved);
 494         c->mfc_un.unres.expires = jiffies + 10*HZ;
 495         return c;
 496 }
 497
 498 /*
 499  *      A cache entry has gone into a resolved state from queued
 500  */
 501
 502 static void ipmr_cache_resolve(struct mfc_cache *uc, struct mfc_cache *c)
 503 {
 504         struct sk_buff *skb;
 505         struct nlmsgerr *e;
 506
 507         /*
 508          *      Play the pending entries through our router
 509          */
 510
 511         while((skb=__skb_dequeue(&uc->mfc_un.unres.unresolved))) {
 512                 if (skb->nh.iph->version == 0) {
 513                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 514
 515                         if (ipmr_fill_mroute(skb, c, NLMSG_DATA(nlh)) > 0) {
 516                                 nlh->nlmsg_len = skb->tail - (u8*)nlh;
 517                         } else {
 518                                 nlh->nlmsg_type = NLMSG_ERROR;
 519                                 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 520                                 skb_trim(skb, nlh->nlmsg_len);
 521                                 e = NLMSG_DATA(nlh);
 522                                 e->error = -EMSGSIZE;
 523                                 memset(&e->msg, 0, sizeof(e->msg));
 524                         }
 525
 526                         rtnl_unicast(skb, NETLINK_CB(skb).pid);
 527                 } else
 528                         ip_mr_forward(skb, c, 0);
 529         }
 530 }
 531
 532 /*
 533  *      Bounce a cache query up to mrouted. We could use netlink for this but mrouted
 534  *      expects the following bizarre scheme.
 535  *
 536  *      Called under mrt_lock.
 537  */
 538
 539 static int ipmr_cache_report(struct sk_buff *pkt, vifi_t vifi, int assert)
 540 {
 541         struct sk_buff *skb;
 542         int ihl = pkt->nh.iph->ihl<<2;
 543         struct igmphdr *igmp;
 544         struct igmpmsg *msg;
 545         int ret;
 546
 547 #ifdef CONFIG_IP_PIMSM
 548         if (assert == IGMPMSG_WHOLEPKT)
 549                 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
 550         else
 551 #endif
 552                 skb = alloc_skb(128, GFP_ATOMIC);
 553
 554         if(!skb)
 555                 return -ENOBUFS;
 556
 557 #ifdef CONFIG_IP_PIMSM
 558         if (assert == IGMPMSG_WHOLEPKT) {
 559                 /* Ugly, but we have no choice with this interface.
 560                    Duplicate old header, fix ihl, length etc.
 561                    And all this only to mangle msg->im_msgtype and
 562                    to set msg->im_mbz to "mbz" :-)
 563                  */
 564                 msg = (struct igmpmsg*)skb_push(skb, sizeof(struct iphdr));
 565                 skb->nh.raw = skb->h.raw = (u8*)msg;
 566                 memcpy(msg, pkt->nh.raw, sizeof(struct iphdr));
 567                 msg->im_msgtype = IGMPMSG_WHOLEPKT;
 568                 msg->im_mbz = 0;
 569                 msg->im_vif = reg_vif_num;
 570                 skb->nh.iph->ihl = sizeof(struct iphdr) >> 2;
 571                 skb->nh.iph->tot_len = htons(ntohs(pkt->nh.iph->tot_len) + sizeof(struct iphdr));
 572         } else
 573 #endif
 574         {
 575
 576         /*
 577          *      Copy the IP header
 578          */
 579
 580         skb->nh.iph = (struct iphdr *)skb_put(skb, ihl);
 581         memcpy(skb->data,pkt->data,ihl);
 582         skb->nh.iph->protocol = 0;                      /* Flag to the kernel this is a route add */
 583         msg = (struct igmpmsg*)skb->nh.iph;
 584         msg->im_vif = vifi;
 585         skb->dst = dst_clone(pkt->dst);
 586
 587         /*
 588          *      Add our header
 589          */
 590
 591         igmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
 592         igmp->type      =
 593         msg->im_msgtype = assert;
 594         igmp->code      =       0;
 595         skb->nh.iph->tot_len=htons(skb->len);                   /* Fix the length */
 596         skb->h.raw = skb->nh.raw;
 597         }
 598
 599         if (mroute_socket == NULL) {
 600                 kfree_skb(skb);
 601                 return -EINVAL;
 602         }
 603
 604         /*
 605          *      Deliver to mrouted
 606          */
 607         if ((ret=sock_queue_rcv_skb(mroute_socket,skb))<0) {
 608                 if (net_ratelimit())
 609                         printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
 610                 kfree_skb(skb);
 611         }
 612
 613         return ret;
 614 }
 615
 616 /*
 617  *      Queue a packet for resolution. It gets locked cache entry!
 618  */
 619
 620 static int
 621 ipmr_cache_unresolved(vifi_t vifi, struct sk_buff *skb)
 622 {
 623         int err;
 624         struct mfc_cache *c;
 625
 626         spin_lock_bh(&mfc_unres_lock);
 627         for (c=mfc_unres_queue; c; c=c->next) {
 628                 if (c->mfc_mcastgrp == skb->nh.iph->daddr &&
 629                     c->mfc_origin == skb->nh.iph->saddr)
 630                         break;
 631         }
 632
 633         if (c == NULL) {
 634                 /*
 635                  *      Create a new entry if allowable
 636                  */
 637
 638                 if (atomic_read(&cache_resolve_queue_len)>=10 ||
 639                     (c=ipmr_cache_alloc_unres())==NULL) {
 640                         spin_unlock_bh(&mfc_unres_lock);
 641
 642                         kfree_skb(skb);
 643                         return -ENOBUFS;
 644                 }
 645
 646                 /*
 647                  *      Fill in the new cache entry
 648                  */
 649                 c->mfc_parent=-1;
 650                 c->mfc_origin=skb->nh.iph->saddr;
 651                 c->mfc_mcastgrp=skb->nh.iph->daddr;
 652
 653                 /*
 654                  *      Reflect first query at mrouted.
 655                  */
 656                 if ((err = ipmr_cache_report(skb, vifi, IGMPMSG_NOCACHE))<0) {
 657                         /* If the report failed throw the cache entry
 658                            out - Brad Parker
 659                          */
 660                         spin_unlock_bh(&mfc_unres_lock);
 661
 662                         kmem_cache_free(mrt_cachep, c);
 663                         kfree_skb(skb);
 664                         return err;
 665                 }
 666
 667                 atomic_inc(&cache_resolve_queue_len);
 668                 c->next = mfc_unres_queue;
 669                 mfc_unres_queue = c;
 670
 671                 mod_timer(&ipmr_expire_timer, c->mfc_un.unres.expires);
 672         }
 673
 674         /*
 675          *      See if we can append the packet
 676          */
 677         if (c->mfc_un.unres.unresolved.qlen>3) {
 678                 kfree_skb(skb);
 679                 err = -ENOBUFS;
 680         } else {
 681                 skb_queue_tail(&c->mfc_un.unres.unresolved,skb);
 682                 err = 0;
 683         }
 684
 685         spin_unlock_bh(&mfc_unres_lock);
 686         return err;
 687 }
 688
 689 /*
 690  *      MFC cache manipulation by user space mroute daemon
 691  */
 692
 693 static int ipmr_mfc_delete(struct mfcctl *mfc)
 694 {
 695         int line;
 696         struct mfc_cache *c, **cp;
 697
 698         line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
 699
 700         for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
 701                 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
 702                     c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
 703                         write_lock_bh(&mrt_lock);
 704                         *cp = c->next;
 705                         write_unlock_bh(&mrt_lock);
 706
 707                         kmem_cache_free(mrt_cachep, c);
 708                         return 0;
 709                 }
 710         }
 711         return -ENOENT;
 712 }
 713
 714 static int ipmr_mfc_add(struct mfcctl *mfc, int mrtsock)
 715 {
 716         int line;
 717         struct mfc_cache *uc, *c, **cp;
 718
 719         line=MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
 720
 721         for (cp=&mfc_cache_array[line]; (c=*cp) != NULL; cp = &c->next) {
 722                 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
 723                     c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr)
 724                         break;
 725         }
 726
 727         if (c != NULL) {
 728                 write_lock_bh(&mrt_lock);
 729                 c->mfc_parent = mfc->mfcc_parent;
 730                 ipmr_update_thresholds(c, mfc->mfcc_ttls);
 731                 if (!mrtsock)
 732                         c->mfc_flags |= MFC_STATIC;
 733                 write_unlock_bh(&mrt_lock);
 734                 return 0;
 735         }
 736
 737         if(!MULTICAST(mfc->mfcc_mcastgrp.s_addr))
 738                 return -EINVAL;
 739
 740         c=ipmr_cache_alloc();
 741         if (c==NULL)
 742                 return -ENOMEM;
 743
 744         c->mfc_origin=mfc->mfcc_origin.s_addr;
 745         c->mfc_mcastgrp=mfc->mfcc_mcastgrp.s_addr;
 746         c->mfc_parent=mfc->mfcc_parent;
 747         ipmr_update_thresholds(c, mfc->mfcc_ttls);
 748         if (!mrtsock)
 749                 c->mfc_flags |= MFC_STATIC;
 750
 751         write_lock_bh(&mrt_lock);
 752         c->next = mfc_cache_array[line];
 753         mfc_cache_array[line] = c;
 754         write_unlock_bh(&mrt_lock);
 755
 756         /*
 757          *      Check to see if we resolved a queued list. If so we
 758          *      need to send on the frames and tidy up.
 759          */
 760         spin_lock_bh(&mfc_unres_lock);
 761         for (cp = &mfc_unres_queue; (uc=*cp) != NULL;
 762              cp = &uc->next) {
 763                 if (uc->mfc_origin == c->mfc_origin &&
 764                     uc->mfc_mcastgrp == c->mfc_mcastgrp) {
 765                         *cp = uc->next;
 766                         if (atomic_dec_and_test(&cache_resolve_queue_len))
 767                                 del_timer(&ipmr_expire_timer);
 768                         break;
 769                 }
 770         }
 771         spin_unlock_bh(&mfc_unres_lock);
 772
 773         if (uc) {
 774                 ipmr_cache_resolve(uc, c);
 775                 kmem_cache_free(mrt_cachep, uc);
 776         }
 777         return 0;
 778 }
 779
 780 /*
 781  *      Close the multicast socket, and clear the vif tables etc
 782  */
 783
 784 static void mroute_clean_tables(struct sock *sk)
 785 {
 786         int i;
 787
 788         /*
 789          *      Shut down all active vif entries
 790          */
 791         for(i=0; i<maxvif; i++) {
 792                 if (!(vif_table[i].flags&VIFF_STATIC))
 793                         vif_delete(i);
 794         }
 795
 796         /*
 797          *      Wipe the cache
 798          */
 799         for (i=0;i<MFC_LINES;i++) {
 800                 struct mfc_cache *c, **cp;
 801
 802                 cp = &mfc_cache_array[i];
 803                 while ((c = *cp) != NULL) {
 804                         if (c->mfc_flags&MFC_STATIC) {
 805                                 cp = &c->next;
 806                                 continue;
 807                         }
 808                         write_lock_bh(&mrt_lock);
 809                         *cp = c->next;
 810                         write_unlock_bh(&mrt_lock);
 811
 812                         kmem_cache_free(mrt_cachep, c);
 813                 }
 814         }
 815
 816         if (atomic_read(&cache_resolve_queue_len) != 0) {
 817                 struct mfc_cache *c;
 818
 819                 spin_lock_bh(&mfc_unres_lock);
 820                 while (mfc_unres_queue != NULL) {
 821                         c = mfc_unres_queue;
 822                         mfc_unres_queue = c->next;
 823                         spin_unlock_bh(&mfc_unres_lock);
 824
 825                         ipmr_destroy_unres(c);
 826
 827                         spin_lock_bh(&mfc_unres_lock);
 828                 }
 829                 spin_unlock_bh(&mfc_unres_lock);
 830         }
 831 }
 832
 833 static void mrtsock_destruct(struct sock *sk)
 834 {
 835         rtnl_lock();
 836         if (sk == mroute_socket) {
 837                 ipv4_devconf.mc_forwarding--;
 838
 839                 write_lock_bh(&mrt_lock);
 840                 mroute_socket=NULL;
 841                 write_unlock_bh(&mrt_lock);
 842
 843                 mroute_clean_tables(sk);
 844         }
 845         rtnl_unlock();
 846 }
 847
 848 /*
 849  *      Socket options and virtual interface manipulation. The whole
 850  *      virtual interface system is a complete heap, but unfortunately
 851  *      that's how BSD mrouted happens to think. Maybe one day with a proper
 852  *      MOSPF/PIM router set up we can clean this up.
 853  */
 854
 855 int ip_mroute_setsockopt(struct sock *sk,int optname,char __user *optval,int optlen)
 856 {
 857         int ret;
 858         struct vifctl vif;
 859         struct mfcctl mfc;
 860
 861         if(optname!=MRT_INIT)
 862         {
 863                 if(sk!=mroute_socket && !capable(CAP_NET_ADMIN))
 864                         return -EACCES;
 865         }
 866
 867         switch(optname)
 868         {
 869                 case MRT_INIT:
 870                         if (sk->sk_type != SOCK_RAW ||
 871                             inet_sk(sk)->num != IPPROTO_IGMP)
 872                                 return -EOPNOTSUPP;
 873                         if(optlen!=sizeof(int))
 874                                 return -ENOPROTOOPT;
 875
 876                         rtnl_lock();
 877                         if (mroute_socket) {
 878                                 rtnl_unlock();
 879                                 return -EADDRINUSE;
 880                         }
 881
 882                         ret = ip_ra_control(sk, 1, mrtsock_destruct);
 883                         if (ret == 0) {
 884                                 write_lock_bh(&mrt_lock);
 885                                 mroute_socket=sk;
 886                                 write_unlock_bh(&mrt_lock);
 887
 888                                 ipv4_devconf.mc_forwarding++;
 889                         }
 890                         rtnl_unlock();
 891                         return ret;
 892                 case MRT_DONE:
 893                         if (sk!=mroute_socket)
 894                                 return -EACCES;
 895                         return ip_ra_control(sk, 0, NULL);
 896                 case MRT_ADD_VIF:
 897                 case MRT_DEL_VIF:
 898                         if(optlen!=sizeof(vif))
 899                                 return -EINVAL;
 900                         if (copy_from_user(&vif,optval,sizeof(vif)))
 901                                 return -EFAULT;
 902                         if(vif.vifc_vifi >= MAXVIFS)
 903                                 return -ENFILE;
 904                         rtnl_lock();
 905                         if (optname==MRT_ADD_VIF) {
 906                                 ret = vif_add(&vif, sk==mroute_socket);
 907                         } else {
 908                                 ret = vif_delete(vif.vifc_vifi);
 909                         }
 910                         rtnl_unlock();
 911                         return ret;
 912
 913                 /*
 914                  *      Manipulate the forwarding caches. These live
 915                  *      in a sort of kernel/user symbiosis.
 916                  */
 917                 case MRT_ADD_MFC:
 918                 case MRT_DEL_MFC:
 919                         if(optlen!=sizeof(mfc))
 920                                 return -EINVAL;
 921                         if (copy_from_user(&mfc,optval, sizeof(mfc)))
 922                                 return -EFAULT;
 923                         rtnl_lock();
 924                         if (optname==MRT_DEL_MFC)
 925                                 ret = ipmr_mfc_delete(&mfc);
 926                         else
 927                                 ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
 928                         rtnl_unlock();
 929                         return ret;
 930                 /*
 931                  *      Control PIM assert.
 932                  */
 933                 case MRT_ASSERT:
 934                 {
 935                         int v;
 936                         if(get_user(v,(int __user *)optval))
 937                                 return -EFAULT;
 938                         mroute_do_assert=(v)?1:0;
 939                         return 0;
 940                 }
 941 #ifdef CONFIG_IP_PIMSM
 942                 case MRT_PIM:
 943                 {
 944                         int v, ret;
 945                         if(get_user(v,(int __user *)optval))
 946                                 return -EFAULT;
 947                         v = (v)?1:0;
 948                         rtnl_lock();
 949                         ret = 0;
 950                         if (v != mroute_do_pim) {
 951                                 mroute_do_pim = v;
 952                                 mroute_do_assert = v;
 953 #ifdef CONFIG_IP_PIMSM_V2
 954                                 if (mroute_do_pim)
 955                                         ret = inet_add_protocol(&pim_protocol,
 956                                                                 IPPROTO_PIM);
 957                                 else
 958                                         ret = inet_del_protocol(&pim_protocol,
 959                                                                 IPPROTO_PIM);
 960                                 if (ret < 0)
 961                                         ret = -EAGAIN;
 962 #endif
 963                         }
 964                         rtnl_unlock();
 965                         return ret;
 966                 }
 967 #endif
 968                 /*
 969                  *      Spurious command, or MRT_VERSION which you cannot
 970                  *      set.
 971                  */
 972                 default:
 973                         return -ENOPROTOOPT;
 974         }
 975 }
 976
 977 /*
 978  *      Getsock opt support for the multicast routing system.
 979  */
 980
 981 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
 982 {
 983         int olr;
 984         int val;
 985
 986         if(optname!=MRT_VERSION &&
 987 #ifdef CONFIG_IP_PIMSM
 988            optname!=MRT_PIM &&
 989 #endif
 990            optname!=MRT_ASSERT)
 991                 return -ENOPROTOOPT;
 992
 993         if (get_user(olr, optlen))
 994                 return -EFAULT;
 995
 996         olr = min_t(unsigned int, olr, sizeof(int));
 997         if (olr < 0)
 998                 return -EINVAL;
 999
1000         if(put_user(olr,optlen))
1001                 return -EFAULT;
1002         if(optname==MRT_VERSION)
1003                 val=0x0305;
1004 #ifdef CONFIG_IP_PIMSM
1005         else if(optname==MRT_PIM)
1006                 val=mroute_do_pim;
1007 #endif
1008         else
1009                 val=mroute_do_assert;
1010         if(copy_to_user(optval,&val,olr))
1011                 return -EFAULT;
1012         return 0;
1013 }
1014
1015 /*
1016  *      The IP multicast ioctl support routines.
1017  */
1018
1019 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1020 {
1021         struct sioc_sg_req sr;
1022         struct sioc_vif_req vr;
1023         struct vif_device *vif;
1024         struct mfc_cache *c;
1025
1026         switch(cmd)
1027         {
1028                 case SIOCGETVIFCNT:
1029                         if (copy_from_user(&vr,arg,sizeof(vr)))
1030                                 return -EFAULT;
1031                         if(vr.vifi>=maxvif)
1032                                 return -EINVAL;
1033                         read_lock(&mrt_lock);
1034                         vif=&vif_table[vr.vifi];
1035                         if(VIF_EXISTS(vr.vifi)) {
1036                                 vr.icount=vif->pkt_in;
1037                                 vr.ocount=vif->pkt_out;
1038                                 vr.ibytes=vif->bytes_in;
1039                                 vr.obytes=vif->bytes_out;
1040                                 read_unlock(&mrt_lock);
1041
1042                                 if (copy_to_user(arg,&vr,sizeof(vr)))
1043                                         return -EFAULT;
1044                                 return 0;
1045                         }
1046                         read_unlock(&mrt_lock);
1047                         return -EADDRNOTAVAIL;
1048                 case SIOCGETSGCNT:
1049                         if (copy_from_user(&sr,arg,sizeof(sr)))
1050                                 return -EFAULT;
1051
1052                         read_lock(&mrt_lock);
1053                         c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1054                         if (c) {
1055                                 sr.pktcnt = c->mfc_un.res.pkt;
1056                                 sr.bytecnt = c->mfc_un.res.bytes;
1057                                 sr.wrong_if = c->mfc_un.res.wrong_if;
1058                                 read_unlock(&mrt_lock);
1059
1060                                 if (copy_to_user(arg,&sr,sizeof(sr)))
1061                                         return -EFAULT;
1062                                 return 0;
1063                         }
1064                         read_unlock(&mrt_lock);
1065                         return -EADDRNOTAVAIL;
1066                 default:
1067                         return -ENOIOCTLCMD;
1068         }
1069 }
1070
1071
1072 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1073 {
1074         struct vif_device *v;
1075         int ct;
1076         if (event != NETDEV_UNREGISTER)
1077                 return NOTIFY_DONE;
1078         v=&vif_table[0];
1079         for(ct=0;ct<maxvif;ct++,v++) {
1080                 if (v->dev==ptr)
1081                         vif_delete(ct);
1082         }
1083         return NOTIFY_DONE;
1084 }
1085
1086
1087 static struct notifier_block ip_mr_notifier={
1088         .notifier_call = ipmr_device_event,
1089 };
1090
1091 /*
1092  *      Encapsulate a packet by attaching a valid IPIP header to it.
1093  *      This avoids tunnel drivers and other mess and gives us the speed so
1094  *      important for multicast video.
1095  */
1096
1097 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1098 {
1099         struct iphdr *iph = (struct iphdr *)skb_push(skb,sizeof(struct iphdr));
1100
1101         iph->version    =       4;
1102         iph->tos        =       skb->nh.iph->tos;
1103         iph->ttl        =       skb->nh.iph->ttl;
1104         iph->frag_off   =       0;
1105         iph->daddr      =       daddr;
1106         iph->saddr      =       saddr;
1107         iph->protocol   =       IPPROTO_IPIP;
1108         iph->ihl        =       5;
1109         iph->tot_len    =       htons(skb->len);
1110         ip_select_ident(iph, skb->dst, NULL);
1111         ip_send_check(iph);
1112
1113         skb->h.ipiph = skb->nh.iph;
1114         skb->nh.iph = iph;
1115         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1116         nf_reset(skb);
1117 }
1118
1119 static inline int ipmr_forward_finish(struct sk_buff *skb)
1120 {
1121         struct ip_options * opt = &(IPCB(skb)->opt);
1122
1123         IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
1124
1125         if (unlikely(opt->optlen))
1126                 ip_forward_options(skb);
1127
1128         return dst_output(skb);
1129 }
1130
1131 /*
1132  *      Processing handlers for ipmr_forward
1133  */
1134
1135 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1136 {
1137         struct iphdr *iph = skb->nh.iph;
1138         struct vif_device *vif = &vif_table[vifi];
1139         struct net_device *dev;
1140         struct rtable *rt;
1141         int    encap = 0;
1142
1143         if (vif->dev == NULL)
1144                 goto out_free;
1145
1146 #ifdef CONFIG_IP_PIMSM
1147         if (vif->flags & VIFF_REGISTER) {
1148                 vif->pkt_out++;
1149                 vif->bytes_out+=skb->len;
1150                 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
1151                 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
1152                 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1153                 kfree_skb(skb);
1154                 return;
1155         }
1156 #endif
1157
1158         if (vif->flags&VIFF_TUNNEL) {
1159                 struct flowi fl = { .oif = vif->link,
1160                                     .nl_u = { .ip4_u =
1161                                               { .daddr = vif->remote,
1162                                                 .saddr = vif->local,
1163                                                 .tos = RT_TOS(iph->tos) } },
1164                                     .proto = IPPROTO_IPIP };
1165                 if (ip_route_output_key(&rt, &fl))
1166                         goto out_free;
1167                 encap = sizeof(struct iphdr);
1168         } else {
1169                 struct flowi fl = { .oif = vif->link,
1170                                     .nl_u = { .ip4_u =
1171                                               { .daddr = iph->daddr,
1172                                                 .tos = RT_TOS(iph->tos) } },
1173                                     .proto = IPPROTO_IPIP };
1174                 if (ip_route_output_key(&rt, &fl))
1175                         goto out_free;
1176         }
1177
1178         dev = rt->u.dst.dev;
1179
1180         if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1181                 /* Do not fragment multicasts. Alas, IPv4 does not
1182                    allow to send ICMP, so that packets will disappear
1183                    to blackhole.
1184                  */
1185
1186                 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
1187                 ip_rt_put(rt);
1188                 goto out_free;
1189         }
1190
1191         encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1192
1193         if (skb_cow(skb, encap)) {
1194                 ip_rt_put(rt);
1195                 goto out_free;
1196         }
1197
1198         vif->pkt_out++;
1199         vif->bytes_out+=skb->len;
1200
1201         dst_release(skb->dst);
1202         skb->dst = &rt->u.dst;
1203         iph = skb->nh.iph;
1204         ip_decrease_ttl(iph);
1205
1206         /* FIXME: forward and output firewalls used to be called here.
1207          * What do we do with netfilter? -- RR */
1208         if (vif->flags & VIFF_TUNNEL) {
1209                 ip_encap(skb, vif->local, vif->remote);
1210                 /* FIXME: extra output firewall step used to be here. --RR */
1211                 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
1212                 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
1213         }
1214
1215         IPCB(skb)->flags |= IPSKB_FORWARDED;
1216
1217         /*
1218          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1219          * not only before forwarding, but after forwarding on all output
1220          * interfaces. It is clear, if mrouter runs a multicasting
1221          * program, it should receive packets not depending to what interface
1222          * program is joined.
1223          * If we will not make it, the program will have to join on all
1224          * interfaces. On the other hand, multihoming host (or router, but
1225          * not mrouter) cannot join to more than one interface - it will
1226          * result in receiving multiple packets.
1227          */
1228         NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
1229                 ipmr_forward_finish);
1230         return;
1231
1232 out_free:
1233         kfree_skb(skb);
1234         return;
1235 }
1236
1237 static int ipmr_find_vif(struct net_device *dev)
1238 {
1239         int ct;
1240         for (ct=maxvif-1; ct>=0; ct--) {
1241                 if (vif_table[ct].dev == dev)
1242                         break;
1243         }
1244         return ct;
1245 }
1246
1247 /* "local" means that we should preserve one skb (for local delivery) */
1248
1249 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1250 {
1251         int psend = -1;
1252         int vif, ct;
1253
1254         vif = cache->mfc_parent;
1255         cache->mfc_un.res.pkt++;
1256         cache->mfc_un.res.bytes += skb->len;
1257
1258         /*
1259          * Wrong interface: drop packet and (maybe) send PIM assert.
1260          */
1261         if (vif_table[vif].dev != skb->dev) {
1262                 int true_vifi;
1263
1264                 if (((struct rtable*)skb->dst)->fl.iif == 0) {
1265                         /* It is our own packet, looped back.
1266                            Very complicated situation...
1267
1268                            The best workaround until routing daemons will be
1269                            fixed is not to redistribute packet, if it was
1270                            send through wrong interface. It means, that
1271                            multicast applications WILL NOT work for
1272                            (S,G), which have default multicast route pointing
1273                            to wrong oif. In any case, it is not a good
1274                            idea to use multicasting applications on router.
1275                          */
1276                         goto dont_forward;
1277                 }
1278
1279                 cache->mfc_un.res.wrong_if++;
1280                 true_vifi = ipmr_find_vif(skb->dev);
1281
1282                 if (true_vifi >= 0 && mroute_do_assert &&
1283                     /* pimsm uses asserts, when switching from RPT to SPT,
1284                        so that we cannot check that packet arrived on an oif.
1285                        It is bad, but otherwise we would need to move pretty
1286                        large chunk of pimd to kernel. Ough... --ANK
1287                      */
1288                     (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1289                     time_after(jiffies,
1290                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1291                         cache->mfc_un.res.last_assert = jiffies;
1292                         ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1293                 }
1294                 goto dont_forward;
1295         }
1296
1297         vif_table[vif].pkt_in++;
1298         vif_table[vif].bytes_in+=skb->len;
1299
1300         /*
1301          *      Forward the frame
1302          */
1303         for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1304                 if (skb->nh.iph->ttl > cache->mfc_un.res.ttls[ct]) {
1305                         if (psend != -1) {
1306                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1307                                 if (skb2)
1308                                         ipmr_queue_xmit(skb2, cache, psend);
1309                         }
1310                         psend=ct;
1311                 }
1312         }
1313         if (psend != -1) {
1314                 if (local) {
1315                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1316                         if (skb2)
1317                                 ipmr_queue_xmit(skb2, cache, psend);
1318                 } else {
1319                         ipmr_queue_xmit(skb, cache, psend);
1320                         return 0;
1321                 }
1322         }
1323
1324 dont_forward:
1325         if (!local)
1326                 kfree_skb(skb);
1327         return 0;
1328 }
1329
1330
1331 /*
1332  *      Multicast packets for forwarding arrive here
1333  */
1334
1335 int ip_mr_input(struct sk_buff *skb)
1336 {
1337         struct mfc_cache *cache;
1338         int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
1339
1340         /* Packet is looped back after forward, it should not be
1341            forwarded second time, but still can be delivered locally.
1342          */
1343         if (IPCB(skb)->flags&IPSKB_FORWARDED)
1344                 goto dont_forward;
1345
1346         if (!local) {
1347                     if (IPCB(skb)->opt.router_alert) {
1348                             if (ip_call_ra_chain(skb))
1349                                     return 0;
1350                     } else if (skb->nh.iph->protocol == IPPROTO_IGMP){
1351                             /* IGMPv1 (and broken IGMPv2 implementations sort of
1352                                Cisco IOS <= 11.2(8)) do not put router alert
1353                                option to IGMP packets destined to routable
1354                                groups. It is very bad, because it means
1355                                that we can forward NO IGMP messages.
1356                              */
1357                             read_lock(&mrt_lock);
1358                             if (mroute_socket) {
1359                                     nf_reset(skb);
1360                                     raw_rcv(mroute_socket, skb);
1361                                     read_unlock(&mrt_lock);
1362                                     return 0;
1363                             }
1364                             read_unlock(&mrt_lock);
1365                     }
1366         }
1367
1368         read_lock(&mrt_lock);
1369         cache = ipmr_cache_find(skb->nh.iph->saddr, skb->nh.iph->daddr);
1370
1371         /*
1372          *      No usable cache entry
1373          */
1374         if (cache==NULL) {
1375                 int vif;
1376
1377                 if (local) {
1378                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1379                         ip_local_deliver(skb);
1380                         if (skb2 == NULL) {
1381                                 read_unlock(&mrt_lock);
1382                                 return -ENOBUFS;
1383                         }
1384                         skb = skb2;
1385                 }
1386
1387                 vif = ipmr_find_vif(skb->dev);
1388                 if (vif >= 0) {
1389                         int err = ipmr_cache_unresolved(vif, skb);
1390                         read_unlock(&mrt_lock);
1391
1392                         return err;
1393                 }
1394                 read_unlock(&mrt_lock);
1395                 kfree_skb(skb);
1396                 return -ENODEV;
1397         }
1398
1399         ip_mr_forward(skb, cache, local);
1400
1401         read_unlock(&mrt_lock);
1402
1403         if (local)
1404                 return ip_local_deliver(skb);
1405
1406         return 0;
1407
1408 dont_forward:
1409         if (local)
1410                 return ip_local_deliver(skb);
1411         kfree_skb(skb);
1412         return 0;
1413 }
1414
1415 #ifdef CONFIG_IP_PIMSM_V1
1416 /*
1417  * Handle IGMP messages of PIMv1
1418  */
1419
1420 int pim_rcv_v1(struct sk_buff * skb)
1421 {
1422         struct igmphdr *pim;
1423         struct iphdr   *encap;
1424         struct net_device  *reg_dev = NULL;
1425
1426         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1427                 goto drop;
1428
1429         pim = (struct igmphdr*)skb->h.raw;
1430
1431         if (!mroute_do_pim ||
1432             skb->len < sizeof(*pim) + sizeof(*encap) ||
1433             pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1434                 goto drop;
1435
1436         encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
1437         /*
1438            Check that:
1439            a. packet is really destinted to a multicast group
1440            b. packet is not a NULL-REGISTER
1441            c. packet is not truncated
1442          */
1443         if (!MULTICAST(encap->daddr) ||
1444             encap->tot_len == 0 ||
1445             ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1446                 goto drop;
1447
1448         read_lock(&mrt_lock);
1449         if (reg_vif_num >= 0)
1450                 reg_dev = vif_table[reg_vif_num].dev;
1451         if (reg_dev)
1452                 dev_hold(reg_dev);
1453         read_unlock(&mrt_lock);
1454
1455         if (reg_dev == NULL)
1456                 goto drop;
1457
1458         skb->mac.raw = skb->nh.raw;
1459         skb_pull(skb, (u8*)encap - skb->data);
1460         skb->nh.iph = (struct iphdr *)skb->data;
1461         skb->dev = reg_dev;
1462         skb->protocol = htons(ETH_P_IP);
1463         skb->ip_summed = 0;
1464         skb->pkt_type = PACKET_HOST;
1465         dst_release(skb->dst);
1466         skb->dst = NULL;
1467         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1468         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1469         nf_reset(skb);
1470         netif_rx(skb);
1471         dev_put(reg_dev);
1472         return 0;
1473  drop:
1474         kfree_skb(skb);
1475         return 0;
1476 }
1477 #endif
1478
1479 #ifdef CONFIG_IP_PIMSM_V2
1480 static int pim_rcv(struct sk_buff * skb)
1481 {
1482         struct pimreghdr *pim;
1483         struct iphdr   *encap;
1484         struct net_device  *reg_dev = NULL;
1485
1486         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1487                 goto drop;
1488
1489         pim = (struct pimreghdr*)skb->h.raw;
1490         if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1491             (pim->flags&PIM_NULL_REGISTER) ||
1492             (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1493              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1494                 goto drop;
1495
1496         /* check if the inner packet is destined to mcast group */
1497         encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
1498         if (!MULTICAST(encap->daddr) ||
1499             encap->tot_len == 0 ||
1500             ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1501                 goto drop;
1502
1503         read_lock(&mrt_lock);
1504         if (reg_vif_num >= 0)
1505                 reg_dev = vif_table[reg_vif_num].dev;
1506         if (reg_dev)
1507                 dev_hold(reg_dev);
1508         read_unlock(&mrt_lock);
1509
1510         if (reg_dev == NULL)
1511                 goto drop;
1512
1513         skb->mac.raw = skb->nh.raw;
1514         skb_pull(skb, (u8*)encap - skb->data);
1515         skb->nh.iph = (struct iphdr *)skb->data;
1516         skb->dev = reg_dev;
1517         skb->protocol = htons(ETH_P_IP);
1518         skb->ip_summed = 0;
1519         skb->pkt_type = PACKET_HOST;
1520         dst_release(skb->dst);
1521         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1522         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1523         skb->dst = NULL;
1524         nf_reset(skb);
1525         netif_rx(skb);
1526         dev_put(reg_dev);
1527         return 0;
1528  drop:
1529         kfree_skb(skb);
1530         return 0;
1531 }
1532 #endif
1533
1534 static int
1535 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1536 {
1537         int ct;
1538         struct rtnexthop *nhp;
1539         struct net_device *dev = vif_table[c->mfc_parent].dev;
1540         u8 *b = skb->tail;
1541         struct rtattr *mp_head;
1542
1543         if (dev)
1544                 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1545
1546         mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1547
1548         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1549                 if (c->mfc_un.res.ttls[ct] < 255) {
1550                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1551                                 goto rtattr_failure;
1552                         nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1553                         nhp->rtnh_flags = 0;
1554                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1555                         nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1556                         nhp->rtnh_len = sizeof(*nhp);
1557                 }
1558         }
1559         mp_head->rta_type = RTA_MULTIPATH;
1560         mp_head->rta_len = skb->tail - (u8*)mp_head;
1561         rtm->rtm_type = RTN_MULTICAST;
1562         return 1;
1563
1564 rtattr_failure:
1565         skb_trim(skb, b - skb->data);
1566         return -EMSGSIZE;
1567 }
1568
1569 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1570 {
1571         int err;
1572         struct mfc_cache *cache;
1573         struct rtable *rt = (struct rtable*)skb->dst;
1574
1575         read_lock(&mrt_lock);
1576         cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1577
1578         if (cache==NULL) {
1579                 struct sk_buff *skb2;
1580                 struct net_device *dev;
1581                 int vif;
1582
1583                 if (nowait) {
1584                         read_unlock(&mrt_lock);
1585                         return -EAGAIN;
1586                 }
1587
1588                 dev = skb->dev;
1589                 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1590                         read_unlock(&mrt_lock);
1591                         return -ENODEV;
1592                 }
1593                 skb2 = skb_clone(skb, GFP_ATOMIC);
1594                 if (!skb2) {
1595                         read_unlock(&mrt_lock);
1596                         return -ENOMEM;
1597                 }
1598
1599                 skb2->nh.raw = skb_push(skb2, sizeof(struct iphdr));
1600                 skb2->nh.iph->ihl = sizeof(struct iphdr)>>2;
1601                 skb2->nh.iph->saddr = rt->rt_src;
1602                 skb2->nh.iph->daddr = rt->rt_dst;
1603                 skb2->nh.iph->version = 0;
1604                 err = ipmr_cache_unresolved(vif, skb2);
1605                 read_unlock(&mrt_lock);
1606                 return err;
1607         }
1608
1609         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1610                 cache->mfc_flags |= MFC_NOTIFY;
1611         err = ipmr_fill_mroute(skb, cache, rtm);
1612         read_unlock(&mrt_lock);
1613         return err;
1614 }
1615
1616 #ifdef CONFIG_PROC_FS
1617 /*
1618  *      The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1619  */
1620 struct ipmr_vif_iter {
1621         int ct;
1622 };
1623
1624 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1625                                            loff_t pos)
1626 {
1627         for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
1628                 if(!VIF_EXISTS(iter->ct))
1629                         continue;
1630                 if (pos-- == 0)
1631                         return &vif_table[iter->ct];
1632         }
1633         return NULL;
1634 }
1635
1636 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1637 {
1638         read_lock(&mrt_lock);
1639         return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
1640                 : SEQ_START_TOKEN;
1641 }
1642
1643 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1644 {
1645         struct ipmr_vif_iter *iter = seq->private;
1646
1647         ++*pos;
1648         if (v == SEQ_START_TOKEN)
1649                 return ipmr_vif_seq_idx(iter, 0);
1650
1651         while (++iter->ct < maxvif) {
1652                 if(!VIF_EXISTS(iter->ct))
1653                         continue;
1654                 return &vif_table[iter->ct];
1655         }
1656         return NULL;
1657 }
1658
1659 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1660 {
1661         read_unlock(&mrt_lock);
1662 }
1663
1664 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1665 {
1666         if (v == SEQ_START_TOKEN) {
1667                 seq_puts(seq,
1668                          "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags Local    Remote\n");
1669         } else {
1670                 const struct vif_device *vif = v;
1671                 const char *name =  vif->dev ? vif->dev->name : "none";
1672
1673                 seq_printf(seq,
1674                            "%2Zd %-10s %8ld %7ld  %8ld %7ld %05X %08X %08X\n",
1675                            vif - vif_table,
1676                            name, vif->bytes_in, vif->pkt_in,
1677                            vif->bytes_out, vif->pkt_out,
1678                            vif->flags, vif->local, vif->remote);
1679         }
1680         return 0;
1681 }
1682
1683 static struct seq_operations ipmr_vif_seq_ops = {
1684         .start = ipmr_vif_seq_start,
1685         .next  = ipmr_vif_seq_next,
1686         .stop  = ipmr_vif_seq_stop,
1687         .show  = ipmr_vif_seq_show,
1688 };
1689
1690 static int ipmr_vif_open(struct inode *inode, struct file *file)
1691 {
1692         struct seq_file *seq;
1693         int rc = -ENOMEM;
1694         struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1695
1696         if (!s)
1697                 goto out;
1698
1699         rc = seq_open(file, &ipmr_vif_seq_ops);
1700         if (rc)
1701                 goto out_kfree;
1702
1703         s->ct = 0;
1704         seq = file->private_data;
1705         seq->private = s;
1706 out:
1707         return rc;
1708 out_kfree:
1709         kfree(s);
1710         goto out;
1711
1712 }
1713
1714 static const struct file_operations ipmr_vif_fops = {
1715         .owner   = THIS_MODULE,
1716         .open    = ipmr_vif_open,
1717         .read    = seq_read,
1718         .llseek  = seq_lseek,
1719         .release = seq_release_private,
1720 };
1721
1722 struct ipmr_mfc_iter {
1723         struct mfc_cache **cache;
1724         int ct;
1725 };
1726
1727
1728 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1729 {
1730         struct mfc_cache *mfc;
1731
1732         it->cache = mfc_cache_array;
1733         read_lock(&mrt_lock);
1734         for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1735                 for(mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
1736                         if (pos-- == 0)
1737                                 return mfc;
1738         read_unlock(&mrt_lock);
1739
1740         it->cache = &mfc_unres_queue;
1741         spin_lock_bh(&mfc_unres_lock);
1742         for(mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1743                 if (pos-- == 0)
1744                         return mfc;
1745         spin_unlock_bh(&mfc_unres_lock);
1746
1747         it->cache = NULL;
1748         return NULL;
1749 }
1750
1751
1752 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1753 {
1754         struct ipmr_mfc_iter *it = seq->private;
1755         it->cache = NULL;
1756         it->ct = 0;
1757         return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
1758                 : SEQ_START_TOKEN;
1759 }
1760
1761 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1762 {
1763         struct mfc_cache *mfc = v;
1764         struct ipmr_mfc_iter *it = seq->private;
1765
1766         ++*pos;
1767
1768         if (v == SEQ_START_TOKEN)
1769                 return ipmr_mfc_seq_idx(seq->private, 0);
1770
1771         if (mfc->next)
1772                 return mfc->next;
1773
1774         if (it->cache == &mfc_unres_queue)
1775                 goto end_of_list;
1776
1777         BUG_ON(it->cache != mfc_cache_array);
1778
1779         while (++it->ct < MFC_LINES) {
1780                 mfc = mfc_cache_array[it->ct];
1781                 if (mfc)
1782                         return mfc;
1783         }
1784
1785         /* exhausted cache_array, show unresolved */
1786         read_unlock(&mrt_lock);
1787         it->cache = &mfc_unres_queue;
1788         it->ct = 0;
1789
1790         spin_lock_bh(&mfc_unres_lock);
1791         mfc = mfc_unres_queue;
1792         if (mfc)
1793                 return mfc;
1794
1795  end_of_list:
1796         spin_unlock_bh(&mfc_unres_lock);
1797         it->cache = NULL;
1798
1799         return NULL;
1800 }
1801
1802 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1803 {
1804         struct ipmr_mfc_iter *it = seq->private;
1805
1806         if (it->cache == &mfc_unres_queue)
1807                 spin_unlock_bh(&mfc_unres_lock);
1808         else if (it->cache == mfc_cache_array)
1809                 read_unlock(&mrt_lock);
1810 }
1811
1812 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1813 {
1814         int n;
1815
1816         if (v == SEQ_START_TOKEN) {
1817                 seq_puts(seq,
1818                  "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
1819         } else {
1820                 const struct mfc_cache *mfc = v;
1821                 const struct ipmr_mfc_iter *it = seq->private;
1822
1823                 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1824                            (unsigned long) mfc->mfc_mcastgrp,
1825                            (unsigned long) mfc->mfc_origin,
1826                            mfc->mfc_parent,
1827                            mfc->mfc_un.res.pkt,
1828                            mfc->mfc_un.res.bytes,
1829                            mfc->mfc_un.res.wrong_if);
1830
1831                 if (it->cache != &mfc_unres_queue) {
1832                         for(n = mfc->mfc_un.res.minvif;
1833                             n < mfc->mfc_un.res.maxvif; n++ ) {
1834                                 if(VIF_EXISTS(n)
1835                                    && mfc->mfc_un.res.ttls[n] < 255)
1836                                 seq_printf(seq,
1837                                            " %2d:%-3d",
1838                                            n, mfc->mfc_un.res.ttls[n]);
1839                         }
1840                 }
1841                 seq_putc(seq, '\n');
1842         }
1843         return 0;
1844 }
1845
1846 static struct seq_operations ipmr_mfc_seq_ops = {
1847         .start = ipmr_mfc_seq_start,
1848         .next  = ipmr_mfc_seq_next,
1849         .stop  = ipmr_mfc_seq_stop,
1850         .show  = ipmr_mfc_seq_show,
1851 };
1852
1853 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1854 {
1855         struct seq_file *seq;
1856         int rc = -ENOMEM;
1857         struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1858
1859         if (!s)
1860                 goto out;
1861
1862         rc = seq_open(file, &ipmr_mfc_seq_ops);
1863         if (rc)
1864                 goto out_kfree;
1865
1866         seq = file->private_data;
1867         seq->private = s;
1868 out:
1869         return rc;
1870 out_kfree:
1871         kfree(s);
1872         goto out;
1873
1874 }
1875
1876 static const struct file_operations ipmr_mfc_fops = {
1877         .owner   = THIS_MODULE,
1878         .open    = ipmr_mfc_open,
1879         .read    = seq_read,
1880         .llseek  = seq_lseek,
1881         .release = seq_release_private,
1882 };
1883 #endif
1884
1885 #ifdef CONFIG_IP_PIMSM_V2
1886 static struct net_protocol pim_protocol = {
1887         .handler        =       pim_rcv,
1888 };
1889 #endif
1890
1891
1892 /*
1893  *      Setup for IP multicast routing
1894  */
1895
1896 void __init ip_mr_init(void)
1897 {
1898         mrt_cachep = kmem_cache_create("ip_mrt_cache",
1899                                        sizeof(struct mfc_cache),
1900                                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1901                                        NULL, NULL);
1902         init_timer(&ipmr_expire_timer);
1903         ipmr_expire_timer.function=ipmr_expire_process;
1904         register_netdevice_notifier(&ip_mr_notifier);
1905 #ifdef CONFIG_PROC_FS
1906         proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
1907         proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);
1908 #endif
1909 }