SAFE public projects git trees. - safe/jmp/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                 if (sk != mroute_socket && !capable(CAP_NET_ADMIN))
 863                         return -EACCES;
 864         }
 865
 866         switch (optname) {
 867         case MRT_INIT:
 868                 if (sk->sk_type != SOCK_RAW ||
 869                     inet_sk(sk)->num != IPPROTO_IGMP)
 870                         return -EOPNOTSUPP;
 871                 if (optlen!=sizeof(int))
 872                         return -ENOPROTOOPT;
 873
 874                 rtnl_lock();
 875                 if (mroute_socket) {
 876                         rtnl_unlock();
 877                         return -EADDRINUSE;
 878                 }
 879
 880                 ret = ip_ra_control(sk, 1, mrtsock_destruct);
 881                 if (ret == 0) {
 882                         write_lock_bh(&mrt_lock);
 883                         mroute_socket=sk;
 884                         write_unlock_bh(&mrt_lock);
 885
 886                         ipv4_devconf.mc_forwarding++;
 887                 }
 888                 rtnl_unlock();
 889                 return ret;
 890         case MRT_DONE:
 891                 if (sk!=mroute_socket)
 892                         return -EACCES;
 893                 return ip_ra_control(sk, 0, NULL);
 894         case MRT_ADD_VIF:
 895         case MRT_DEL_VIF:
 896                 if (optlen!=sizeof(vif))
 897                         return -EINVAL;
 898                 if (copy_from_user(&vif,optval,sizeof(vif)))
 899                         return -EFAULT;
 900                 if (vif.vifc_vifi >= MAXVIFS)
 901                         return -ENFILE;
 902                 rtnl_lock();
 903                 if (optname==MRT_ADD_VIF) {
 904                         ret = vif_add(&vif, sk==mroute_socket);
 905                 } else {
 906                         ret = vif_delete(vif.vifc_vifi);
 907                 }
 908                 rtnl_unlock();
 909                 return ret;
 910
 911                 /*
 912                  *      Manipulate the forwarding caches. These live
 913                  *      in a sort of kernel/user symbiosis.
 914                  */
 915         case MRT_ADD_MFC:
 916         case MRT_DEL_MFC:
 917                 if (optlen!=sizeof(mfc))
 918                         return -EINVAL;
 919                 if (copy_from_user(&mfc,optval, sizeof(mfc)))
 920                         return -EFAULT;
 921                 rtnl_lock();
 922                 if (optname==MRT_DEL_MFC)
 923                         ret = ipmr_mfc_delete(&mfc);
 924                 else
 925                         ret = ipmr_mfc_add(&mfc, sk==mroute_socket);
 926                 rtnl_unlock();
 927                 return ret;
 928                 /*
 929                  *      Control PIM assert.
 930                  */
 931         case MRT_ASSERT:
 932         {
 933                 int v;
 934                 if (get_user(v,(int __user *)optval))
 935                         return -EFAULT;
 936                 mroute_do_assert=(v)?1:0;
 937                 return 0;
 938         }
 939 #ifdef CONFIG_IP_PIMSM
 940         case MRT_PIM:
 941         {
 942                 int v, ret;
 943                 if (get_user(v,(int __user *)optval))
 944                         return -EFAULT;
 945                 v = (v)?1:0;
 946                 rtnl_lock();
 947                 ret = 0;
 948                 if (v != mroute_do_pim) {
 949                         mroute_do_pim = v;
 950                         mroute_do_assert = v;
 951 #ifdef CONFIG_IP_PIMSM_V2
 952                         if (mroute_do_pim)
 953                                 ret = inet_add_protocol(&pim_protocol,
 954                                                         IPPROTO_PIM);
 955                         else
 956                                 ret = inet_del_protocol(&pim_protocol,
 957                                                         IPPROTO_PIM);
 958                         if (ret < 0)
 959                                 ret = -EAGAIN;
 960 #endif
 961                 }
 962                 rtnl_unlock();
 963                 return ret;
 964         }
 965 #endif
 966         /*
 967          *      Spurious command, or MRT_VERSION which you cannot
 968          *      set.
 969          */
 970         default:
 971                 return -ENOPROTOOPT;
 972         }
 973 }
 974
 975 /*
 976  *      Getsock opt support for the multicast routing system.
 977  */
 978
 979 int ip_mroute_getsockopt(struct sock *sk,int optname,char __user *optval,int __user *optlen)
 980 {
 981         int olr;
 982         int val;
 983
 984         if (optname!=MRT_VERSION &&
 985 #ifdef CONFIG_IP_PIMSM
 986            optname!=MRT_PIM &&
 987 #endif
 988            optname!=MRT_ASSERT)
 989                 return -ENOPROTOOPT;
 990
 991         if (get_user(olr, optlen))
 992                 return -EFAULT;
 993
 994         olr = min_t(unsigned int, olr, sizeof(int));
 995         if (olr < 0)
 996                 return -EINVAL;
 997
 998         if (put_user(olr,optlen))
 999                 return -EFAULT;
1000         if (optname==MRT_VERSION)
1001                 val=0x0305;
1002 #ifdef CONFIG_IP_PIMSM
1003         else if (optname==MRT_PIM)
1004                 val=mroute_do_pim;
1005 #endif
1006         else
1007                 val=mroute_do_assert;
1008         if (copy_to_user(optval,&val,olr))
1009                 return -EFAULT;
1010         return 0;
1011 }
1012
1013 /*
1014  *      The IP multicast ioctl support routines.
1015  */
1016
1017 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1018 {
1019         struct sioc_sg_req sr;
1020         struct sioc_vif_req vr;
1021         struct vif_device *vif;
1022         struct mfc_cache *c;
1023
1024         switch (cmd) {
1025         case SIOCGETVIFCNT:
1026                 if (copy_from_user(&vr,arg,sizeof(vr)))
1027                         return -EFAULT;
1028                 if (vr.vifi>=maxvif)
1029                         return -EINVAL;
1030                 read_lock(&mrt_lock);
1031                 vif=&vif_table[vr.vifi];
1032                 if (VIF_EXISTS(vr.vifi))        {
1033                         vr.icount=vif->pkt_in;
1034                         vr.ocount=vif->pkt_out;
1035                         vr.ibytes=vif->bytes_in;
1036                         vr.obytes=vif->bytes_out;
1037                         read_unlock(&mrt_lock);
1038
1039                         if (copy_to_user(arg,&vr,sizeof(vr)))
1040                                 return -EFAULT;
1041                         return 0;
1042                 }
1043                 read_unlock(&mrt_lock);
1044                 return -EADDRNOTAVAIL;
1045         case SIOCGETSGCNT:
1046                 if (copy_from_user(&sr,arg,sizeof(sr)))
1047                         return -EFAULT;
1048
1049                 read_lock(&mrt_lock);
1050                 c = ipmr_cache_find(sr.src.s_addr, sr.grp.s_addr);
1051                 if (c) {
1052                         sr.pktcnt = c->mfc_un.res.pkt;
1053                         sr.bytecnt = c->mfc_un.res.bytes;
1054                         sr.wrong_if = c->mfc_un.res.wrong_if;
1055                         read_unlock(&mrt_lock);
1056
1057                         if (copy_to_user(arg,&sr,sizeof(sr)))
1058                                 return -EFAULT;
1059                         return 0;
1060                 }
1061                 read_unlock(&mrt_lock);
1062                 return -EADDRNOTAVAIL;
1063         default:
1064                 return -ENOIOCTLCMD;
1065         }
1066 }
1067
1068
1069 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1070 {
1071         struct vif_device *v;
1072         int ct;
1073         if (event != NETDEV_UNREGISTER)
1074                 return NOTIFY_DONE;
1075         v=&vif_table[0];
1076         for (ct=0;ct<maxvif;ct++,v++) {
1077                 if (v->dev==ptr)
1078                         vif_delete(ct);
1079         }
1080         return NOTIFY_DONE;
1081 }
1082
1083
1084 static struct notifier_block ip_mr_notifier={
1085         .notifier_call = ipmr_device_event,
1086 };
1087
1088 /*
1089  *      Encapsulate a packet by attaching a valid IPIP header to it.
1090  *      This avoids tunnel drivers and other mess and gives us the speed so
1091  *      important for multicast video.
1092  */
1093
1094 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1095 {
1096         struct iphdr *iph = (struct iphdr *)skb_push(skb,sizeof(struct iphdr));
1097
1098         iph->version    =       4;
1099         iph->tos        =       skb->nh.iph->tos;
1100         iph->ttl        =       skb->nh.iph->ttl;
1101         iph->frag_off   =       0;
1102         iph->daddr      =       daddr;
1103         iph->saddr      =       saddr;
1104         iph->protocol   =       IPPROTO_IPIP;
1105         iph->ihl        =       5;
1106         iph->tot_len    =       htons(skb->len);
1107         ip_select_ident(iph, skb->dst, NULL);
1108         ip_send_check(iph);
1109
1110         skb->h.ipiph = skb->nh.iph;
1111         skb->nh.iph = iph;
1112         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1113         nf_reset(skb);
1114 }
1115
1116 static inline int ipmr_forward_finish(struct sk_buff *skb)
1117 {
1118         struct ip_options * opt = &(IPCB(skb)->opt);
1119
1120         IP_INC_STATS_BH(IPSTATS_MIB_OUTFORWDATAGRAMS);
1121
1122         if (unlikely(opt->optlen))
1123                 ip_forward_options(skb);
1124
1125         return dst_output(skb);
1126 }
1127
1128 /*
1129  *      Processing handlers for ipmr_forward
1130  */
1131
1132 static void ipmr_queue_xmit(struct sk_buff *skb, struct mfc_cache *c, int vifi)
1133 {
1134         struct iphdr *iph = skb->nh.iph;
1135         struct vif_device *vif = &vif_table[vifi];
1136         struct net_device *dev;
1137         struct rtable *rt;
1138         int    encap = 0;
1139
1140         if (vif->dev == NULL)
1141                 goto out_free;
1142
1143 #ifdef CONFIG_IP_PIMSM
1144         if (vif->flags & VIFF_REGISTER) {
1145                 vif->pkt_out++;
1146                 vif->bytes_out+=skb->len;
1147                 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_bytes += skb->len;
1148                 ((struct net_device_stats*)netdev_priv(vif->dev))->tx_packets++;
1149                 ipmr_cache_report(skb, vifi, IGMPMSG_WHOLEPKT);
1150                 kfree_skb(skb);
1151                 return;
1152         }
1153 #endif
1154
1155         if (vif->flags&VIFF_TUNNEL) {
1156                 struct flowi fl = { .oif = vif->link,
1157                                     .nl_u = { .ip4_u =
1158                                               { .daddr = vif->remote,
1159                                                 .saddr = vif->local,
1160                                                 .tos = RT_TOS(iph->tos) } },
1161                                     .proto = IPPROTO_IPIP };
1162                 if (ip_route_output_key(&rt, &fl))
1163                         goto out_free;
1164                 encap = sizeof(struct iphdr);
1165         } else {
1166                 struct flowi fl = { .oif = vif->link,
1167                                     .nl_u = { .ip4_u =
1168                                               { .daddr = iph->daddr,
1169                                                 .tos = RT_TOS(iph->tos) } },
1170                                     .proto = IPPROTO_IPIP };
1171                 if (ip_route_output_key(&rt, &fl))
1172                         goto out_free;
1173         }
1174
1175         dev = rt->u.dst.dev;
1176
1177         if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1178                 /* Do not fragment multicasts. Alas, IPv4 does not
1179                    allow to send ICMP, so that packets will disappear
1180                    to blackhole.
1181                  */
1182
1183                 IP_INC_STATS_BH(IPSTATS_MIB_FRAGFAILS);
1184                 ip_rt_put(rt);
1185                 goto out_free;
1186         }
1187
1188         encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1189
1190         if (skb_cow(skb, encap)) {
1191                 ip_rt_put(rt);
1192                 goto out_free;
1193         }
1194
1195         vif->pkt_out++;
1196         vif->bytes_out+=skb->len;
1197
1198         dst_release(skb->dst);
1199         skb->dst = &rt->u.dst;
1200         iph = skb->nh.iph;
1201         ip_decrease_ttl(iph);
1202
1203         /* FIXME: forward and output firewalls used to be called here.
1204          * What do we do with netfilter? -- RR */
1205         if (vif->flags & VIFF_TUNNEL) {
1206                 ip_encap(skb, vif->local, vif->remote);
1207                 /* FIXME: extra output firewall step used to be here. --RR */
1208                 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_packets++;
1209                 ((struct ip_tunnel *)netdev_priv(vif->dev))->stat.tx_bytes+=skb->len;
1210         }
1211
1212         IPCB(skb)->flags |= IPSKB_FORWARDED;
1213
1214         /*
1215          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1216          * not only before forwarding, but after forwarding on all output
1217          * interfaces. It is clear, if mrouter runs a multicasting
1218          * program, it should receive packets not depending to what interface
1219          * program is joined.
1220          * If we will not make it, the program will have to join on all
1221          * interfaces. On the other hand, multihoming host (or router, but
1222          * not mrouter) cannot join to more than one interface - it will
1223          * result in receiving multiple packets.
1224          */
1225         NF_HOOK(PF_INET, NF_IP_FORWARD, skb, skb->dev, dev,
1226                 ipmr_forward_finish);
1227         return;
1228
1229 out_free:
1230         kfree_skb(skb);
1231         return;
1232 }
1233
1234 static int ipmr_find_vif(struct net_device *dev)
1235 {
1236         int ct;
1237         for (ct=maxvif-1; ct>=0; ct--) {
1238                 if (vif_table[ct].dev == dev)
1239                         break;
1240         }
1241         return ct;
1242 }
1243
1244 /* "local" means that we should preserve one skb (for local delivery) */
1245
1246 static int ip_mr_forward(struct sk_buff *skb, struct mfc_cache *cache, int local)
1247 {
1248         int psend = -1;
1249         int vif, ct;
1250
1251         vif = cache->mfc_parent;
1252         cache->mfc_un.res.pkt++;
1253         cache->mfc_un.res.bytes += skb->len;
1254
1255         /*
1256          * Wrong interface: drop packet and (maybe) send PIM assert.
1257          */
1258         if (vif_table[vif].dev != skb->dev) {
1259                 int true_vifi;
1260
1261                 if (((struct rtable*)skb->dst)->fl.iif == 0) {
1262                         /* It is our own packet, looped back.
1263                            Very complicated situation...
1264
1265                            The best workaround until routing daemons will be
1266                            fixed is not to redistribute packet, if it was
1267                            send through wrong interface. It means, that
1268                            multicast applications WILL NOT work for
1269                            (S,G), which have default multicast route pointing
1270                            to wrong oif. In any case, it is not a good
1271                            idea to use multicasting applications on router.
1272                          */
1273                         goto dont_forward;
1274                 }
1275
1276                 cache->mfc_un.res.wrong_if++;
1277                 true_vifi = ipmr_find_vif(skb->dev);
1278
1279                 if (true_vifi >= 0 && mroute_do_assert &&
1280                     /* pimsm uses asserts, when switching from RPT to SPT,
1281                        so that we cannot check that packet arrived on an oif.
1282                        It is bad, but otherwise we would need to move pretty
1283                        large chunk of pimd to kernel. Ough... --ANK
1284                      */
1285                     (mroute_do_pim || cache->mfc_un.res.ttls[true_vifi] < 255) &&
1286                     time_after(jiffies,
1287                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1288                         cache->mfc_un.res.last_assert = jiffies;
1289                         ipmr_cache_report(skb, true_vifi, IGMPMSG_WRONGVIF);
1290                 }
1291                 goto dont_forward;
1292         }
1293
1294         vif_table[vif].pkt_in++;
1295         vif_table[vif].bytes_in+=skb->len;
1296
1297         /*
1298          *      Forward the frame
1299          */
1300         for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1301                 if (skb->nh.iph->ttl > cache->mfc_un.res.ttls[ct]) {
1302                         if (psend != -1) {
1303                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1304                                 if (skb2)
1305                                         ipmr_queue_xmit(skb2, cache, psend);
1306                         }
1307                         psend=ct;
1308                 }
1309         }
1310         if (psend != -1) {
1311                 if (local) {
1312                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1313                         if (skb2)
1314                                 ipmr_queue_xmit(skb2, cache, psend);
1315                 } else {
1316                         ipmr_queue_xmit(skb, cache, psend);
1317                         return 0;
1318                 }
1319         }
1320
1321 dont_forward:
1322         if (!local)
1323                 kfree_skb(skb);
1324         return 0;
1325 }
1326
1327
1328 /*
1329  *      Multicast packets for forwarding arrive here
1330  */
1331
1332 int ip_mr_input(struct sk_buff *skb)
1333 {
1334         struct mfc_cache *cache;
1335         int local = ((struct rtable*)skb->dst)->rt_flags&RTCF_LOCAL;
1336
1337         /* Packet is looped back after forward, it should not be
1338            forwarded second time, but still can be delivered locally.
1339          */
1340         if (IPCB(skb)->flags&IPSKB_FORWARDED)
1341                 goto dont_forward;
1342
1343         if (!local) {
1344                     if (IPCB(skb)->opt.router_alert) {
1345                             if (ip_call_ra_chain(skb))
1346                                     return 0;
1347                     } else if (skb->nh.iph->protocol == IPPROTO_IGMP){
1348                             /* IGMPv1 (and broken IGMPv2 implementations sort of
1349                                Cisco IOS <= 11.2(8)) do not put router alert
1350                                option to IGMP packets destined to routable
1351                                groups. It is very bad, because it means
1352                                that we can forward NO IGMP messages.
1353                              */
1354                             read_lock(&mrt_lock);
1355                             if (mroute_socket) {
1356                                     nf_reset(skb);
1357                                     raw_rcv(mroute_socket, skb);
1358                                     read_unlock(&mrt_lock);
1359                                     return 0;
1360                             }
1361                             read_unlock(&mrt_lock);
1362                     }
1363         }
1364
1365         read_lock(&mrt_lock);
1366         cache = ipmr_cache_find(skb->nh.iph->saddr, skb->nh.iph->daddr);
1367
1368         /*
1369          *      No usable cache entry
1370          */
1371         if (cache==NULL) {
1372                 int vif;
1373
1374                 if (local) {
1375                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1376                         ip_local_deliver(skb);
1377                         if (skb2 == NULL) {
1378                                 read_unlock(&mrt_lock);
1379                                 return -ENOBUFS;
1380                         }
1381                         skb = skb2;
1382                 }
1383
1384                 vif = ipmr_find_vif(skb->dev);
1385                 if (vif >= 0) {
1386                         int err = ipmr_cache_unresolved(vif, skb);
1387                         read_unlock(&mrt_lock);
1388
1389                         return err;
1390                 }
1391                 read_unlock(&mrt_lock);
1392                 kfree_skb(skb);
1393                 return -ENODEV;
1394         }
1395
1396         ip_mr_forward(skb, cache, local);
1397
1398         read_unlock(&mrt_lock);
1399
1400         if (local)
1401                 return ip_local_deliver(skb);
1402
1403         return 0;
1404
1405 dont_forward:
1406         if (local)
1407                 return ip_local_deliver(skb);
1408         kfree_skb(skb);
1409         return 0;
1410 }
1411
1412 #ifdef CONFIG_IP_PIMSM_V1
1413 /*
1414  * Handle IGMP messages of PIMv1
1415  */
1416
1417 int pim_rcv_v1(struct sk_buff * skb)
1418 {
1419         struct igmphdr *pim;
1420         struct iphdr   *encap;
1421         struct net_device  *reg_dev = NULL;
1422
1423         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1424                 goto drop;
1425
1426         pim = (struct igmphdr*)skb->h.raw;
1427
1428         if (!mroute_do_pim ||
1429             skb->len < sizeof(*pim) + sizeof(*encap) ||
1430             pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1431                 goto drop;
1432
1433         encap = (struct iphdr*)(skb->h.raw + sizeof(struct igmphdr));
1434         /*
1435            Check that:
1436            a. packet is really destinted to a multicast group
1437            b. packet is not a NULL-REGISTER
1438            c. packet is not truncated
1439          */
1440         if (!MULTICAST(encap->daddr) ||
1441             encap->tot_len == 0 ||
1442             ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1443                 goto drop;
1444
1445         read_lock(&mrt_lock);
1446         if (reg_vif_num >= 0)
1447                 reg_dev = vif_table[reg_vif_num].dev;
1448         if (reg_dev)
1449                 dev_hold(reg_dev);
1450         read_unlock(&mrt_lock);
1451
1452         if (reg_dev == NULL)
1453                 goto drop;
1454
1455         skb->mac.raw = skb->nh.raw;
1456         skb_pull(skb, (u8*)encap - skb->data);
1457         skb->nh.iph = (struct iphdr *)skb->data;
1458         skb->dev = reg_dev;
1459         skb->protocol = htons(ETH_P_IP);
1460         skb->ip_summed = 0;
1461         skb->pkt_type = PACKET_HOST;
1462         dst_release(skb->dst);
1463         skb->dst = NULL;
1464         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1465         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1466         nf_reset(skb);
1467         netif_rx(skb);
1468         dev_put(reg_dev);
1469         return 0;
1470  drop:
1471         kfree_skb(skb);
1472         return 0;
1473 }
1474 #endif
1475
1476 #ifdef CONFIG_IP_PIMSM_V2
1477 static int pim_rcv(struct sk_buff * skb)
1478 {
1479         struct pimreghdr *pim;
1480         struct iphdr   *encap;
1481         struct net_device  *reg_dev = NULL;
1482
1483         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
1484                 goto drop;
1485
1486         pim = (struct pimreghdr*)skb->h.raw;
1487         if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1488             (pim->flags&PIM_NULL_REGISTER) ||
1489             (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1490              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1491                 goto drop;
1492
1493         /* check if the inner packet is destined to mcast group */
1494         encap = (struct iphdr*)(skb->h.raw + sizeof(struct pimreghdr));
1495         if (!MULTICAST(encap->daddr) ||
1496             encap->tot_len == 0 ||
1497             ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
1498                 goto drop;
1499
1500         read_lock(&mrt_lock);
1501         if (reg_vif_num >= 0)
1502                 reg_dev = vif_table[reg_vif_num].dev;
1503         if (reg_dev)
1504                 dev_hold(reg_dev);
1505         read_unlock(&mrt_lock);
1506
1507         if (reg_dev == NULL)
1508                 goto drop;
1509
1510         skb->mac.raw = skb->nh.raw;
1511         skb_pull(skb, (u8*)encap - skb->data);
1512         skb->nh.iph = (struct iphdr *)skb->data;
1513         skb->dev = reg_dev;
1514         skb->protocol = htons(ETH_P_IP);
1515         skb->ip_summed = 0;
1516         skb->pkt_type = PACKET_HOST;
1517         dst_release(skb->dst);
1518         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_bytes += skb->len;
1519         ((struct net_device_stats*)netdev_priv(reg_dev))->rx_packets++;
1520         skb->dst = NULL;
1521         nf_reset(skb);
1522         netif_rx(skb);
1523         dev_put(reg_dev);
1524         return 0;
1525  drop:
1526         kfree_skb(skb);
1527         return 0;
1528 }
1529 #endif
1530
1531 static int
1532 ipmr_fill_mroute(struct sk_buff *skb, struct mfc_cache *c, struct rtmsg *rtm)
1533 {
1534         int ct;
1535         struct rtnexthop *nhp;
1536         struct net_device *dev = vif_table[c->mfc_parent].dev;
1537         u8 *b = skb->tail;
1538         struct rtattr *mp_head;
1539
1540         if (dev)
1541                 RTA_PUT(skb, RTA_IIF, 4, &dev->ifindex);
1542
1543         mp_head = (struct rtattr*)skb_put(skb, RTA_LENGTH(0));
1544
1545         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1546                 if (c->mfc_un.res.ttls[ct] < 255) {
1547                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1548                                 goto rtattr_failure;
1549                         nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1550                         nhp->rtnh_flags = 0;
1551                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1552                         nhp->rtnh_ifindex = vif_table[ct].dev->ifindex;
1553                         nhp->rtnh_len = sizeof(*nhp);
1554                 }
1555         }
1556         mp_head->rta_type = RTA_MULTIPATH;
1557         mp_head->rta_len = skb->tail - (u8*)mp_head;
1558         rtm->rtm_type = RTN_MULTICAST;
1559         return 1;
1560
1561 rtattr_failure:
1562         skb_trim(skb, b - skb->data);
1563         return -EMSGSIZE;
1564 }
1565
1566 int ipmr_get_route(struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1567 {
1568         int err;
1569         struct mfc_cache *cache;
1570         struct rtable *rt = (struct rtable*)skb->dst;
1571
1572         read_lock(&mrt_lock);
1573         cache = ipmr_cache_find(rt->rt_src, rt->rt_dst);
1574
1575         if (cache==NULL) {
1576                 struct sk_buff *skb2;
1577                 struct net_device *dev;
1578                 int vif;
1579
1580                 if (nowait) {
1581                         read_unlock(&mrt_lock);
1582                         return -EAGAIN;
1583                 }
1584
1585                 dev = skb->dev;
1586                 if (dev == NULL || (vif = ipmr_find_vif(dev)) < 0) {
1587                         read_unlock(&mrt_lock);
1588                         return -ENODEV;
1589                 }
1590                 skb2 = skb_clone(skb, GFP_ATOMIC);
1591                 if (!skb2) {
1592                         read_unlock(&mrt_lock);
1593                         return -ENOMEM;
1594                 }
1595
1596                 skb2->nh.raw = skb_push(skb2, sizeof(struct iphdr));
1597                 skb2->nh.iph->ihl = sizeof(struct iphdr)>>2;
1598                 skb2->nh.iph->saddr = rt->rt_src;
1599                 skb2->nh.iph->daddr = rt->rt_dst;
1600                 skb2->nh.iph->version = 0;
1601                 err = ipmr_cache_unresolved(vif, skb2);
1602                 read_unlock(&mrt_lock);
1603                 return err;
1604         }
1605
1606         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1607                 cache->mfc_flags |= MFC_NOTIFY;
1608         err = ipmr_fill_mroute(skb, cache, rtm);
1609         read_unlock(&mrt_lock);
1610         return err;
1611 }
1612
1613 #ifdef CONFIG_PROC_FS
1614 /*
1615  *      The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
1616  */
1617 struct ipmr_vif_iter {
1618         int ct;
1619 };
1620
1621 static struct vif_device *ipmr_vif_seq_idx(struct ipmr_vif_iter *iter,
1622                                            loff_t pos)
1623 {
1624         for (iter->ct = 0; iter->ct < maxvif; ++iter->ct) {
1625                 if (!VIF_EXISTS(iter->ct))
1626                         continue;
1627                 if (pos-- == 0)
1628                         return &vif_table[iter->ct];
1629         }
1630         return NULL;
1631 }
1632
1633 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
1634 {
1635         read_lock(&mrt_lock);
1636         return *pos ? ipmr_vif_seq_idx(seq->private, *pos - 1)
1637                 : SEQ_START_TOKEN;
1638 }
1639
1640 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1641 {
1642         struct ipmr_vif_iter *iter = seq->private;
1643
1644         ++*pos;
1645         if (v == SEQ_START_TOKEN)
1646                 return ipmr_vif_seq_idx(iter, 0);
1647
1648         while (++iter->ct < maxvif) {
1649                 if (!VIF_EXISTS(iter->ct))
1650                         continue;
1651                 return &vif_table[iter->ct];
1652         }
1653         return NULL;
1654 }
1655
1656 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
1657 {
1658         read_unlock(&mrt_lock);
1659 }
1660
1661 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
1662 {
1663         if (v == SEQ_START_TOKEN) {
1664                 seq_puts(seq,
1665                          "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags Local    Remote\n");
1666         } else {
1667                 const struct vif_device *vif = v;
1668                 const char *name =  vif->dev ? vif->dev->name : "none";
1669
1670                 seq_printf(seq,
1671                            "%2Zd %-10s %8ld %7ld  %8ld %7ld %05X %08X %08X\n",
1672                            vif - vif_table,
1673                            name, vif->bytes_in, vif->pkt_in,
1674                            vif->bytes_out, vif->pkt_out,
1675                            vif->flags, vif->local, vif->remote);
1676         }
1677         return 0;
1678 }
1679
1680 static struct seq_operations ipmr_vif_seq_ops = {
1681         .start = ipmr_vif_seq_start,
1682         .next  = ipmr_vif_seq_next,
1683         .stop  = ipmr_vif_seq_stop,
1684         .show  = ipmr_vif_seq_show,
1685 };
1686
1687 static int ipmr_vif_open(struct inode *inode, struct file *file)
1688 {
1689         struct seq_file *seq;
1690         int rc = -ENOMEM;
1691         struct ipmr_vif_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1692
1693         if (!s)
1694                 goto out;
1695
1696         rc = seq_open(file, &ipmr_vif_seq_ops);
1697         if (rc)
1698                 goto out_kfree;
1699
1700         s->ct = 0;
1701         seq = file->private_data;
1702         seq->private = s;
1703 out:
1704         return rc;
1705 out_kfree:
1706         kfree(s);
1707         goto out;
1708
1709 }
1710
1711 static const struct file_operations ipmr_vif_fops = {
1712         .owner   = THIS_MODULE,
1713         .open    = ipmr_vif_open,
1714         .read    = seq_read,
1715         .llseek  = seq_lseek,
1716         .release = seq_release_private,
1717 };
1718
1719 struct ipmr_mfc_iter {
1720         struct mfc_cache **cache;
1721         int ct;
1722 };
1723
1724
1725 static struct mfc_cache *ipmr_mfc_seq_idx(struct ipmr_mfc_iter *it, loff_t pos)
1726 {
1727         struct mfc_cache *mfc;
1728
1729         it->cache = mfc_cache_array;
1730         read_lock(&mrt_lock);
1731         for (it->ct = 0; it->ct < MFC_LINES; it->ct++)
1732                 for (mfc = mfc_cache_array[it->ct]; mfc; mfc = mfc->next)
1733                         if (pos-- == 0)
1734                                 return mfc;
1735         read_unlock(&mrt_lock);
1736
1737         it->cache = &mfc_unres_queue;
1738         spin_lock_bh(&mfc_unres_lock);
1739         for (mfc = mfc_unres_queue; mfc; mfc = mfc->next)
1740                 if (pos-- == 0)
1741                         return mfc;
1742         spin_unlock_bh(&mfc_unres_lock);
1743
1744         it->cache = NULL;
1745         return NULL;
1746 }
1747
1748
1749 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
1750 {
1751         struct ipmr_mfc_iter *it = seq->private;
1752         it->cache = NULL;
1753         it->ct = 0;
1754         return *pos ? ipmr_mfc_seq_idx(seq->private, *pos - 1)
1755                 : SEQ_START_TOKEN;
1756 }
1757
1758 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1759 {
1760         struct mfc_cache *mfc = v;
1761         struct ipmr_mfc_iter *it = seq->private;
1762
1763         ++*pos;
1764
1765         if (v == SEQ_START_TOKEN)
1766                 return ipmr_mfc_seq_idx(seq->private, 0);
1767
1768         if (mfc->next)
1769                 return mfc->next;
1770
1771         if (it->cache == &mfc_unres_queue)
1772                 goto end_of_list;
1773
1774         BUG_ON(it->cache != mfc_cache_array);
1775
1776         while (++it->ct < MFC_LINES) {
1777                 mfc = mfc_cache_array[it->ct];
1778                 if (mfc)
1779                         return mfc;
1780         }
1781
1782         /* exhausted cache_array, show unresolved */
1783         read_unlock(&mrt_lock);
1784         it->cache = &mfc_unres_queue;
1785         it->ct = 0;
1786
1787         spin_lock_bh(&mfc_unres_lock);
1788         mfc = mfc_unres_queue;
1789         if (mfc)
1790                 return mfc;
1791
1792  end_of_list:
1793         spin_unlock_bh(&mfc_unres_lock);
1794         it->cache = NULL;
1795
1796         return NULL;
1797 }
1798
1799 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
1800 {
1801         struct ipmr_mfc_iter *it = seq->private;
1802
1803         if (it->cache == &mfc_unres_queue)
1804                 spin_unlock_bh(&mfc_unres_lock);
1805         else if (it->cache == mfc_cache_array)
1806                 read_unlock(&mrt_lock);
1807 }
1808
1809 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
1810 {
1811         int n;
1812
1813         if (v == SEQ_START_TOKEN) {
1814                 seq_puts(seq,
1815                  "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
1816         } else {
1817                 const struct mfc_cache *mfc = v;
1818                 const struct ipmr_mfc_iter *it = seq->private;
1819
1820                 seq_printf(seq, "%08lX %08lX %-3d %8ld %8ld %8ld",
1821                            (unsigned long) mfc->mfc_mcastgrp,
1822                            (unsigned long) mfc->mfc_origin,
1823                            mfc->mfc_parent,
1824                            mfc->mfc_un.res.pkt,
1825                            mfc->mfc_un.res.bytes,
1826                            mfc->mfc_un.res.wrong_if);
1827
1828                 if (it->cache != &mfc_unres_queue) {
1829                         for (n = mfc->mfc_un.res.minvif;
1830                              n < mfc->mfc_un.res.maxvif; n++ ) {
1831                                 if (VIF_EXISTS(n)
1832                                    && mfc->mfc_un.res.ttls[n] < 255)
1833                                 seq_printf(seq,
1834                                            " %2d:%-3d",
1835                                            n, mfc->mfc_un.res.ttls[n]);
1836                         }
1837                 }
1838                 seq_putc(seq, '\n');
1839         }
1840         return 0;
1841 }
1842
1843 static struct seq_operations ipmr_mfc_seq_ops = {
1844         .start = ipmr_mfc_seq_start,
1845         .next  = ipmr_mfc_seq_next,
1846         .stop  = ipmr_mfc_seq_stop,
1847         .show  = ipmr_mfc_seq_show,
1848 };
1849
1850 static int ipmr_mfc_open(struct inode *inode, struct file *file)
1851 {
1852         struct seq_file *seq;
1853         int rc = -ENOMEM;
1854         struct ipmr_mfc_iter *s = kmalloc(sizeof(*s), GFP_KERNEL);
1855
1856         if (!s)
1857                 goto out;
1858
1859         rc = seq_open(file, &ipmr_mfc_seq_ops);
1860         if (rc)
1861                 goto out_kfree;
1862
1863         seq = file->private_data;
1864         seq->private = s;
1865 out:
1866         return rc;
1867 out_kfree:
1868         kfree(s);
1869         goto out;
1870
1871 }
1872
1873 static const struct file_operations ipmr_mfc_fops = {
1874         .owner   = THIS_MODULE,
1875         .open    = ipmr_mfc_open,
1876         .read    = seq_read,
1877         .llseek  = seq_lseek,
1878         .release = seq_release_private,
1879 };
1880 #endif
1881
1882 #ifdef CONFIG_IP_PIMSM_V2
1883 static struct net_protocol pim_protocol = {
1884         .handler        =       pim_rcv,
1885 };
1886 #endif
1887
1888
1889 /*
1890  *      Setup for IP multicast routing
1891  */
1892
1893 void __init ip_mr_init(void)
1894 {
1895         mrt_cachep = kmem_cache_create("ip_mrt_cache",
1896                                        sizeof(struct mfc_cache),
1897                                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
1898                                        NULL, NULL);
1899         init_timer(&ipmr_expire_timer);
1900         ipmr_expire_timer.function=ipmr_expire_process;
1901         register_netdevice_notifier(&ip_mr_notifier);
1902 #ifdef CONFIG_PROC_FS
1903         proc_net_fops_create("ip_mr_vif", 0, &ipmr_vif_fops);
1904         proc_net_fops_create("ip_mr_cache", 0, &ipmr_mfc_fops);
1905 #endif
1906 }