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