net/ipv4/igmp.c

   1 /*
   2  *      Linux NET3:     Internet Group Management Protocol  [IGMP]
   3  *
   4  *      This code implements the IGMP protocol as defined in RFC1112. There has
   5  *      been a further revision of this protocol since which is now supported.
   6  *
   7  *      If you have trouble with this module be careful what gcc you have used,
   8  *      the older version didn't come out right using gcc 2.5.8, the newer one
   9  *      seems to fall out with gcc 2.6.2.
  10  *
  11  *      Authors:
  12  *              Alan Cox <alan@lxorguk.ukuu.org.uk>
  13  *
  14  *      This program is free software; you can redistribute it and/or
  15  *      modify it under the terms of the GNU General Public License
  16  *      as published by the Free Software Foundation; either version
  17  *      2 of the License, or (at your option) any later version.
  18  *
  19  *      Fixes:
  20  *
  21  *              Alan Cox        :       Added lots of __inline__ to optimise
  22  *                                      the memory usage of all the tiny little
  23  *                                      functions.
  24  *              Alan Cox        :       Dumped the header building experiment.
  25  *              Alan Cox        :       Minor tweaks ready for multicast routing
  26  *                                      and extended IGMP protocol.
  27  *              Alan Cox        :       Removed a load of inline directives. Gcc 2.5.8
  28  *                                      writes utterly bogus code otherwise (sigh)
  29  *                                      fixed IGMP loopback to behave in the manner
  30  *                                      desired by mrouted, fixed the fact it has been
  31  *                                      broken since 1.3.6 and cleaned up a few minor
  32  *                                      points.
  33  *
  34  *              Chih-Jen Chang  :       Tried to revise IGMP to Version 2
  35  *              Tsu-Sheng Tsao          E-mail: chihjenc@scf.usc.edu and tsusheng@scf.usc.edu
  36  *                                      The enhancements are mainly based on Steve Deering's
  37  *                                      ipmulti-3.5 source code.
  38  *              Chih-Jen Chang  :       Added the igmp_get_mrouter_info and
  39  *              Tsu-Sheng Tsao          igmp_set_mrouter_info to keep track of
  40  *                                      the mrouted version on that device.
  41  *              Chih-Jen Chang  :       Added the max_resp_time parameter to
  42  *              Tsu-Sheng Tsao          igmp_heard_query(). Using this parameter
  43  *                                      to identify the multicast router version
  44  *                                      and do what the IGMP version 2 specified.
  45  *              Chih-Jen Chang  :       Added a timer to revert to IGMP V2 router
  46  *              Tsu-Sheng Tsao          if the specified time expired.
  47  *              Alan Cox        :       Stop IGMP from 0.0.0.0 being accepted.
  48  *              Alan Cox        :       Use GFP_ATOMIC in the right places.
  49  *              Christian Daudt :       igmp timer wasn't set for local group
  50  *                                      memberships but was being deleted,
  51  *                                      which caused a "del_timer() called
  52  *                                      from %p with timer not initialized\n"
  53  *                                      message (960131).
  54  *              Christian Daudt :       removed del_timer from
  55  *                                      igmp_timer_expire function (960205).
  56  *             Christian Daudt :       igmp_heard_report now only calls
  57  *                                     igmp_timer_expire if tm->running is
  58  *                                     true (960216).
  59  *              Malcolm Beattie :       ttl comparison wrong in igmp_rcv made
  60  *                                      igmp_heard_query never trigger. Expiry
  61  *                                      miscalculation fixed in igmp_heard_query
  62  *                                      and random() made to return unsigned to
  63  *                                      prevent negative expiry times.
  64  *              Alexey Kuznetsov:       Wrong group leaving behaviour, backport
  65  *                                      fix from pending 2.1.x patches.
  66  *              Alan Cox:               Forget to enable FDDI support earlier.
  67  *              Alexey Kuznetsov:       Fixed leaving groups on device down.
  68  *              Alexey Kuznetsov:       Accordance to igmp-v2-06 draft.
  69  *              David L Stevens:        IGMPv3 support, with help from
  70  *                                      Vinay Kulkarni
  71  */
  72
  73 #include <linux/module.h>
  74 #include <linux/slab.h>
  75 #include <asm/uaccess.h>
  76 #include <asm/system.h>
  77 #include <linux/types.h>
  78 #include <linux/kernel.h>
  79 #include <linux/jiffies.h>
  80 #include <linux/string.h>
  81 #include <linux/socket.h>
  82 #include <linux/sockios.h>
  83 #include <linux/in.h>
  84 #include <linux/inet.h>
  85 #include <linux/netdevice.h>
  86 #include <linux/skbuff.h>
  87 #include <linux/inetdevice.h>
  88 #include <linux/igmp.h>
  89 #include <linux/if_arp.h>
  90 #include <linux/rtnetlink.h>
  91 #include <linux/times.h>
  92
  93 #include <net/net_namespace.h>
  94 #include <net/arp.h>
  95 #include <net/ip.h>
  96 #include <net/protocol.h>
  97 #include <net/route.h>
  98 #include <net/sock.h>
  99 #include <net/checksum.h>
 100 #include <linux/netfilter_ipv4.h>
 101 #ifdef CONFIG_IP_MROUTE
 102 #include <linux/mroute.h>
 103 #endif
 104 #ifdef CONFIG_PROC_FS
 105 #include <linux/proc_fs.h>
 106 #include <linux/seq_file.h>
 107 #endif
 108
 109 #define IP_MAX_MEMBERSHIPS      20
 110 #define IP_MAX_MSF              10
 111
 112 #ifdef CONFIG_IP_MULTICAST
 113 /* Parameter names and values are taken from igmp-v2-06 draft */
 114
 115 #define IGMP_V1_Router_Present_Timeout          (400*HZ)
 116 #define IGMP_V2_Router_Present_Timeout          (400*HZ)
 117 #define IGMP_Unsolicited_Report_Interval        (10*HZ)
 118 #define IGMP_Query_Response_Interval            (10*HZ)
 119 #define IGMP_Unsolicited_Report_Count           2
 120
 121
 122 #define IGMP_Initial_Report_Delay               (1)
 123
 124 /* IGMP_Initial_Report_Delay is not from IGMP specs!
 125  * IGMP specs require to report membership immediately after
 126  * joining a group, but we delay the first report by a
 127  * small interval. It seems more natural and still does not
 128  * contradict to specs provided this delay is small enough.
 129  */
 130
 131 #define IGMP_V1_SEEN(in_dev) \
 132         (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \
 133          IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \
 134          ((in_dev)->mr_v1_seen && \
 135           time_before(jiffies, (in_dev)->mr_v1_seen)))
 136 #define IGMP_V2_SEEN(in_dev) \
 137         (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \
 138          IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \
 139          ((in_dev)->mr_v2_seen && \
 140           time_before(jiffies, (in_dev)->mr_v2_seen)))
 141
 142 static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im);
 143 static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr);
 144 static void igmpv3_clear_delrec(struct in_device *in_dev);
 145 static int sf_setstate(struct ip_mc_list *pmc);
 146 static void sf_markstate(struct ip_mc_list *pmc);
 147 #endif
 148 static void ip_mc_clear_src(struct ip_mc_list *pmc);
 149 static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
 150                          int sfcount, __be32 *psfsrc, int delta);
 151
 152
 153 static void ip_mc_list_reclaim(struct rcu_head *head)
 154 {
 155         kfree(container_of(head, struct ip_mc_list, rcu));
 156 }
 157
 158 static void ip_ma_put(struct ip_mc_list *im)
 159 {
 160         if (atomic_dec_and_test(&im->refcnt)) {
 161                 in_dev_put(im->interface);
 162                 call_rcu(&im->rcu, ip_mc_list_reclaim);
 163         }
 164 }
 165
 166 #define for_each_pmc_rcu(in_dev, pmc)                           \
 167         for (pmc = rcu_dereference(in_dev->mc_list);            \
 168              pmc != NULL;                                       \
 169              pmc = rcu_dereference(pmc->next_rcu))
 170
 171 #define for_each_pmc_rtnl(in_dev, pmc)                          \
 172         for (pmc = rtnl_dereference(in_dev->mc_list);           \
 173              pmc != NULL;                                       \
 174              pmc = rtnl_dereference(pmc->next_rcu))
 175
 176 #ifdef CONFIG_IP_MULTICAST
 177
 178 /*
 179  *      Timer management
 180  */
 181
 182 static void igmp_stop_timer(struct ip_mc_list *im)
 183 {
 184         spin_lock_bh(&im->lock);
 185         if (del_timer(&im->timer))
 186                 atomic_dec(&im->refcnt);
 187         im->tm_running = 0;
 188         im->reporter = 0;
 189         im->unsolicit_count = 0;
 190         spin_unlock_bh(&im->lock);
 191 }
 192
 193 /* It must be called with locked im->lock */
 194 static void igmp_start_timer(struct ip_mc_list *im, int max_delay)
 195 {
 196         int tv = net_random() % max_delay;
 197
 198         im->tm_running = 1;
 199         if (!mod_timer(&im->timer, jiffies+tv+2))
 200                 atomic_inc(&im->refcnt);
 201 }
 202
 203 static void igmp_gq_start_timer(struct in_device *in_dev)
 204 {
 205         int tv = net_random() % in_dev->mr_maxdelay;
 206
 207         in_dev->mr_gq_running = 1;
 208         if (!mod_timer(&in_dev->mr_gq_timer, jiffies+tv+2))
 209                 in_dev_hold(in_dev);
 210 }
 211
 212 static void igmp_ifc_start_timer(struct in_device *in_dev, int delay)
 213 {
 214         int tv = net_random() % delay;
 215
 216         if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2))
 217                 in_dev_hold(in_dev);
 218 }
 219
 220 static void igmp_mod_timer(struct ip_mc_list *im, int max_delay)
 221 {
 222         spin_lock_bh(&im->lock);
 223         im->unsolicit_count = 0;
 224         if (del_timer(&im->timer)) {
 225                 if ((long)(im->timer.expires-jiffies) < max_delay) {
 226                         add_timer(&im->timer);
 227                         im->tm_running = 1;
 228                         spin_unlock_bh(&im->lock);
 229                         return;
 230                 }
 231                 atomic_dec(&im->refcnt);
 232         }
 233         igmp_start_timer(im, max_delay);
 234         spin_unlock_bh(&im->lock);
 235 }
 236
 237
 238 /*
 239  *      Send an IGMP report.
 240  */
 241
 242 #define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4)
 243
 244
 245 static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type,
 246         int gdeleted, int sdeleted)
 247 {
 248         switch (type) {
 249         case IGMPV3_MODE_IS_INCLUDE:
 250         case IGMPV3_MODE_IS_EXCLUDE:
 251                 if (gdeleted || sdeleted)
 252                         return 0;
 253                 if (!(pmc->gsquery && !psf->sf_gsresp)) {
 254                         if (pmc->sfmode == MCAST_INCLUDE)
 255                                 return 1;
 256                         /* don't include if this source is excluded
 257                          * in all filters
 258                          */
 259                         if (psf->sf_count[MCAST_INCLUDE])
 260                                 return type == IGMPV3_MODE_IS_INCLUDE;
 261                         return pmc->sfcount[MCAST_EXCLUDE] ==
 262                                 psf->sf_count[MCAST_EXCLUDE];
 263                 }
 264                 return 0;
 265         case IGMPV3_CHANGE_TO_INCLUDE:
 266                 if (gdeleted || sdeleted)
 267                         return 0;
 268                 return psf->sf_count[MCAST_INCLUDE] != 0;
 269         case IGMPV3_CHANGE_TO_EXCLUDE:
 270                 if (gdeleted || sdeleted)
 271                         return 0;
 272                 if (pmc->sfcount[MCAST_EXCLUDE] == 0 ||
 273                     psf->sf_count[MCAST_INCLUDE])
 274                         return 0;
 275                 return pmc->sfcount[MCAST_EXCLUDE] ==
 276                         psf->sf_count[MCAST_EXCLUDE];
 277         case IGMPV3_ALLOW_NEW_SOURCES:
 278                 if (gdeleted || !psf->sf_crcount)
 279                         return 0;
 280                 return (pmc->sfmode == MCAST_INCLUDE) ^ sdeleted;
 281         case IGMPV3_BLOCK_OLD_SOURCES:
 282                 if (pmc->sfmode == MCAST_INCLUDE)
 283                         return gdeleted || (psf->sf_crcount && sdeleted);
 284                 return psf->sf_crcount && !gdeleted && !sdeleted;
 285         }
 286         return 0;
 287 }
 288
 289 static int
 290 igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted)
 291 {
 292         struct ip_sf_list *psf;
 293         int scount = 0;
 294
 295         for (psf=pmc->sources; psf; psf=psf->sf_next) {
 296                 if (!is_in(pmc, psf, type, gdeleted, sdeleted))
 297                         continue;
 298                 scount++;
 299         }
 300         return scount;
 301 }
 302
 303 #define igmp_skb_size(skb) (*(unsigned int *)((skb)->cb))
 304
 305 static struct sk_buff *igmpv3_newpack(struct net_device *dev, int size)
 306 {
 307         struct sk_buff *skb;
 308         struct rtable *rt;
 309         struct iphdr *pip;
 310         struct igmpv3_report *pig;
 311         struct net *net = dev_net(dev);
 312
 313         while (1) {
 314                 skb = alloc_skb(size + LL_ALLOCATED_SPACE(dev),
 315                                 GFP_ATOMIC | __GFP_NOWARN);
 316                 if (skb)
 317                         break;
 318                 size >>= 1;
 319                 if (size < 256)
 320                         return NULL;
 321         }
 322         igmp_skb_size(skb) = size;
 323
 324         {
 325                 struct flowi fl = { .oif = dev->ifindex,
 326                                     .fl4_dst = IGMPV3_ALL_MCR,
 327                                     .proto = IPPROTO_IGMP };
 328                 rt = ip_route_output_key(net, &fl);
 329                 if (IS_ERR(rt)) {
 330                         kfree_skb(skb);
 331                         return NULL;
 332                 }
 333         }
 334         if (rt->rt_src == 0) {
 335                 kfree_skb(skb);
 336                 ip_rt_put(rt);
 337                 return NULL;
 338         }
 339
 340         skb_dst_set(skb, &rt->dst);
 341         skb->dev = dev;
 342
 343         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 344
 345         skb_reset_network_header(skb);
 346         pip = ip_hdr(skb);
 347         skb_put(skb, sizeof(struct iphdr) + 4);
 348
 349         pip->version  = 4;
 350         pip->ihl      = (sizeof(struct iphdr)+4)>>2;
 351         pip->tos      = 0xc0;
 352         pip->frag_off = htons(IP_DF);
 353         pip->ttl      = 1;
 354         pip->daddr    = rt->rt_dst;
 355         pip->saddr    = rt->rt_src;
 356         pip->protocol = IPPROTO_IGMP;
 357         pip->tot_len  = 0;      /* filled in later */
 358         ip_select_ident(pip, &rt->dst, NULL);
 359         ((u8*)&pip[1])[0] = IPOPT_RA;
 360         ((u8*)&pip[1])[1] = 4;
 361         ((u8*)&pip[1])[2] = 0;
 362         ((u8*)&pip[1])[3] = 0;
 363
 364         skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4;
 365         skb_put(skb, sizeof(*pig));
 366         pig = igmpv3_report_hdr(skb);
 367         pig->type = IGMPV3_HOST_MEMBERSHIP_REPORT;
 368         pig->resv1 = 0;
 369         pig->csum = 0;
 370         pig->resv2 = 0;
 371         pig->ngrec = 0;
 372         return skb;
 373 }
 374
 375 static int igmpv3_sendpack(struct sk_buff *skb)
 376 {
 377         struct igmphdr *pig = igmp_hdr(skb);
 378         const int igmplen = skb->tail - skb->transport_header;
 379
 380         pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen);
 381
 382         return ip_local_out(skb);
 383 }
 384
 385 static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel)
 386 {
 387         return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel);
 388 }
 389
 390 static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc,
 391         int type, struct igmpv3_grec **ppgr)
 392 {
 393         struct net_device *dev = pmc->interface->dev;
 394         struct igmpv3_report *pih;
 395         struct igmpv3_grec *pgr;
 396
 397         if (!skb)
 398                 skb = igmpv3_newpack(dev, dev->mtu);
 399         if (!skb)
 400                 return NULL;
 401         pgr = (struct igmpv3_grec *)skb_put(skb, sizeof(struct igmpv3_grec));
 402         pgr->grec_type = type;
 403         pgr->grec_auxwords = 0;
 404         pgr->grec_nsrcs = 0;
 405         pgr->grec_mca = pmc->multiaddr;
 406         pih = igmpv3_report_hdr(skb);
 407         pih->ngrec = htons(ntohs(pih->ngrec)+1);
 408         *ppgr = pgr;
 409         return skb;
 410 }
 411
 412 #define AVAILABLE(skb) ((skb) ? ((skb)->dev ? igmp_skb_size(skb) - (skb)->len : \
 413         skb_tailroom(skb)) : 0)
 414
 415 static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
 416         int type, int gdeleted, int sdeleted)
 417 {
 418         struct net_device *dev = pmc->interface->dev;
 419         struct igmpv3_report *pih;
 420         struct igmpv3_grec *pgr = NULL;
 421         struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list;
 422         int scount, stotal, first, isquery, truncate;
 423
 424         if (pmc->multiaddr == IGMP_ALL_HOSTS)
 425                 return skb;
 426
 427         isquery = type == IGMPV3_MODE_IS_INCLUDE ||
 428                   type == IGMPV3_MODE_IS_EXCLUDE;
 429         truncate = type == IGMPV3_MODE_IS_EXCLUDE ||
 430                     type == IGMPV3_CHANGE_TO_EXCLUDE;
 431
 432         stotal = scount = 0;
 433
 434         psf_list = sdeleted ? &pmc->tomb : &pmc->sources;
 435
 436         if (!*psf_list)
 437                 goto empty_source;
 438
 439         pih = skb ? igmpv3_report_hdr(skb) : NULL;
 440
 441         /* EX and TO_EX get a fresh packet, if needed */
 442         if (truncate) {
 443                 if (pih && pih->ngrec &&
 444                     AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {
 445                         if (skb)
 446                                 igmpv3_sendpack(skb);
 447                         skb = igmpv3_newpack(dev, dev->mtu);
 448                 }
 449         }
 450         first = 1;
 451         psf_prev = NULL;
 452         for (psf=*psf_list; psf; psf=psf_next) {
 453                 __be32 *psrc;
 454
 455                 psf_next = psf->sf_next;
 456
 457                 if (!is_in(pmc, psf, type, gdeleted, sdeleted)) {
 458                         psf_prev = psf;
 459                         continue;
 460                 }
 461
 462                 /* clear marks on query responses */
 463                 if (isquery)
 464                         psf->sf_gsresp = 0;
 465
 466                 if (AVAILABLE(skb) < sizeof(__be32) +
 467                     first*sizeof(struct igmpv3_grec)) {
 468                         if (truncate && !first)
 469                                 break;   /* truncate these */
 470                         if (pgr)
 471                                 pgr->grec_nsrcs = htons(scount);
 472                         if (skb)
 473                                 igmpv3_sendpack(skb);
 474                         skb = igmpv3_newpack(dev, dev->mtu);
 475                         first = 1;
 476                         scount = 0;
 477                 }
 478                 if (first) {
 479                         skb = add_grhead(skb, pmc, type, &pgr);
 480                         first = 0;
 481                 }
 482                 if (!skb)
 483                         return NULL;
 484                 psrc = (__be32 *)skb_put(skb, sizeof(__be32));
 485                 *psrc = psf->sf_inaddr;
 486                 scount++; stotal++;
 487                 if ((type == IGMPV3_ALLOW_NEW_SOURCES ||
 488                      type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) {
 489                         psf->sf_crcount--;
 490                         if ((sdeleted || gdeleted) && psf->sf_crcount == 0) {
 491                                 if (psf_prev)
 492                                         psf_prev->sf_next = psf->sf_next;
 493                                 else
 494                                         *psf_list = psf->sf_next;
 495                                 kfree(psf);
 496                                 continue;
 497                         }
 498                 }
 499                 psf_prev = psf;
 500         }
 501
 502 empty_source:
 503         if (!stotal) {
 504                 if (type == IGMPV3_ALLOW_NEW_SOURCES ||
 505                     type == IGMPV3_BLOCK_OLD_SOURCES)
 506                         return skb;
 507                 if (pmc->crcount || isquery) {
 508                         /* make sure we have room for group header */
 509                         if (skb && AVAILABLE(skb)<sizeof(struct igmpv3_grec)) {
 510                                 igmpv3_sendpack(skb);
 511                                 skb = NULL; /* add_grhead will get a new one */
 512                         }
 513                         skb = add_grhead(skb, pmc, type, &pgr);
 514                 }
 515         }
 516         if (pgr)
 517                 pgr->grec_nsrcs = htons(scount);
 518
 519         if (isquery)
 520                 pmc->gsquery = 0;       /* clear query state on report */
 521         return skb;
 522 }
 523
 524 static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc)
 525 {
 526         struct sk_buff *skb = NULL;
 527         int type;
 528
 529         if (!pmc) {
 530                 rcu_read_lock();
 531                 for_each_pmc_rcu(in_dev, pmc) {
 532                         if (pmc->multiaddr == IGMP_ALL_HOSTS)
 533                                 continue;
 534                         spin_lock_bh(&pmc->lock);
 535                         if (pmc->sfcount[MCAST_EXCLUDE])
 536                                 type = IGMPV3_MODE_IS_EXCLUDE;
 537                         else
 538                                 type = IGMPV3_MODE_IS_INCLUDE;
 539                         skb = add_grec(skb, pmc, type, 0, 0);
 540                         spin_unlock_bh(&pmc->lock);
 541                 }
 542                 rcu_read_unlock();
 543         } else {
 544                 spin_lock_bh(&pmc->lock);
 545                 if (pmc->sfcount[MCAST_EXCLUDE])
 546                         type = IGMPV3_MODE_IS_EXCLUDE;
 547                 else
 548                         type = IGMPV3_MODE_IS_INCLUDE;
 549                 skb = add_grec(skb, pmc, type, 0, 0);
 550                 spin_unlock_bh(&pmc->lock);
 551         }
 552         if (!skb)
 553                 return 0;
 554         return igmpv3_sendpack(skb);
 555 }
 556
 557 /*
 558  * remove zero-count source records from a source filter list
 559  */
 560 static void igmpv3_clear_zeros(struct ip_sf_list **ppsf)
 561 {
 562         struct ip_sf_list *psf_prev, *psf_next, *psf;
 563
 564         psf_prev = NULL;
 565         for (psf=*ppsf; psf; psf = psf_next) {
 566                 psf_next = psf->sf_next;
 567                 if (psf->sf_crcount == 0) {
 568                         if (psf_prev)
 569                                 psf_prev->sf_next = psf->sf_next;
 570                         else
 571                                 *ppsf = psf->sf_next;
 572                         kfree(psf);
 573                 } else
 574                         psf_prev = psf;
 575         }
 576 }
 577
 578 static void igmpv3_send_cr(struct in_device *in_dev)
 579 {
 580         struct ip_mc_list *pmc, *pmc_prev, *pmc_next;
 581         struct sk_buff *skb = NULL;
 582         int type, dtype;
 583
 584         rcu_read_lock();
 585         spin_lock_bh(&in_dev->mc_tomb_lock);
 586
 587         /* deleted MCA's */
 588         pmc_prev = NULL;
 589         for (pmc=in_dev->mc_tomb; pmc; pmc=pmc_next) {
 590                 pmc_next = pmc->next;
 591                 if (pmc->sfmode == MCAST_INCLUDE) {
 592                         type = IGMPV3_BLOCK_OLD_SOURCES;
 593                         dtype = IGMPV3_BLOCK_OLD_SOURCES;
 594                         skb = add_grec(skb, pmc, type, 1, 0);
 595                         skb = add_grec(skb, pmc, dtype, 1, 1);
 596                 }
 597                 if (pmc->crcount) {
 598                         if (pmc->sfmode == MCAST_EXCLUDE) {
 599                                 type = IGMPV3_CHANGE_TO_INCLUDE;
 600                                 skb = add_grec(skb, pmc, type, 1, 0);
 601                         }
 602                         pmc->crcount--;
 603                         if (pmc->crcount == 0) {
 604                                 igmpv3_clear_zeros(&pmc->tomb);
 605                                 igmpv3_clear_zeros(&pmc->sources);
 606                         }
 607                 }
 608                 if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) {
 609                         if (pmc_prev)
 610                                 pmc_prev->next = pmc_next;
 611                         else
 612                                 in_dev->mc_tomb = pmc_next;
 613                         in_dev_put(pmc->interface);
 614                         kfree(pmc);
 615                 } else
 616                         pmc_prev = pmc;
 617         }
 618         spin_unlock_bh(&in_dev->mc_tomb_lock);
 619
 620         /* change recs */
 621         for_each_pmc_rcu(in_dev, pmc) {
 622                 spin_lock_bh(&pmc->lock);
 623                 if (pmc->sfcount[MCAST_EXCLUDE]) {
 624                         type = IGMPV3_BLOCK_OLD_SOURCES;
 625                         dtype = IGMPV3_ALLOW_NEW_SOURCES;
 626                 } else {
 627                         type = IGMPV3_ALLOW_NEW_SOURCES;
 628                         dtype = IGMPV3_BLOCK_OLD_SOURCES;
 629                 }
 630                 skb = add_grec(skb, pmc, type, 0, 0);
 631                 skb = add_grec(skb, pmc, dtype, 0, 1);  /* deleted sources */
 632
 633                 /* filter mode changes */
 634                 if (pmc->crcount) {
 635                         if (pmc->sfmode == MCAST_EXCLUDE)
 636                                 type = IGMPV3_CHANGE_TO_EXCLUDE;
 637                         else
 638                                 type = IGMPV3_CHANGE_TO_INCLUDE;
 639                         skb = add_grec(skb, pmc, type, 0, 0);
 640                         pmc->crcount--;
 641                 }
 642                 spin_unlock_bh(&pmc->lock);
 643         }
 644         rcu_read_unlock();
 645
 646         if (!skb)
 647                 return;
 648         (void) igmpv3_sendpack(skb);
 649 }
 650
 651 static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
 652         int type)
 653 {
 654         struct sk_buff *skb;
 655         struct iphdr *iph;
 656         struct igmphdr *ih;
 657         struct rtable *rt;
 658         struct net_device *dev = in_dev->dev;
 659         struct net *net = dev_net(dev);
 660         __be32  group = pmc ? pmc->multiaddr : 0;
 661         __be32  dst;
 662
 663         if (type == IGMPV3_HOST_MEMBERSHIP_REPORT)
 664                 return igmpv3_send_report(in_dev, pmc);
 665         else if (type == IGMP_HOST_LEAVE_MESSAGE)
 666                 dst = IGMP_ALL_ROUTER;
 667         else
 668                 dst = group;
 669
 670         {
 671                 struct flowi fl = { .oif = dev->ifindex,
 672                                     .fl4_dst = dst,
 673                                     .proto = IPPROTO_IGMP };
 674                 rt = ip_route_output_key(net, &fl);
 675                 if (IS_ERR(rt))
 676                         return -1;
 677         }
 678         if (rt->rt_src == 0) {
 679                 ip_rt_put(rt);
 680                 return -1;
 681         }
 682
 683         skb = alloc_skb(IGMP_SIZE+LL_ALLOCATED_SPACE(dev), GFP_ATOMIC);
 684         if (skb == NULL) {
 685                 ip_rt_put(rt);
 686                 return -1;
 687         }
 688
 689         skb_dst_set(skb, &rt->dst);
 690
 691         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 692
 693         skb_reset_network_header(skb);
 694         iph = ip_hdr(skb);
 695         skb_put(skb, sizeof(struct iphdr) + 4);
 696
 697         iph->version  = 4;
 698         iph->ihl      = (sizeof(struct iphdr)+4)>>2;
 699         iph->tos      = 0xc0;
 700         iph->frag_off = htons(IP_DF);
 701         iph->ttl      = 1;
 702         iph->daddr    = dst;
 703         iph->saddr    = rt->rt_src;
 704         iph->protocol = IPPROTO_IGMP;
 705         ip_select_ident(iph, &rt->dst, NULL);
 706         ((u8*)&iph[1])[0] = IPOPT_RA;
 707         ((u8*)&iph[1])[1] = 4;
 708         ((u8*)&iph[1])[2] = 0;
 709         ((u8*)&iph[1])[3] = 0;
 710
 711         ih = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
 712         ih->type = type;
 713         ih->code = 0;
 714         ih->csum = 0;
 715         ih->group = group;
 716         ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
 717
 718         return ip_local_out(skb);
 719 }
 720
 721 static void igmp_gq_timer_expire(unsigned long data)
 722 {
 723         struct in_device *in_dev = (struct in_device *)data;
 724
 725         in_dev->mr_gq_running = 0;
 726         igmpv3_send_report(in_dev, NULL);
 727         __in_dev_put(in_dev);
 728 }
 729
 730 static void igmp_ifc_timer_expire(unsigned long data)
 731 {
 732         struct in_device *in_dev = (struct in_device *)data;
 733
 734         igmpv3_send_cr(in_dev);
 735         if (in_dev->mr_ifc_count) {
 736                 in_dev->mr_ifc_count--;
 737                 igmp_ifc_start_timer(in_dev, IGMP_Unsolicited_Report_Interval);
 738         }
 739         __in_dev_put(in_dev);
 740 }
 741
 742 static void igmp_ifc_event(struct in_device *in_dev)
 743 {
 744         if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev))
 745                 return;
 746         in_dev->mr_ifc_count = in_dev->mr_qrv ? in_dev->mr_qrv :
 747                 IGMP_Unsolicited_Report_Count;
 748         igmp_ifc_start_timer(in_dev, 1);
 749 }
 750
 751
 752 static void igmp_timer_expire(unsigned long data)
 753 {
 754         struct ip_mc_list *im=(struct ip_mc_list *)data;
 755         struct in_device *in_dev = im->interface;
 756
 757         spin_lock(&im->lock);
 758         im->tm_running = 0;
 759
 760         if (im->unsolicit_count) {
 761                 im->unsolicit_count--;
 762                 igmp_start_timer(im, IGMP_Unsolicited_Report_Interval);
 763         }
 764         im->reporter = 1;
 765         spin_unlock(&im->lock);
 766
 767         if (IGMP_V1_SEEN(in_dev))
 768                 igmp_send_report(in_dev, im, IGMP_HOST_MEMBERSHIP_REPORT);
 769         else if (IGMP_V2_SEEN(in_dev))
 770                 igmp_send_report(in_dev, im, IGMPV2_HOST_MEMBERSHIP_REPORT);
 771         else
 772                 igmp_send_report(in_dev, im, IGMPV3_HOST_MEMBERSHIP_REPORT);
 773
 774         ip_ma_put(im);
 775 }
 776
 777 /* mark EXCLUDE-mode sources */
 778 static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
 779 {
 780         struct ip_sf_list *psf;
 781         int i, scount;
 782
 783         scount = 0;
 784         for (psf=pmc->sources; psf; psf=psf->sf_next) {
 785                 if (scount == nsrcs)
 786                         break;
 787                 for (i=0; i<nsrcs; i++) {
 788                         /* skip inactive filters */
 789                         if (pmc->sfcount[MCAST_INCLUDE] ||
 790                             pmc->sfcount[MCAST_EXCLUDE] !=
 791                             psf->sf_count[MCAST_EXCLUDE])
 792                                 continue;
 793                         if (srcs[i] == psf->sf_inaddr) {
 794                                 scount++;
 795                                 break;
 796                         }
 797                 }
 798         }
 799         pmc->gsquery = 0;
 800         if (scount == nsrcs)    /* all sources excluded */
 801                 return 0;
 802         return 1;
 803 }
 804
 805 static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
 806 {
 807         struct ip_sf_list *psf;
 808         int i, scount;
 809
 810         if (pmc->sfmode == MCAST_EXCLUDE)
 811                 return igmp_xmarksources(pmc, nsrcs, srcs);
 812
 813         /* mark INCLUDE-mode sources */
 814         scount = 0;
 815         for (psf=pmc->sources; psf; psf=psf->sf_next) {
 816                 if (scount == nsrcs)
 817                         break;
 818                 for (i=0; i<nsrcs; i++)
 819                         if (srcs[i] == psf->sf_inaddr) {
 820                                 psf->sf_gsresp = 1;
 821                                 scount++;
 822                                 break;
 823                         }
 824         }
 825         if (!scount) {
 826                 pmc->gsquery = 0;
 827                 return 0;
 828         }
 829         pmc->gsquery = 1;
 830         return 1;
 831 }
 832
 833 static void igmp_heard_report(struct in_device *in_dev, __be32 group)
 834 {
 835         struct ip_mc_list *im;
 836
 837         /* Timers are only set for non-local groups */
 838
 839         if (group == IGMP_ALL_HOSTS)
 840                 return;
 841
 842         rcu_read_lock();
 843         for_each_pmc_rcu(in_dev, im) {
 844                 if (im->multiaddr == group) {
 845                         igmp_stop_timer(im);
 846                         break;
 847                 }
 848         }
 849         rcu_read_unlock();
 850 }
 851
 852 static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
 853         int len)
 854 {
 855         struct igmphdr          *ih = igmp_hdr(skb);
 856         struct igmpv3_query *ih3 = igmpv3_query_hdr(skb);
 857         struct ip_mc_list       *im;
 858         __be32                  group = ih->group;
 859         int                     max_delay;
 860         int                     mark = 0;
 861
 862
 863         if (len == 8) {
 864                 if (ih->code == 0) {
 865                         /* Alas, old v1 router presents here. */
 866
 867                         max_delay = IGMP_Query_Response_Interval;
 868                         in_dev->mr_v1_seen = jiffies +
 869                                 IGMP_V1_Router_Present_Timeout;
 870                         group = 0;
 871                 } else {
 872                         /* v2 router present */
 873                         max_delay = ih->code*(HZ/IGMP_TIMER_SCALE);
 874                         in_dev->mr_v2_seen = jiffies +
 875                                 IGMP_V2_Router_Present_Timeout;
 876                 }
 877                 /* cancel the interface change timer */
 878                 in_dev->mr_ifc_count = 0;
 879                 if (del_timer(&in_dev->mr_ifc_timer))
 880                         __in_dev_put(in_dev);
 881                 /* clear deleted report items */
 882                 igmpv3_clear_delrec(in_dev);
 883         } else if (len < 12) {
 884                 return; /* ignore bogus packet; freed by caller */
 885         } else if (IGMP_V1_SEEN(in_dev)) {
 886                 /* This is a v3 query with v1 queriers present */
 887                 max_delay = IGMP_Query_Response_Interval;
 888                 group = 0;
 889         } else if (IGMP_V2_SEEN(in_dev)) {
 890                 /* this is a v3 query with v2 queriers present;
 891                  * Interpretation of the max_delay code is problematic here.
 892                  * A real v2 host would use ih_code directly, while v3 has a
 893                  * different encoding. We use the v3 encoding as more likely
 894                  * to be intended in a v3 query.
 895                  */
 896                 max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE);
 897         } else { /* v3 */
 898                 if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
 899                         return;
 900
 901                 ih3 = igmpv3_query_hdr(skb);
 902                 if (ih3->nsrcs) {
 903                         if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)
 904                                            + ntohs(ih3->nsrcs)*sizeof(__be32)))
 905                                 return;
 906                         ih3 = igmpv3_query_hdr(skb);
 907                 }
 908
 909                 max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE);
 910                 if (!max_delay)
 911                         max_delay = 1;  /* can't mod w/ 0 */
 912                 in_dev->mr_maxdelay = max_delay;
 913                 if (ih3->qrv)
 914                         in_dev->mr_qrv = ih3->qrv;
 915                 if (!group) { /* general query */
 916                         if (ih3->nsrcs)
 917                                 return; /* no sources allowed */
 918                         igmp_gq_start_timer(in_dev);
 919                         return;
 920                 }
 921                 /* mark sources to include, if group & source-specific */
 922                 mark = ih3->nsrcs != 0;
 923         }
 924
 925         /*
 926          * - Start the timers in all of our membership records
 927          *   that the query applies to for the interface on
 928          *   which the query arrived excl. those that belong
 929          *   to a "local" group (224.0.0.X)
 930          * - For timers already running check if they need to
 931          *   be reset.
 932          * - Use the igmp->igmp_code field as the maximum
 933          *   delay possible
 934          */
 935         rcu_read_lock();
 936         for_each_pmc_rcu(in_dev, im) {
 937                 int changed;
 938
 939                 if (group && group != im->multiaddr)
 940                         continue;
 941                 if (im->multiaddr == IGMP_ALL_HOSTS)
 942                         continue;
 943                 spin_lock_bh(&im->lock);
 944                 if (im->tm_running)
 945                         im->gsquery = im->gsquery && mark;
 946                 else
 947                         im->gsquery = mark;
 948                 changed = !im->gsquery ||
 949                         igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs);
 950                 spin_unlock_bh(&im->lock);
 951                 if (changed)
 952                         igmp_mod_timer(im, max_delay);
 953         }
 954         rcu_read_unlock();
 955 }
 956
 957 /* called in rcu_read_lock() section */
 958 int igmp_rcv(struct sk_buff *skb)
 959 {
 960         /* This basically follows the spec line by line -- see RFC1112 */
 961         struct igmphdr *ih;
 962         struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
 963         int len = skb->len;
 964
 965         if (in_dev == NULL)
 966                 goto drop;
 967
 968         if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
 969                 goto drop;
 970
 971         switch (skb->ip_summed) {
 972         case CHECKSUM_COMPLETE:
 973                 if (!csum_fold(skb->csum))
 974                         break;
 975                 /* fall through */
 976         case CHECKSUM_NONE:
 977                 skb->csum = 0;
 978                 if (__skb_checksum_complete(skb))
 979                         goto drop;
 980         }
 981
 982         ih = igmp_hdr(skb);
 983         switch (ih->type) {
 984         case IGMP_HOST_MEMBERSHIP_QUERY:
 985                 igmp_heard_query(in_dev, skb, len);
 986                 break;
 987         case IGMP_HOST_MEMBERSHIP_REPORT:
 988         case IGMPV2_HOST_MEMBERSHIP_REPORT:
 989                 /* Is it our report looped back? */
 990                 if (rt_is_output_route(skb_rtable(skb)))
 991                         break;
 992                 /* don't rely on MC router hearing unicast reports */
 993                 if (skb->pkt_type == PACKET_MULTICAST ||
 994                     skb->pkt_type == PACKET_BROADCAST)
 995                         igmp_heard_report(in_dev, ih->group);
 996                 break;
 997         case IGMP_PIM:
 998 #ifdef CONFIG_IP_PIMSM_V1
 999                 return pim_rcv_v1(skb);
1000 #endif
1001         case IGMPV3_HOST_MEMBERSHIP_REPORT:
1002         case IGMP_DVMRP:
1003         case IGMP_TRACE:
1004         case IGMP_HOST_LEAVE_MESSAGE:
1005         case IGMP_MTRACE:
1006         case IGMP_MTRACE_RESP:
1007                 break;
1008         default:
1009                 break;
1010         }
1011
1012 drop:
1013         kfree_skb(skb);
1014         return 0;
1015 }
1016
1017 #endif
1018
1019
1020 /*
1021  *      Add a filter to a device
1022  */
1023
1024 static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
1025 {
1026         char buf[MAX_ADDR_LEN];
1027         struct net_device *dev = in_dev->dev;
1028
1029         /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG.
1030            We will get multicast token leakage, when IFF_MULTICAST
1031            is changed. This check should be done in dev->set_multicast_list
1032            routine. Something sort of:
1033            if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
1034            --ANK
1035            */
1036         if (arp_mc_map(addr, buf, dev, 0) == 0)
1037                 dev_mc_add(dev, buf);
1038 }
1039
1040 /*
1041  *      Remove a filter from a device
1042  */
1043
1044 static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
1045 {
1046         char buf[MAX_ADDR_LEN];
1047         struct net_device *dev = in_dev->dev;
1048
1049         if (arp_mc_map(addr, buf, dev, 0) == 0)
1050                 dev_mc_del(dev, buf);
1051 }
1052
1053 #ifdef CONFIG_IP_MULTICAST
1054 /*
1055  * deleted ip_mc_list manipulation
1056  */
1057 static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im)
1058 {
1059         struct ip_mc_list *pmc;
1060
1061         /* this is an "ip_mc_list" for convenience; only the fields below
1062          * are actually used. In particular, the refcnt and users are not
1063          * used for management of the delete list. Using the same structure
1064          * for deleted items allows change reports to use common code with
1065          * non-deleted or query-response MCA's.
1066          */
1067         pmc = kzalloc(sizeof(*pmc), GFP_KERNEL);
1068         if (!pmc)
1069                 return;
1070         spin_lock_bh(&im->lock);
1071         pmc->interface = im->interface;
1072         in_dev_hold(in_dev);
1073         pmc->multiaddr = im->multiaddr;
1074         pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
1075                 IGMP_Unsolicited_Report_Count;
1076         pmc->sfmode = im->sfmode;
1077         if (pmc->sfmode == MCAST_INCLUDE) {
1078                 struct ip_sf_list *psf;
1079
1080                 pmc->tomb = im->tomb;
1081                 pmc->sources = im->sources;
1082                 im->tomb = im->sources = NULL;
1083                 for (psf=pmc->sources; psf; psf=psf->sf_next)
1084                         psf->sf_crcount = pmc->crcount;
1085         }
1086         spin_unlock_bh(&im->lock);
1087
1088         spin_lock_bh(&in_dev->mc_tomb_lock);
1089         pmc->next = in_dev->mc_tomb;
1090         in_dev->mc_tomb = pmc;
1091         spin_unlock_bh(&in_dev->mc_tomb_lock);
1092 }
1093
1094 static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
1095 {
1096         struct ip_mc_list *pmc, *pmc_prev;
1097         struct ip_sf_list *psf, *psf_next;
1098
1099         spin_lock_bh(&in_dev->mc_tomb_lock);
1100         pmc_prev = NULL;
1101         for (pmc=in_dev->mc_tomb; pmc; pmc=pmc->next) {
1102                 if (pmc->multiaddr == multiaddr)
1103                         break;
1104                 pmc_prev = pmc;
1105         }
1106         if (pmc) {
1107                 if (pmc_prev)
1108                         pmc_prev->next = pmc->next;
1109                 else
1110                         in_dev->mc_tomb = pmc->next;
1111         }
1112         spin_unlock_bh(&in_dev->mc_tomb_lock);
1113         if (pmc) {
1114                 for (psf=pmc->tomb; psf; psf=psf_next) {
1115                         psf_next = psf->sf_next;
1116                         kfree(psf);
1117                 }
1118                 in_dev_put(pmc->interface);
1119                 kfree(pmc);
1120         }
1121 }
1122
1123 static void igmpv3_clear_delrec(struct in_device *in_dev)
1124 {
1125         struct ip_mc_list *pmc, *nextpmc;
1126
1127         spin_lock_bh(&in_dev->mc_tomb_lock);
1128         pmc = in_dev->mc_tomb;
1129         in_dev->mc_tomb = NULL;
1130         spin_unlock_bh(&in_dev->mc_tomb_lock);
1131
1132         for (; pmc; pmc = nextpmc) {
1133                 nextpmc = pmc->next;
1134                 ip_mc_clear_src(pmc);
1135                 in_dev_put(pmc->interface);
1136                 kfree(pmc);
1137         }
1138         /* clear dead sources, too */
1139         rcu_read_lock();
1140         for_each_pmc_rcu(in_dev, pmc) {
1141                 struct ip_sf_list *psf, *psf_next;
1142
1143                 spin_lock_bh(&pmc->lock);
1144                 psf = pmc->tomb;
1145                 pmc->tomb = NULL;
1146                 spin_unlock_bh(&pmc->lock);
1147                 for (; psf; psf=psf_next) {
1148                         psf_next = psf->sf_next;
1149                         kfree(psf);
1150                 }
1151         }
1152         rcu_read_unlock();
1153 }
1154 #endif
1155
1156 static void igmp_group_dropped(struct ip_mc_list *im)
1157 {
1158         struct in_device *in_dev = im->interface;
1159 #ifdef CONFIG_IP_MULTICAST
1160         int reporter;
1161 #endif
1162
1163         if (im->loaded) {
1164                 im->loaded = 0;
1165                 ip_mc_filter_del(in_dev, im->multiaddr);
1166         }
1167
1168 #ifdef CONFIG_IP_MULTICAST
1169         if (im->multiaddr == IGMP_ALL_HOSTS)
1170                 return;
1171
1172         reporter = im->reporter;
1173         igmp_stop_timer(im);
1174
1175         if (!in_dev->dead) {
1176                 if (IGMP_V1_SEEN(in_dev))
1177                         goto done;
1178                 if (IGMP_V2_SEEN(in_dev)) {
1179                         if (reporter)
1180                                 igmp_send_report(in_dev, im, IGMP_HOST_LEAVE_MESSAGE);
1181                         goto done;
1182                 }
1183                 /* IGMPv3 */
1184                 igmpv3_add_delrec(in_dev, im);
1185
1186                 igmp_ifc_event(in_dev);
1187         }
1188 done:
1189 #endif
1190         ip_mc_clear_src(im);
1191 }
1192
1193 static void igmp_group_added(struct ip_mc_list *im)
1194 {
1195         struct in_device *in_dev = im->interface;
1196
1197         if (im->loaded == 0) {
1198                 im->loaded = 1;
1199                 ip_mc_filter_add(in_dev, im->multiaddr);
1200         }
1201
1202 #ifdef CONFIG_IP_MULTICAST
1203         if (im->multiaddr == IGMP_ALL_HOSTS)
1204                 return;
1205
1206         if (in_dev->dead)
1207                 return;
1208         if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) {
1209                 spin_lock_bh(&im->lock);
1210                 igmp_start_timer(im, IGMP_Initial_Report_Delay);
1211                 spin_unlock_bh(&im->lock);
1212                 return;
1213         }
1214         /* else, v3 */
1215
1216         im->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
1217                 IGMP_Unsolicited_Report_Count;
1218         igmp_ifc_event(in_dev);
1219 #endif
1220 }
1221
1222
1223 /*
1224  *      Multicast list managers
1225  */
1226
1227
1228 /*
1229  *      A socket has joined a multicast group on device dev.
1230  */
1231
1232 void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
1233 {
1234         struct ip_mc_list *im;
1235
1236         ASSERT_RTNL();
1237
1238         for_each_pmc_rtnl(in_dev, im) {
1239                 if (im->multiaddr == addr) {
1240                         im->users++;
1241                         ip_mc_add_src(in_dev, &addr, MCAST_EXCLUDE, 0, NULL, 0);
1242                         goto out;
1243                 }
1244         }
1245
1246         im = kzalloc(sizeof(*im), GFP_KERNEL);
1247         if (!im)
1248                 goto out;
1249
1250         im->users = 1;
1251         im->interface = in_dev;
1252         in_dev_hold(in_dev);
1253         im->multiaddr = addr;
1254         /* initial mode is (EX, empty) */
1255         im->sfmode = MCAST_EXCLUDE;
1256         im->sfcount[MCAST_EXCLUDE] = 1;
1257         atomic_set(&im->refcnt, 1);
1258         spin_lock_init(&im->lock);
1259 #ifdef CONFIG_IP_MULTICAST
1260         setup_timer(&im->timer, &igmp_timer_expire, (unsigned long)im);
1261         im->unsolicit_count = IGMP_Unsolicited_Report_Count;
1262 #endif
1263
1264         im->next_rcu = in_dev->mc_list;
1265         in_dev->mc_count++;
1266         rcu_assign_pointer(in_dev->mc_list, im);
1267
1268 #ifdef CONFIG_IP_MULTICAST
1269         igmpv3_del_delrec(in_dev, im->multiaddr);
1270 #endif
1271         igmp_group_added(im);
1272         if (!in_dev->dead)
1273                 ip_rt_multicast_event(in_dev);
1274 out:
1275         return;
1276 }
1277 EXPORT_SYMBOL(ip_mc_inc_group);
1278
1279 /*
1280  *      Resend IGMP JOIN report; used for bonding.
1281  *      Called with rcu_read_lock()
1282  */
1283 void ip_mc_rejoin_groups(struct in_device *in_dev)
1284 {
1285 #ifdef CONFIG_IP_MULTICAST
1286         struct ip_mc_list *im;
1287         int type;
1288
1289         for_each_pmc_rcu(in_dev, im) {
1290                 if (im->multiaddr == IGMP_ALL_HOSTS)
1291                         continue;
1292
1293                 /* a failover is happening and switches
1294                  * must be notified immediately
1295                  */
1296                 if (IGMP_V1_SEEN(in_dev))
1297                         type = IGMP_HOST_MEMBERSHIP_REPORT;
1298                 else if (IGMP_V2_SEEN(in_dev))
1299                         type = IGMPV2_HOST_MEMBERSHIP_REPORT;
1300                 else
1301                         type = IGMPV3_HOST_MEMBERSHIP_REPORT;
1302                 igmp_send_report(in_dev, im, type);
1303         }
1304 #endif
1305 }
1306 EXPORT_SYMBOL(ip_mc_rejoin_groups);
1307
1308 /*
1309  *      A socket has left a multicast group on device dev
1310  */
1311
1312 void ip_mc_dec_group(struct in_device *in_dev, __be32 addr)
1313 {
1314         struct ip_mc_list *i;
1315         struct ip_mc_list __rcu **ip;
1316
1317         ASSERT_RTNL();
1318
1319         for (ip = &in_dev->mc_list;
1320              (i = rtnl_dereference(*ip)) != NULL;
1321              ip = &i->next_rcu) {
1322                 if (i->multiaddr == addr) {
1323                         if (--i->users == 0) {
1324                                 *ip = i->next_rcu;
1325                                 in_dev->mc_count--;
1326                                 igmp_group_dropped(i);
1327
1328                                 if (!in_dev->dead)
1329                                         ip_rt_multicast_event(in_dev);
1330
1331                                 ip_ma_put(i);
1332                                 return;
1333                         }
1334                         break;
1335                 }
1336         }
1337 }
1338 EXPORT_SYMBOL(ip_mc_dec_group);
1339
1340 /* Device changing type */
1341
1342 void ip_mc_unmap(struct in_device *in_dev)
1343 {
1344         struct ip_mc_list *pmc;
1345
1346         ASSERT_RTNL();
1347
1348         for_each_pmc_rtnl(in_dev, pmc)
1349                 igmp_group_dropped(pmc);
1350 }
1351
1352 void ip_mc_remap(struct in_device *in_dev)
1353 {
1354         struct ip_mc_list *pmc;
1355
1356         ASSERT_RTNL();
1357
1358         for_each_pmc_rtnl(in_dev, pmc)
1359                 igmp_group_added(pmc);
1360 }
1361
1362 /* Device going down */
1363
1364 void ip_mc_down(struct in_device *in_dev)
1365 {
1366         struct ip_mc_list *pmc;
1367
1368         ASSERT_RTNL();
1369
1370         for_each_pmc_rtnl(in_dev, pmc)
1371                 igmp_group_dropped(pmc);
1372
1373 #ifdef CONFIG_IP_MULTICAST
1374         in_dev->mr_ifc_count = 0;
1375         if (del_timer(&in_dev->mr_ifc_timer))
1376                 __in_dev_put(in_dev);
1377         in_dev->mr_gq_running = 0;
1378         if (del_timer(&in_dev->mr_gq_timer))
1379                 __in_dev_put(in_dev);
1380         igmpv3_clear_delrec(in_dev);
1381 #endif
1382
1383         ip_mc_dec_group(in_dev, IGMP_ALL_HOSTS);
1384 }
1385
1386 void ip_mc_init_dev(struct in_device *in_dev)
1387 {
1388         ASSERT_RTNL();
1389
1390         in_dev->mc_tomb = NULL;
1391 #ifdef CONFIG_IP_MULTICAST
1392         in_dev->mr_gq_running = 0;
1393         setup_timer(&in_dev->mr_gq_timer, igmp_gq_timer_expire,
1394                         (unsigned long)in_dev);
1395         in_dev->mr_ifc_count = 0;
1396         in_dev->mc_count     = 0;
1397         setup_timer(&in_dev->mr_ifc_timer, igmp_ifc_timer_expire,
1398                         (unsigned long)in_dev);
1399         in_dev->mr_qrv = IGMP_Unsolicited_Report_Count;
1400 #endif
1401
1402         spin_lock_init(&in_dev->mc_tomb_lock);
1403 }
1404
1405 /* Device going up */
1406
1407 void ip_mc_up(struct in_device *in_dev)
1408 {
1409         struct ip_mc_list *pmc;
1410
1411         ASSERT_RTNL();
1412
1413         ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS);
1414
1415         for_each_pmc_rtnl(in_dev, pmc)
1416                 igmp_group_added(pmc);
1417 }
1418
1419 /*
1420  *      Device is about to be destroyed: clean up.
1421  */
1422
1423 void ip_mc_destroy_dev(struct in_device *in_dev)
1424 {
1425         struct ip_mc_list *i;
1426
1427         ASSERT_RTNL();
1428
1429         /* Deactivate timers */
1430         ip_mc_down(in_dev);
1431
1432         while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) {
1433                 in_dev->mc_list = i->next_rcu;
1434                 in_dev->mc_count--;
1435
1436                 igmp_group_dropped(i);
1437                 ip_ma_put(i);
1438         }
1439 }
1440
1441 /* RTNL is locked */
1442 static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr)
1443 {
1444         struct flowi fl = { .fl4_dst = imr->imr_multiaddr.s_addr };
1445         struct net_device *dev = NULL;
1446         struct in_device *idev = NULL;
1447
1448         if (imr->imr_ifindex) {
1449                 idev = inetdev_by_index(net, imr->imr_ifindex);
1450                 return idev;
1451         }
1452         if (imr->imr_address.s_addr) {
1453                 dev = __ip_dev_find(net, imr->imr_address.s_addr, false);
1454                 if (!dev)
1455                         return NULL;
1456         }
1457
1458         if (!dev) {
1459                 struct rtable *rt = ip_route_output_key(net, &fl);
1460                 if (!IS_ERR(rt)) {
1461                         dev = rt->dst.dev;
1462                         ip_rt_put(rt);
1463                 }
1464         }
1465         if (dev) {
1466                 imr->imr_ifindex = dev->ifindex;
1467                 idev = __in_dev_get_rtnl(dev);
1468         }
1469         return idev;
1470 }
1471
1472 /*
1473  *      Join a socket to a group
1474  */
1475 int sysctl_igmp_max_memberships __read_mostly = IP_MAX_MEMBERSHIPS;
1476 int sysctl_igmp_max_msf __read_mostly = IP_MAX_MSF;
1477
1478
1479 static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
1480         __be32 *psfsrc)
1481 {
1482         struct ip_sf_list *psf, *psf_prev;
1483         int rv = 0;
1484
1485         psf_prev = NULL;
1486         for (psf=pmc->sources; psf; psf=psf->sf_next) {
1487                 if (psf->sf_inaddr == *psfsrc)
1488                         break;
1489                 psf_prev = psf;
1490         }
1491         if (!psf || psf->sf_count[sfmode] == 0) {
1492                 /* source filter not found, or count wrong =>  bug */
1493                 return -ESRCH;
1494         }
1495         psf->sf_count[sfmode]--;
1496         if (psf->sf_count[sfmode] == 0) {
1497                 ip_rt_multicast_event(pmc->interface);
1498         }
1499         if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) {
1500 #ifdef CONFIG_IP_MULTICAST
1501                 struct in_device *in_dev = pmc->interface;
1502 #endif
1503
1504                 /* no more filters for this source */
1505                 if (psf_prev)
1506                         psf_prev->sf_next = psf->sf_next;
1507                 else
1508                         pmc->sources = psf->sf_next;
1509 #ifdef CONFIG_IP_MULTICAST
1510                 if (psf->sf_oldin &&
1511                     !IGMP_V1_SEEN(in_dev) && !IGMP_V2_SEEN(in_dev)) {
1512                         psf->sf_crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
1513                                 IGMP_Unsolicited_Report_Count;
1514                         psf->sf_next = pmc->tomb;
1515                         pmc->tomb = psf;
1516                         rv = 1;
1517                 } else
1518 #endif
1519                         kfree(psf);
1520         }
1521         return rv;
1522 }
1523
1524 #ifndef CONFIG_IP_MULTICAST
1525 #define igmp_ifc_event(x)       do { } while (0)
1526 #endif
1527
1528 static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
1529                          int sfcount, __be32 *psfsrc, int delta)
1530 {
1531         struct ip_mc_list *pmc;
1532         int     changerec = 0;
1533         int     i, err;
1534
1535         if (!in_dev)
1536                 return -ENODEV;
1537         rcu_read_lock();
1538         for_each_pmc_rcu(in_dev, pmc) {
1539                 if (*pmca == pmc->multiaddr)
1540                         break;
1541         }
1542         if (!pmc) {
1543                 /* MCA not found?? bug */
1544                 rcu_read_unlock();
1545                 return -ESRCH;
1546         }
1547         spin_lock_bh(&pmc->lock);
1548         rcu_read_unlock();
1549 #ifdef CONFIG_IP_MULTICAST
1550         sf_markstate(pmc);
1551 #endif
1552         if (!delta) {
1553                 err = -EINVAL;
1554                 if (!pmc->sfcount[sfmode])
1555                         goto out_unlock;
1556                 pmc->sfcount[sfmode]--;
1557         }
1558         err = 0;
1559         for (i=0; i<sfcount; i++) {
1560                 int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
1561
1562                 changerec |= rv > 0;
1563                 if (!err && rv < 0)
1564                         err = rv;
1565         }
1566         if (pmc->sfmode == MCAST_EXCLUDE &&
1567             pmc->sfcount[MCAST_EXCLUDE] == 0 &&
1568             pmc->sfcount[MCAST_INCLUDE]) {
1569 #ifdef CONFIG_IP_MULTICAST
1570                 struct ip_sf_list *psf;
1571 #endif
1572
1573                 /* filter mode change */
1574                 pmc->sfmode = MCAST_INCLUDE;
1575 #ifdef CONFIG_IP_MULTICAST
1576                 pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
1577                         IGMP_Unsolicited_Report_Count;
1578                 in_dev->mr_ifc_count = pmc->crcount;
1579                 for (psf=pmc->sources; psf; psf = psf->sf_next)
1580                         psf->sf_crcount = 0;
1581                 igmp_ifc_event(pmc->interface);
1582         } else if (sf_setstate(pmc) || changerec) {
1583                 igmp_ifc_event(pmc->interface);
1584 #endif
1585         }
1586 out_unlock:
1587         spin_unlock_bh(&pmc->lock);
1588         return err;
1589 }
1590
1591 /*
1592  * Add multicast single-source filter to the interface list
1593  */
1594 static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode,
1595         __be32 *psfsrc, int delta)
1596 {
1597         struct ip_sf_list *psf, *psf_prev;
1598
1599         psf_prev = NULL;
1600         for (psf=pmc->sources; psf; psf=psf->sf_next) {
1601                 if (psf->sf_inaddr == *psfsrc)
1602                         break;
1603                 psf_prev = psf;
1604         }
1605         if (!psf) {
1606                 psf = kzalloc(sizeof(*psf), GFP_ATOMIC);
1607                 if (!psf)
1608                         return -ENOBUFS;
1609                 psf->sf_inaddr = *psfsrc;
1610                 if (psf_prev) {
1611                         psf_prev->sf_next = psf;
1612                 } else
1613                         pmc->sources = psf;
1614         }
1615         psf->sf_count[sfmode]++;
1616         if (psf->sf_count[sfmode] == 1) {
1617                 ip_rt_multicast_event(pmc->interface);
1618         }
1619         return 0;
1620 }
1621
1622 #ifdef CONFIG_IP_MULTICAST
1623 static void sf_markstate(struct ip_mc_list *pmc)
1624 {
1625         struct ip_sf_list *psf;
1626         int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
1627
1628         for (psf=pmc->sources; psf; psf=psf->sf_next)
1629                 if (pmc->sfcount[MCAST_EXCLUDE]) {
1630                         psf->sf_oldin = mca_xcount ==
1631                                 psf->sf_count[MCAST_EXCLUDE] &&
1632                                 !psf->sf_count[MCAST_INCLUDE];
1633                 } else
1634                         psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0;
1635 }
1636
1637 static int sf_setstate(struct ip_mc_list *pmc)
1638 {
1639         struct ip_sf_list *psf, *dpsf;
1640         int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
1641         int qrv = pmc->interface->mr_qrv;
1642         int new_in, rv;
1643
1644         rv = 0;
1645         for (psf=pmc->sources; psf; psf=psf->sf_next) {
1646                 if (pmc->sfcount[MCAST_EXCLUDE]) {
1647                         new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] &&
1648                                 !psf->sf_count[MCAST_INCLUDE];
1649                 } else
1650                         new_in = psf->sf_count[MCAST_INCLUDE] != 0;
1651                 if (new_in) {
1652                         if (!psf->sf_oldin) {
1653                                 struct ip_sf_list *prev = NULL;
1654
1655                                 for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) {
1656                                         if (dpsf->sf_inaddr == psf->sf_inaddr)
1657                                                 break;
1658                                         prev = dpsf;
1659                                 }
1660                                 if (dpsf) {
1661                                         if (prev)
1662                                                 prev->sf_next = dpsf->sf_next;
1663                                         else
1664                                                 pmc->tomb = dpsf->sf_next;
1665                                         kfree(dpsf);
1666                                 }
1667                                 psf->sf_crcount = qrv;
1668                                 rv++;
1669                         }
1670                 } else if (psf->sf_oldin) {
1671
1672                         psf->sf_crcount = 0;
1673                         /*
1674                          * add or update "delete" records if an active filter
1675                          * is now inactive
1676                          */
1677                         for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next)
1678                                 if (dpsf->sf_inaddr == psf->sf_inaddr)
1679                                         break;
1680                         if (!dpsf) {
1681                                 dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC);
1682                                 if (!dpsf)
1683                                         continue;
1684                                 *dpsf = *psf;
1685                                 /* pmc->lock held by callers */
1686                                 dpsf->sf_next = pmc->tomb;
1687                                 pmc->tomb = dpsf;
1688                         }
1689                         dpsf->sf_crcount = qrv;
1690                         rv++;
1691                 }
1692         }
1693         return rv;
1694 }
1695 #endif
1696
1697 /*
1698  * Add multicast source filter list to the interface list
1699  */
1700 static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
1701                          int sfcount, __be32 *psfsrc, int delta)
1702 {
1703         struct ip_mc_list *pmc;
1704         int     isexclude;
1705         int     i, err;
1706
1707         if (!in_dev)
1708                 return -ENODEV;
1709         rcu_read_lock();
1710         for_each_pmc_rcu(in_dev, pmc) {
1711                 if (*pmca == pmc->multiaddr)
1712                         break;
1713         }
1714         if (!pmc) {
1715                 /* MCA not found?? bug */
1716                 rcu_read_unlock();
1717                 return -ESRCH;
1718         }
1719         spin_lock_bh(&pmc->lock);
1720         rcu_read_unlock();
1721
1722 #ifdef CONFIG_IP_MULTICAST
1723         sf_markstate(pmc);
1724 #endif
1725         isexclude = pmc->sfmode == MCAST_EXCLUDE;
1726         if (!delta)
1727                 pmc->sfcount[sfmode]++;
1728         err = 0;
1729         for (i=0; i<sfcount; i++) {
1730                 err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i], delta);
1731                 if (err)
1732                         break;
1733         }
1734         if (err) {
1735                 int j;
1736
1737                 pmc->sfcount[sfmode]--;
1738                 for (j=0; j<i; j++)
1739                         (void) ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
1740         } else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) {
1741 #ifdef CONFIG_IP_MULTICAST
1742                 struct ip_sf_list *psf;
1743                 in_dev = pmc->interface;
1744 #endif
1745
1746                 /* filter mode change */
1747                 if (pmc->sfcount[MCAST_EXCLUDE])
1748                         pmc->sfmode = MCAST_EXCLUDE;
1749                 else if (pmc->sfcount[MCAST_INCLUDE])
1750                         pmc->sfmode = MCAST_INCLUDE;
1751 #ifdef CONFIG_IP_MULTICAST
1752                 /* else no filters; keep old mode for reports */
1753
1754                 pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
1755                         IGMP_Unsolicited_Report_Count;
1756                 in_dev->mr_ifc_count = pmc->crcount;
1757                 for (psf=pmc->sources; psf; psf = psf->sf_next)
1758                         psf->sf_crcount = 0;
1759                 igmp_ifc_event(in_dev);
1760         } else if (sf_setstate(pmc)) {
1761                 igmp_ifc_event(in_dev);
1762 #endif
1763         }
1764         spin_unlock_bh(&pmc->lock);
1765         return err;
1766 }
1767
1768 static void ip_mc_clear_src(struct ip_mc_list *pmc)
1769 {
1770         struct ip_sf_list *psf, *nextpsf;
1771
1772         for (psf=pmc->tomb; psf; psf=nextpsf) {
1773                 nextpsf = psf->sf_next;
1774                 kfree(psf);
1775         }
1776         pmc->tomb = NULL;
1777         for (psf=pmc->sources; psf; psf=nextpsf) {
1778                 nextpsf = psf->sf_next;
1779                 kfree(psf);
1780         }
1781         pmc->sources = NULL;
1782         pmc->sfmode = MCAST_EXCLUDE;
1783         pmc->sfcount[MCAST_INCLUDE] = 0;
1784         pmc->sfcount[MCAST_EXCLUDE] = 1;
1785 }
1786
1787
1788 /*
1789  * Join a multicast group
1790  */
1791 int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr)
1792 {
1793         int err;
1794         __be32 addr = imr->imr_multiaddr.s_addr;
1795         struct ip_mc_socklist *iml = NULL, *i;
1796         struct in_device *in_dev;
1797         struct inet_sock *inet = inet_sk(sk);
1798         struct net *net = sock_net(sk);
1799         int ifindex;
1800         int count = 0;
1801
1802         if (!ipv4_is_multicast(addr))
1803                 return -EINVAL;
1804
1805         rtnl_lock();
1806
1807         in_dev = ip_mc_find_dev(net, imr);
1808
1809         if (!in_dev) {
1810                 iml = NULL;
1811                 err = -ENODEV;
1812                 goto done;
1813         }
1814
1815         err = -EADDRINUSE;
1816         ifindex = imr->imr_ifindex;
1817         for_each_pmc_rtnl(inet, i) {
1818                 if (i->multi.imr_multiaddr.s_addr == addr &&
1819                     i->multi.imr_ifindex == ifindex)
1820                         goto done;
1821                 count++;
1822         }
1823         err = -ENOBUFS;
1824         if (count >= sysctl_igmp_max_memberships)
1825                 goto done;
1826         iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);
1827         if (iml == NULL)
1828                 goto done;
1829
1830         memcpy(&iml->multi, imr, sizeof(*imr));
1831         iml->next_rcu = inet->mc_list;
1832         iml->sflist = NULL;
1833         iml->sfmode = MCAST_EXCLUDE;
1834         rcu_assign_pointer(inet->mc_list, iml);
1835         ip_mc_inc_group(in_dev, addr);
1836         err = 0;
1837 done:
1838         rtnl_unlock();
1839         return err;
1840 }
1841 EXPORT_SYMBOL(ip_mc_join_group);
1842
1843 static void ip_sf_socklist_reclaim(struct rcu_head *rp)
1844 {
1845         kfree(container_of(rp, struct ip_sf_socklist, rcu));
1846         /* sk_omem_alloc should have been decreased by the caller*/
1847 }
1848
1849 static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
1850                            struct in_device *in_dev)
1851 {
1852         struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist);
1853         int err;
1854
1855         if (psf == NULL) {
1856                 /* any-source empty exclude case */
1857                 return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
1858                         iml->sfmode, 0, NULL, 0);
1859         }
1860         err = ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
1861                         iml->sfmode, psf->sl_count, psf->sl_addr, 0);
1862         rcu_assign_pointer(iml->sflist, NULL);
1863         /* decrease mem now to avoid the memleak warning */
1864         atomic_sub(IP_SFLSIZE(psf->sl_max), &sk->sk_omem_alloc);
1865         call_rcu(&psf->rcu, ip_sf_socklist_reclaim);
1866         return err;
1867 }
1868
1869
1870 static void ip_mc_socklist_reclaim(struct rcu_head *rp)
1871 {
1872         kfree(container_of(rp, struct ip_mc_socklist, rcu));
1873         /* sk_omem_alloc should have been decreased by the caller*/
1874 }
1875
1876
1877 /*
1878  *      Ask a socket to leave a group.
1879  */
1880
1881 int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
1882 {
1883         struct inet_sock *inet = inet_sk(sk);
1884         struct ip_mc_socklist *iml;
1885         struct ip_mc_socklist __rcu **imlp;
1886         struct in_device *in_dev;
1887         struct net *net = sock_net(sk);
1888         __be32 group = imr->imr_multiaddr.s_addr;
1889         u32 ifindex;
1890         int ret = -EADDRNOTAVAIL;
1891
1892         rtnl_lock();
1893         in_dev = ip_mc_find_dev(net, imr);
1894         ifindex = imr->imr_ifindex;
1895         for (imlp = &inet->mc_list;
1896              (iml = rtnl_dereference(*imlp)) != NULL;
1897              imlp = &iml->next_rcu) {
1898                 if (iml->multi.imr_multiaddr.s_addr != group)
1899                         continue;
1900                 if (ifindex) {
1901                         if (iml->multi.imr_ifindex != ifindex)
1902                                 continue;
1903                 } else if (imr->imr_address.s_addr && imr->imr_address.s_addr !=
1904                                 iml->multi.imr_address.s_addr)
1905                         continue;
1906
1907                 (void) ip_mc_leave_src(sk, iml, in_dev);
1908
1909                 *imlp = iml->next_rcu;
1910
1911                 if (in_dev)
1912                         ip_mc_dec_group(in_dev, group);
1913                 rtnl_unlock();
1914                 /* decrease mem now to avoid the memleak warning */
1915                 atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
1916                 call_rcu(&iml->rcu, ip_mc_socklist_reclaim);
1917                 return 0;
1918         }
1919         if (!in_dev)
1920                 ret = -ENODEV;
1921         rtnl_unlock();
1922         return ret;
1923 }
1924
1925 int ip_mc_source(int add, int omode, struct sock *sk, struct
1926         ip_mreq_source *mreqs, int ifindex)
1927 {
1928         int err;
1929         struct ip_mreqn imr;
1930         __be32 addr = mreqs->imr_multiaddr;
1931         struct ip_mc_socklist *pmc;
1932         struct in_device *in_dev = NULL;
1933         struct inet_sock *inet = inet_sk(sk);
1934         struct ip_sf_socklist *psl;
1935         struct net *net = sock_net(sk);
1936         int leavegroup = 0;
1937         int i, j, rv;
1938
1939         if (!ipv4_is_multicast(addr))
1940                 return -EINVAL;
1941
1942         rtnl_lock();
1943
1944         imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr;
1945         imr.imr_address.s_addr = mreqs->imr_interface;
1946         imr.imr_ifindex = ifindex;
1947         in_dev = ip_mc_find_dev(net, &imr);
1948
1949         if (!in_dev) {
1950                 err = -ENODEV;
1951                 goto done;
1952         }
1953         err = -EADDRNOTAVAIL;
1954
1955         for_each_pmc_rtnl(inet, pmc) {
1956                 if ((pmc->multi.imr_multiaddr.s_addr ==
1957                      imr.imr_multiaddr.s_addr) &&
1958                     (pmc->multi.imr_ifindex == imr.imr_ifindex))
1959                         break;
1960         }
1961         if (!pmc) {             /* must have a prior join */
1962                 err = -EINVAL;
1963                 goto done;
1964         }
1965         /* if a source filter was set, must be the same mode as before */
1966         if (pmc->sflist) {
1967                 if (pmc->sfmode != omode) {
1968                         err = -EINVAL;
1969                         goto done;
1970                 }
1971         } else if (pmc->sfmode != omode) {
1972                 /* allow mode switches for empty-set filters */
1973                 ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 0, NULL, 0);
1974                 ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0,
1975                         NULL, 0);
1976                 pmc->sfmode = omode;
1977         }
1978
1979         psl = rtnl_dereference(pmc->sflist);
1980         if (!add) {
1981                 if (!psl)
1982                         goto done;      /* err = -EADDRNOTAVAIL */
1983                 rv = !0;
1984                 for (i=0; i<psl->sl_count; i++) {
1985                         rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
1986                                 sizeof(__be32));
1987                         if (rv == 0)
1988                                 break;
1989                 }
1990                 if (rv)         /* source not found */
1991                         goto done;      /* err = -EADDRNOTAVAIL */
1992
1993                 /* special case - (INCLUDE, empty) == LEAVE_GROUP */
1994                 if (psl->sl_count == 1 && omode == MCAST_INCLUDE) {
1995                         leavegroup = 1;
1996                         goto done;
1997                 }
1998
1999                 /* update the interface filter */
2000                 ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
2001                         &mreqs->imr_sourceaddr, 1);
2002
2003                 for (j=i+1; j<psl->sl_count; j++)
2004                         psl->sl_addr[j-1] = psl->sl_addr[j];
2005                 psl->sl_count--;
2006                 err = 0;
2007                 goto done;
2008         }
2009         /* else, add a new source to the filter */
2010
2011         if (psl && psl->sl_count >= sysctl_igmp_max_msf) {
2012                 err = -ENOBUFS;
2013                 goto done;
2014         }
2015         if (!psl || psl->sl_count == psl->sl_max) {
2016                 struct ip_sf_socklist *newpsl;
2017                 int count = IP_SFBLOCK;
2018
2019                 if (psl)
2020                         count += psl->sl_max;
2021                 newpsl = sock_kmalloc(sk, IP_SFLSIZE(count), GFP_KERNEL);
2022                 if (!newpsl) {
2023                         err = -ENOBUFS;
2024                         goto done;
2025                 }
2026                 newpsl->sl_max = count;
2027                 newpsl->sl_count = count - IP_SFBLOCK;
2028                 if (psl) {
2029                         for (i=0; i<psl->sl_count; i++)
2030                                 newpsl->sl_addr[i] = psl->sl_addr[i];
2031                         /* decrease mem now to avoid the memleak warning */
2032                         atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
2033                         call_rcu(&psl->rcu, ip_sf_socklist_reclaim);
2034                 }
2035                 rcu_assign_pointer(pmc->sflist, newpsl);
2036                 psl = newpsl;
2037         }
2038         rv = 1; /* > 0 for insert logic below if sl_count is 0 */
2039         for (i=0; i<psl->sl_count; i++) {
2040                 rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
2041                         sizeof(__be32));
2042                 if (rv == 0)
2043                         break;
2044         }
2045         if (rv == 0)            /* address already there is an error */
2046                 goto done;
2047         for (j=psl->sl_count-1; j>=i; j--)
2048                 psl->sl_addr[j+1] = psl->sl_addr[j];
2049         psl->sl_addr[i] = mreqs->imr_sourceaddr;
2050         psl->sl_count++;
2051         err = 0;
2052         /* update the interface list */
2053         ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
2054                 &mreqs->imr_sourceaddr, 1);
2055 done:
2056         rtnl_unlock();
2057         if (leavegroup)
2058                 return ip_mc_leave_group(sk, &imr);
2059         return err;
2060 }
2061
2062 int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex)
2063 {
2064         int err = 0;
2065         struct ip_mreqn imr;
2066         __be32 addr = msf->imsf_multiaddr;
2067         struct ip_mc_socklist *pmc;
2068         struct in_device *in_dev;
2069         struct inet_sock *inet = inet_sk(sk);
2070         struct ip_sf_socklist *newpsl, *psl;
2071         struct net *net = sock_net(sk);
2072         int leavegroup = 0;
2073
2074         if (!ipv4_is_multicast(addr))
2075                 return -EINVAL;
2076         if (msf->imsf_fmode != MCAST_INCLUDE &&
2077             msf->imsf_fmode != MCAST_EXCLUDE)
2078                 return -EINVAL;
2079
2080         rtnl_lock();
2081
2082         imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
2083         imr.imr_address.s_addr = msf->imsf_interface;
2084         imr.imr_ifindex = ifindex;
2085         in_dev = ip_mc_find_dev(net, &imr);
2086
2087         if (!in_dev) {
2088                 err = -ENODEV;
2089                 goto done;
2090         }
2091
2092         /* special case - (INCLUDE, empty) == LEAVE_GROUP */
2093         if (msf->imsf_fmode == MCAST_INCLUDE && msf->imsf_numsrc == 0) {
2094                 leavegroup = 1;
2095                 goto done;
2096         }
2097
2098         for_each_pmc_rtnl(inet, pmc) {
2099                 if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
2100                     pmc->multi.imr_ifindex == imr.imr_ifindex)
2101                         break;
2102         }
2103         if (!pmc) {             /* must have a prior join */
2104                 err = -EINVAL;
2105                 goto done;
2106         }
2107         if (msf->imsf_numsrc) {
2108                 newpsl = sock_kmalloc(sk, IP_SFLSIZE(msf->imsf_numsrc),
2109                                                            GFP_KERNEL);
2110                 if (!newpsl) {
2111                         err = -ENOBUFS;
2112                         goto done;
2113                 }
2114                 newpsl->sl_max = newpsl->sl_count = msf->imsf_numsrc;
2115                 memcpy(newpsl->sl_addr, msf->imsf_slist,
2116                         msf->imsf_numsrc * sizeof(msf->imsf_slist[0]));
2117                 err = ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
2118                         msf->imsf_fmode, newpsl->sl_count, newpsl->sl_addr, 0);
2119                 if (err) {
2120                         sock_kfree_s(sk, newpsl, IP_SFLSIZE(newpsl->sl_max));
2121                         goto done;
2122                 }
2123         } else {
2124                 newpsl = NULL;
2125                 (void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
2126                                      msf->imsf_fmode, 0, NULL, 0);
2127         }
2128         psl = rtnl_dereference(pmc->sflist);
2129         if (psl) {
2130                 (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
2131                         psl->sl_count, psl->sl_addr, 0);
2132                 /* decrease mem now to avoid the memleak warning */
2133                 atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
2134                 call_rcu(&psl->rcu, ip_sf_socklist_reclaim);
2135         } else
2136                 (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
2137                         0, NULL, 0);
2138         rcu_assign_pointer(pmc->sflist, newpsl);
2139         pmc->sfmode = msf->imsf_fmode;
2140         err = 0;
2141 done:
2142         rtnl_unlock();
2143         if (leavegroup)
2144                 err = ip_mc_leave_group(sk, &imr);
2145         return err;
2146 }
2147
2148 int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
2149         struct ip_msfilter __user *optval, int __user *optlen)
2150 {
2151         int err, len, count, copycount;
2152         struct ip_mreqn imr;
2153         __be32 addr = msf->imsf_multiaddr;
2154         struct ip_mc_socklist *pmc;
2155         struct in_device *in_dev;
2156         struct inet_sock *inet = inet_sk(sk);
2157         struct ip_sf_socklist *psl;
2158         struct net *net = sock_net(sk);
2159
2160         if (!ipv4_is_multicast(addr))
2161                 return -EINVAL;
2162
2163         rtnl_lock();
2164
2165         imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
2166         imr.imr_address.s_addr = msf->imsf_interface;
2167         imr.imr_ifindex = 0;
2168         in_dev = ip_mc_find_dev(net, &imr);
2169
2170         if (!in_dev) {
2171                 err = -ENODEV;
2172                 goto done;
2173         }
2174         err = -EADDRNOTAVAIL;
2175
2176         for_each_pmc_rtnl(inet, pmc) {
2177                 if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
2178                     pmc->multi.imr_ifindex == imr.imr_ifindex)
2179                         break;
2180         }
2181         if (!pmc)               /* must have a prior join */
2182                 goto done;
2183         msf->imsf_fmode = pmc->sfmode;
2184         psl = rtnl_dereference(pmc->sflist);
2185         rtnl_unlock();
2186         if (!psl) {
2187                 len = 0;
2188                 count = 0;
2189         } else {
2190                 count = psl->sl_count;
2191         }
2192         copycount = count < msf->imsf_numsrc ? count : msf->imsf_numsrc;
2193         len = copycount * sizeof(psl->sl_addr[0]);
2194         msf->imsf_numsrc = count;
2195         if (put_user(IP_MSFILTER_SIZE(copycount), optlen) ||
2196             copy_to_user(optval, msf, IP_MSFILTER_SIZE(0))) {
2197                 return -EFAULT;
2198         }
2199         if (len &&
2200             copy_to_user(&optval->imsf_slist[0], psl->sl_addr, len))
2201                 return -EFAULT;
2202         return 0;
2203 done:
2204         rtnl_unlock();
2205         return err;
2206 }
2207
2208 int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
2209         struct group_filter __user *optval, int __user *optlen)
2210 {
2211         int err, i, count, copycount;
2212         struct sockaddr_in *psin;
2213         __be32 addr;
2214         struct ip_mc_socklist *pmc;
2215         struct inet_sock *inet = inet_sk(sk);
2216         struct ip_sf_socklist *psl;
2217
2218         psin = (struct sockaddr_in *)&gsf->gf_group;
2219         if (psin->sin_family != AF_INET)
2220                 return -EINVAL;
2221         addr = psin->sin_addr.s_addr;
2222         if (!ipv4_is_multicast(addr))
2223                 return -EINVAL;
2224
2225         rtnl_lock();
2226
2227         err = -EADDRNOTAVAIL;
2228
2229         for_each_pmc_rtnl(inet, pmc) {
2230                 if (pmc->multi.imr_multiaddr.s_addr == addr &&
2231                     pmc->multi.imr_ifindex == gsf->gf_interface)
2232                         break;
2233         }
2234         if (!pmc)               /* must have a prior join */
2235                 goto done;
2236         gsf->gf_fmode = pmc->sfmode;
2237         psl = rtnl_dereference(pmc->sflist);
2238         rtnl_unlock();
2239         count = psl ? psl->sl_count : 0;
2240         copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc;
2241         gsf->gf_numsrc = count;
2242         if (put_user(GROUP_FILTER_SIZE(copycount), optlen) ||
2243             copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) {
2244                 return -EFAULT;
2245         }
2246         for (i=0; i<copycount; i++) {
2247                 struct sockaddr_storage ss;
2248
2249                 psin = (struct sockaddr_in *)&ss;
2250                 memset(&ss, 0, sizeof(ss));
2251                 psin->sin_family = AF_INET;
2252                 psin->sin_addr.s_addr = psl->sl_addr[i];
2253                 if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss)))
2254                         return -EFAULT;
2255         }
2256         return 0;
2257 done:
2258         rtnl_unlock();
2259         return err;
2260 }
2261
2262 /*
2263  * check if a multicast source filter allows delivery for a given <src,dst,intf>
2264  */
2265 int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif)
2266 {
2267         struct inet_sock *inet = inet_sk(sk);
2268         struct ip_mc_socklist *pmc;
2269         struct ip_sf_socklist *psl;
2270         int i;
2271         int ret;
2272
2273         ret = 1;
2274         if (!ipv4_is_multicast(loc_addr))
2275                 goto out;
2276
2277         rcu_read_lock();
2278         for_each_pmc_rcu(inet, pmc) {
2279                 if (pmc->multi.imr_multiaddr.s_addr == loc_addr &&
2280                     pmc->multi.imr_ifindex == dif)
2281                         break;
2282         }
2283         ret = inet->mc_all;
2284         if (!pmc)
2285                 goto unlock;
2286         psl = rcu_dereference(pmc->sflist);
2287         ret = (pmc->sfmode == MCAST_EXCLUDE);
2288         if (!psl)
2289                 goto unlock;
2290
2291         for (i=0; i<psl->sl_count; i++) {
2292                 if (psl->sl_addr[i] == rmt_addr)
2293                         break;
2294         }
2295         ret = 0;
2296         if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)
2297                 goto unlock;
2298         if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)
2299                 goto unlock;
2300         ret = 1;
2301 unlock:
2302         rcu_read_unlock();
2303 out:
2304         return ret;
2305 }
2306
2307 /*
2308  *      A socket is closing.
2309  */
2310
2311 void ip_mc_drop_socket(struct sock *sk)
2312 {
2313         struct inet_sock *inet = inet_sk(sk);
2314         struct ip_mc_socklist *iml;
2315         struct net *net = sock_net(sk);
2316
2317         if (inet->mc_list == NULL)
2318                 return;
2319
2320         rtnl_lock();
2321         while ((iml = rtnl_dereference(inet->mc_list)) != NULL) {
2322                 struct in_device *in_dev;
2323
2324                 inet->mc_list = iml->next_rcu;
2325                 in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
2326                 (void) ip_mc_leave_src(sk, iml, in_dev);
2327                 if (in_dev != NULL)
2328                         ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
2329                 /* decrease mem now to avoid the memleak warning */
2330                 atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
2331                 call_rcu(&iml->rcu, ip_mc_socklist_reclaim);
2332         }
2333         rtnl_unlock();
2334 }
2335
2336 /* called with rcu_read_lock() */
2337 int ip_check_mc_rcu(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u16 proto)
2338 {
2339         struct ip_mc_list *im;
2340         struct ip_sf_list *psf;
2341         int rv = 0;
2342
2343         for_each_pmc_rcu(in_dev, im) {
2344                 if (im->multiaddr == mc_addr)
2345                         break;
2346         }
2347         if (im && proto == IPPROTO_IGMP) {
2348                 rv = 1;
2349         } else if (im) {
2350                 if (src_addr) {
2351                         for (psf=im->sources; psf; psf=psf->sf_next) {
2352                                 if (psf->sf_inaddr == src_addr)
2353                                         break;
2354                         }
2355                         if (psf)
2356                                 rv = psf->sf_count[MCAST_INCLUDE] ||
2357                                         psf->sf_count[MCAST_EXCLUDE] !=
2358                                         im->sfcount[MCAST_EXCLUDE];
2359                         else
2360                                 rv = im->sfcount[MCAST_EXCLUDE] != 0;
2361                 } else
2362                         rv = 1; /* unspecified source; tentatively allow */
2363         }
2364         return rv;
2365 }
2366
2367 #if defined(CONFIG_PROC_FS)
2368 struct igmp_mc_iter_state {
2369         struct seq_net_private p;
2370         struct net_device *dev;
2371         struct in_device *in_dev;
2372 };
2373
2374 #define igmp_mc_seq_private(seq)        ((struct igmp_mc_iter_state *)(seq)->private)
2375
2376 static inline struct ip_mc_list *igmp_mc_get_first(struct seq_file *seq)
2377 {
2378         struct net *net = seq_file_net(seq);
2379         struct ip_mc_list *im = NULL;
2380         struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
2381
2382         state->in_dev = NULL;
2383         for_each_netdev_rcu(net, state->dev) {
2384                 struct in_device *in_dev;
2385
2386                 in_dev = __in_dev_get_rcu(state->dev);
2387                 if (!in_dev)
2388                         continue;
2389                 im = rcu_dereference(in_dev->mc_list);
2390                 if (im) {
2391                         state->in_dev = in_dev;
2392                         break;
2393                 }
2394         }
2395         return im;
2396 }
2397
2398 static struct ip_mc_list *igmp_mc_get_next(struct seq_file *seq, struct ip_mc_list *im)
2399 {
2400         struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
2401
2402         im = rcu_dereference(im->next_rcu);
2403         while (!im) {
2404                 state->dev = next_net_device_rcu(state->dev);
2405                 if (!state->dev) {
2406                         state->in_dev = NULL;
2407                         break;
2408                 }
2409                 state->in_dev = __in_dev_get_rcu(state->dev);
2410                 if (!state->in_dev)
2411                         continue;
2412                 im = rcu_dereference(state->in_dev->mc_list);
2413         }
2414         return im;
2415 }
2416
2417 static struct ip_mc_list *igmp_mc_get_idx(struct seq_file *seq, loff_t pos)
2418 {
2419         struct ip_mc_list *im = igmp_mc_get_first(seq);
2420         if (im)
2421                 while (pos && (im = igmp_mc_get_next(seq, im)) != NULL)
2422                         --pos;
2423         return pos ? NULL : im;
2424 }
2425
2426 static void *igmp_mc_seq_start(struct seq_file *seq, loff_t *pos)
2427         __acquires(rcu)
2428 {
2429         rcu_read_lock();
2430         return *pos ? igmp_mc_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2431 }
2432
2433 static void *igmp_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2434 {
2435         struct ip_mc_list *im;
2436         if (v == SEQ_START_TOKEN)
2437                 im = igmp_mc_get_first(seq);
2438         else
2439                 im = igmp_mc_get_next(seq, v);
2440         ++*pos;
2441         return im;
2442 }
2443
2444 static void igmp_mc_seq_stop(struct seq_file *seq, void *v)
2445         __releases(rcu)
2446 {
2447         struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
2448
2449         state->in_dev = NULL;
2450         state->dev = NULL;
2451         rcu_read_unlock();
2452 }
2453
2454 static int igmp_mc_seq_show(struct seq_file *seq, void *v)
2455 {
2456         if (v == SEQ_START_TOKEN)
2457                 seq_puts(seq,
2458                          "Idx\tDevice    : Count Querier\tGroup    Users Timer\tReporter\n");
2459         else {
2460                 struct ip_mc_list *im = (struct ip_mc_list *)v;
2461                 struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
2462                 char   *querier;
2463 #ifdef CONFIG_IP_MULTICAST
2464                 querier = IGMP_V1_SEEN(state->in_dev) ? "V1" :
2465                           IGMP_V2_SEEN(state->in_dev) ? "V2" :
2466                           "V3";
2467 #else
2468                 querier = "NONE";
2469 #endif
2470
2471                 if (rcu_dereference(state->in_dev->mc_list) == im) {
2472                         seq_printf(seq, "%d\t%-10s: %5d %7s\n",
2473                                    state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier);
2474                 }
2475
2476                 seq_printf(seq,
2477                            "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
2478                            im->multiaddr, im->users,
2479                            im->tm_running, im->tm_running ?
2480                            jiffies_to_clock_t(im->timer.expires-jiffies) : 0,
2481                            im->reporter);
2482         }
2483         return 0;
2484 }
2485
2486 static const struct seq_operations igmp_mc_seq_ops = {
2487         .start  =       igmp_mc_seq_start,
2488         .next   =       igmp_mc_seq_next,
2489         .stop   =       igmp_mc_seq_stop,
2490         .show   =       igmp_mc_seq_show,
2491 };
2492
2493 static int igmp_mc_seq_open(struct inode *inode, struct file *file)
2494 {
2495         return seq_open_net(inode, file, &igmp_mc_seq_ops,
2496                         sizeof(struct igmp_mc_iter_state));
2497 }
2498
2499 static const struct file_operations igmp_mc_seq_fops = {
2500         .owner          =       THIS_MODULE,
2501         .open           =       igmp_mc_seq_open,
2502         .read           =       seq_read,
2503         .llseek         =       seq_lseek,
2504         .release        =       seq_release_net,
2505 };
2506
2507 struct igmp_mcf_iter_state {
2508         struct seq_net_private p;
2509         struct net_device *dev;
2510         struct in_device *idev;
2511         struct ip_mc_list *im;
2512 };
2513
2514 #define igmp_mcf_seq_private(seq)       ((struct igmp_mcf_iter_state *)(seq)->private)
2515
2516 static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq)
2517 {
2518         struct net *net = seq_file_net(seq);
2519         struct ip_sf_list *psf = NULL;
2520         struct ip_mc_list *im = NULL;
2521         struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
2522
2523         state->idev = NULL;
2524         state->im = NULL;
2525         for_each_netdev_rcu(net, state->dev) {
2526                 struct in_device *idev;
2527                 idev = __in_dev_get_rcu(state->dev);
2528                 if (unlikely(idev == NULL))
2529                         continue;
2530                 im = rcu_dereference(idev->mc_list);
2531                 if (likely(im != NULL)) {
2532                         spin_lock_bh(&im->lock);
2533                         psf = im->sources;
2534                         if (likely(psf != NULL)) {
2535                                 state->im = im;
2536                                 state->idev = idev;
2537                                 break;
2538                         }
2539                         spin_unlock_bh(&im->lock);
2540                 }
2541         }
2542         return psf;
2543 }
2544
2545 static struct ip_sf_list *igmp_mcf_get_next(struct seq_file *seq, struct ip_sf_list *psf)
2546 {
2547         struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
2548
2549         psf = psf->sf_next;
2550         while (!psf) {
2551                 spin_unlock_bh(&state->im->lock);
2552                 state->im = state->im->next;
2553                 while (!state->im) {
2554                         state->dev = next_net_device_rcu(state->dev);
2555                         if (!state->dev) {
2556                                 state->idev = NULL;
2557                                 goto out;
2558                         }
2559                         state->idev = __in_dev_get_rcu(state->dev);
2560                         if (!state->idev)
2561                                 continue;
2562                         state->im = rcu_dereference(state->idev->mc_list);
2563                 }
2564                 if (!state->im)
2565                         break;
2566                 spin_lock_bh(&state->im->lock);
2567                 psf = state->im->sources;
2568         }
2569 out:
2570         return psf;
2571 }
2572
2573 static struct ip_sf_list *igmp_mcf_get_idx(struct seq_file *seq, loff_t pos)
2574 {
2575         struct ip_sf_list *psf = igmp_mcf_get_first(seq);
2576         if (psf)
2577                 while (pos && (psf = igmp_mcf_get_next(seq, psf)) != NULL)
2578                         --pos;
2579         return pos ? NULL : psf;
2580 }
2581
2582 static void *igmp_mcf_seq_start(struct seq_file *seq, loff_t *pos)
2583         __acquires(rcu)
2584 {
2585         rcu_read_lock();
2586         return *pos ? igmp_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2587 }
2588
2589 static void *igmp_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2590 {
2591         struct ip_sf_list *psf;
2592         if (v == SEQ_START_TOKEN)
2593                 psf = igmp_mcf_get_first(seq);
2594         else
2595                 psf = igmp_mcf_get_next(seq, v);
2596         ++*pos;
2597         return psf;
2598 }
2599
2600 static void igmp_mcf_seq_stop(struct seq_file *seq, void *v)
2601         __releases(rcu)
2602 {
2603         struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
2604         if (likely(state->im != NULL)) {
2605                 spin_unlock_bh(&state->im->lock);
2606                 state->im = NULL;
2607         }
2608         state->idev = NULL;
2609         state->dev = NULL;
2610         rcu_read_unlock();
2611 }
2612
2613 static int igmp_mcf_seq_show(struct seq_file *seq, void *v)
2614 {
2615         struct ip_sf_list *psf = (struct ip_sf_list *)v;
2616         struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
2617
2618         if (v == SEQ_START_TOKEN) {
2619                 seq_printf(seq,
2620                            "%3s %6s "
2621                            "%10s %10s %6s %6s\n", "Idx",
2622                            "Device", "MCA",
2623                            "SRC", "INC", "EXC");
2624         } else {
2625                 seq_printf(seq,
2626                            "%3d %6.6s 0x%08x "
2627                            "0x%08x %6lu %6lu\n",
2628                            state->dev->ifindex, state->dev->name,
2629                            ntohl(state->im->multiaddr),
2630                            ntohl(psf->sf_inaddr),
2631                            psf->sf_count[MCAST_INCLUDE],
2632                            psf->sf_count[MCAST_EXCLUDE]);
2633         }
2634         return 0;
2635 }
2636
2637 static const struct seq_operations igmp_mcf_seq_ops = {
2638         .start  =       igmp_mcf_seq_start,
2639         .next   =       igmp_mcf_seq_next,
2640         .stop   =       igmp_mcf_seq_stop,
2641         .show   =       igmp_mcf_seq_show,
2642 };
2643
2644 static int igmp_mcf_seq_open(struct inode *inode, struct file *file)
2645 {
2646         return seq_open_net(inode, file, &igmp_mcf_seq_ops,
2647                         sizeof(struct igmp_mcf_iter_state));
2648 }
2649
2650 static const struct file_operations igmp_mcf_seq_fops = {
2651         .owner          =       THIS_MODULE,
2652         .open           =       igmp_mcf_seq_open,
2653         .read           =       seq_read,
2654         .llseek         =       seq_lseek,
2655         .release        =       seq_release_net,
2656 };
2657
2658 static int __net_init igmp_net_init(struct net *net)
2659 {
2660         struct proc_dir_entry *pde;
2661
2662         pde = proc_net_fops_create(net, "igmp", S_IRUGO, &igmp_mc_seq_fops);
2663         if (!pde)
2664                 goto out_igmp;
2665         pde = proc_net_fops_create(net, "mcfilter", S_IRUGO, &igmp_mcf_seq_fops);
2666         if (!pde)
2667                 goto out_mcfilter;
2668         return 0;
2669
2670 out_mcfilter:
2671         proc_net_remove(net, "igmp");
2672 out_igmp:
2673         return -ENOMEM;
2674 }
2675
2676 static void __net_exit igmp_net_exit(struct net *net)
2677 {
2678         proc_net_remove(net, "mcfilter");
2679         proc_net_remove(net, "igmp");
2680 }
2681
2682 static struct pernet_operations igmp_net_ops = {
2683         .init = igmp_net_init,
2684         .exit = igmp_net_exit,
2685 };
2686
2687 int __init igmp_mc_proc_init(void)
2688 {
2689         return register_pernet_subsys(&igmp_net_ops);
2690 }
2691 #endif