net/ipv4/ipmr.c

   1 /*
   2  *      IP multicast routing support for mrouted 3.6/3.8
   3  *
   4  *              (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
   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  *      Fixes:
  13  *      Michael Chastain        :       Incorrect size of copying.
  14  *      Alan Cox                :       Added the cache manager code
  15  *      Alan Cox                :       Fixed the clone/copy bug and device race.
  16  *      Mike McLagan            :       Routing by source
  17  *      Malcolm Beattie         :       Buffer handling fixes.
  18  *      Alexey Kuznetsov        :       Double buffer free and other fixes.
  19  *      SVR Anand               :       Fixed several multicast bugs and problems.
  20  *      Alexey Kuznetsov        :       Status, optimisations and more.
  21  *      Brad Parker             :       Better behaviour on mrouted upcall
  22  *                                      overflow.
  23  *      Carlos Picoto           :       PIMv1 Support
  24  *      Pavlin Ivanov Radoslavov:       PIMv2 Registers must checksum only PIM header
  25  *                                      Relax this requirement to work with older peers.
  26  *
  27  */
  28
  29 #include <asm/system.h>
  30 #include <asm/uaccess.h>
  31 #include <linux/types.h>
  32 #include <linux/capability.h>
  33 #include <linux/errno.h>
  34 #include <linux/timer.h>
  35 #include <linux/mm.h>
  36 #include <linux/kernel.h>
  37 #include <linux/fcntl.h>
  38 #include <linux/stat.h>
  39 #include <linux/socket.h>
  40 #include <linux/in.h>
  41 #include <linux/inet.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/inetdevice.h>
  44 #include <linux/igmp.h>
  45 #include <linux/proc_fs.h>
  46 #include <linux/seq_file.h>
  47 #include <linux/mroute.h>
  48 #include <linux/init.h>
  49 #include <linux/if_ether.h>
  50 #include <linux/slab.h>
  51 #include <net/net_namespace.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 #include <net/netlink.h>
  66 #include <net/fib_rules.h>
  67
  68 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
  69 #define CONFIG_IP_PIMSM 1
  70 #endif
  71
  72 struct mr_table {
  73         struct list_head        list;
  74 #ifdef CONFIG_NET_NS
  75         struct net              *net;
  76 #endif
  77         u32                     id;
  78         struct sock             *mroute_sk;
  79         struct timer_list       ipmr_expire_timer;
  80         struct list_head        mfc_unres_queue;
  81         struct list_head        mfc_cache_array[MFC_LINES];
  82         struct vif_device       vif_table[MAXVIFS];
  83         int                     maxvif;
  84         atomic_t                cache_resolve_queue_len;
  85         int                     mroute_do_assert;
  86         int                     mroute_do_pim;
  87 #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
  88         int                     mroute_reg_vif_num;
  89 #endif
  90 };
  91
  92 struct ipmr_rule {
  93         struct fib_rule         common;
  94 };
  95
  96 struct ipmr_result {
  97         struct mr_table         *mrt;
  98 };
  99
 100 /* Big lock, protecting vif table, mrt cache and mroute socket state.
 101    Note that the changes are semaphored via rtnl_lock.
 102  */
 103
 104 static DEFINE_RWLOCK(mrt_lock);
 105
 106 /*
 107  *      Multicast router control variables
 108  */
 109
 110 #define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
 111
 112 /* Special spinlock for queue of unresolved entries */
 113 static DEFINE_SPINLOCK(mfc_unres_lock);
 114
 115 /* We return to original Alan's scheme. Hash table of resolved
 116    entries is changed only in process context and protected
 117    with weak lock mrt_lock. Queue of unresolved entries is protected
 118    with strong spinlock mfc_unres_lock.
 119
 120    In this case data path is free of exclusive locks at all.
 121  */
 122
 123 static struct kmem_cache *mrt_cachep __read_mostly;
 124
 125 static struct mr_table *ipmr_new_table(struct net *net, u32 id);
 126 static int ip_mr_forward(struct net *net, struct mr_table *mrt,
 127                          struct sk_buff *skb, struct mfc_cache *cache,
 128                          int local);
 129 static int ipmr_cache_report(struct mr_table *mrt,
 130                              struct sk_buff *pkt, vifi_t vifi, int assert);
 131 static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
 132                               struct mfc_cache *c, struct rtmsg *rtm);
 133 static void ipmr_expire_process(unsigned long arg);
 134
 135 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
 136 #define ipmr_for_each_table(mrt, net) \
 137         list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
 138
 139 static struct mr_table *ipmr_get_table(struct net *net, u32 id)
 140 {
 141         struct mr_table *mrt;
 142
 143         ipmr_for_each_table(mrt, net) {
 144                 if (mrt->id == id)
 145                         return mrt;
 146         }
 147         return NULL;
 148 }
 149
 150 static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
 151                            struct mr_table **mrt)
 152 {
 153         struct ipmr_result res;
 154         struct fib_lookup_arg arg = { .result = &res, };
 155         int err;
 156
 157         err = fib_rules_lookup(net->ipv4.mr_rules_ops, flp, 0, &arg);
 158         if (err < 0)
 159                 return err;
 160         *mrt = res.mrt;
 161         return 0;
 162 }
 163
 164 static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
 165                             int flags, struct fib_lookup_arg *arg)
 166 {
 167         struct ipmr_result *res = arg->result;
 168         struct mr_table *mrt;
 169
 170         switch (rule->action) {
 171         case FR_ACT_TO_TBL:
 172                 break;
 173         case FR_ACT_UNREACHABLE:
 174                 return -ENETUNREACH;
 175         case FR_ACT_PROHIBIT:
 176                 return -EACCES;
 177         case FR_ACT_BLACKHOLE:
 178         default:
 179                 return -EINVAL;
 180         }
 181
 182         mrt = ipmr_get_table(rule->fr_net, rule->table);
 183         if (mrt == NULL)
 184                 return -EAGAIN;
 185         res->mrt = mrt;
 186         return 0;
 187 }
 188
 189 static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
 190 {
 191         return 1;
 192 }
 193
 194 static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
 195         FRA_GENERIC_POLICY,
 196 };
 197
 198 static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
 199                                struct fib_rule_hdr *frh, struct nlattr **tb)
 200 {
 201         return 0;
 202 }
 203
 204 static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
 205                              struct nlattr **tb)
 206 {
 207         return 1;
 208 }
 209
 210 static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
 211                           struct fib_rule_hdr *frh)
 212 {
 213         frh->dst_len = 0;
 214         frh->src_len = 0;
 215         frh->tos     = 0;
 216         return 0;
 217 }
 218
 219 static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
 220         .family         = RTNL_FAMILY_IPMR,
 221         .rule_size      = sizeof(struct ipmr_rule),
 222         .addr_size      = sizeof(u32),
 223         .action         = ipmr_rule_action,
 224         .match          = ipmr_rule_match,
 225         .configure      = ipmr_rule_configure,
 226         .compare        = ipmr_rule_compare,
 227         .default_pref   = fib_default_rule_pref,
 228         .fill           = ipmr_rule_fill,
 229         .nlgroup        = RTNLGRP_IPV4_RULE,
 230         .policy         = ipmr_rule_policy,
 231         .owner          = THIS_MODULE,
 232 };
 233
 234 static int __net_init ipmr_rules_init(struct net *net)
 235 {
 236         struct fib_rules_ops *ops;
 237         struct mr_table *mrt;
 238         int err;
 239
 240         ops = fib_rules_register(&ipmr_rules_ops_template, net);
 241         if (IS_ERR(ops))
 242                 return PTR_ERR(ops);
 243
 244         INIT_LIST_HEAD(&net->ipv4.mr_tables);
 245
 246         mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
 247         if (mrt == NULL) {
 248                 err = -ENOMEM;
 249                 goto err1;
 250         }
 251
 252         err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
 253         if (err < 0)
 254                 goto err2;
 255
 256         net->ipv4.mr_rules_ops = ops;
 257         return 0;
 258
 259 err2:
 260         kfree(mrt);
 261 err1:
 262         fib_rules_unregister(ops);
 263         return err;
 264 }
 265
 266 static void __net_exit ipmr_rules_exit(struct net *net)
 267 {
 268         struct mr_table *mrt, *next;
 269
 270         list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
 271                 list_del(&mrt->list);
 272                 kfree(mrt);
 273         }
 274         fib_rules_unregister(net->ipv4.mr_rules_ops);
 275 }
 276 #else
 277 #define ipmr_for_each_table(mrt, net) \
 278         for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
 279
 280 static struct mr_table *ipmr_get_table(struct net *net, u32 id)
 281 {
 282         return net->ipv4.mrt;
 283 }
 284
 285 static int ipmr_fib_lookup(struct net *net, struct flowi *flp,
 286                            struct mr_table **mrt)
 287 {
 288         *mrt = net->ipv4.mrt;
 289         return 0;
 290 }
 291
 292 static int __net_init ipmr_rules_init(struct net *net)
 293 {
 294         net->ipv4.mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
 295         return net->ipv4.mrt ? 0 : -ENOMEM;
 296 }
 297
 298 static void __net_exit ipmr_rules_exit(struct net *net)
 299 {
 300         kfree(net->ipv4.mrt);
 301 }
 302 #endif
 303
 304 static struct mr_table *ipmr_new_table(struct net *net, u32 id)
 305 {
 306         struct mr_table *mrt;
 307         unsigned int i;
 308
 309         mrt = ipmr_get_table(net, id);
 310         if (mrt != NULL)
 311                 return mrt;
 312
 313         mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
 314         if (mrt == NULL)
 315                 return NULL;
 316         write_pnet(&mrt->net, net);
 317         mrt->id = id;
 318
 319         /* Forwarding cache */
 320         for (i = 0; i < MFC_LINES; i++)
 321                 INIT_LIST_HEAD(&mrt->mfc_cache_array[i]);
 322
 323         INIT_LIST_HEAD(&mrt->mfc_unres_queue);
 324
 325         setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
 326                     (unsigned long)mrt);
 327
 328 #ifdef CONFIG_IP_PIMSM
 329         mrt->mroute_reg_vif_num = -1;
 330 #endif
 331 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
 332         list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
 333 #endif
 334         return mrt;
 335 }
 336
 337 /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
 338
 339 static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
 340 {
 341         struct net *net = dev_net(dev);
 342
 343         dev_close(dev);
 344
 345         dev = __dev_get_by_name(net, "tunl0");
 346         if (dev) {
 347                 const struct net_device_ops *ops = dev->netdev_ops;
 348                 struct ifreq ifr;
 349                 struct ip_tunnel_parm p;
 350
 351                 memset(&p, 0, sizeof(p));
 352                 p.iph.daddr = v->vifc_rmt_addr.s_addr;
 353                 p.iph.saddr = v->vifc_lcl_addr.s_addr;
 354                 p.iph.version = 4;
 355                 p.iph.ihl = 5;
 356                 p.iph.protocol = IPPROTO_IPIP;
 357                 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
 358                 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
 359
 360                 if (ops->ndo_do_ioctl) {
 361                         mm_segment_t oldfs = get_fs();
 362
 363                         set_fs(KERNEL_DS);
 364                         ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
 365                         set_fs(oldfs);
 366                 }
 367         }
 368 }
 369
 370 static
 371 struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
 372 {
 373         struct net_device  *dev;
 374
 375         dev = __dev_get_by_name(net, "tunl0");
 376
 377         if (dev) {
 378                 const struct net_device_ops *ops = dev->netdev_ops;
 379                 int err;
 380                 struct ifreq ifr;
 381                 struct ip_tunnel_parm p;
 382                 struct in_device  *in_dev;
 383
 384                 memset(&p, 0, sizeof(p));
 385                 p.iph.daddr = v->vifc_rmt_addr.s_addr;
 386                 p.iph.saddr = v->vifc_lcl_addr.s_addr;
 387                 p.iph.version = 4;
 388                 p.iph.ihl = 5;
 389                 p.iph.protocol = IPPROTO_IPIP;
 390                 sprintf(p.name, "dvmrp%d", v->vifc_vifi);
 391                 ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
 392
 393                 if (ops->ndo_do_ioctl) {
 394                         mm_segment_t oldfs = get_fs();
 395
 396                         set_fs(KERNEL_DS);
 397                         err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
 398                         set_fs(oldfs);
 399                 } else
 400                         err = -EOPNOTSUPP;
 401
 402                 dev = NULL;
 403
 404                 if (err == 0 &&
 405                     (dev = __dev_get_by_name(net, p.name)) != NULL) {
 406                         dev->flags |= IFF_MULTICAST;
 407
 408                         in_dev = __in_dev_get_rtnl(dev);
 409                         if (in_dev == NULL)
 410                                 goto failure;
 411
 412                         ipv4_devconf_setall(in_dev);
 413                         IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
 414
 415                         if (dev_open(dev))
 416                                 goto failure;
 417                         dev_hold(dev);
 418                 }
 419         }
 420         return dev;
 421
 422 failure:
 423         /* allow the register to be completed before unregistering. */
 424         rtnl_unlock();
 425         rtnl_lock();
 426
 427         unregister_netdevice(dev);
 428         return NULL;
 429 }
 430
 431 #ifdef CONFIG_IP_PIMSM
 432
 433 static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
 434 {
 435         struct net *net = dev_net(dev);
 436         struct mr_table *mrt;
 437         struct flowi fl = {
 438                 .oif            = dev->ifindex,
 439                 .iif            = skb->skb_iif,
 440                 .mark           = skb->mark,
 441         };
 442         int err;
 443
 444         err = ipmr_fib_lookup(net, &fl, &mrt);
 445         if (err < 0) {
 446                 kfree_skb(skb);
 447                 return err;
 448         }
 449
 450         read_lock(&mrt_lock);
 451         dev->stats.tx_bytes += skb->len;
 452         dev->stats.tx_packets++;
 453         ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
 454         read_unlock(&mrt_lock);
 455         kfree_skb(skb);
 456         return NETDEV_TX_OK;
 457 }
 458
 459 static const struct net_device_ops reg_vif_netdev_ops = {
 460         .ndo_start_xmit = reg_vif_xmit,
 461 };
 462
 463 static void reg_vif_setup(struct net_device *dev)
 464 {
 465         dev->type               = ARPHRD_PIMREG;
 466         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
 467         dev->flags              = IFF_NOARP;
 468         dev->netdev_ops         = &reg_vif_netdev_ops,
 469         dev->destructor         = free_netdev;
 470         dev->features           |= NETIF_F_NETNS_LOCAL;
 471 }
 472
 473 static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
 474 {
 475         struct net_device *dev;
 476         struct in_device *in_dev;
 477         char name[IFNAMSIZ];
 478
 479         if (mrt->id == RT_TABLE_DEFAULT)
 480                 sprintf(name, "pimreg");
 481         else
 482                 sprintf(name, "pimreg%u", mrt->id);
 483
 484         dev = alloc_netdev(0, name, reg_vif_setup);
 485
 486         if (dev == NULL)
 487                 return NULL;
 488
 489         dev_net_set(dev, net);
 490
 491         if (register_netdevice(dev)) {
 492                 free_netdev(dev);
 493                 return NULL;
 494         }
 495         dev->iflink = 0;
 496
 497         rcu_read_lock();
 498         if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
 499                 rcu_read_unlock();
 500                 goto failure;
 501         }
 502
 503         ipv4_devconf_setall(in_dev);
 504         IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
 505         rcu_read_unlock();
 506
 507         if (dev_open(dev))
 508                 goto failure;
 509
 510         dev_hold(dev);
 511
 512         return dev;
 513
 514 failure:
 515         /* allow the register to be completed before unregistering. */
 516         rtnl_unlock();
 517         rtnl_lock();
 518
 519         unregister_netdevice(dev);
 520         return NULL;
 521 }
 522 #endif
 523
 524 /*
 525  *      Delete a VIF entry
 526  *      @notify: Set to 1, if the caller is a notifier_call
 527  */
 528
 529 static int vif_delete(struct mr_table *mrt, int vifi, int notify,
 530                       struct list_head *head)
 531 {
 532         struct vif_device *v;
 533         struct net_device *dev;
 534         struct in_device *in_dev;
 535
 536         if (vifi < 0 || vifi >= mrt->maxvif)
 537                 return -EADDRNOTAVAIL;
 538
 539         v = &mrt->vif_table[vifi];
 540
 541         write_lock_bh(&mrt_lock);
 542         dev = v->dev;
 543         v->dev = NULL;
 544
 545         if (!dev) {
 546                 write_unlock_bh(&mrt_lock);
 547                 return -EADDRNOTAVAIL;
 548         }
 549
 550 #ifdef CONFIG_IP_PIMSM
 551         if (vifi == mrt->mroute_reg_vif_num)
 552                 mrt->mroute_reg_vif_num = -1;
 553 #endif
 554
 555         if (vifi+1 == mrt->maxvif) {
 556                 int tmp;
 557                 for (tmp=vifi-1; tmp>=0; tmp--) {
 558                         if (VIF_EXISTS(mrt, tmp))
 559                                 break;
 560                 }
 561                 mrt->maxvif = tmp+1;
 562         }
 563
 564         write_unlock_bh(&mrt_lock);
 565
 566         dev_set_allmulti(dev, -1);
 567
 568         if ((in_dev = __in_dev_get_rtnl(dev)) != NULL) {
 569                 IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
 570                 ip_rt_multicast_event(in_dev);
 571         }
 572
 573         if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER) && !notify)
 574                 unregister_netdevice_queue(dev, head);
 575
 576         dev_put(dev);
 577         return 0;
 578 }
 579
 580 static inline void ipmr_cache_free(struct mfc_cache *c)
 581 {
 582         kmem_cache_free(mrt_cachep, c);
 583 }
 584
 585 /* Destroy an unresolved cache entry, killing queued skbs
 586    and reporting error to netlink readers.
 587  */
 588
 589 static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
 590 {
 591         struct net *net = read_pnet(&mrt->net);
 592         struct sk_buff *skb;
 593         struct nlmsgerr *e;
 594
 595         atomic_dec(&mrt->cache_resolve_queue_len);
 596
 597         while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
 598                 if (ip_hdr(skb)->version == 0) {
 599                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 600                         nlh->nlmsg_type = NLMSG_ERROR;
 601                         nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 602                         skb_trim(skb, nlh->nlmsg_len);
 603                         e = NLMSG_DATA(nlh);
 604                         e->error = -ETIMEDOUT;
 605                         memset(&e->msg, 0, sizeof(e->msg));
 606
 607                         rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
 608                 } else
 609                         kfree_skb(skb);
 610         }
 611
 612         ipmr_cache_free(c);
 613 }
 614
 615
 616 /* Timer process for the unresolved queue. */
 617
 618 static void ipmr_expire_process(unsigned long arg)
 619 {
 620         struct mr_table *mrt = (struct mr_table *)arg;
 621         unsigned long now;
 622         unsigned long expires;
 623         struct mfc_cache *c, *next;
 624
 625         if (!spin_trylock(&mfc_unres_lock)) {
 626                 mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
 627                 return;
 628         }
 629
 630         if (list_empty(&mrt->mfc_unres_queue))
 631                 goto out;
 632
 633         now = jiffies;
 634         expires = 10*HZ;
 635
 636         list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
 637                 if (time_after(c->mfc_un.unres.expires, now)) {
 638                         unsigned long interval = c->mfc_un.unres.expires - now;
 639                         if (interval < expires)
 640                                 expires = interval;
 641                         continue;
 642                 }
 643
 644                 list_del(&c->list);
 645                 ipmr_destroy_unres(mrt, c);
 646         }
 647
 648         if (!list_empty(&mrt->mfc_unres_queue))
 649                 mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
 650
 651 out:
 652         spin_unlock(&mfc_unres_lock);
 653 }
 654
 655 /* Fill oifs list. It is called under write locked mrt_lock. */
 656
 657 static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
 658                                    unsigned char *ttls)
 659 {
 660         int vifi;
 661
 662         cache->mfc_un.res.minvif = MAXVIFS;
 663         cache->mfc_un.res.maxvif = 0;
 664         memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
 665
 666         for (vifi = 0; vifi < mrt->maxvif; vifi++) {
 667                 if (VIF_EXISTS(mrt, vifi) &&
 668                     ttls[vifi] && ttls[vifi] < 255) {
 669                         cache->mfc_un.res.ttls[vifi] = ttls[vifi];
 670                         if (cache->mfc_un.res.minvif > vifi)
 671                                 cache->mfc_un.res.minvif = vifi;
 672                         if (cache->mfc_un.res.maxvif <= vifi)
 673                                 cache->mfc_un.res.maxvif = vifi + 1;
 674                 }
 675         }
 676 }
 677
 678 static int vif_add(struct net *net, struct mr_table *mrt,
 679                    struct vifctl *vifc, int mrtsock)
 680 {
 681         int vifi = vifc->vifc_vifi;
 682         struct vif_device *v = &mrt->vif_table[vifi];
 683         struct net_device *dev;
 684         struct in_device *in_dev;
 685         int err;
 686
 687         /* Is vif busy ? */
 688         if (VIF_EXISTS(mrt, vifi))
 689                 return -EADDRINUSE;
 690
 691         switch (vifc->vifc_flags) {
 692 #ifdef CONFIG_IP_PIMSM
 693         case VIFF_REGISTER:
 694                 /*
 695                  * Special Purpose VIF in PIM
 696                  * All the packets will be sent to the daemon
 697                  */
 698                 if (mrt->mroute_reg_vif_num >= 0)
 699                         return -EADDRINUSE;
 700                 dev = ipmr_reg_vif(net, mrt);
 701                 if (!dev)
 702                         return -ENOBUFS;
 703                 err = dev_set_allmulti(dev, 1);
 704                 if (err) {
 705                         unregister_netdevice(dev);
 706                         dev_put(dev);
 707                         return err;
 708                 }
 709                 break;
 710 #endif
 711         case VIFF_TUNNEL:
 712                 dev = ipmr_new_tunnel(net, vifc);
 713                 if (!dev)
 714                         return -ENOBUFS;
 715                 err = dev_set_allmulti(dev, 1);
 716                 if (err) {
 717                         ipmr_del_tunnel(dev, vifc);
 718                         dev_put(dev);
 719                         return err;
 720                 }
 721                 break;
 722
 723         case VIFF_USE_IFINDEX:
 724         case 0:
 725                 if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
 726                         dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
 727                         if (dev && dev->ip_ptr == NULL) {
 728                                 dev_put(dev);
 729                                 return -EADDRNOTAVAIL;
 730                         }
 731                 } else
 732                         dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
 733
 734                 if (!dev)
 735                         return -EADDRNOTAVAIL;
 736                 err = dev_set_allmulti(dev, 1);
 737                 if (err) {
 738                         dev_put(dev);
 739                         return err;
 740                 }
 741                 break;
 742         default:
 743                 return -EINVAL;
 744         }
 745
 746         if ((in_dev = __in_dev_get_rtnl(dev)) == NULL) {
 747                 dev_put(dev);
 748                 return -EADDRNOTAVAIL;
 749         }
 750         IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
 751         ip_rt_multicast_event(in_dev);
 752
 753         /*
 754          *      Fill in the VIF structures
 755          */
 756         v->rate_limit = vifc->vifc_rate_limit;
 757         v->local = vifc->vifc_lcl_addr.s_addr;
 758         v->remote = vifc->vifc_rmt_addr.s_addr;
 759         v->flags = vifc->vifc_flags;
 760         if (!mrtsock)
 761                 v->flags |= VIFF_STATIC;
 762         v->threshold = vifc->vifc_threshold;
 763         v->bytes_in = 0;
 764         v->bytes_out = 0;
 765         v->pkt_in = 0;
 766         v->pkt_out = 0;
 767         v->link = dev->ifindex;
 768         if (v->flags&(VIFF_TUNNEL|VIFF_REGISTER))
 769                 v->link = dev->iflink;
 770
 771         /* And finish update writing critical data */
 772         write_lock_bh(&mrt_lock);
 773         v->dev = dev;
 774 #ifdef CONFIG_IP_PIMSM
 775         if (v->flags&VIFF_REGISTER)
 776                 mrt->mroute_reg_vif_num = vifi;
 777 #endif
 778         if (vifi+1 > mrt->maxvif)
 779                 mrt->maxvif = vifi+1;
 780         write_unlock_bh(&mrt_lock);
 781         return 0;
 782 }
 783
 784 static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
 785                                          __be32 origin,
 786                                          __be32 mcastgrp)
 787 {
 788         int line = MFC_HASH(mcastgrp, origin);
 789         struct mfc_cache *c;
 790
 791         list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
 792                 if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
 793                         return c;
 794         }
 795         return NULL;
 796 }
 797
 798 /*
 799  *      Allocate a multicast cache entry
 800  */
 801 static struct mfc_cache *ipmr_cache_alloc(void)
 802 {
 803         struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
 804         if (c == NULL)
 805                 return NULL;
 806         c->mfc_un.res.minvif = MAXVIFS;
 807         return c;
 808 }
 809
 810 static struct mfc_cache *ipmr_cache_alloc_unres(void)
 811 {
 812         struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
 813         if (c == NULL)
 814                 return NULL;
 815         skb_queue_head_init(&c->mfc_un.unres.unresolved);
 816         c->mfc_un.unres.expires = jiffies + 10*HZ;
 817         return c;
 818 }
 819
 820 /*
 821  *      A cache entry has gone into a resolved state from queued
 822  */
 823
 824 static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
 825                                struct mfc_cache *uc, struct mfc_cache *c)
 826 {
 827         struct sk_buff *skb;
 828         struct nlmsgerr *e;
 829
 830         /*
 831          *      Play the pending entries through our router
 832          */
 833
 834         while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
 835                 if (ip_hdr(skb)->version == 0) {
 836                         struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
 837
 838                         if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
 839                                 nlh->nlmsg_len = (skb_tail_pointer(skb) -
 840                                                   (u8 *)nlh);
 841                         } else {
 842                                 nlh->nlmsg_type = NLMSG_ERROR;
 843                                 nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
 844                                 skb_trim(skb, nlh->nlmsg_len);
 845                                 e = NLMSG_DATA(nlh);
 846                                 e->error = -EMSGSIZE;
 847                                 memset(&e->msg, 0, sizeof(e->msg));
 848                         }
 849
 850                         rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
 851                 } else
 852                         ip_mr_forward(net, mrt, skb, c, 0);
 853         }
 854 }
 855
 856 /*
 857  *      Bounce a cache query up to mrouted. We could use netlink for this but mrouted
 858  *      expects the following bizarre scheme.
 859  *
 860  *      Called under mrt_lock.
 861  */
 862
 863 static int ipmr_cache_report(struct mr_table *mrt,
 864                              struct sk_buff *pkt, vifi_t vifi, int assert)
 865 {
 866         struct sk_buff *skb;
 867         const int ihl = ip_hdrlen(pkt);
 868         struct igmphdr *igmp;
 869         struct igmpmsg *msg;
 870         int ret;
 871
 872 #ifdef CONFIG_IP_PIMSM
 873         if (assert == IGMPMSG_WHOLEPKT)
 874                 skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
 875         else
 876 #endif
 877                 skb = alloc_skb(128, GFP_ATOMIC);
 878
 879         if (!skb)
 880                 return -ENOBUFS;
 881
 882 #ifdef CONFIG_IP_PIMSM
 883         if (assert == IGMPMSG_WHOLEPKT) {
 884                 /* Ugly, but we have no choice with this interface.
 885                    Duplicate old header, fix ihl, length etc.
 886                    And all this only to mangle msg->im_msgtype and
 887                    to set msg->im_mbz to "mbz" :-)
 888                  */
 889                 skb_push(skb, sizeof(struct iphdr));
 890                 skb_reset_network_header(skb);
 891                 skb_reset_transport_header(skb);
 892                 msg = (struct igmpmsg *)skb_network_header(skb);
 893                 memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
 894                 msg->im_msgtype = IGMPMSG_WHOLEPKT;
 895                 msg->im_mbz = 0;
 896                 msg->im_vif = mrt->mroute_reg_vif_num;
 897                 ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
 898                 ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
 899                                              sizeof(struct iphdr));
 900         } else
 901 #endif
 902         {
 903
 904         /*
 905          *      Copy the IP header
 906          */
 907
 908         skb->network_header = skb->tail;
 909         skb_put(skb, ihl);
 910         skb_copy_to_linear_data(skb, pkt->data, ihl);
 911         ip_hdr(skb)->protocol = 0;                      /* Flag to the kernel this is a route add */
 912         msg = (struct igmpmsg *)skb_network_header(skb);
 913         msg->im_vif = vifi;
 914         skb_dst_set(skb, dst_clone(skb_dst(pkt)));
 915
 916         /*
 917          *      Add our header
 918          */
 919
 920         igmp=(struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
 921         igmp->type      =
 922         msg->im_msgtype = assert;
 923         igmp->code      =       0;
 924         ip_hdr(skb)->tot_len = htons(skb->len);                 /* Fix the length */
 925         skb->transport_header = skb->network_header;
 926         }
 927
 928         if (mrt->mroute_sk == NULL) {
 929                 kfree_skb(skb);
 930                 return -EINVAL;
 931         }
 932
 933         /*
 934          *      Deliver to mrouted
 935          */
 936         ret = sock_queue_rcv_skb(mrt->mroute_sk, skb);
 937         if (ret < 0) {
 938                 if (net_ratelimit())
 939                         printk(KERN_WARNING "mroute: pending queue full, dropping entries.\n");
 940                 kfree_skb(skb);
 941         }
 942
 943         return ret;
 944 }
 945
 946 /*
 947  *      Queue a packet for resolution. It gets locked cache entry!
 948  */
 949
 950 static int
 951 ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
 952 {
 953         bool found = false;
 954         int err;
 955         struct mfc_cache *c;
 956         const struct iphdr *iph = ip_hdr(skb);
 957
 958         spin_lock_bh(&mfc_unres_lock);
 959         list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
 960                 if (c->mfc_mcastgrp == iph->daddr &&
 961                     c->mfc_origin == iph->saddr) {
 962                         found = true;
 963                         break;
 964                 }
 965         }
 966
 967         if (!found) {
 968                 /*
 969                  *      Create a new entry if allowable
 970                  */
 971
 972                 if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
 973                     (c = ipmr_cache_alloc_unres()) == NULL) {
 974                         spin_unlock_bh(&mfc_unres_lock);
 975
 976                         kfree_skb(skb);
 977                         return -ENOBUFS;
 978                 }
 979
 980                 /*
 981                  *      Fill in the new cache entry
 982                  */
 983                 c->mfc_parent   = -1;
 984                 c->mfc_origin   = iph->saddr;
 985                 c->mfc_mcastgrp = iph->daddr;
 986
 987                 /*
 988                  *      Reflect first query at mrouted.
 989                  */
 990                 err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
 991                 if (err < 0) {
 992                         /* If the report failed throw the cache entry
 993                            out - Brad Parker
 994                          */
 995                         spin_unlock_bh(&mfc_unres_lock);
 996
 997                         ipmr_cache_free(c);
 998                         kfree_skb(skb);
 999                         return err;
1000                 }
1001
1002                 atomic_inc(&mrt->cache_resolve_queue_len);
1003                 list_add(&c->list, &mrt->mfc_unres_queue);
1004
1005                 if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
1006                         mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
1007         }
1008
1009         /*
1010          *      See if we can append the packet
1011          */
1012         if (c->mfc_un.unres.unresolved.qlen>3) {
1013                 kfree_skb(skb);
1014                 err = -ENOBUFS;
1015         } else {
1016                 skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
1017                 err = 0;
1018         }
1019
1020         spin_unlock_bh(&mfc_unres_lock);
1021         return err;
1022 }
1023
1024 /*
1025  *      MFC cache manipulation by user space mroute daemon
1026  */
1027
1028 static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc)
1029 {
1030         int line;
1031         struct mfc_cache *c, *next;
1032
1033         line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
1034
1035         list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
1036                 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
1037                     c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
1038                         write_lock_bh(&mrt_lock);
1039                         list_del(&c->list);
1040                         write_unlock_bh(&mrt_lock);
1041
1042                         ipmr_cache_free(c);
1043                         return 0;
1044                 }
1045         }
1046         return -ENOENT;
1047 }
1048
1049 static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
1050                         struct mfcctl *mfc, int mrtsock)
1051 {
1052         bool found = false;
1053         int line;
1054         struct mfc_cache *uc, *c;
1055
1056         if (mfc->mfcc_parent >= MAXVIFS)
1057                 return -ENFILE;
1058
1059         line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
1060
1061         list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
1062                 if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
1063                     c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
1064                         found = true;
1065                         break;
1066                 }
1067         }
1068
1069         if (found) {
1070                 write_lock_bh(&mrt_lock);
1071                 c->mfc_parent = mfc->mfcc_parent;
1072                 ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
1073                 if (!mrtsock)
1074                         c->mfc_flags |= MFC_STATIC;
1075                 write_unlock_bh(&mrt_lock);
1076                 return 0;
1077         }
1078
1079         if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
1080                 return -EINVAL;
1081
1082         c = ipmr_cache_alloc();
1083         if (c == NULL)
1084                 return -ENOMEM;
1085
1086         c->mfc_origin = mfc->mfcc_origin.s_addr;
1087         c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
1088         c->mfc_parent = mfc->mfcc_parent;
1089         ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
1090         if (!mrtsock)
1091                 c->mfc_flags |= MFC_STATIC;
1092
1093         write_lock_bh(&mrt_lock);
1094         list_add(&c->list, &mrt->mfc_cache_array[line]);
1095         write_unlock_bh(&mrt_lock);
1096
1097         /*
1098          *      Check to see if we resolved a queued list. If so we
1099          *      need to send on the frames and tidy up.
1100          */
1101         found = false;
1102         spin_lock_bh(&mfc_unres_lock);
1103         list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
1104                 if (uc->mfc_origin == c->mfc_origin &&
1105                     uc->mfc_mcastgrp == c->mfc_mcastgrp) {
1106                         list_del(&uc->list);
1107                         atomic_dec(&mrt->cache_resolve_queue_len);
1108                         found = true;
1109                         break;
1110                 }
1111         }
1112         if (list_empty(&mrt->mfc_unres_queue))
1113                 del_timer(&mrt->ipmr_expire_timer);
1114         spin_unlock_bh(&mfc_unres_lock);
1115
1116         if (found) {
1117                 ipmr_cache_resolve(net, mrt, uc, c);
1118                 ipmr_cache_free(uc);
1119         }
1120         return 0;
1121 }
1122
1123 /*
1124  *      Close the multicast socket, and clear the vif tables etc
1125  */
1126
1127 static void mroute_clean_tables(struct mr_table *mrt)
1128 {
1129         int i;
1130         LIST_HEAD(list);
1131         struct mfc_cache *c, *next;
1132
1133         /*
1134          *      Shut down all active vif entries
1135          */
1136         for (i = 0; i < mrt->maxvif; i++) {
1137                 if (!(mrt->vif_table[i].flags&VIFF_STATIC))
1138                         vif_delete(mrt, i, 0, &list);
1139         }
1140         unregister_netdevice_many(&list);
1141
1142         /*
1143          *      Wipe the cache
1144          */
1145         for (i = 0; i < MFC_LINES; i++) {
1146                 list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
1147                         if (c->mfc_flags&MFC_STATIC)
1148                                 continue;
1149                         write_lock_bh(&mrt_lock);
1150                         list_del(&c->list);
1151                         write_unlock_bh(&mrt_lock);
1152
1153                         ipmr_cache_free(c);
1154                 }
1155         }
1156
1157         if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
1158                 spin_lock_bh(&mfc_unres_lock);
1159                 list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
1160                         list_del(&c->list);
1161                         ipmr_destroy_unres(mrt, c);
1162                 }
1163                 spin_unlock_bh(&mfc_unres_lock);
1164         }
1165 }
1166
1167 static void mrtsock_destruct(struct sock *sk)
1168 {
1169         struct net *net = sock_net(sk);
1170         struct mr_table *mrt;
1171
1172         rtnl_lock();
1173         ipmr_for_each_table(mrt, net) {
1174                 if (sk == mrt->mroute_sk) {
1175                         IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
1176
1177                         write_lock_bh(&mrt_lock);
1178                         mrt->mroute_sk = NULL;
1179                         write_unlock_bh(&mrt_lock);
1180
1181                         mroute_clean_tables(mrt);
1182                 }
1183         }
1184         rtnl_unlock();
1185 }
1186
1187 /*
1188  *      Socket options and virtual interface manipulation. The whole
1189  *      virtual interface system is a complete heap, but unfortunately
1190  *      that's how BSD mrouted happens to think. Maybe one day with a proper
1191  *      MOSPF/PIM router set up we can clean this up.
1192  */
1193
1194 int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
1195 {
1196         int ret;
1197         struct vifctl vif;
1198         struct mfcctl mfc;
1199         struct net *net = sock_net(sk);
1200         struct mr_table *mrt;
1201
1202         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1203         if (mrt == NULL)
1204                 return -ENOENT;
1205
1206         if (optname != MRT_INIT) {
1207                 if (sk != mrt->mroute_sk && !capable(CAP_NET_ADMIN))
1208                         return -EACCES;
1209         }
1210
1211         switch (optname) {
1212         case MRT_INIT:
1213                 if (sk->sk_type != SOCK_RAW ||
1214                     inet_sk(sk)->inet_num != IPPROTO_IGMP)
1215                         return -EOPNOTSUPP;
1216                 if (optlen != sizeof(int))
1217                         return -ENOPROTOOPT;
1218
1219                 rtnl_lock();
1220                 if (mrt->mroute_sk) {
1221                         rtnl_unlock();
1222                         return -EADDRINUSE;
1223                 }
1224
1225                 ret = ip_ra_control(sk, 1, mrtsock_destruct);
1226                 if (ret == 0) {
1227                         write_lock_bh(&mrt_lock);
1228                         mrt->mroute_sk = sk;
1229                         write_unlock_bh(&mrt_lock);
1230
1231                         IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
1232                 }
1233                 rtnl_unlock();
1234                 return ret;
1235         case MRT_DONE:
1236                 if (sk != mrt->mroute_sk)
1237                         return -EACCES;
1238                 return ip_ra_control(sk, 0, NULL);
1239         case MRT_ADD_VIF:
1240         case MRT_DEL_VIF:
1241                 if (optlen != sizeof(vif))
1242                         return -EINVAL;
1243                 if (copy_from_user(&vif, optval, sizeof(vif)))
1244                         return -EFAULT;
1245                 if (vif.vifc_vifi >= MAXVIFS)
1246                         return -ENFILE;
1247                 rtnl_lock();
1248                 if (optname == MRT_ADD_VIF) {
1249                         ret = vif_add(net, mrt, &vif, sk == mrt->mroute_sk);
1250                 } else {
1251                         ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
1252                 }
1253                 rtnl_unlock();
1254                 return ret;
1255
1256                 /*
1257                  *      Manipulate the forwarding caches. These live
1258                  *      in a sort of kernel/user symbiosis.
1259                  */
1260         case MRT_ADD_MFC:
1261         case MRT_DEL_MFC:
1262                 if (optlen != sizeof(mfc))
1263                         return -EINVAL;
1264                 if (copy_from_user(&mfc, optval, sizeof(mfc)))
1265                         return -EFAULT;
1266                 rtnl_lock();
1267                 if (optname == MRT_DEL_MFC)
1268                         ret = ipmr_mfc_delete(mrt, &mfc);
1269                 else
1270                         ret = ipmr_mfc_add(net, mrt, &mfc, sk == mrt->mroute_sk);
1271                 rtnl_unlock();
1272                 return ret;
1273                 /*
1274                  *      Control PIM assert.
1275                  */
1276         case MRT_ASSERT:
1277         {
1278                 int v;
1279                 if (get_user(v,(int __user *)optval))
1280                         return -EFAULT;
1281                 mrt->mroute_do_assert = (v) ? 1 : 0;
1282                 return 0;
1283         }
1284 #ifdef CONFIG_IP_PIMSM
1285         case MRT_PIM:
1286         {
1287                 int v;
1288
1289                 if (get_user(v,(int __user *)optval))
1290                         return -EFAULT;
1291                 v = (v) ? 1 : 0;
1292
1293                 rtnl_lock();
1294                 ret = 0;
1295                 if (v != mrt->mroute_do_pim) {
1296                         mrt->mroute_do_pim = v;
1297                         mrt->mroute_do_assert = v;
1298                 }
1299                 rtnl_unlock();
1300                 return ret;
1301         }
1302 #endif
1303 #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
1304         case MRT_TABLE:
1305         {
1306                 u32 v;
1307
1308                 if (optlen != sizeof(u32))
1309                         return -EINVAL;
1310                 if (get_user(v, (u32 __user *)optval))
1311                         return -EFAULT;
1312                 if (sk == mrt->mroute_sk)
1313                         return -EBUSY;
1314
1315                 rtnl_lock();
1316                 ret = 0;
1317                 if (!ipmr_new_table(net, v))
1318                         ret = -ENOMEM;
1319                 raw_sk(sk)->ipmr_table = v;
1320                 rtnl_unlock();
1321                 return ret;
1322         }
1323 #endif
1324         /*
1325          *      Spurious command, or MRT_VERSION which you cannot
1326          *      set.
1327          */
1328         default:
1329                 return -ENOPROTOOPT;
1330         }
1331 }
1332
1333 /*
1334  *      Getsock opt support for the multicast routing system.
1335  */
1336
1337 int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
1338 {
1339         int olr;
1340         int val;
1341         struct net *net = sock_net(sk);
1342         struct mr_table *mrt;
1343
1344         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1345         if (mrt == NULL)
1346                 return -ENOENT;
1347
1348         if (optname != MRT_VERSION &&
1349 #ifdef CONFIG_IP_PIMSM
1350            optname!=MRT_PIM &&
1351 #endif
1352            optname!=MRT_ASSERT)
1353                 return -ENOPROTOOPT;
1354
1355         if (get_user(olr, optlen))
1356                 return -EFAULT;
1357
1358         olr = min_t(unsigned int, olr, sizeof(int));
1359         if (olr < 0)
1360                 return -EINVAL;
1361
1362         if (put_user(olr, optlen))
1363                 return -EFAULT;
1364         if (optname == MRT_VERSION)
1365                 val = 0x0305;
1366 #ifdef CONFIG_IP_PIMSM
1367         else if (optname == MRT_PIM)
1368                 val = mrt->mroute_do_pim;
1369 #endif
1370         else
1371                 val = mrt->mroute_do_assert;
1372         if (copy_to_user(optval, &val, olr))
1373                 return -EFAULT;
1374         return 0;
1375 }
1376
1377 /*
1378  *      The IP multicast ioctl support routines.
1379  */
1380
1381 int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
1382 {
1383         struct sioc_sg_req sr;
1384         struct sioc_vif_req vr;
1385         struct vif_device *vif;
1386         struct mfc_cache *c;
1387         struct net *net = sock_net(sk);
1388         struct mr_table *mrt;
1389
1390         mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
1391         if (mrt == NULL)
1392                 return -ENOENT;
1393
1394         switch (cmd) {
1395         case SIOCGETVIFCNT:
1396                 if (copy_from_user(&vr, arg, sizeof(vr)))
1397                         return -EFAULT;
1398                 if (vr.vifi >= mrt->maxvif)
1399                         return -EINVAL;
1400                 read_lock(&mrt_lock);
1401                 vif = &mrt->vif_table[vr.vifi];
1402                 if (VIF_EXISTS(mrt, vr.vifi)) {
1403                         vr.icount = vif->pkt_in;
1404                         vr.ocount = vif->pkt_out;
1405                         vr.ibytes = vif->bytes_in;
1406                         vr.obytes = vif->bytes_out;
1407                         read_unlock(&mrt_lock);
1408
1409                         if (copy_to_user(arg, &vr, sizeof(vr)))
1410                                 return -EFAULT;
1411                         return 0;
1412                 }
1413                 read_unlock(&mrt_lock);
1414                 return -EADDRNOTAVAIL;
1415         case SIOCGETSGCNT:
1416                 if (copy_from_user(&sr, arg, sizeof(sr)))
1417                         return -EFAULT;
1418
1419                 read_lock(&mrt_lock);
1420                 c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
1421                 if (c) {
1422                         sr.pktcnt = c->mfc_un.res.pkt;
1423                         sr.bytecnt = c->mfc_un.res.bytes;
1424                         sr.wrong_if = c->mfc_un.res.wrong_if;
1425                         read_unlock(&mrt_lock);
1426
1427                         if (copy_to_user(arg, &sr, sizeof(sr)))
1428                                 return -EFAULT;
1429                         return 0;
1430                 }
1431                 read_unlock(&mrt_lock);
1432                 return -EADDRNOTAVAIL;
1433         default:
1434                 return -ENOIOCTLCMD;
1435         }
1436 }
1437
1438
1439 static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
1440 {
1441         struct net_device *dev = ptr;
1442         struct net *net = dev_net(dev);
1443         struct mr_table *mrt;
1444         struct vif_device *v;
1445         int ct;
1446         LIST_HEAD(list);
1447
1448         if (event != NETDEV_UNREGISTER)
1449                 return NOTIFY_DONE;
1450
1451         ipmr_for_each_table(mrt, net) {
1452                 v = &mrt->vif_table[0];
1453                 for (ct = 0; ct < mrt->maxvif; ct++, v++) {
1454                         if (v->dev == dev)
1455                                 vif_delete(mrt, ct, 1, &list);
1456                 }
1457         }
1458         unregister_netdevice_many(&list);
1459         return NOTIFY_DONE;
1460 }
1461
1462
1463 static struct notifier_block ip_mr_notifier = {
1464         .notifier_call = ipmr_device_event,
1465 };
1466
1467 /*
1468  *      Encapsulate a packet by attaching a valid IPIP header to it.
1469  *      This avoids tunnel drivers and other mess and gives us the speed so
1470  *      important for multicast video.
1471  */
1472
1473 static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
1474 {
1475         struct iphdr *iph;
1476         struct iphdr *old_iph = ip_hdr(skb);
1477
1478         skb_push(skb, sizeof(struct iphdr));
1479         skb->transport_header = skb->network_header;
1480         skb_reset_network_header(skb);
1481         iph = ip_hdr(skb);
1482
1483         iph->version    =       4;
1484         iph->tos        =       old_iph->tos;
1485         iph->ttl        =       old_iph->ttl;
1486         iph->frag_off   =       0;
1487         iph->daddr      =       daddr;
1488         iph->saddr      =       saddr;
1489         iph->protocol   =       IPPROTO_IPIP;
1490         iph->ihl        =       5;
1491         iph->tot_len    =       htons(skb->len);
1492         ip_select_ident(iph, skb_dst(skb), NULL);
1493         ip_send_check(iph);
1494
1495         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
1496         nf_reset(skb);
1497 }
1498
1499 static inline int ipmr_forward_finish(struct sk_buff *skb)
1500 {
1501         struct ip_options * opt = &(IPCB(skb)->opt);
1502
1503         IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
1504
1505         if (unlikely(opt->optlen))
1506                 ip_forward_options(skb);
1507
1508         return dst_output(skb);
1509 }
1510
1511 /*
1512  *      Processing handlers for ipmr_forward
1513  */
1514
1515 static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
1516                             struct sk_buff *skb, struct mfc_cache *c, int vifi)
1517 {
1518         const struct iphdr *iph = ip_hdr(skb);
1519         struct vif_device *vif = &mrt->vif_table[vifi];
1520         struct net_device *dev;
1521         struct rtable *rt;
1522         int    encap = 0;
1523
1524         if (vif->dev == NULL)
1525                 goto out_free;
1526
1527 #ifdef CONFIG_IP_PIMSM
1528         if (vif->flags & VIFF_REGISTER) {
1529                 vif->pkt_out++;
1530                 vif->bytes_out += skb->len;
1531                 vif->dev->stats.tx_bytes += skb->len;
1532                 vif->dev->stats.tx_packets++;
1533                 ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
1534                 goto out_free;
1535         }
1536 #endif
1537
1538         if (vif->flags&VIFF_TUNNEL) {
1539                 struct flowi fl = { .oif = vif->link,
1540                                     .nl_u = { .ip4_u =
1541                                               { .daddr = vif->remote,
1542                                                 .saddr = vif->local,
1543                                                 .tos = RT_TOS(iph->tos) } },
1544                                     .proto = IPPROTO_IPIP };
1545                 if (ip_route_output_key(net, &rt, &fl))
1546                         goto out_free;
1547                 encap = sizeof(struct iphdr);
1548         } else {
1549                 struct flowi fl = { .oif = vif->link,
1550                                     .nl_u = { .ip4_u =
1551                                               { .daddr = iph->daddr,
1552                                                 .tos = RT_TOS(iph->tos) } },
1553                                     .proto = IPPROTO_IPIP };
1554                 if (ip_route_output_key(net, &rt, &fl))
1555                         goto out_free;
1556         }
1557
1558         dev = rt->u.dst.dev;
1559
1560         if (skb->len+encap > dst_mtu(&rt->u.dst) && (ntohs(iph->frag_off) & IP_DF)) {
1561                 /* Do not fragment multicasts. Alas, IPv4 does not
1562                    allow to send ICMP, so that packets will disappear
1563                    to blackhole.
1564                  */
1565
1566                 IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
1567                 ip_rt_put(rt);
1568                 goto out_free;
1569         }
1570
1571         encap += LL_RESERVED_SPACE(dev) + rt->u.dst.header_len;
1572
1573         if (skb_cow(skb, encap)) {
1574                 ip_rt_put(rt);
1575                 goto out_free;
1576         }
1577
1578         vif->pkt_out++;
1579         vif->bytes_out += skb->len;
1580
1581         skb_dst_drop(skb);
1582         skb_dst_set(skb, &rt->u.dst);
1583         ip_decrease_ttl(ip_hdr(skb));
1584
1585         /* FIXME: forward and output firewalls used to be called here.
1586          * What do we do with netfilter? -- RR */
1587         if (vif->flags & VIFF_TUNNEL) {
1588                 ip_encap(skb, vif->local, vif->remote);
1589                 /* FIXME: extra output firewall step used to be here. --RR */
1590                 vif->dev->stats.tx_packets++;
1591                 vif->dev->stats.tx_bytes += skb->len;
1592         }
1593
1594         IPCB(skb)->flags |= IPSKB_FORWARDED;
1595
1596         /*
1597          * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
1598          * not only before forwarding, but after forwarding on all output
1599          * interfaces. It is clear, if mrouter runs a multicasting
1600          * program, it should receive packets not depending to what interface
1601          * program is joined.
1602          * If we will not make it, the program will have to join on all
1603          * interfaces. On the other hand, multihoming host (or router, but
1604          * not mrouter) cannot join to more than one interface - it will
1605          * result in receiving multiple packets.
1606          */
1607         NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
1608                 ipmr_forward_finish);
1609         return;
1610
1611 out_free:
1612         kfree_skb(skb);
1613 }
1614
1615 static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
1616 {
1617         int ct;
1618
1619         for (ct = mrt->maxvif-1; ct >= 0; ct--) {
1620                 if (mrt->vif_table[ct].dev == dev)
1621                         break;
1622         }
1623         return ct;
1624 }
1625
1626 /* "local" means that we should preserve one skb (for local delivery) */
1627
1628 static int ip_mr_forward(struct net *net, struct mr_table *mrt,
1629                          struct sk_buff *skb, struct mfc_cache *cache,
1630                          int local)
1631 {
1632         int psend = -1;
1633         int vif, ct;
1634
1635         vif = cache->mfc_parent;
1636         cache->mfc_un.res.pkt++;
1637         cache->mfc_un.res.bytes += skb->len;
1638
1639         /*
1640          * Wrong interface: drop packet and (maybe) send PIM assert.
1641          */
1642         if (mrt->vif_table[vif].dev != skb->dev) {
1643                 int true_vifi;
1644
1645                 if (skb_rtable(skb)->fl.iif == 0) {
1646                         /* It is our own packet, looped back.
1647                            Very complicated situation...
1648
1649                            The best workaround until routing daemons will be
1650                            fixed is not to redistribute packet, if it was
1651                            send through wrong interface. It means, that
1652                            multicast applications WILL NOT work for
1653                            (S,G), which have default multicast route pointing
1654                            to wrong oif. In any case, it is not a good
1655                            idea to use multicasting applications on router.
1656                          */
1657                         goto dont_forward;
1658                 }
1659
1660                 cache->mfc_un.res.wrong_if++;
1661                 true_vifi = ipmr_find_vif(mrt, skb->dev);
1662
1663                 if (true_vifi >= 0 && mrt->mroute_do_assert &&
1664                     /* pimsm uses asserts, when switching from RPT to SPT,
1665                        so that we cannot check that packet arrived on an oif.
1666                        It is bad, but otherwise we would need to move pretty
1667                        large chunk of pimd to kernel. Ough... --ANK
1668                      */
1669                     (mrt->mroute_do_pim ||
1670                      cache->mfc_un.res.ttls[true_vifi] < 255) &&
1671                     time_after(jiffies,
1672                                cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
1673                         cache->mfc_un.res.last_assert = jiffies;
1674                         ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
1675                 }
1676                 goto dont_forward;
1677         }
1678
1679         mrt->vif_table[vif].pkt_in++;
1680         mrt->vif_table[vif].bytes_in += skb->len;
1681
1682         /*
1683          *      Forward the frame
1684          */
1685         for (ct = cache->mfc_un.res.maxvif-1; ct >= cache->mfc_un.res.minvif; ct--) {
1686                 if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
1687                         if (psend != -1) {
1688                                 struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1689                                 if (skb2)
1690                                         ipmr_queue_xmit(net, mrt, skb2, cache,
1691                                                         psend);
1692                         }
1693                         psend = ct;
1694                 }
1695         }
1696         if (psend != -1) {
1697                 if (local) {
1698                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1699                         if (skb2)
1700                                 ipmr_queue_xmit(net, mrt, skb2, cache, psend);
1701                 } else {
1702                         ipmr_queue_xmit(net, mrt, skb, cache, psend);
1703                         return 0;
1704                 }
1705         }
1706
1707 dont_forward:
1708         if (!local)
1709                 kfree_skb(skb);
1710         return 0;
1711 }
1712
1713
1714 /*
1715  *      Multicast packets for forwarding arrive here
1716  */
1717
1718 int ip_mr_input(struct sk_buff *skb)
1719 {
1720         struct mfc_cache *cache;
1721         struct net *net = dev_net(skb->dev);
1722         int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
1723         struct mr_table *mrt;
1724         int err;
1725
1726         /* Packet is looped back after forward, it should not be
1727            forwarded second time, but still can be delivered locally.
1728          */
1729         if (IPCB(skb)->flags&IPSKB_FORWARDED)
1730                 goto dont_forward;
1731
1732         err = ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt);
1733         if (err < 0) {
1734                 kfree_skb(skb);
1735                 return err;
1736         }
1737
1738         if (!local) {
1739                     if (IPCB(skb)->opt.router_alert) {
1740                             if (ip_call_ra_chain(skb))
1741                                     return 0;
1742                     } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP){
1743                             /* IGMPv1 (and broken IGMPv2 implementations sort of
1744                                Cisco IOS <= 11.2(8)) do not put router alert
1745                                option to IGMP packets destined to routable
1746                                groups. It is very bad, because it means
1747                                that we can forward NO IGMP messages.
1748                              */
1749                             read_lock(&mrt_lock);
1750                             if (mrt->mroute_sk) {
1751                                     nf_reset(skb);
1752                                     raw_rcv(mrt->mroute_sk, skb);
1753                                     read_unlock(&mrt_lock);
1754                                     return 0;
1755                             }
1756                             read_unlock(&mrt_lock);
1757                     }
1758         }
1759
1760         read_lock(&mrt_lock);
1761         cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
1762
1763         /*
1764          *      No usable cache entry
1765          */
1766         if (cache == NULL) {
1767                 int vif;
1768
1769                 if (local) {
1770                         struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
1771                         ip_local_deliver(skb);
1772                         if (skb2 == NULL) {
1773                                 read_unlock(&mrt_lock);
1774                                 return -ENOBUFS;
1775                         }
1776                         skb = skb2;
1777                 }
1778
1779                 vif = ipmr_find_vif(mrt, skb->dev);
1780                 if (vif >= 0) {
1781                         int err2 = ipmr_cache_unresolved(mrt, vif, skb);
1782                         read_unlock(&mrt_lock);
1783
1784                         return err2;
1785                 }
1786                 read_unlock(&mrt_lock);
1787                 kfree_skb(skb);
1788                 return -ENODEV;
1789         }
1790
1791         ip_mr_forward(net, mrt, skb, cache, local);
1792
1793         read_unlock(&mrt_lock);
1794
1795         if (local)
1796                 return ip_local_deliver(skb);
1797
1798         return 0;
1799
1800 dont_forward:
1801         if (local)
1802                 return ip_local_deliver(skb);
1803         kfree_skb(skb);
1804         return 0;
1805 }
1806
1807 #ifdef CONFIG_IP_PIMSM
1808 static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
1809                      unsigned int pimlen)
1810 {
1811         struct net_device *reg_dev = NULL;
1812         struct iphdr *encap;
1813
1814         encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
1815         /*
1816            Check that:
1817            a. packet is really destinted to a multicast group
1818            b. packet is not a NULL-REGISTER
1819            c. packet is not truncated
1820          */
1821         if (!ipv4_is_multicast(encap->daddr) ||
1822             encap->tot_len == 0 ||
1823             ntohs(encap->tot_len) + pimlen > skb->len)
1824                 return 1;
1825
1826         read_lock(&mrt_lock);
1827         if (mrt->mroute_reg_vif_num >= 0)
1828                 reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
1829         if (reg_dev)
1830                 dev_hold(reg_dev);
1831         read_unlock(&mrt_lock);
1832
1833         if (reg_dev == NULL)
1834                 return 1;
1835
1836         skb->mac_header = skb->network_header;
1837         skb_pull(skb, (u8*)encap - skb->data);
1838         skb_reset_network_header(skb);
1839         skb->protocol = htons(ETH_P_IP);
1840         skb->ip_summed = 0;
1841         skb->pkt_type = PACKET_HOST;
1842
1843         skb_tunnel_rx(skb, reg_dev);
1844
1845         netif_rx(skb);
1846         dev_put(reg_dev);
1847
1848         return 0;
1849 }
1850 #endif
1851
1852 #ifdef CONFIG_IP_PIMSM_V1
1853 /*
1854  * Handle IGMP messages of PIMv1
1855  */
1856
1857 int pim_rcv_v1(struct sk_buff * skb)
1858 {
1859         struct igmphdr *pim;
1860         struct net *net = dev_net(skb->dev);
1861         struct mr_table *mrt;
1862
1863         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1864                 goto drop;
1865
1866         pim = igmp_hdr(skb);
1867
1868         if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
1869                 goto drop;
1870
1871         if (!mrt->mroute_do_pim ||
1872             pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
1873                 goto drop;
1874
1875         if (__pim_rcv(mrt, skb, sizeof(*pim))) {
1876 drop:
1877                 kfree_skb(skb);
1878         }
1879         return 0;
1880 }
1881 #endif
1882
1883 #ifdef CONFIG_IP_PIMSM_V2
1884 static int pim_rcv(struct sk_buff * skb)
1885 {
1886         struct pimreghdr *pim;
1887         struct net *net = dev_net(skb->dev);
1888         struct mr_table *mrt;
1889
1890         if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
1891                 goto drop;
1892
1893         pim = (struct pimreghdr *)skb_transport_header(skb);
1894         if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
1895             (pim->flags&PIM_NULL_REGISTER) ||
1896             (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
1897              csum_fold(skb_checksum(skb, 0, skb->len, 0))))
1898                 goto drop;
1899
1900         if (ipmr_fib_lookup(net, &skb_rtable(skb)->fl, &mrt) < 0)
1901                 goto drop;
1902
1903         if (__pim_rcv(mrt, skb, sizeof(*pim))) {
1904 drop:
1905                 kfree_skb(skb);
1906         }
1907         return 0;
1908 }
1909 #endif
1910
1911 static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
1912                               struct mfc_cache *c, struct rtmsg *rtm)
1913 {
1914         int ct;
1915         struct rtnexthop *nhp;
1916         u8 *b = skb_tail_pointer(skb);
1917         struct rtattr *mp_head;
1918
1919         /* If cache is unresolved, don't try to parse IIF and OIF */
1920         if (c->mfc_parent >= MAXVIFS)
1921                 return -ENOENT;
1922
1923         if (VIF_EXISTS(mrt, c->mfc_parent))
1924                 RTA_PUT(skb, RTA_IIF, 4, &mrt->vif_table[c->mfc_parent].dev->ifindex);
1925
1926         mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
1927
1928         for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
1929                 if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
1930                         if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
1931                                 goto rtattr_failure;
1932                         nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
1933                         nhp->rtnh_flags = 0;
1934                         nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
1935                         nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
1936                         nhp->rtnh_len = sizeof(*nhp);
1937                 }
1938         }
1939         mp_head->rta_type = RTA_MULTIPATH;
1940         mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
1941         rtm->rtm_type = RTN_MULTICAST;
1942         return 1;
1943
1944 rtattr_failure:
1945         nlmsg_trim(skb, b);
1946         return -EMSGSIZE;
1947 }
1948
1949 int ipmr_get_route(struct net *net,
1950                    struct sk_buff *skb, struct rtmsg *rtm, int nowait)
1951 {
1952         int err;
1953         struct mr_table *mrt;
1954         struct mfc_cache *cache;
1955         struct rtable *rt = skb_rtable(skb);
1956
1957         mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
1958         if (mrt == NULL)
1959                 return -ENOENT;
1960
1961         read_lock(&mrt_lock);
1962         cache = ipmr_cache_find(mrt, rt->rt_src, rt->rt_dst);
1963
1964         if (cache == NULL) {
1965                 struct sk_buff *skb2;
1966                 struct iphdr *iph;
1967                 struct net_device *dev;
1968                 int vif;
1969
1970                 if (nowait) {
1971                         read_unlock(&mrt_lock);
1972                         return -EAGAIN;
1973                 }
1974
1975                 dev = skb->dev;
1976                 if (dev == NULL || (vif = ipmr_find_vif(mrt, dev)) < 0) {
1977                         read_unlock(&mrt_lock);
1978                         return -ENODEV;
1979                 }
1980                 skb2 = skb_clone(skb, GFP_ATOMIC);
1981                 if (!skb2) {
1982                         read_unlock(&mrt_lock);
1983                         return -ENOMEM;
1984                 }
1985
1986                 skb_push(skb2, sizeof(struct iphdr));
1987                 skb_reset_network_header(skb2);
1988                 iph = ip_hdr(skb2);
1989                 iph->ihl = sizeof(struct iphdr) >> 2;
1990                 iph->saddr = rt->rt_src;
1991                 iph->daddr = rt->rt_dst;
1992                 iph->version = 0;
1993                 err = ipmr_cache_unresolved(mrt, vif, skb2);
1994                 read_unlock(&mrt_lock);
1995                 return err;
1996         }
1997
1998         if (!nowait && (rtm->rtm_flags&RTM_F_NOTIFY))
1999                 cache->mfc_flags |= MFC_NOTIFY;
2000         err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
2001         read_unlock(&mrt_lock);
2002         return err;
2003 }
2004
2005 static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
2006                             u32 pid, u32 seq, struct mfc_cache *c)
2007 {
2008         struct nlmsghdr *nlh;
2009         struct rtmsg *rtm;
2010
2011         nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
2012         if (nlh == NULL)
2013                 return -EMSGSIZE;
2014
2015         rtm = nlmsg_data(nlh);
2016         rtm->rtm_family   = RTNL_FAMILY_IPMR;
2017         rtm->rtm_dst_len  = 32;
2018         rtm->rtm_src_len  = 32;
2019         rtm->rtm_tos      = 0;
2020         rtm->rtm_table    = mrt->id;
2021         NLA_PUT_U32(skb, RTA_TABLE, mrt->id);
2022         rtm->rtm_type     = RTN_MULTICAST;
2023         rtm->rtm_scope    = RT_SCOPE_UNIVERSE;
2024         rtm->rtm_protocol = RTPROT_UNSPEC;
2025         rtm->rtm_flags    = 0;
2026
2027         NLA_PUT_BE32(skb, RTA_SRC, c->mfc_origin);
2028         NLA_PUT_BE32(skb, RTA_DST, c->mfc_mcastgrp);
2029
2030         if (__ipmr_fill_mroute(mrt, skb, c, rtm) < 0)
2031                 goto nla_put_failure;
2032
2033         return nlmsg_end(skb, nlh);
2034
2035 nla_put_failure:
2036         nlmsg_cancel(skb, nlh);
2037         return -EMSGSIZE;
2038 }
2039
2040 static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
2041 {
2042         struct net *net = sock_net(skb->sk);
2043         struct mr_table *mrt;
2044         struct mfc_cache *mfc;
2045         unsigned int t = 0, s_t;
2046         unsigned int h = 0, s_h;
2047         unsigned int e = 0, s_e;
2048
2049         s_t = cb->args[0];
2050         s_h = cb->args[1];
2051         s_e = cb->args[2];
2052
2053         read_lock(&mrt_lock);
2054         ipmr_for_each_table(mrt, net) {
2055                 if (t < s_t)
2056                         goto next_table;
2057                 if (t > s_t)
2058                         s_h = 0;
2059                 for (h = s_h; h < MFC_LINES; h++) {
2060                         list_for_each_entry(mfc, &mrt->mfc_cache_array[h], list) {
2061                                 if (e < s_e)
2062                                         goto next_entry;
2063                                 if (ipmr_fill_mroute(mrt, skb,
2064                                                      NETLINK_CB(cb->skb).pid,
2065                                                      cb->nlh->nlmsg_seq,
2066                                                      mfc) < 0)
2067                                         goto done;
2068 next_entry:
2069                                 e++;
2070                         }
2071                         e = s_e = 0;
2072                 }
2073                 s_h = 0;
2074 next_table:
2075                 t++;
2076         }
2077 done:
2078         read_unlock(&mrt_lock);
2079
2080         cb->args[2] = e;
2081         cb->args[1] = h;
2082         cb->args[0] = t;
2083
2084         return skb->len;
2085 }
2086
2087 #ifdef CONFIG_PROC_FS
2088 /*
2089  *      The /proc interfaces to multicast routing /proc/ip_mr_cache /proc/ip_mr_vif
2090  */
2091 struct ipmr_vif_iter {
2092         struct seq_net_private p;
2093         struct mr_table *mrt;
2094         int ct;
2095 };
2096
2097 static struct vif_device *ipmr_vif_seq_idx(struct net *net,
2098                                            struct ipmr_vif_iter *iter,
2099                                            loff_t pos)
2100 {
2101         struct mr_table *mrt = iter->mrt;
2102
2103         for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
2104                 if (!VIF_EXISTS(mrt, iter->ct))
2105                         continue;
2106                 if (pos-- == 0)
2107                         return &mrt->vif_table[iter->ct];
2108         }
2109         return NULL;
2110 }
2111
2112 static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
2113         __acquires(mrt_lock)
2114 {
2115         struct ipmr_vif_iter *iter = seq->private;
2116         struct net *net = seq_file_net(seq);
2117         struct mr_table *mrt;
2118
2119         mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2120         if (mrt == NULL)
2121                 return ERR_PTR(-ENOENT);
2122
2123         iter->mrt = mrt;
2124
2125         read_lock(&mrt_lock);
2126         return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
2127                 : SEQ_START_TOKEN;
2128 }
2129
2130 static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2131 {
2132         struct ipmr_vif_iter *iter = seq->private;
2133         struct net *net = seq_file_net(seq);
2134         struct mr_table *mrt = iter->mrt;
2135
2136         ++*pos;
2137         if (v == SEQ_START_TOKEN)
2138                 return ipmr_vif_seq_idx(net, iter, 0);
2139
2140         while (++iter->ct < mrt->maxvif) {
2141                 if (!VIF_EXISTS(mrt, iter->ct))
2142                         continue;
2143                 return &mrt->vif_table[iter->ct];
2144         }
2145         return NULL;
2146 }
2147
2148 static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
2149         __releases(mrt_lock)
2150 {
2151         read_unlock(&mrt_lock);
2152 }
2153
2154 static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
2155 {
2156         struct ipmr_vif_iter *iter = seq->private;
2157         struct mr_table *mrt = iter->mrt;
2158
2159         if (v == SEQ_START_TOKEN) {
2160                 seq_puts(seq,
2161                          "Interface      BytesIn  PktsIn  BytesOut PktsOut Flags Local    Remote\n");
2162         } else {
2163                 const struct vif_device *vif = v;
2164                 const char *name =  vif->dev ? vif->dev->name : "none";
2165
2166                 seq_printf(seq,
2167                            "%2Zd %-10s %8ld %7ld  %8ld %7ld %05X %08X %08X\n",
2168                            vif - mrt->vif_table,
2169                            name, vif->bytes_in, vif->pkt_in,
2170                            vif->bytes_out, vif->pkt_out,
2171                            vif->flags, vif->local, vif->remote);
2172         }
2173         return 0;
2174 }
2175
2176 static const struct seq_operations ipmr_vif_seq_ops = {
2177         .start = ipmr_vif_seq_start,
2178         .next  = ipmr_vif_seq_next,
2179         .stop  = ipmr_vif_seq_stop,
2180         .show  = ipmr_vif_seq_show,
2181 };
2182
2183 static int ipmr_vif_open(struct inode *inode, struct file *file)
2184 {
2185         return seq_open_net(inode, file, &ipmr_vif_seq_ops,
2186                             sizeof(struct ipmr_vif_iter));
2187 }
2188
2189 static const struct file_operations ipmr_vif_fops = {
2190         .owner   = THIS_MODULE,
2191         .open    = ipmr_vif_open,
2192         .read    = seq_read,
2193         .llseek  = seq_lseek,
2194         .release = seq_release_net,
2195 };
2196
2197 struct ipmr_mfc_iter {
2198         struct seq_net_private p;
2199         struct mr_table *mrt;
2200         struct list_head *cache;
2201         int ct;
2202 };
2203
2204
2205 static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
2206                                           struct ipmr_mfc_iter *it, loff_t pos)
2207 {
2208         struct mr_table *mrt = it->mrt;
2209         struct mfc_cache *mfc;
2210
2211         read_lock(&mrt_lock);
2212         for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
2213                 it->cache = &mrt->mfc_cache_array[it->ct];
2214                 list_for_each_entry(mfc, it->cache, list)
2215                         if (pos-- == 0)
2216                                 return mfc;
2217         }
2218         read_unlock(&mrt_lock);
2219
2220         spin_lock_bh(&mfc_unres_lock);
2221         it->cache = &mrt->mfc_unres_queue;
2222         list_for_each_entry(mfc, it->cache, list)
2223                 if (pos-- == 0)
2224                         return mfc;
2225         spin_unlock_bh(&mfc_unres_lock);
2226
2227         it->cache = NULL;
2228         return NULL;
2229 }
2230
2231
2232 static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
2233 {
2234         struct ipmr_mfc_iter *it = seq->private;
2235         struct net *net = seq_file_net(seq);
2236         struct mr_table *mrt;
2237
2238         mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
2239         if (mrt == NULL)
2240                 return ERR_PTR(-ENOENT);
2241
2242         it->mrt = mrt;
2243         it->cache = NULL;
2244         it->ct = 0;
2245         return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
2246                 : SEQ_START_TOKEN;
2247 }
2248
2249 static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2250 {
2251         struct mfc_cache *mfc = v;
2252         struct ipmr_mfc_iter *it = seq->private;
2253         struct net *net = seq_file_net(seq);
2254         struct mr_table *mrt = it->mrt;
2255
2256         ++*pos;
2257
2258         if (v == SEQ_START_TOKEN)
2259                 return ipmr_mfc_seq_idx(net, seq->private, 0);
2260
2261         if (mfc->list.next != it->cache)
2262                 return list_entry(mfc->list.next, struct mfc_cache, list);
2263
2264         if (it->cache == &mrt->mfc_unres_queue)
2265                 goto end_of_list;
2266
2267         BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
2268
2269         while (++it->ct < MFC_LINES) {
2270                 it->cache = &mrt->mfc_cache_array[it->ct];
2271                 if (list_empty(it->cache))
2272                         continue;
2273                 return list_first_entry(it->cache, struct mfc_cache, list);
2274         }
2275
2276         /* exhausted cache_array, show unresolved */
2277         read_unlock(&mrt_lock);
2278         it->cache = &mrt->mfc_unres_queue;
2279         it->ct = 0;
2280
2281         spin_lock_bh(&mfc_unres_lock);
2282         if (!list_empty(it->cache))
2283                 return list_first_entry(it->cache, struct mfc_cache, list);
2284
2285  end_of_list:
2286         spin_unlock_bh(&mfc_unres_lock);
2287         it->cache = NULL;
2288
2289         return NULL;
2290 }
2291
2292 static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
2293 {
2294         struct ipmr_mfc_iter *it = seq->private;
2295         struct mr_table *mrt = it->mrt;
2296
2297         if (it->cache == &mrt->mfc_unres_queue)
2298                 spin_unlock_bh(&mfc_unres_lock);
2299         else if (it->cache == &mrt->mfc_cache_array[it->ct])
2300                 read_unlock(&mrt_lock);
2301 }
2302
2303 static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
2304 {
2305         int n;
2306
2307         if (v == SEQ_START_TOKEN) {
2308                 seq_puts(seq,
2309                  "Group    Origin   Iif     Pkts    Bytes    Wrong Oifs\n");
2310         } else {
2311                 const struct mfc_cache *mfc = v;
2312                 const struct ipmr_mfc_iter *it = seq->private;
2313                 const struct mr_table *mrt = it->mrt;
2314
2315                 seq_printf(seq, "%08X %08X %-3hd",
2316                            (__force u32) mfc->mfc_mcastgrp,
2317                            (__force u32) mfc->mfc_origin,
2318                            mfc->mfc_parent);
2319
2320                 if (it->cache != &mrt->mfc_unres_queue) {
2321                         seq_printf(seq, " %8lu %8lu %8lu",
2322                                    mfc->mfc_un.res.pkt,
2323                                    mfc->mfc_un.res.bytes,
2324                                    mfc->mfc_un.res.wrong_if);
2325                         for (n = mfc->mfc_un.res.minvif;
2326                              n < mfc->mfc_un.res.maxvif; n++ ) {
2327                                 if (VIF_EXISTS(mrt, n) &&
2328                                     mfc->mfc_un.res.ttls[n] < 255)
2329                                         seq_printf(seq,
2330                                            " %2d:%-3d",
2331                                            n, mfc->mfc_un.res.ttls[n]);
2332                         }
2333                 } else {
2334                         /* unresolved mfc_caches don't contain
2335                          * pkt, bytes and wrong_if values
2336                          */
2337                         seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
2338                 }
2339                 seq_putc(seq, '\n');
2340         }
2341         return 0;
2342 }
2343
2344 static const struct seq_operations ipmr_mfc_seq_ops = {
2345         .start = ipmr_mfc_seq_start,
2346         .next  = ipmr_mfc_seq_next,
2347         .stop  = ipmr_mfc_seq_stop,
2348         .show  = ipmr_mfc_seq_show,
2349 };
2350
2351 static int ipmr_mfc_open(struct inode *inode, struct file *file)
2352 {
2353         return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
2354                             sizeof(struct ipmr_mfc_iter));
2355 }
2356
2357 static const struct file_operations ipmr_mfc_fops = {
2358         .owner   = THIS_MODULE,
2359         .open    = ipmr_mfc_open,
2360         .read    = seq_read,
2361         .llseek  = seq_lseek,
2362         .release = seq_release_net,
2363 };
2364 #endif
2365
2366 #ifdef CONFIG_IP_PIMSM_V2
2367 static const struct net_protocol pim_protocol = {
2368         .handler        =       pim_rcv,
2369         .netns_ok       =       1,
2370 };
2371 #endif
2372
2373
2374 /*
2375  *      Setup for IP multicast routing
2376  */
2377 static int __net_init ipmr_net_init(struct net *net)
2378 {
2379         int err;
2380
2381         err = ipmr_rules_init(net);
2382         if (err < 0)
2383                 goto fail;
2384
2385 #ifdef CONFIG_PROC_FS
2386         err = -ENOMEM;
2387         if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
2388                 goto proc_vif_fail;
2389         if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
2390                 goto proc_cache_fail;
2391 #endif
2392         return 0;
2393
2394 #ifdef CONFIG_PROC_FS
2395 proc_cache_fail:
2396         proc_net_remove(net, "ip_mr_vif");
2397 proc_vif_fail:
2398         ipmr_rules_exit(net);
2399 #endif
2400 fail:
2401         return err;
2402 }
2403
2404 static void __net_exit ipmr_net_exit(struct net *net)
2405 {
2406 #ifdef CONFIG_PROC_FS
2407         proc_net_remove(net, "ip_mr_cache");
2408         proc_net_remove(net, "ip_mr_vif");
2409 #endif
2410         ipmr_rules_exit(net);
2411 }
2412
2413 static struct pernet_operations ipmr_net_ops = {
2414         .init = ipmr_net_init,
2415         .exit = ipmr_net_exit,
2416 };
2417
2418 int __init ip_mr_init(void)
2419 {
2420         int err;
2421
2422         mrt_cachep = kmem_cache_create("ip_mrt_cache",
2423                                        sizeof(struct mfc_cache),
2424                                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
2425                                        NULL);
2426         if (!mrt_cachep)
2427                 return -ENOMEM;
2428
2429         err = register_pernet_subsys(&ipmr_net_ops);
2430         if (err)
2431                 goto reg_pernet_fail;
2432
2433         err = register_netdevice_notifier(&ip_mr_notifier);
2434         if (err)
2435                 goto reg_notif_fail;
2436 #ifdef CONFIG_IP_PIMSM_V2
2437         if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
2438                 printk(KERN_ERR "ip_mr_init: can't add PIM protocol\n");
2439                 err = -EAGAIN;
2440                 goto add_proto_fail;
2441         }
2442 #endif
2443         rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE, NULL, ipmr_rtm_dumproute);
2444         return 0;
2445
2446 #ifdef CONFIG_IP_PIMSM_V2
2447 add_proto_fail:
2448         unregister_netdevice_notifier(&ip_mr_notifier);
2449 #endif
2450 reg_notif_fail:
2451         unregister_pernet_subsys(&ipmr_net_ops);
2452 reg_pernet_fail:
2453         kmem_cache_destroy(mrt_cachep);
2454         return err;
2455 }