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 <linux/uaccess.h> 76 #include <linux/types.h> 77 #include <linux/kernel.h> 78 #include <linux/jiffies.h> 79 #include <linux/string.h> 80 #include <linux/socket.h> 81 #include <linux/sockios.h> 82 #include <linux/in.h> 83 #include <linux/inet.h> 84 #include <linux/netdevice.h> 85 #include <linux/skbuff.h> 86 #include <linux/inetdevice.h> 87 #include <linux/igmp.h> 88 #include <linux/if_arp.h> 89 #include <linux/rtnetlink.h> 90 #include <linux/times.h> 91 #include <linux/pkt_sched.h> 92 #include <linux/byteorder/generic.h> 93 94 #include <net/net_namespace.h> 95 #include <net/arp.h> 96 #include <net/ip.h> 97 #include <net/protocol.h> 98 #include <net/route.h> 99 #include <net/sock.h> 100 #include <net/checksum.h> 101 #include <net/inet_common.h> 102 #include <linux/netfilter_ipv4.h> 103 #ifdef CONFIG_IP_MROUTE 104 #include <linux/mroute.h> 105 #endif 106 #ifdef CONFIG_PROC_FS 107 #include <linux/proc_fs.h> 108 #include <linux/seq_file.h> 109 #endif 110 111 #ifdef CONFIG_IP_MULTICAST 112 /* Parameter names and values are taken from igmp-v2-06 draft */ 113 114 #define IGMP_V2_UNSOLICITED_REPORT_INTERVAL (10*HZ) 115 #define IGMP_V3_UNSOLICITED_REPORT_INTERVAL (1*HZ) 116 #define IGMP_QUERY_INTERVAL (125*HZ) 117 #define IGMP_QUERY_RESPONSE_INTERVAL (10*HZ) 118 119 #define IGMP_INITIAL_REPORT_DELAY (1) 120 121 /* IGMP_INITIAL_REPORT_DELAY is not from IGMP specs! 122 * IGMP specs require to report membership immediately after 123 * joining a group, but we delay the first report by a 124 * small interval. It seems more natural and still does not 125 * contradict to specs provided this delay is small enough. 126 */ 127 128 #define IGMP_V1_SEEN(in_dev) \ 129 (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \ 130 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \ 131 ((in_dev)->mr_v1_seen && \ 132 time_before(jiffies, (in_dev)->mr_v1_seen))) 133 #define IGMP_V2_SEEN(in_dev) \ 134 (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \ 135 IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \ 136 ((in_dev)->mr_v2_seen && \ 137 time_before(jiffies, (in_dev)->mr_v2_seen))) 138 139 static int unsolicited_report_interval(struct in_device *in_dev) 140 { 141 int interval_ms, interval_jiffies; 142 143 if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) 144 interval_ms = IN_DEV_CONF_GET( 145 in_dev, 146 IGMPV2_UNSOLICITED_REPORT_INTERVAL); 147 else /* v3 */ 148 interval_ms = IN_DEV_CONF_GET( 149 in_dev, 150 IGMPV3_UNSOLICITED_REPORT_INTERVAL); 151 152 interval_jiffies = msecs_to_jiffies(interval_ms); 153 154 /* _timer functions can't handle a delay of 0 jiffies so ensure 155 * we always return a positive value. 156 */ 157 if (interval_jiffies <= 0) 158 interval_jiffies = 1; 159 return interval_jiffies; 160 } 161 162 static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im, 163 gfp_t gfp); 164 static void igmpv3_del_delrec(struct in_device *in_dev, struct ip_mc_list *im); 165 static void igmpv3_clear_delrec(struct in_device *in_dev); 166 static int sf_setstate(struct ip_mc_list *pmc); 167 static void sf_markstate(struct ip_mc_list *pmc); 168 #endif 169 static void ip_mc_clear_src(struct ip_mc_list *pmc); 170 static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode, 171 int sfcount, __be32 *psfsrc, int delta); 172 173 static void ip_ma_put(struct ip_mc_list *im) 174 { 175 if (refcount_dec_and_test(&im->refcnt)) { 176 in_dev_put(im->interface); 177 kfree_rcu(im, rcu); 178 } 179 } 180 181 #define for_each_pmc_rcu(in_dev, pmc) \ 182 for (pmc = rcu_dereference(in_dev->mc_list); \ 183 pmc != NULL; \ 184 pmc = rcu_dereference(pmc->next_rcu)) 185 186 #define for_each_pmc_rtnl(in_dev, pmc) \ 187 for (pmc = rtnl_dereference(in_dev->mc_list); \ 188 pmc != NULL; \ 189 pmc = rtnl_dereference(pmc->next_rcu)) 190 191 static void ip_sf_list_clear_all(struct ip_sf_list *psf) 192 { 193 struct ip_sf_list *next; 194 195 while (psf) { 196 next = psf->sf_next; 197 kfree(psf); 198 psf = next; 199 } 200 } 201 202 #ifdef CONFIG_IP_MULTICAST 203 204 /* 205 * Timer management 206 */ 207 208 static void igmp_stop_timer(struct ip_mc_list *im) 209 { 210 spin_lock_bh(&im->lock); 211 if (del_timer(&im->timer)) 212 refcount_dec(&im->refcnt); 213 im->tm_running = 0; 214 im->reporter = 0; 215 im->unsolicit_count = 0; 216 spin_unlock_bh(&im->lock); 217 } 218 219 /* It must be called with locked im->lock */ 220 static void igmp_start_timer(struct ip_mc_list *im, int max_delay) 221 { 222 int tv = prandom_u32() % max_delay; 223 224 im->tm_running = 1; 225 if (!mod_timer(&im->timer, jiffies+tv+2)) 226 refcount_inc(&im->refcnt); 227 } 228 229 static void igmp_gq_start_timer(struct in_device *in_dev) 230 { 231 int tv = prandom_u32() % in_dev->mr_maxdelay; 232 unsigned long exp = jiffies + tv + 2; 233 234 if (in_dev->mr_gq_running && 235 time_after_eq(exp, (in_dev->mr_gq_timer).expires)) 236 return; 237 238 in_dev->mr_gq_running = 1; 239 if (!mod_timer(&in_dev->mr_gq_timer, exp)) 240 in_dev_hold(in_dev); 241 } 242 243 static void igmp_ifc_start_timer(struct in_device *in_dev, int delay) 244 { 245 int tv = prandom_u32() % delay; 246 247 if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2)) 248 in_dev_hold(in_dev); 249 } 250 251 static void igmp_mod_timer(struct ip_mc_list *im, int max_delay) 252 { 253 spin_lock_bh(&im->lock); 254 im->unsolicit_count = 0; 255 if (del_timer(&im->timer)) { 256 if ((long)(im->timer.expires-jiffies) < max_delay) { 257 add_timer(&im->timer); 258 im->tm_running = 1; 259 spin_unlock_bh(&im->lock); 260 return; 261 } 262 refcount_dec(&im->refcnt); 263 } 264 igmp_start_timer(im, max_delay); 265 spin_unlock_bh(&im->lock); 266 } 267 268 269 /* 270 * Send an IGMP report. 271 */ 272 273 #define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4) 274 275 276 static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type, 277 int gdeleted, int sdeleted) 278 { 279 switch (type) { 280 case IGMPV3_MODE_IS_INCLUDE: 281 case IGMPV3_MODE_IS_EXCLUDE: 282 if (gdeleted || sdeleted) 283 return 0; 284 if (!(pmc->gsquery && !psf->sf_gsresp)) { 285 if (pmc->sfmode == MCAST_INCLUDE) 286 return 1; 287 /* don't include if this source is excluded 288 * in all filters 289 */ 290 if (psf->sf_count[MCAST_INCLUDE]) 291 return type == IGMPV3_MODE_IS_INCLUDE; 292 return pmc->sfcount[MCAST_EXCLUDE] == 293 psf->sf_count[MCAST_EXCLUDE]; 294 } 295 return 0; 296 case IGMPV3_CHANGE_TO_INCLUDE: 297 if (gdeleted || sdeleted) 298 return 0; 299 return psf->sf_count[MCAST_INCLUDE] != 0; 300 case IGMPV3_CHANGE_TO_EXCLUDE: 301 if (gdeleted || sdeleted) 302 return 0; 303 if (pmc->sfcount[MCAST_EXCLUDE] == 0 || 304 psf->sf_count[MCAST_INCLUDE]) 305 return 0; 306 return pmc->sfcount[MCAST_EXCLUDE] == 307 psf->sf_count[MCAST_EXCLUDE]; 308 case IGMPV3_ALLOW_NEW_SOURCES: 309 if (gdeleted || !psf->sf_crcount) 310 return 0; 311 return (pmc->sfmode == MCAST_INCLUDE) ^ sdeleted; 312 case IGMPV3_BLOCK_OLD_SOURCES: 313 if (pmc->sfmode == MCAST_INCLUDE) 314 return gdeleted || (psf->sf_crcount && sdeleted); 315 return psf->sf_crcount && !gdeleted && !sdeleted; 316 } 317 return 0; 318 } 319 320 static int 321 igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted) 322 { 323 struct ip_sf_list *psf; 324 int scount = 0; 325 326 for (psf = pmc->sources; psf; psf = psf->sf_next) { 327 if (!is_in(pmc, psf, type, gdeleted, sdeleted)) 328 continue; 329 scount++; 330 } 331 return scount; 332 } 333 334 /* source address selection per RFC 3376 section 4.2.13 */ 335 static __be32 igmpv3_get_srcaddr(struct net_device *dev, 336 const struct flowi4 *fl4) 337 { 338 struct in_device *in_dev = __in_dev_get_rcu(dev); 339 const struct in_ifaddr *ifa; 340 341 if (!in_dev) 342 return htonl(INADDR_ANY); 343 344 in_dev_for_each_ifa_rcu(ifa, in_dev) { 345 if (fl4->saddr == ifa->ifa_local) 346 return fl4->saddr; 347 } 348 349 return htonl(INADDR_ANY); 350 } 351 352 static struct sk_buff *igmpv3_newpack(struct net_device *dev, unsigned int mtu) 353 { 354 struct sk_buff *skb; 355 struct rtable *rt; 356 struct iphdr *pip; 357 struct igmpv3_report *pig; 358 struct net *net = dev_net(dev); 359 struct flowi4 fl4; 360 int hlen = LL_RESERVED_SPACE(dev); 361 int tlen = dev->needed_tailroom; 362 unsigned int size = mtu; 363 364 while (1) { 365 skb = alloc_skb(size + hlen + tlen, 366 GFP_ATOMIC | __GFP_NOWARN); 367 if (skb) 368 break; 369 size >>= 1; 370 if (size < 256) 371 return NULL; 372 } 373 skb->priority = TC_PRIO_CONTROL; 374 375 rt = ip_route_output_ports(net, &fl4, NULL, IGMPV3_ALL_MCR, 0, 376 0, 0, 377 IPPROTO_IGMP, 0, dev->ifindex); 378 if (IS_ERR(rt)) { 379 kfree_skb(skb); 380 return NULL; 381 } 382 383 skb_dst_set(skb, &rt->dst); 384 skb->dev = dev; 385 386 skb_reserve(skb, hlen); 387 skb_tailroom_reserve(skb, mtu, tlen); 388 389 skb_reset_network_header(skb); 390 pip = ip_hdr(skb); 391 skb_put(skb, sizeof(struct iphdr) + 4); 392 393 pip->version = 4; 394 pip->ihl = (sizeof(struct iphdr)+4)>>2; 395 pip->tos = 0xc0; 396 pip->frag_off = htons(IP_DF); 397 pip->ttl = 1; 398 pip->daddr = fl4.daddr; 399 400 rcu_read_lock(); 401 pip->saddr = igmpv3_get_srcaddr(dev, &fl4); 402 rcu_read_unlock(); 403 404 pip->protocol = IPPROTO_IGMP; 405 pip->tot_len = 0; /* filled in later */ 406 ip_select_ident(net, skb, NULL); 407 ((u8 *)&pip[1])[0] = IPOPT_RA; 408 ((u8 *)&pip[1])[1] = 4; 409 ((u8 *)&pip[1])[2] = 0; 410 ((u8 *)&pip[1])[3] = 0; 411 412 skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4; 413 skb_put(skb, sizeof(*pig)); 414 pig = igmpv3_report_hdr(skb); 415 pig->type = IGMPV3_HOST_MEMBERSHIP_REPORT; 416 pig->resv1 = 0; 417 pig->csum = 0; 418 pig->resv2 = 0; 419 pig->ngrec = 0; 420 return skb; 421 } 422 423 static int igmpv3_sendpack(struct sk_buff *skb) 424 { 425 struct igmphdr *pig = igmp_hdr(skb); 426 const int igmplen = skb_tail_pointer(skb) - skb_transport_header(skb); 427 428 pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen); 429 430 return ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb); 431 } 432 433 static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel) 434 { 435 return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel); 436 } 437 438 static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc, 439 int type, struct igmpv3_grec **ppgr, unsigned int mtu) 440 { 441 struct net_device *dev = pmc->interface->dev; 442 struct igmpv3_report *pih; 443 struct igmpv3_grec *pgr; 444 445 if (!skb) { 446 skb = igmpv3_newpack(dev, mtu); 447 if (!skb) 448 return NULL; 449 } 450 pgr = skb_put(skb, sizeof(struct igmpv3_grec)); 451 pgr->grec_type = type; 452 pgr->grec_auxwords = 0; 453 pgr->grec_nsrcs = 0; 454 pgr->grec_mca = pmc->multiaddr; 455 pih = igmpv3_report_hdr(skb); 456 pih->ngrec = htons(ntohs(pih->ngrec)+1); 457 *ppgr = pgr; 458 return skb; 459 } 460 461 #define AVAILABLE(skb) ((skb) ? skb_availroom(skb) : 0) 462 463 static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc, 464 int type, int gdeleted, int sdeleted) 465 { 466 struct net_device *dev = pmc->interface->dev; 467 struct net *net = dev_net(dev); 468 struct igmpv3_report *pih; 469 struct igmpv3_grec *pgr = NULL; 470 struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list; 471 int scount, stotal, first, isquery, truncate; 472 unsigned int mtu; 473 474 if (pmc->multiaddr == IGMP_ALL_HOSTS) 475 return skb; 476 if (ipv4_is_local_multicast(pmc->multiaddr) && !net->ipv4.sysctl_igmp_llm_reports) 477 return skb; 478 479 mtu = READ_ONCE(dev->mtu); 480 if (mtu < IPV4_MIN_MTU) 481 return skb; 482 483 isquery = type == IGMPV3_MODE_IS_INCLUDE || 484 type == IGMPV3_MODE_IS_EXCLUDE; 485 truncate = type == IGMPV3_MODE_IS_EXCLUDE || 486 type == IGMPV3_CHANGE_TO_EXCLUDE; 487 488 stotal = scount = 0; 489 490 psf_list = sdeleted ? &pmc->tomb : &pmc->sources; 491 492 if (!*psf_list) 493 goto empty_source; 494 495 pih = skb ? igmpv3_report_hdr(skb) : NULL; 496 497 /* EX and TO_EX get a fresh packet, if needed */ 498 if (truncate) { 499 if (pih && pih->ngrec && 500 AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) { 501 if (skb) 502 igmpv3_sendpack(skb); 503 skb = igmpv3_newpack(dev, mtu); 504 } 505 } 506 first = 1; 507 psf_prev = NULL; 508 for (psf = *psf_list; psf; psf = psf_next) { 509 __be32 *psrc; 510 511 psf_next = psf->sf_next; 512 513 if (!is_in(pmc, psf, type, gdeleted, sdeleted)) { 514 psf_prev = psf; 515 continue; 516 } 517 518 /* Based on RFC3376 5.1. Should not send source-list change 519 * records when there is a filter mode change. 520 */ 521 if (((gdeleted && pmc->sfmode == MCAST_EXCLUDE) || 522 (!gdeleted && pmc->crcount)) && 523 (type == IGMPV3_ALLOW_NEW_SOURCES || 524 type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) 525 goto decrease_sf_crcount; 526 527 /* clear marks on query responses */ 528 if (isquery) 529 psf->sf_gsresp = 0; 530 531 if (AVAILABLE(skb) < sizeof(__be32) + 532 first*sizeof(struct igmpv3_grec)) { 533 if (truncate && !first) 534 break; /* truncate these */ 535 if (pgr) 536 pgr->grec_nsrcs = htons(scount); 537 if (skb) 538 igmpv3_sendpack(skb); 539 skb = igmpv3_newpack(dev, mtu); 540 first = 1; 541 scount = 0; 542 } 543 if (first) { 544 skb = add_grhead(skb, pmc, type, &pgr, mtu); 545 first = 0; 546 } 547 if (!skb) 548 return NULL; 549 psrc = skb_put(skb, sizeof(__be32)); 550 *psrc = psf->sf_inaddr; 551 scount++; stotal++; 552 if ((type == IGMPV3_ALLOW_NEW_SOURCES || 553 type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) { 554 decrease_sf_crcount: 555 psf->sf_crcount--; 556 if ((sdeleted || gdeleted) && psf->sf_crcount == 0) { 557 if (psf_prev) 558 psf_prev->sf_next = psf->sf_next; 559 else 560 *psf_list = psf->sf_next; 561 kfree(psf); 562 continue; 563 } 564 } 565 psf_prev = psf; 566 } 567 568 empty_source: 569 if (!stotal) { 570 if (type == IGMPV3_ALLOW_NEW_SOURCES || 571 type == IGMPV3_BLOCK_OLD_SOURCES) 572 return skb; 573 if (pmc->crcount || isquery) { 574 /* make sure we have room for group header */ 575 if (skb && AVAILABLE(skb) < sizeof(struct igmpv3_grec)) { 576 igmpv3_sendpack(skb); 577 skb = NULL; /* add_grhead will get a new one */ 578 } 579 skb = add_grhead(skb, pmc, type, &pgr, mtu); 580 } 581 } 582 if (pgr) 583 pgr->grec_nsrcs = htons(scount); 584 585 if (isquery) 586 pmc->gsquery = 0; /* clear query state on report */ 587 return skb; 588 } 589 590 static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc) 591 { 592 struct sk_buff *skb = NULL; 593 struct net *net = dev_net(in_dev->dev); 594 int type; 595 596 if (!pmc) { 597 rcu_read_lock(); 598 for_each_pmc_rcu(in_dev, pmc) { 599 if (pmc->multiaddr == IGMP_ALL_HOSTS) 600 continue; 601 if (ipv4_is_local_multicast(pmc->multiaddr) && 602 !net->ipv4.sysctl_igmp_llm_reports) 603 continue; 604 spin_lock_bh(&pmc->lock); 605 if (pmc->sfcount[MCAST_EXCLUDE]) 606 type = IGMPV3_MODE_IS_EXCLUDE; 607 else 608 type = IGMPV3_MODE_IS_INCLUDE; 609 skb = add_grec(skb, pmc, type, 0, 0); 610 spin_unlock_bh(&pmc->lock); 611 } 612 rcu_read_unlock(); 613 } else { 614 spin_lock_bh(&pmc->lock); 615 if (pmc->sfcount[MCAST_EXCLUDE]) 616 type = IGMPV3_MODE_IS_EXCLUDE; 617 else 618 type = IGMPV3_MODE_IS_INCLUDE; 619 skb = add_grec(skb, pmc, type, 0, 0); 620 spin_unlock_bh(&pmc->lock); 621 } 622 if (!skb) 623 return 0; 624 return igmpv3_sendpack(skb); 625 } 626 627 /* 628 * remove zero-count source records from a source filter list 629 */ 630 static void igmpv3_clear_zeros(struct ip_sf_list **ppsf) 631 { 632 struct ip_sf_list *psf_prev, *psf_next, *psf; 633 634 psf_prev = NULL; 635 for (psf = *ppsf; psf; psf = psf_next) { 636 psf_next = psf->sf_next; 637 if (psf->sf_crcount == 0) { 638 if (psf_prev) 639 psf_prev->sf_next = psf->sf_next; 640 else 641 *ppsf = psf->sf_next; 642 kfree(psf); 643 } else 644 psf_prev = psf; 645 } 646 } 647 648 static void kfree_pmc(struct ip_mc_list *pmc) 649 { 650 ip_sf_list_clear_all(pmc->sources); 651 ip_sf_list_clear_all(pmc->tomb); 652 kfree(pmc); 653 } 654 655 static void igmpv3_send_cr(struct in_device *in_dev) 656 { 657 struct ip_mc_list *pmc, *pmc_prev, *pmc_next; 658 struct sk_buff *skb = NULL; 659 int type, dtype; 660 661 rcu_read_lock(); 662 spin_lock_bh(&in_dev->mc_tomb_lock); 663 664 /* deleted MCA's */ 665 pmc_prev = NULL; 666 for (pmc = in_dev->mc_tomb; pmc; pmc = pmc_next) { 667 pmc_next = pmc->next; 668 if (pmc->sfmode == MCAST_INCLUDE) { 669 type = IGMPV3_BLOCK_OLD_SOURCES; 670 dtype = IGMPV3_BLOCK_OLD_SOURCES; 671 skb = add_grec(skb, pmc, type, 1, 0); 672 skb = add_grec(skb, pmc, dtype, 1, 1); 673 } 674 if (pmc->crcount) { 675 if (pmc->sfmode == MCAST_EXCLUDE) { 676 type = IGMPV3_CHANGE_TO_INCLUDE; 677 skb = add_grec(skb, pmc, type, 1, 0); 678 } 679 pmc->crcount--; 680 if (pmc->crcount == 0) { 681 igmpv3_clear_zeros(&pmc->tomb); 682 igmpv3_clear_zeros(&pmc->sources); 683 } 684 } 685 if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) { 686 if (pmc_prev) 687 pmc_prev->next = pmc_next; 688 else 689 in_dev->mc_tomb = pmc_next; 690 in_dev_put(pmc->interface); 691 kfree_pmc(pmc); 692 } else 693 pmc_prev = pmc; 694 } 695 spin_unlock_bh(&in_dev->mc_tomb_lock); 696 697 /* change recs */ 698 for_each_pmc_rcu(in_dev, pmc) { 699 spin_lock_bh(&pmc->lock); 700 if (pmc->sfcount[MCAST_EXCLUDE]) { 701 type = IGMPV3_BLOCK_OLD_SOURCES; 702 dtype = IGMPV3_ALLOW_NEW_SOURCES; 703 } else { 704 type = IGMPV3_ALLOW_NEW_SOURCES; 705 dtype = IGMPV3_BLOCK_OLD_SOURCES; 706 } 707 skb = add_grec(skb, pmc, type, 0, 0); 708 skb = add_grec(skb, pmc, dtype, 0, 1); /* deleted sources */ 709 710 /* filter mode changes */ 711 if (pmc->crcount) { 712 if (pmc->sfmode == MCAST_EXCLUDE) 713 type = IGMPV3_CHANGE_TO_EXCLUDE; 714 else 715 type = IGMPV3_CHANGE_TO_INCLUDE; 716 skb = add_grec(skb, pmc, type, 0, 0); 717 pmc->crcount--; 718 } 719 spin_unlock_bh(&pmc->lock); 720 } 721 rcu_read_unlock(); 722 723 if (!skb) 724 return; 725 (void) igmpv3_sendpack(skb); 726 } 727 728 static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc, 729 int type) 730 { 731 struct sk_buff *skb; 732 struct iphdr *iph; 733 struct igmphdr *ih; 734 struct rtable *rt; 735 struct net_device *dev = in_dev->dev; 736 struct net *net = dev_net(dev); 737 __be32 group = pmc ? pmc->multiaddr : 0; 738 struct flowi4 fl4; 739 __be32 dst; 740 int hlen, tlen; 741 742 if (type == IGMPV3_HOST_MEMBERSHIP_REPORT) 743 return igmpv3_send_report(in_dev, pmc); 744 745 if (ipv4_is_local_multicast(group) && !net->ipv4.sysctl_igmp_llm_reports) 746 return 0; 747 748 if (type == IGMP_HOST_LEAVE_MESSAGE) 749 dst = IGMP_ALL_ROUTER; 750 else 751 dst = group; 752 753 rt = ip_route_output_ports(net, &fl4, NULL, dst, 0, 754 0, 0, 755 IPPROTO_IGMP, 0, dev->ifindex); 756 if (IS_ERR(rt)) 757 return -1; 758 759 hlen = LL_RESERVED_SPACE(dev); 760 tlen = dev->needed_tailroom; 761 skb = alloc_skb(IGMP_SIZE + hlen + tlen, GFP_ATOMIC); 762 if (!skb) { 763 ip_rt_put(rt); 764 return -1; 765 } 766 skb->priority = TC_PRIO_CONTROL; 767 768 skb_dst_set(skb, &rt->dst); 769 770 skb_reserve(skb, hlen); 771 772 skb_reset_network_header(skb); 773 iph = ip_hdr(skb); 774 skb_put(skb, sizeof(struct iphdr) + 4); 775 776 iph->version = 4; 777 iph->ihl = (sizeof(struct iphdr)+4)>>2; 778 iph->tos = 0xc0; 779 iph->frag_off = htons(IP_DF); 780 iph->ttl = 1; 781 iph->daddr = dst; 782 iph->saddr = fl4.saddr; 783 iph->protocol = IPPROTO_IGMP; 784 ip_select_ident(net, skb, NULL); 785 ((u8 *)&iph[1])[0] = IPOPT_RA; 786 ((u8 *)&iph[1])[1] = 4; 787 ((u8 *)&iph[1])[2] = 0; 788 ((u8 *)&iph[1])[3] = 0; 789 790 ih = skb_put(skb, sizeof(struct igmphdr)); 791 ih->type = type; 792 ih->code = 0; 793 ih->csum = 0; 794 ih->group = group; 795 ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr)); 796 797 return ip_local_out(net, skb->sk, skb); 798 } 799 800 static void igmp_gq_timer_expire(struct timer_list *t) 801 { 802 struct in_device *in_dev = from_timer(in_dev, t, mr_gq_timer); 803 804 in_dev->mr_gq_running = 0; 805 igmpv3_send_report(in_dev, NULL); 806 in_dev_put(in_dev); 807 } 808 809 static void igmp_ifc_timer_expire(struct timer_list *t) 810 { 811 struct in_device *in_dev = from_timer(in_dev, t, mr_ifc_timer); 812 813 igmpv3_send_cr(in_dev); 814 if (in_dev->mr_ifc_count) { 815 in_dev->mr_ifc_count--; 816 igmp_ifc_start_timer(in_dev, 817 unsolicited_report_interval(in_dev)); 818 } 819 in_dev_put(in_dev); 820 } 821 822 static void igmp_ifc_event(struct in_device *in_dev) 823 { 824 struct net *net = dev_net(in_dev->dev); 825 if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) 826 return; 827 in_dev->mr_ifc_count = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 828 igmp_ifc_start_timer(in_dev, 1); 829 } 830 831 832 static void igmp_timer_expire(struct timer_list *t) 833 { 834 struct ip_mc_list *im = from_timer(im, t, timer); 835 struct in_device *in_dev = im->interface; 836 837 spin_lock(&im->lock); 838 im->tm_running = 0; 839 840 if (im->unsolicit_count && --im->unsolicit_count) 841 igmp_start_timer(im, unsolicited_report_interval(in_dev)); 842 843 im->reporter = 1; 844 spin_unlock(&im->lock); 845 846 if (IGMP_V1_SEEN(in_dev)) 847 igmp_send_report(in_dev, im, IGMP_HOST_MEMBERSHIP_REPORT); 848 else if (IGMP_V2_SEEN(in_dev)) 849 igmp_send_report(in_dev, im, IGMPV2_HOST_MEMBERSHIP_REPORT); 850 else 851 igmp_send_report(in_dev, im, IGMPV3_HOST_MEMBERSHIP_REPORT); 852 853 ip_ma_put(im); 854 } 855 856 /* mark EXCLUDE-mode sources */ 857 static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs) 858 { 859 struct ip_sf_list *psf; 860 int i, scount; 861 862 scount = 0; 863 for (psf = pmc->sources; psf; psf = psf->sf_next) { 864 if (scount == nsrcs) 865 break; 866 for (i = 0; i < nsrcs; i++) { 867 /* skip inactive filters */ 868 if (psf->sf_count[MCAST_INCLUDE] || 869 pmc->sfcount[MCAST_EXCLUDE] != 870 psf->sf_count[MCAST_EXCLUDE]) 871 break; 872 if (srcs[i] == psf->sf_inaddr) { 873 scount++; 874 break; 875 } 876 } 877 } 878 pmc->gsquery = 0; 879 if (scount == nsrcs) /* all sources excluded */ 880 return 0; 881 return 1; 882 } 883 884 static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs) 885 { 886 struct ip_sf_list *psf; 887 int i, scount; 888 889 if (pmc->sfmode == MCAST_EXCLUDE) 890 return igmp_xmarksources(pmc, nsrcs, srcs); 891 892 /* mark INCLUDE-mode sources */ 893 scount = 0; 894 for (psf = pmc->sources; psf; psf = psf->sf_next) { 895 if (scount == nsrcs) 896 break; 897 for (i = 0; i < nsrcs; i++) 898 if (srcs[i] == psf->sf_inaddr) { 899 psf->sf_gsresp = 1; 900 scount++; 901 break; 902 } 903 } 904 if (!scount) { 905 pmc->gsquery = 0; 906 return 0; 907 } 908 pmc->gsquery = 1; 909 return 1; 910 } 911 912 /* return true if packet was dropped */ 913 static bool igmp_heard_report(struct in_device *in_dev, __be32 group) 914 { 915 struct ip_mc_list *im; 916 struct net *net = dev_net(in_dev->dev); 917 918 /* Timers are only set for non-local groups */ 919 920 if (group == IGMP_ALL_HOSTS) 921 return false; 922 if (ipv4_is_local_multicast(group) && !net->ipv4.sysctl_igmp_llm_reports) 923 return false; 924 925 rcu_read_lock(); 926 for_each_pmc_rcu(in_dev, im) { 927 if (im->multiaddr == group) { 928 igmp_stop_timer(im); 929 break; 930 } 931 } 932 rcu_read_unlock(); 933 return false; 934 } 935 936 /* return true if packet was dropped */ 937 static bool igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb, 938 int len) 939 { 940 struct igmphdr *ih = igmp_hdr(skb); 941 struct igmpv3_query *ih3 = igmpv3_query_hdr(skb); 942 struct ip_mc_list *im; 943 __be32 group = ih->group; 944 int max_delay; 945 int mark = 0; 946 struct net *net = dev_net(in_dev->dev); 947 948 949 if (len == 8) { 950 if (ih->code == 0) { 951 /* Alas, old v1 router presents here. */ 952 953 max_delay = IGMP_QUERY_RESPONSE_INTERVAL; 954 in_dev->mr_v1_seen = jiffies + 955 (in_dev->mr_qrv * in_dev->mr_qi) + 956 in_dev->mr_qri; 957 group = 0; 958 } else { 959 /* v2 router present */ 960 max_delay = ih->code*(HZ/IGMP_TIMER_SCALE); 961 in_dev->mr_v2_seen = jiffies + 962 (in_dev->mr_qrv * in_dev->mr_qi) + 963 in_dev->mr_qri; 964 } 965 /* cancel the interface change timer */ 966 in_dev->mr_ifc_count = 0; 967 if (del_timer(&in_dev->mr_ifc_timer)) 968 __in_dev_put(in_dev); 969 /* clear deleted report items */ 970 igmpv3_clear_delrec(in_dev); 971 } else if (len < 12) { 972 return true; /* ignore bogus packet; freed by caller */ 973 } else if (IGMP_V1_SEEN(in_dev)) { 974 /* This is a v3 query with v1 queriers present */ 975 max_delay = IGMP_QUERY_RESPONSE_INTERVAL; 976 group = 0; 977 } else if (IGMP_V2_SEEN(in_dev)) { 978 /* this is a v3 query with v2 queriers present; 979 * Interpretation of the max_delay code is problematic here. 980 * A real v2 host would use ih_code directly, while v3 has a 981 * different encoding. We use the v3 encoding as more likely 982 * to be intended in a v3 query. 983 */ 984 max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE); 985 if (!max_delay) 986 max_delay = 1; /* can't mod w/ 0 */ 987 } else { /* v3 */ 988 if (!pskb_may_pull(skb, sizeof(struct igmpv3_query))) 989 return true; 990 991 ih3 = igmpv3_query_hdr(skb); 992 if (ih3->nsrcs) { 993 if (!pskb_may_pull(skb, sizeof(struct igmpv3_query) 994 + ntohs(ih3->nsrcs)*sizeof(__be32))) 995 return true; 996 ih3 = igmpv3_query_hdr(skb); 997 } 998 999 max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE); 1000 if (!max_delay) 1001 max_delay = 1; /* can't mod w/ 0 */ 1002 in_dev->mr_maxdelay = max_delay; 1003 1004 /* RFC3376, 4.1.6. QRV and 4.1.7. QQIC, when the most recently 1005 * received value was zero, use the default or statically 1006 * configured value. 1007 */ 1008 in_dev->mr_qrv = ih3->qrv ?: net->ipv4.sysctl_igmp_qrv; 1009 in_dev->mr_qi = IGMPV3_QQIC(ih3->qqic)*HZ ?: IGMP_QUERY_INTERVAL; 1010 1011 /* RFC3376, 8.3. Query Response Interval: 1012 * The number of seconds represented by the [Query Response 1013 * Interval] must be less than the [Query Interval]. 1014 */ 1015 if (in_dev->mr_qri >= in_dev->mr_qi) 1016 in_dev->mr_qri = (in_dev->mr_qi/HZ - 1)*HZ; 1017 1018 if (!group) { /* general query */ 1019 if (ih3->nsrcs) 1020 return true; /* no sources allowed */ 1021 igmp_gq_start_timer(in_dev); 1022 return false; 1023 } 1024 /* mark sources to include, if group & source-specific */ 1025 mark = ih3->nsrcs != 0; 1026 } 1027 1028 /* 1029 * - Start the timers in all of our membership records 1030 * that the query applies to for the interface on 1031 * which the query arrived excl. those that belong 1032 * to a "local" group (224.0.0.X) 1033 * - For timers already running check if they need to 1034 * be reset. 1035 * - Use the igmp->igmp_code field as the maximum 1036 * delay possible 1037 */ 1038 rcu_read_lock(); 1039 for_each_pmc_rcu(in_dev, im) { 1040 int changed; 1041 1042 if (group && group != im->multiaddr) 1043 continue; 1044 if (im->multiaddr == IGMP_ALL_HOSTS) 1045 continue; 1046 if (ipv4_is_local_multicast(im->multiaddr) && 1047 !net->ipv4.sysctl_igmp_llm_reports) 1048 continue; 1049 spin_lock_bh(&im->lock); 1050 if (im->tm_running) 1051 im->gsquery = im->gsquery && mark; 1052 else 1053 im->gsquery = mark; 1054 changed = !im->gsquery || 1055 igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs); 1056 spin_unlock_bh(&im->lock); 1057 if (changed) 1058 igmp_mod_timer(im, max_delay); 1059 } 1060 rcu_read_unlock(); 1061 return false; 1062 } 1063 1064 /* called in rcu_read_lock() section */ 1065 int igmp_rcv(struct sk_buff *skb) 1066 { 1067 /* This basically follows the spec line by line -- see RFC1112 */ 1068 struct igmphdr *ih; 1069 struct net_device *dev = skb->dev; 1070 struct in_device *in_dev; 1071 int len = skb->len; 1072 bool dropped = true; 1073 1074 if (netif_is_l3_master(dev)) { 1075 dev = dev_get_by_index_rcu(dev_net(dev), IPCB(skb)->iif); 1076 if (!dev) 1077 goto drop; 1078 } 1079 1080 in_dev = __in_dev_get_rcu(dev); 1081 if (!in_dev) 1082 goto drop; 1083 1084 if (!pskb_may_pull(skb, sizeof(struct igmphdr))) 1085 goto drop; 1086 1087 if (skb_checksum_simple_validate(skb)) 1088 goto drop; 1089 1090 ih = igmp_hdr(skb); 1091 switch (ih->type) { 1092 case IGMP_HOST_MEMBERSHIP_QUERY: 1093 dropped = igmp_heard_query(in_dev, skb, len); 1094 break; 1095 case IGMP_HOST_MEMBERSHIP_REPORT: 1096 case IGMPV2_HOST_MEMBERSHIP_REPORT: 1097 /* Is it our report looped back? */ 1098 if (rt_is_output_route(skb_rtable(skb))) 1099 break; 1100 /* don't rely on MC router hearing unicast reports */ 1101 if (skb->pkt_type == PACKET_MULTICAST || 1102 skb->pkt_type == PACKET_BROADCAST) 1103 dropped = igmp_heard_report(in_dev, ih->group); 1104 break; 1105 case IGMP_PIM: 1106 #ifdef CONFIG_IP_PIMSM_V1 1107 return pim_rcv_v1(skb); 1108 #endif 1109 case IGMPV3_HOST_MEMBERSHIP_REPORT: 1110 case IGMP_DVMRP: 1111 case IGMP_TRACE: 1112 case IGMP_HOST_LEAVE_MESSAGE: 1113 case IGMP_MTRACE: 1114 case IGMP_MTRACE_RESP: 1115 break; 1116 default: 1117 break; 1118 } 1119 1120 drop: 1121 if (dropped) 1122 kfree_skb(skb); 1123 else 1124 consume_skb(skb); 1125 return 0; 1126 } 1127 1128 #endif 1129 1130 1131 /* 1132 * Add a filter to a device 1133 */ 1134 1135 static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr) 1136 { 1137 char buf[MAX_ADDR_LEN]; 1138 struct net_device *dev = in_dev->dev; 1139 1140 /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG. 1141 We will get multicast token leakage, when IFF_MULTICAST 1142 is changed. This check should be done in ndo_set_rx_mode 1143 routine. Something sort of: 1144 if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; } 1145 --ANK 1146 */ 1147 if (arp_mc_map(addr, buf, dev, 0) == 0) 1148 dev_mc_add(dev, buf); 1149 } 1150 1151 /* 1152 * Remove a filter from a device 1153 */ 1154 1155 static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr) 1156 { 1157 char buf[MAX_ADDR_LEN]; 1158 struct net_device *dev = in_dev->dev; 1159 1160 if (arp_mc_map(addr, buf, dev, 0) == 0) 1161 dev_mc_del(dev, buf); 1162 } 1163 1164 #ifdef CONFIG_IP_MULTICAST 1165 /* 1166 * deleted ip_mc_list manipulation 1167 */ 1168 static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im, 1169 gfp_t gfp) 1170 { 1171 struct ip_mc_list *pmc; 1172 struct net *net = dev_net(in_dev->dev); 1173 1174 /* this is an "ip_mc_list" for convenience; only the fields below 1175 * are actually used. In particular, the refcnt and users are not 1176 * used for management of the delete list. Using the same structure 1177 * for deleted items allows change reports to use common code with 1178 * non-deleted or query-response MCA's. 1179 */ 1180 pmc = kzalloc(sizeof(*pmc), gfp); 1181 if (!pmc) 1182 return; 1183 spin_lock_init(&pmc->lock); 1184 spin_lock_bh(&im->lock); 1185 pmc->interface = im->interface; 1186 in_dev_hold(in_dev); 1187 pmc->multiaddr = im->multiaddr; 1188 pmc->crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 1189 pmc->sfmode = im->sfmode; 1190 if (pmc->sfmode == MCAST_INCLUDE) { 1191 struct ip_sf_list *psf; 1192 1193 pmc->tomb = im->tomb; 1194 pmc->sources = im->sources; 1195 im->tomb = im->sources = NULL; 1196 for (psf = pmc->sources; psf; psf = psf->sf_next) 1197 psf->sf_crcount = pmc->crcount; 1198 } 1199 spin_unlock_bh(&im->lock); 1200 1201 spin_lock_bh(&in_dev->mc_tomb_lock); 1202 pmc->next = in_dev->mc_tomb; 1203 in_dev->mc_tomb = pmc; 1204 spin_unlock_bh(&in_dev->mc_tomb_lock); 1205 } 1206 1207 /* 1208 * restore ip_mc_list deleted records 1209 */ 1210 static void igmpv3_del_delrec(struct in_device *in_dev, struct ip_mc_list *im) 1211 { 1212 struct ip_mc_list *pmc, *pmc_prev; 1213 struct ip_sf_list *psf; 1214 struct net *net = dev_net(in_dev->dev); 1215 __be32 multiaddr = im->multiaddr; 1216 1217 spin_lock_bh(&in_dev->mc_tomb_lock); 1218 pmc_prev = NULL; 1219 for (pmc = in_dev->mc_tomb; pmc; pmc = pmc->next) { 1220 if (pmc->multiaddr == multiaddr) 1221 break; 1222 pmc_prev = pmc; 1223 } 1224 if (pmc) { 1225 if (pmc_prev) 1226 pmc_prev->next = pmc->next; 1227 else 1228 in_dev->mc_tomb = pmc->next; 1229 } 1230 spin_unlock_bh(&in_dev->mc_tomb_lock); 1231 1232 spin_lock_bh(&im->lock); 1233 if (pmc) { 1234 im->interface = pmc->interface; 1235 if (im->sfmode == MCAST_INCLUDE) { 1236 im->tomb = pmc->tomb; 1237 pmc->tomb = NULL; 1238 1239 im->sources = pmc->sources; 1240 pmc->sources = NULL; 1241 1242 for (psf = im->sources; psf; psf = psf->sf_next) 1243 psf->sf_crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 1244 } else { 1245 im->crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 1246 } 1247 in_dev_put(pmc->interface); 1248 kfree_pmc(pmc); 1249 } 1250 spin_unlock_bh(&im->lock); 1251 } 1252 1253 /* 1254 * flush ip_mc_list deleted records 1255 */ 1256 static void igmpv3_clear_delrec(struct in_device *in_dev) 1257 { 1258 struct ip_mc_list *pmc, *nextpmc; 1259 1260 spin_lock_bh(&in_dev->mc_tomb_lock); 1261 pmc = in_dev->mc_tomb; 1262 in_dev->mc_tomb = NULL; 1263 spin_unlock_bh(&in_dev->mc_tomb_lock); 1264 1265 for (; pmc; pmc = nextpmc) { 1266 nextpmc = pmc->next; 1267 ip_mc_clear_src(pmc); 1268 in_dev_put(pmc->interface); 1269 kfree_pmc(pmc); 1270 } 1271 /* clear dead sources, too */ 1272 rcu_read_lock(); 1273 for_each_pmc_rcu(in_dev, pmc) { 1274 struct ip_sf_list *psf; 1275 1276 spin_lock_bh(&pmc->lock); 1277 psf = pmc->tomb; 1278 pmc->tomb = NULL; 1279 spin_unlock_bh(&pmc->lock); 1280 ip_sf_list_clear_all(psf); 1281 } 1282 rcu_read_unlock(); 1283 } 1284 #endif 1285 1286 static void __igmp_group_dropped(struct ip_mc_list *im, gfp_t gfp) 1287 { 1288 struct in_device *in_dev = im->interface; 1289 #ifdef CONFIG_IP_MULTICAST 1290 struct net *net = dev_net(in_dev->dev); 1291 int reporter; 1292 #endif 1293 1294 if (im->loaded) { 1295 im->loaded = 0; 1296 ip_mc_filter_del(in_dev, im->multiaddr); 1297 } 1298 1299 #ifdef CONFIG_IP_MULTICAST 1300 if (im->multiaddr == IGMP_ALL_HOSTS) 1301 return; 1302 if (ipv4_is_local_multicast(im->multiaddr) && !net->ipv4.sysctl_igmp_llm_reports) 1303 return; 1304 1305 reporter = im->reporter; 1306 igmp_stop_timer(im); 1307 1308 if (!in_dev->dead) { 1309 if (IGMP_V1_SEEN(in_dev)) 1310 return; 1311 if (IGMP_V2_SEEN(in_dev)) { 1312 if (reporter) 1313 igmp_send_report(in_dev, im, IGMP_HOST_LEAVE_MESSAGE); 1314 return; 1315 } 1316 /* IGMPv3 */ 1317 igmpv3_add_delrec(in_dev, im, gfp); 1318 1319 igmp_ifc_event(in_dev); 1320 } 1321 #endif 1322 } 1323 1324 static void igmp_group_dropped(struct ip_mc_list *im) 1325 { 1326 __igmp_group_dropped(im, GFP_KERNEL); 1327 } 1328 1329 static void igmp_group_added(struct ip_mc_list *im) 1330 { 1331 struct in_device *in_dev = im->interface; 1332 #ifdef CONFIG_IP_MULTICAST 1333 struct net *net = dev_net(in_dev->dev); 1334 #endif 1335 1336 if (im->loaded == 0) { 1337 im->loaded = 1; 1338 ip_mc_filter_add(in_dev, im->multiaddr); 1339 } 1340 1341 #ifdef CONFIG_IP_MULTICAST 1342 if (im->multiaddr == IGMP_ALL_HOSTS) 1343 return; 1344 if (ipv4_is_local_multicast(im->multiaddr) && !net->ipv4.sysctl_igmp_llm_reports) 1345 return; 1346 1347 if (in_dev->dead) 1348 return; 1349 1350 im->unsolicit_count = net->ipv4.sysctl_igmp_qrv; 1351 if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) { 1352 spin_lock_bh(&im->lock); 1353 igmp_start_timer(im, IGMP_INITIAL_REPORT_DELAY); 1354 spin_unlock_bh(&im->lock); 1355 return; 1356 } 1357 /* else, v3 */ 1358 1359 /* Based on RFC3376 5.1, for newly added INCLUDE SSM, we should 1360 * not send filter-mode change record as the mode should be from 1361 * IN() to IN(A). 1362 */ 1363 if (im->sfmode == MCAST_EXCLUDE) 1364 im->crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 1365 1366 igmp_ifc_event(in_dev); 1367 #endif 1368 } 1369 1370 1371 /* 1372 * Multicast list managers 1373 */ 1374 1375 static u32 ip_mc_hash(const struct ip_mc_list *im) 1376 { 1377 return hash_32((__force u32)im->multiaddr, MC_HASH_SZ_LOG); 1378 } 1379 1380 static void ip_mc_hash_add(struct in_device *in_dev, 1381 struct ip_mc_list *im) 1382 { 1383 struct ip_mc_list __rcu **mc_hash; 1384 u32 hash; 1385 1386 mc_hash = rtnl_dereference(in_dev->mc_hash); 1387 if (mc_hash) { 1388 hash = ip_mc_hash(im); 1389 im->next_hash = mc_hash[hash]; 1390 rcu_assign_pointer(mc_hash[hash], im); 1391 return; 1392 } 1393 1394 /* do not use a hash table for small number of items */ 1395 if (in_dev->mc_count < 4) 1396 return; 1397 1398 mc_hash = kzalloc(sizeof(struct ip_mc_list *) << MC_HASH_SZ_LOG, 1399 GFP_KERNEL); 1400 if (!mc_hash) 1401 return; 1402 1403 for_each_pmc_rtnl(in_dev, im) { 1404 hash = ip_mc_hash(im); 1405 im->next_hash = mc_hash[hash]; 1406 RCU_INIT_POINTER(mc_hash[hash], im); 1407 } 1408 1409 rcu_assign_pointer(in_dev->mc_hash, mc_hash); 1410 } 1411 1412 static void ip_mc_hash_remove(struct in_device *in_dev, 1413 struct ip_mc_list *im) 1414 { 1415 struct ip_mc_list __rcu **mc_hash = rtnl_dereference(in_dev->mc_hash); 1416 struct ip_mc_list *aux; 1417 1418 if (!mc_hash) 1419 return; 1420 mc_hash += ip_mc_hash(im); 1421 while ((aux = rtnl_dereference(*mc_hash)) != im) 1422 mc_hash = &aux->next_hash; 1423 *mc_hash = im->next_hash; 1424 } 1425 1426 1427 /* 1428 * A socket has joined a multicast group on device dev. 1429 */ 1430 static void ____ip_mc_inc_group(struct in_device *in_dev, __be32 addr, 1431 unsigned int mode, gfp_t gfp) 1432 { 1433 struct ip_mc_list *im; 1434 1435 ASSERT_RTNL(); 1436 1437 for_each_pmc_rtnl(in_dev, im) { 1438 if (im->multiaddr == addr) { 1439 im->users++; 1440 ip_mc_add_src(in_dev, &addr, mode, 0, NULL, 0); 1441 goto out; 1442 } 1443 } 1444 1445 im = kzalloc(sizeof(*im), gfp); 1446 if (!im) 1447 goto out; 1448 1449 im->users = 1; 1450 im->interface = in_dev; 1451 in_dev_hold(in_dev); 1452 im->multiaddr = addr; 1453 /* initial mode is (EX, empty) */ 1454 im->sfmode = mode; 1455 im->sfcount[mode] = 1; 1456 refcount_set(&im->refcnt, 1); 1457 spin_lock_init(&im->lock); 1458 #ifdef CONFIG_IP_MULTICAST 1459 timer_setup(&im->timer, igmp_timer_expire, 0); 1460 #endif 1461 1462 im->next_rcu = in_dev->mc_list; 1463 in_dev->mc_count++; 1464 rcu_assign_pointer(in_dev->mc_list, im); 1465 1466 ip_mc_hash_add(in_dev, im); 1467 1468 #ifdef CONFIG_IP_MULTICAST 1469 igmpv3_del_delrec(in_dev, im); 1470 #endif 1471 igmp_group_added(im); 1472 if (!in_dev->dead) 1473 ip_rt_multicast_event(in_dev); 1474 out: 1475 return; 1476 } 1477 1478 void __ip_mc_inc_group(struct in_device *in_dev, __be32 addr, gfp_t gfp) 1479 { 1480 ____ip_mc_inc_group(in_dev, addr, MCAST_EXCLUDE, gfp); 1481 } 1482 EXPORT_SYMBOL(__ip_mc_inc_group); 1483 1484 void ip_mc_inc_group(struct in_device *in_dev, __be32 addr) 1485 { 1486 __ip_mc_inc_group(in_dev, addr, MCAST_EXCLUDE); 1487 } 1488 EXPORT_SYMBOL(ip_mc_inc_group); 1489 1490 static int ip_mc_check_iphdr(struct sk_buff *skb) 1491 { 1492 const struct iphdr *iph; 1493 unsigned int len; 1494 unsigned int offset = skb_network_offset(skb) + sizeof(*iph); 1495 1496 if (!pskb_may_pull(skb, offset)) 1497 return -EINVAL; 1498 1499 iph = ip_hdr(skb); 1500 1501 if (iph->version != 4 || ip_hdrlen(skb) < sizeof(*iph)) 1502 return -EINVAL; 1503 1504 offset += ip_hdrlen(skb) - sizeof(*iph); 1505 1506 if (!pskb_may_pull(skb, offset)) 1507 return -EINVAL; 1508 1509 iph = ip_hdr(skb); 1510 1511 if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl))) 1512 return -EINVAL; 1513 1514 len = skb_network_offset(skb) + ntohs(iph->tot_len); 1515 if (skb->len < len || len < offset) 1516 return -EINVAL; 1517 1518 skb_set_transport_header(skb, offset); 1519 1520 return 0; 1521 } 1522 1523 static int ip_mc_check_igmp_reportv3(struct sk_buff *skb) 1524 { 1525 unsigned int len = skb_transport_offset(skb); 1526 1527 len += sizeof(struct igmpv3_report); 1528 1529 return ip_mc_may_pull(skb, len) ? 0 : -EINVAL; 1530 } 1531 1532 static int ip_mc_check_igmp_query(struct sk_buff *skb) 1533 { 1534 unsigned int transport_len = ip_transport_len(skb); 1535 unsigned int len; 1536 1537 /* IGMPv{1,2}? */ 1538 if (transport_len != sizeof(struct igmphdr)) { 1539 /* or IGMPv3? */ 1540 if (transport_len < sizeof(struct igmpv3_query)) 1541 return -EINVAL; 1542 1543 len = skb_transport_offset(skb) + sizeof(struct igmpv3_query); 1544 if (!ip_mc_may_pull(skb, len)) 1545 return -EINVAL; 1546 } 1547 1548 /* RFC2236+RFC3376 (IGMPv2+IGMPv3) require the multicast link layer 1549 * all-systems destination addresses (224.0.0.1) for general queries 1550 */ 1551 if (!igmp_hdr(skb)->group && 1552 ip_hdr(skb)->daddr != htonl(INADDR_ALLHOSTS_GROUP)) 1553 return -EINVAL; 1554 1555 return 0; 1556 } 1557 1558 static int ip_mc_check_igmp_msg(struct sk_buff *skb) 1559 { 1560 switch (igmp_hdr(skb)->type) { 1561 case IGMP_HOST_LEAVE_MESSAGE: 1562 case IGMP_HOST_MEMBERSHIP_REPORT: 1563 case IGMPV2_HOST_MEMBERSHIP_REPORT: 1564 return 0; 1565 case IGMPV3_HOST_MEMBERSHIP_REPORT: 1566 return ip_mc_check_igmp_reportv3(skb); 1567 case IGMP_HOST_MEMBERSHIP_QUERY: 1568 return ip_mc_check_igmp_query(skb); 1569 default: 1570 return -ENOMSG; 1571 } 1572 } 1573 1574 static inline __sum16 ip_mc_validate_checksum(struct sk_buff *skb) 1575 { 1576 return skb_checksum_simple_validate(skb); 1577 } 1578 1579 static int ip_mc_check_igmp_csum(struct sk_buff *skb) 1580 { 1581 unsigned int len = skb_transport_offset(skb) + sizeof(struct igmphdr); 1582 unsigned int transport_len = ip_transport_len(skb); 1583 struct sk_buff *skb_chk; 1584 1585 if (!ip_mc_may_pull(skb, len)) 1586 return -EINVAL; 1587 1588 skb_chk = skb_checksum_trimmed(skb, transport_len, 1589 ip_mc_validate_checksum); 1590 if (!skb_chk) 1591 return -EINVAL; 1592 1593 if (skb_chk != skb) 1594 kfree_skb(skb_chk); 1595 1596 return 0; 1597 } 1598 1599 /** 1600 * ip_mc_check_igmp - checks whether this is a sane IGMP packet 1601 * @skb: the skb to validate 1602 * 1603 * Checks whether an IPv4 packet is a valid IGMP packet. If so sets 1604 * skb transport header accordingly and returns zero. 1605 * 1606 * -EINVAL: A broken packet was detected, i.e. it violates some internet 1607 * standard 1608 * -ENOMSG: IP header validation succeeded but it is not an IGMP packet. 1609 * -ENOMEM: A memory allocation failure happened. 1610 * 1611 * Caller needs to set the skb network header and free any returned skb if it 1612 * differs from the provided skb. 1613 */ 1614 int ip_mc_check_igmp(struct sk_buff *skb) 1615 { 1616 int ret = ip_mc_check_iphdr(skb); 1617 1618 if (ret < 0) 1619 return ret; 1620 1621 if (ip_hdr(skb)->protocol != IPPROTO_IGMP) 1622 return -ENOMSG; 1623 1624 ret = ip_mc_check_igmp_csum(skb); 1625 if (ret < 0) 1626 return ret; 1627 1628 return ip_mc_check_igmp_msg(skb); 1629 } 1630 EXPORT_SYMBOL(ip_mc_check_igmp); 1631 1632 /* 1633 * Resend IGMP JOIN report; used by netdev notifier. 1634 */ 1635 static void ip_mc_rejoin_groups(struct in_device *in_dev) 1636 { 1637 #ifdef CONFIG_IP_MULTICAST 1638 struct ip_mc_list *im; 1639 int type; 1640 struct net *net = dev_net(in_dev->dev); 1641 1642 ASSERT_RTNL(); 1643 1644 for_each_pmc_rtnl(in_dev, im) { 1645 if (im->multiaddr == IGMP_ALL_HOSTS) 1646 continue; 1647 if (ipv4_is_local_multicast(im->multiaddr) && 1648 !net->ipv4.sysctl_igmp_llm_reports) 1649 continue; 1650 1651 /* a failover is happening and switches 1652 * must be notified immediately 1653 */ 1654 if (IGMP_V1_SEEN(in_dev)) 1655 type = IGMP_HOST_MEMBERSHIP_REPORT; 1656 else if (IGMP_V2_SEEN(in_dev)) 1657 type = IGMPV2_HOST_MEMBERSHIP_REPORT; 1658 else 1659 type = IGMPV3_HOST_MEMBERSHIP_REPORT; 1660 igmp_send_report(in_dev, im, type); 1661 } 1662 #endif 1663 } 1664 1665 /* 1666 * A socket has left a multicast group on device dev 1667 */ 1668 1669 void __ip_mc_dec_group(struct in_device *in_dev, __be32 addr, gfp_t gfp) 1670 { 1671 struct ip_mc_list *i; 1672 struct ip_mc_list __rcu **ip; 1673 1674 ASSERT_RTNL(); 1675 1676 for (ip = &in_dev->mc_list; 1677 (i = rtnl_dereference(*ip)) != NULL; 1678 ip = &i->next_rcu) { 1679 if (i->multiaddr == addr) { 1680 if (--i->users == 0) { 1681 ip_mc_hash_remove(in_dev, i); 1682 *ip = i->next_rcu; 1683 in_dev->mc_count--; 1684 __igmp_group_dropped(i, gfp); 1685 ip_mc_clear_src(i); 1686 1687 if (!in_dev->dead) 1688 ip_rt_multicast_event(in_dev); 1689 1690 ip_ma_put(i); 1691 return; 1692 } 1693 break; 1694 } 1695 } 1696 } 1697 EXPORT_SYMBOL(__ip_mc_dec_group); 1698 1699 /* Device changing type */ 1700 1701 void ip_mc_unmap(struct in_device *in_dev) 1702 { 1703 struct ip_mc_list *pmc; 1704 1705 ASSERT_RTNL(); 1706 1707 for_each_pmc_rtnl(in_dev, pmc) 1708 igmp_group_dropped(pmc); 1709 } 1710 1711 void ip_mc_remap(struct in_device *in_dev) 1712 { 1713 struct ip_mc_list *pmc; 1714 1715 ASSERT_RTNL(); 1716 1717 for_each_pmc_rtnl(in_dev, pmc) { 1718 #ifdef CONFIG_IP_MULTICAST 1719 igmpv3_del_delrec(in_dev, pmc); 1720 #endif 1721 igmp_group_added(pmc); 1722 } 1723 } 1724 1725 /* Device going down */ 1726 1727 void ip_mc_down(struct in_device *in_dev) 1728 { 1729 struct ip_mc_list *pmc; 1730 1731 ASSERT_RTNL(); 1732 1733 for_each_pmc_rtnl(in_dev, pmc) 1734 igmp_group_dropped(pmc); 1735 1736 #ifdef CONFIG_IP_MULTICAST 1737 in_dev->mr_ifc_count = 0; 1738 if (del_timer(&in_dev->mr_ifc_timer)) 1739 __in_dev_put(in_dev); 1740 in_dev->mr_gq_running = 0; 1741 if (del_timer(&in_dev->mr_gq_timer)) 1742 __in_dev_put(in_dev); 1743 #endif 1744 1745 ip_mc_dec_group(in_dev, IGMP_ALL_HOSTS); 1746 } 1747 1748 #ifdef CONFIG_IP_MULTICAST 1749 static void ip_mc_reset(struct in_device *in_dev) 1750 { 1751 struct net *net = dev_net(in_dev->dev); 1752 1753 in_dev->mr_qi = IGMP_QUERY_INTERVAL; 1754 in_dev->mr_qri = IGMP_QUERY_RESPONSE_INTERVAL; 1755 in_dev->mr_qrv = net->ipv4.sysctl_igmp_qrv; 1756 } 1757 #else 1758 static void ip_mc_reset(struct in_device *in_dev) 1759 { 1760 } 1761 #endif 1762 1763 void ip_mc_init_dev(struct in_device *in_dev) 1764 { 1765 ASSERT_RTNL(); 1766 1767 #ifdef CONFIG_IP_MULTICAST 1768 timer_setup(&in_dev->mr_gq_timer, igmp_gq_timer_expire, 0); 1769 timer_setup(&in_dev->mr_ifc_timer, igmp_ifc_timer_expire, 0); 1770 #endif 1771 ip_mc_reset(in_dev); 1772 1773 spin_lock_init(&in_dev->mc_tomb_lock); 1774 } 1775 1776 /* Device going up */ 1777 1778 void ip_mc_up(struct in_device *in_dev) 1779 { 1780 struct ip_mc_list *pmc; 1781 1782 ASSERT_RTNL(); 1783 1784 ip_mc_reset(in_dev); 1785 ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS); 1786 1787 for_each_pmc_rtnl(in_dev, pmc) { 1788 #ifdef CONFIG_IP_MULTICAST 1789 igmpv3_del_delrec(in_dev, pmc); 1790 #endif 1791 igmp_group_added(pmc); 1792 } 1793 } 1794 1795 /* 1796 * Device is about to be destroyed: clean up. 1797 */ 1798 1799 void ip_mc_destroy_dev(struct in_device *in_dev) 1800 { 1801 struct ip_mc_list *i; 1802 1803 ASSERT_RTNL(); 1804 1805 /* Deactivate timers */ 1806 ip_mc_down(in_dev); 1807 #ifdef CONFIG_IP_MULTICAST 1808 igmpv3_clear_delrec(in_dev); 1809 #endif 1810 1811 while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) { 1812 in_dev->mc_list = i->next_rcu; 1813 in_dev->mc_count--; 1814 ip_ma_put(i); 1815 } 1816 } 1817 1818 /* RTNL is locked */ 1819 static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr) 1820 { 1821 struct net_device *dev = NULL; 1822 struct in_device *idev = NULL; 1823 1824 if (imr->imr_ifindex) { 1825 idev = inetdev_by_index(net, imr->imr_ifindex); 1826 return idev; 1827 } 1828 if (imr->imr_address.s_addr) { 1829 dev = __ip_dev_find(net, imr->imr_address.s_addr, false); 1830 if (!dev) 1831 return NULL; 1832 } 1833 1834 if (!dev) { 1835 struct rtable *rt = ip_route_output(net, 1836 imr->imr_multiaddr.s_addr, 1837 0, 0, 0); 1838 if (!IS_ERR(rt)) { 1839 dev = rt->dst.dev; 1840 ip_rt_put(rt); 1841 } 1842 } 1843 if (dev) { 1844 imr->imr_ifindex = dev->ifindex; 1845 idev = __in_dev_get_rtnl(dev); 1846 } 1847 return idev; 1848 } 1849 1850 /* 1851 * Join a socket to a group 1852 */ 1853 1854 static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode, 1855 __be32 *psfsrc) 1856 { 1857 struct ip_sf_list *psf, *psf_prev; 1858 int rv = 0; 1859 1860 psf_prev = NULL; 1861 for (psf = pmc->sources; psf; psf = psf->sf_next) { 1862 if (psf->sf_inaddr == *psfsrc) 1863 break; 1864 psf_prev = psf; 1865 } 1866 if (!psf || psf->sf_count[sfmode] == 0) { 1867 /* source filter not found, or count wrong => bug */ 1868 return -ESRCH; 1869 } 1870 psf->sf_count[sfmode]--; 1871 if (psf->sf_count[sfmode] == 0) { 1872 ip_rt_multicast_event(pmc->interface); 1873 } 1874 if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) { 1875 #ifdef CONFIG_IP_MULTICAST 1876 struct in_device *in_dev = pmc->interface; 1877 struct net *net = dev_net(in_dev->dev); 1878 #endif 1879 1880 /* no more filters for this source */ 1881 if (psf_prev) 1882 psf_prev->sf_next = psf->sf_next; 1883 else 1884 pmc->sources = psf->sf_next; 1885 #ifdef CONFIG_IP_MULTICAST 1886 if (psf->sf_oldin && 1887 !IGMP_V1_SEEN(in_dev) && !IGMP_V2_SEEN(in_dev)) { 1888 psf->sf_crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 1889 psf->sf_next = pmc->tomb; 1890 pmc->tomb = psf; 1891 rv = 1; 1892 } else 1893 #endif 1894 kfree(psf); 1895 } 1896 return rv; 1897 } 1898 1899 #ifndef CONFIG_IP_MULTICAST 1900 #define igmp_ifc_event(x) do { } while (0) 1901 #endif 1902 1903 static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode, 1904 int sfcount, __be32 *psfsrc, int delta) 1905 { 1906 struct ip_mc_list *pmc; 1907 int changerec = 0; 1908 int i, err; 1909 1910 if (!in_dev) 1911 return -ENODEV; 1912 rcu_read_lock(); 1913 for_each_pmc_rcu(in_dev, pmc) { 1914 if (*pmca == pmc->multiaddr) 1915 break; 1916 } 1917 if (!pmc) { 1918 /* MCA not found?? bug */ 1919 rcu_read_unlock(); 1920 return -ESRCH; 1921 } 1922 spin_lock_bh(&pmc->lock); 1923 rcu_read_unlock(); 1924 #ifdef CONFIG_IP_MULTICAST 1925 sf_markstate(pmc); 1926 #endif 1927 if (!delta) { 1928 err = -EINVAL; 1929 if (!pmc->sfcount[sfmode]) 1930 goto out_unlock; 1931 pmc->sfcount[sfmode]--; 1932 } 1933 err = 0; 1934 for (i = 0; i < sfcount; i++) { 1935 int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]); 1936 1937 changerec |= rv > 0; 1938 if (!err && rv < 0) 1939 err = rv; 1940 } 1941 if (pmc->sfmode == MCAST_EXCLUDE && 1942 pmc->sfcount[MCAST_EXCLUDE] == 0 && 1943 pmc->sfcount[MCAST_INCLUDE]) { 1944 #ifdef CONFIG_IP_MULTICAST 1945 struct ip_sf_list *psf; 1946 struct net *net = dev_net(in_dev->dev); 1947 #endif 1948 1949 /* filter mode change */ 1950 pmc->sfmode = MCAST_INCLUDE; 1951 #ifdef CONFIG_IP_MULTICAST 1952 pmc->crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 1953 in_dev->mr_ifc_count = pmc->crcount; 1954 for (psf = pmc->sources; psf; psf = psf->sf_next) 1955 psf->sf_crcount = 0; 1956 igmp_ifc_event(pmc->interface); 1957 } else if (sf_setstate(pmc) || changerec) { 1958 igmp_ifc_event(pmc->interface); 1959 #endif 1960 } 1961 out_unlock: 1962 spin_unlock_bh(&pmc->lock); 1963 return err; 1964 } 1965 1966 /* 1967 * Add multicast single-source filter to the interface list 1968 */ 1969 static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode, 1970 __be32 *psfsrc) 1971 { 1972 struct ip_sf_list *psf, *psf_prev; 1973 1974 psf_prev = NULL; 1975 for (psf = pmc->sources; psf; psf = psf->sf_next) { 1976 if (psf->sf_inaddr == *psfsrc) 1977 break; 1978 psf_prev = psf; 1979 } 1980 if (!psf) { 1981 psf = kzalloc(sizeof(*psf), GFP_ATOMIC); 1982 if (!psf) 1983 return -ENOBUFS; 1984 psf->sf_inaddr = *psfsrc; 1985 if (psf_prev) { 1986 psf_prev->sf_next = psf; 1987 } else 1988 pmc->sources = psf; 1989 } 1990 psf->sf_count[sfmode]++; 1991 if (psf->sf_count[sfmode] == 1) { 1992 ip_rt_multicast_event(pmc->interface); 1993 } 1994 return 0; 1995 } 1996 1997 #ifdef CONFIG_IP_MULTICAST 1998 static void sf_markstate(struct ip_mc_list *pmc) 1999 { 2000 struct ip_sf_list *psf; 2001 int mca_xcount = pmc->sfcount[MCAST_EXCLUDE]; 2002 2003 for (psf = pmc->sources; psf; psf = psf->sf_next) 2004 if (pmc->sfcount[MCAST_EXCLUDE]) { 2005 psf->sf_oldin = mca_xcount == 2006 psf->sf_count[MCAST_EXCLUDE] && 2007 !psf->sf_count[MCAST_INCLUDE]; 2008 } else 2009 psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0; 2010 } 2011 2012 static int sf_setstate(struct ip_mc_list *pmc) 2013 { 2014 struct ip_sf_list *psf, *dpsf; 2015 int mca_xcount = pmc->sfcount[MCAST_EXCLUDE]; 2016 int qrv = pmc->interface->mr_qrv; 2017 int new_in, rv; 2018 2019 rv = 0; 2020 for (psf = pmc->sources; psf; psf = psf->sf_next) { 2021 if (pmc->sfcount[MCAST_EXCLUDE]) { 2022 new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] && 2023 !psf->sf_count[MCAST_INCLUDE]; 2024 } else 2025 new_in = psf->sf_count[MCAST_INCLUDE] != 0; 2026 if (new_in) { 2027 if (!psf->sf_oldin) { 2028 struct ip_sf_list *prev = NULL; 2029 2030 for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next) { 2031 if (dpsf->sf_inaddr == psf->sf_inaddr) 2032 break; 2033 prev = dpsf; 2034 } 2035 if (dpsf) { 2036 if (prev) 2037 prev->sf_next = dpsf->sf_next; 2038 else 2039 pmc->tomb = dpsf->sf_next; 2040 kfree(dpsf); 2041 } 2042 psf->sf_crcount = qrv; 2043 rv++; 2044 } 2045 } else if (psf->sf_oldin) { 2046 2047 psf->sf_crcount = 0; 2048 /* 2049 * add or update "delete" records if an active filter 2050 * is now inactive 2051 */ 2052 for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next) 2053 if (dpsf->sf_inaddr == psf->sf_inaddr) 2054 break; 2055 if (!dpsf) { 2056 dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC); 2057 if (!dpsf) 2058 continue; 2059 *dpsf = *psf; 2060 /* pmc->lock held by callers */ 2061 dpsf->sf_next = pmc->tomb; 2062 pmc->tomb = dpsf; 2063 } 2064 dpsf->sf_crcount = qrv; 2065 rv++; 2066 } 2067 } 2068 return rv; 2069 } 2070 #endif 2071 2072 /* 2073 * Add multicast source filter list to the interface list 2074 */ 2075 static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode, 2076 int sfcount, __be32 *psfsrc, int delta) 2077 { 2078 struct ip_mc_list *pmc; 2079 int isexclude; 2080 int i, err; 2081 2082 if (!in_dev) 2083 return -ENODEV; 2084 rcu_read_lock(); 2085 for_each_pmc_rcu(in_dev, pmc) { 2086 if (*pmca == pmc->multiaddr) 2087 break; 2088 } 2089 if (!pmc) { 2090 /* MCA not found?? bug */ 2091 rcu_read_unlock(); 2092 return -ESRCH; 2093 } 2094 spin_lock_bh(&pmc->lock); 2095 rcu_read_unlock(); 2096 2097 #ifdef CONFIG_IP_MULTICAST 2098 sf_markstate(pmc); 2099 #endif 2100 isexclude = pmc->sfmode == MCAST_EXCLUDE; 2101 if (!delta) 2102 pmc->sfcount[sfmode]++; 2103 err = 0; 2104 for (i = 0; i < sfcount; i++) { 2105 err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i]); 2106 if (err) 2107 break; 2108 } 2109 if (err) { 2110 int j; 2111 2112 if (!delta) 2113 pmc->sfcount[sfmode]--; 2114 for (j = 0; j < i; j++) 2115 (void) ip_mc_del1_src(pmc, sfmode, &psfsrc[j]); 2116 } else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) { 2117 #ifdef CONFIG_IP_MULTICAST 2118 struct ip_sf_list *psf; 2119 struct net *net = dev_net(pmc->interface->dev); 2120 in_dev = pmc->interface; 2121 #endif 2122 2123 /* filter mode change */ 2124 if (pmc->sfcount[MCAST_EXCLUDE]) 2125 pmc->sfmode = MCAST_EXCLUDE; 2126 else if (pmc->sfcount[MCAST_INCLUDE]) 2127 pmc->sfmode = MCAST_INCLUDE; 2128 #ifdef CONFIG_IP_MULTICAST 2129 /* else no filters; keep old mode for reports */ 2130 2131 pmc->crcount = in_dev->mr_qrv ?: net->ipv4.sysctl_igmp_qrv; 2132 in_dev->mr_ifc_count = pmc->crcount; 2133 for (psf = pmc->sources; psf; psf = psf->sf_next) 2134 psf->sf_crcount = 0; 2135 igmp_ifc_event(in_dev); 2136 } else if (sf_setstate(pmc)) { 2137 igmp_ifc_event(in_dev); 2138 #endif 2139 } 2140 spin_unlock_bh(&pmc->lock); 2141 return err; 2142 } 2143 2144 static void ip_mc_clear_src(struct ip_mc_list *pmc) 2145 { 2146 struct ip_sf_list *tomb, *sources; 2147 2148 spin_lock_bh(&pmc->lock); 2149 tomb = pmc->tomb; 2150 pmc->tomb = NULL; 2151 sources = pmc->sources; 2152 pmc->sources = NULL; 2153 pmc->sfmode = MCAST_EXCLUDE; 2154 pmc->sfcount[MCAST_INCLUDE] = 0; 2155 pmc->sfcount[MCAST_EXCLUDE] = 1; 2156 spin_unlock_bh(&pmc->lock); 2157 2158 ip_sf_list_clear_all(tomb); 2159 ip_sf_list_clear_all(sources); 2160 } 2161 2162 /* Join a multicast group 2163 */ 2164 static int __ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr, 2165 unsigned int mode) 2166 { 2167 __be32 addr = imr->imr_multiaddr.s_addr; 2168 struct ip_mc_socklist *iml, *i; 2169 struct in_device *in_dev; 2170 struct inet_sock *inet = inet_sk(sk); 2171 struct net *net = sock_net(sk); 2172 int ifindex; 2173 int count = 0; 2174 int err; 2175 2176 ASSERT_RTNL(); 2177 2178 if (!ipv4_is_multicast(addr)) 2179 return -EINVAL; 2180 2181 in_dev = ip_mc_find_dev(net, imr); 2182 2183 if (!in_dev) { 2184 err = -ENODEV; 2185 goto done; 2186 } 2187 2188 err = -EADDRINUSE; 2189 ifindex = imr->imr_ifindex; 2190 for_each_pmc_rtnl(inet, i) { 2191 if (i->multi.imr_multiaddr.s_addr == addr && 2192 i->multi.imr_ifindex == ifindex) 2193 goto done; 2194 count++; 2195 } 2196 err = -ENOBUFS; 2197 if (count >= net->ipv4.sysctl_igmp_max_memberships) 2198 goto done; 2199 iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL); 2200 if (!iml) 2201 goto done; 2202 2203 memcpy(&iml->multi, imr, sizeof(*imr)); 2204 iml->next_rcu = inet->mc_list; 2205 iml->sflist = NULL; 2206 iml->sfmode = mode; 2207 rcu_assign_pointer(inet->mc_list, iml); 2208 __ip_mc_inc_group(in_dev, addr, mode); 2209 err = 0; 2210 done: 2211 return err; 2212 } 2213 2214 /* Join ASM (Any-Source Multicast) group 2215 */ 2216 int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr) 2217 { 2218 return __ip_mc_join_group(sk, imr, MCAST_EXCLUDE); 2219 } 2220 EXPORT_SYMBOL(ip_mc_join_group); 2221 2222 /* Join SSM (Source-Specific Multicast) group 2223 */ 2224 int ip_mc_join_group_ssm(struct sock *sk, struct ip_mreqn *imr, 2225 unsigned int mode) 2226 { 2227 return __ip_mc_join_group(sk, imr, mode); 2228 } 2229 2230 static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml, 2231 struct in_device *in_dev) 2232 { 2233 struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist); 2234 int err; 2235 2236 if (!psf) { 2237 /* any-source empty exclude case */ 2238 return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr, 2239 iml->sfmode, 0, NULL, 0); 2240 } 2241 err = ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr, 2242 iml->sfmode, psf->sl_count, psf->sl_addr, 0); 2243 RCU_INIT_POINTER(iml->sflist, NULL); 2244 /* decrease mem now to avoid the memleak warning */ 2245 atomic_sub(IP_SFLSIZE(psf->sl_max), &sk->sk_omem_alloc); 2246 kfree_rcu(psf, rcu); 2247 return err; 2248 } 2249 2250 int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr) 2251 { 2252 struct inet_sock *inet = inet_sk(sk); 2253 struct ip_mc_socklist *iml; 2254 struct ip_mc_socklist __rcu **imlp; 2255 struct in_device *in_dev; 2256 struct net *net = sock_net(sk); 2257 __be32 group = imr->imr_multiaddr.s_addr; 2258 u32 ifindex; 2259 int ret = -EADDRNOTAVAIL; 2260 2261 ASSERT_RTNL(); 2262 2263 in_dev = ip_mc_find_dev(net, imr); 2264 if (!imr->imr_ifindex && !imr->imr_address.s_addr && !in_dev) { 2265 ret = -ENODEV; 2266 goto out; 2267 } 2268 ifindex = imr->imr_ifindex; 2269 for (imlp = &inet->mc_list; 2270 (iml = rtnl_dereference(*imlp)) != NULL; 2271 imlp = &iml->next_rcu) { 2272 if (iml->multi.imr_multiaddr.s_addr != group) 2273 continue; 2274 if (ifindex) { 2275 if (iml->multi.imr_ifindex != ifindex) 2276 continue; 2277 } else if (imr->imr_address.s_addr && imr->imr_address.s_addr != 2278 iml->multi.imr_address.s_addr) 2279 continue; 2280 2281 (void) ip_mc_leave_src(sk, iml, in_dev); 2282 2283 *imlp = iml->next_rcu; 2284 2285 if (in_dev) 2286 ip_mc_dec_group(in_dev, group); 2287 2288 /* decrease mem now to avoid the memleak warning */ 2289 atomic_sub(sizeof(*iml), &sk->sk_omem_alloc); 2290 kfree_rcu(iml, rcu); 2291 return 0; 2292 } 2293 out: 2294 return ret; 2295 } 2296 EXPORT_SYMBOL(ip_mc_leave_group); 2297 2298 int ip_mc_source(int add, int omode, struct sock *sk, struct 2299 ip_mreq_source *mreqs, int ifindex) 2300 { 2301 int err; 2302 struct ip_mreqn imr; 2303 __be32 addr = mreqs->imr_multiaddr; 2304 struct ip_mc_socklist *pmc; 2305 struct in_device *in_dev = NULL; 2306 struct inet_sock *inet = inet_sk(sk); 2307 struct ip_sf_socklist *psl; 2308 struct net *net = sock_net(sk); 2309 int leavegroup = 0; 2310 int i, j, rv; 2311 2312 if (!ipv4_is_multicast(addr)) 2313 return -EINVAL; 2314 2315 ASSERT_RTNL(); 2316 2317 imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr; 2318 imr.imr_address.s_addr = mreqs->imr_interface; 2319 imr.imr_ifindex = ifindex; 2320 in_dev = ip_mc_find_dev(net, &imr); 2321 2322 if (!in_dev) { 2323 err = -ENODEV; 2324 goto done; 2325 } 2326 err = -EADDRNOTAVAIL; 2327 2328 for_each_pmc_rtnl(inet, pmc) { 2329 if ((pmc->multi.imr_multiaddr.s_addr == 2330 imr.imr_multiaddr.s_addr) && 2331 (pmc->multi.imr_ifindex == imr.imr_ifindex)) 2332 break; 2333 } 2334 if (!pmc) { /* must have a prior join */ 2335 err = -EINVAL; 2336 goto done; 2337 } 2338 /* if a source filter was set, must be the same mode as before */ 2339 if (pmc->sflist) { 2340 if (pmc->sfmode != omode) { 2341 err = -EINVAL; 2342 goto done; 2343 } 2344 } else if (pmc->sfmode != omode) { 2345 /* allow mode switches for empty-set filters */ 2346 ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 0, NULL, 0); 2347 ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0, 2348 NULL, 0); 2349 pmc->sfmode = omode; 2350 } 2351 2352 psl = rtnl_dereference(pmc->sflist); 2353 if (!add) { 2354 if (!psl) 2355 goto done; /* err = -EADDRNOTAVAIL */ 2356 rv = !0; 2357 for (i = 0; i < psl->sl_count; i++) { 2358 rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr, 2359 sizeof(__be32)); 2360 if (rv == 0) 2361 break; 2362 } 2363 if (rv) /* source not found */ 2364 goto done; /* err = -EADDRNOTAVAIL */ 2365 2366 /* special case - (INCLUDE, empty) == LEAVE_GROUP */ 2367 if (psl->sl_count == 1 && omode == MCAST_INCLUDE) { 2368 leavegroup = 1; 2369 goto done; 2370 } 2371 2372 /* update the interface filter */ 2373 ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1, 2374 &mreqs->imr_sourceaddr, 1); 2375 2376 for (j = i+1; j < psl->sl_count; j++) 2377 psl->sl_addr[j-1] = psl->sl_addr[j]; 2378 psl->sl_count--; 2379 err = 0; 2380 goto done; 2381 } 2382 /* else, add a new source to the filter */ 2383 2384 if (psl && psl->sl_count >= net->ipv4.sysctl_igmp_max_msf) { 2385 err = -ENOBUFS; 2386 goto done; 2387 } 2388 if (!psl || psl->sl_count == psl->sl_max) { 2389 struct ip_sf_socklist *newpsl; 2390 int count = IP_SFBLOCK; 2391 2392 if (psl) 2393 count += psl->sl_max; 2394 newpsl = sock_kmalloc(sk, IP_SFLSIZE(count), GFP_KERNEL); 2395 if (!newpsl) { 2396 err = -ENOBUFS; 2397 goto done; 2398 } 2399 newpsl->sl_max = count; 2400 newpsl->sl_count = count - IP_SFBLOCK; 2401 if (psl) { 2402 for (i = 0; i < psl->sl_count; i++) 2403 newpsl->sl_addr[i] = psl->sl_addr[i]; 2404 /* decrease mem now to avoid the memleak warning */ 2405 atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc); 2406 kfree_rcu(psl, rcu); 2407 } 2408 rcu_assign_pointer(pmc->sflist, newpsl); 2409 psl = newpsl; 2410 } 2411 rv = 1; /* > 0 for insert logic below if sl_count is 0 */ 2412 for (i = 0; i < psl->sl_count; i++) { 2413 rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr, 2414 sizeof(__be32)); 2415 if (rv == 0) 2416 break; 2417 } 2418 if (rv == 0) /* address already there is an error */ 2419 goto done; 2420 for (j = psl->sl_count-1; j >= i; j--) 2421 psl->sl_addr[j+1] = psl->sl_addr[j]; 2422 psl->sl_addr[i] = mreqs->imr_sourceaddr; 2423 psl->sl_count++; 2424 err = 0; 2425 /* update the interface list */ 2426 ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1, 2427 &mreqs->imr_sourceaddr, 1); 2428 done: 2429 if (leavegroup) 2430 err = ip_mc_leave_group(sk, &imr); 2431 return err; 2432 } 2433 2434 int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex) 2435 { 2436 int err = 0; 2437 struct ip_mreqn imr; 2438 __be32 addr = msf->imsf_multiaddr; 2439 struct ip_mc_socklist *pmc; 2440 struct in_device *in_dev; 2441 struct inet_sock *inet = inet_sk(sk); 2442 struct ip_sf_socklist *newpsl, *psl; 2443 struct net *net = sock_net(sk); 2444 int leavegroup = 0; 2445 2446 if (!ipv4_is_multicast(addr)) 2447 return -EINVAL; 2448 if (msf->imsf_fmode != MCAST_INCLUDE && 2449 msf->imsf_fmode != MCAST_EXCLUDE) 2450 return -EINVAL; 2451 2452 ASSERT_RTNL(); 2453 2454 imr.imr_multiaddr.s_addr = msf->imsf_multiaddr; 2455 imr.imr_address.s_addr = msf->imsf_interface; 2456 imr.imr_ifindex = ifindex; 2457 in_dev = ip_mc_find_dev(net, &imr); 2458 2459 if (!in_dev) { 2460 err = -ENODEV; 2461 goto done; 2462 } 2463 2464 /* special case - (INCLUDE, empty) == LEAVE_GROUP */ 2465 if (msf->imsf_fmode == MCAST_INCLUDE && msf->imsf_numsrc == 0) { 2466 leavegroup = 1; 2467 goto done; 2468 } 2469 2470 for_each_pmc_rtnl(inet, pmc) { 2471 if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr && 2472 pmc->multi.imr_ifindex == imr.imr_ifindex) 2473 break; 2474 } 2475 if (!pmc) { /* must have a prior join */ 2476 err = -EINVAL; 2477 goto done; 2478 } 2479 if (msf->imsf_numsrc) { 2480 newpsl = sock_kmalloc(sk, IP_SFLSIZE(msf->imsf_numsrc), 2481 GFP_KERNEL); 2482 if (!newpsl) { 2483 err = -ENOBUFS; 2484 goto done; 2485 } 2486 newpsl->sl_max = newpsl->sl_count = msf->imsf_numsrc; 2487 memcpy(newpsl->sl_addr, msf->imsf_slist, 2488 msf->imsf_numsrc * sizeof(msf->imsf_slist[0])); 2489 err = ip_mc_add_src(in_dev, &msf->imsf_multiaddr, 2490 msf->imsf_fmode, newpsl->sl_count, newpsl->sl_addr, 0); 2491 if (err) { 2492 sock_kfree_s(sk, newpsl, IP_SFLSIZE(newpsl->sl_max)); 2493 goto done; 2494 } 2495 } else { 2496 newpsl = NULL; 2497 (void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr, 2498 msf->imsf_fmode, 0, NULL, 0); 2499 } 2500 psl = rtnl_dereference(pmc->sflist); 2501 if (psl) { 2502 (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode, 2503 psl->sl_count, psl->sl_addr, 0); 2504 /* decrease mem now to avoid the memleak warning */ 2505 atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc); 2506 kfree_rcu(psl, rcu); 2507 } else 2508 (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode, 2509 0, NULL, 0); 2510 rcu_assign_pointer(pmc->sflist, newpsl); 2511 pmc->sfmode = msf->imsf_fmode; 2512 err = 0; 2513 done: 2514 if (leavegroup) 2515 err = ip_mc_leave_group(sk, &imr); 2516 return err; 2517 } 2518 2519 int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf, 2520 struct ip_msfilter __user *optval, int __user *optlen) 2521 { 2522 int err, len, count, copycount; 2523 struct ip_mreqn imr; 2524 __be32 addr = msf->imsf_multiaddr; 2525 struct ip_mc_socklist *pmc; 2526 struct in_device *in_dev; 2527 struct inet_sock *inet = inet_sk(sk); 2528 struct ip_sf_socklist *psl; 2529 struct net *net = sock_net(sk); 2530 2531 ASSERT_RTNL(); 2532 2533 if (!ipv4_is_multicast(addr)) 2534 return -EINVAL; 2535 2536 imr.imr_multiaddr.s_addr = msf->imsf_multiaddr; 2537 imr.imr_address.s_addr = msf->imsf_interface; 2538 imr.imr_ifindex = 0; 2539 in_dev = ip_mc_find_dev(net, &imr); 2540 2541 if (!in_dev) { 2542 err = -ENODEV; 2543 goto done; 2544 } 2545 err = -EADDRNOTAVAIL; 2546 2547 for_each_pmc_rtnl(inet, pmc) { 2548 if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr && 2549 pmc->multi.imr_ifindex == imr.imr_ifindex) 2550 break; 2551 } 2552 if (!pmc) /* must have a prior join */ 2553 goto done; 2554 msf->imsf_fmode = pmc->sfmode; 2555 psl = rtnl_dereference(pmc->sflist); 2556 if (!psl) { 2557 len = 0; 2558 count = 0; 2559 } else { 2560 count = psl->sl_count; 2561 } 2562 copycount = count < msf->imsf_numsrc ? count : msf->imsf_numsrc; 2563 len = copycount * sizeof(psl->sl_addr[0]); 2564 msf->imsf_numsrc = count; 2565 if (put_user(IP_MSFILTER_SIZE(copycount), optlen) || 2566 copy_to_user(optval, msf, IP_MSFILTER_SIZE(0))) { 2567 return -EFAULT; 2568 } 2569 if (len && 2570 copy_to_user(&optval->imsf_slist[0], psl->sl_addr, len)) 2571 return -EFAULT; 2572 return 0; 2573 done: 2574 return err; 2575 } 2576 2577 int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf, 2578 struct group_filter __user *optval, int __user *optlen) 2579 { 2580 int err, i, count, copycount; 2581 struct sockaddr_in *psin; 2582 __be32 addr; 2583 struct ip_mc_socklist *pmc; 2584 struct inet_sock *inet = inet_sk(sk); 2585 struct ip_sf_socklist *psl; 2586 2587 ASSERT_RTNL(); 2588 2589 psin = (struct sockaddr_in *)&gsf->gf_group; 2590 if (psin->sin_family != AF_INET) 2591 return -EINVAL; 2592 addr = psin->sin_addr.s_addr; 2593 if (!ipv4_is_multicast(addr)) 2594 return -EINVAL; 2595 2596 err = -EADDRNOTAVAIL; 2597 2598 for_each_pmc_rtnl(inet, pmc) { 2599 if (pmc->multi.imr_multiaddr.s_addr == addr && 2600 pmc->multi.imr_ifindex == gsf->gf_interface) 2601 break; 2602 } 2603 if (!pmc) /* must have a prior join */ 2604 goto done; 2605 gsf->gf_fmode = pmc->sfmode; 2606 psl = rtnl_dereference(pmc->sflist); 2607 count = psl ? psl->sl_count : 0; 2608 copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc; 2609 gsf->gf_numsrc = count; 2610 if (put_user(GROUP_FILTER_SIZE(copycount), optlen) || 2611 copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) { 2612 return -EFAULT; 2613 } 2614 for (i = 0; i < copycount; i++) { 2615 struct sockaddr_storage ss; 2616 2617 psin = (struct sockaddr_in *)&ss; 2618 memset(&ss, 0, sizeof(ss)); 2619 psin->sin_family = AF_INET; 2620 psin->sin_addr.s_addr = psl->sl_addr[i]; 2621 if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss))) 2622 return -EFAULT; 2623 } 2624 return 0; 2625 done: 2626 return err; 2627 } 2628 2629 /* 2630 * check if a multicast source filter allows delivery for a given <src,dst,intf> 2631 */ 2632 int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, 2633 int dif, int sdif) 2634 { 2635 struct inet_sock *inet = inet_sk(sk); 2636 struct ip_mc_socklist *pmc; 2637 struct ip_sf_socklist *psl; 2638 int i; 2639 int ret; 2640 2641 ret = 1; 2642 if (!ipv4_is_multicast(loc_addr)) 2643 goto out; 2644 2645 rcu_read_lock(); 2646 for_each_pmc_rcu(inet, pmc) { 2647 if (pmc->multi.imr_multiaddr.s_addr == loc_addr && 2648 (pmc->multi.imr_ifindex == dif || 2649 (sdif && pmc->multi.imr_ifindex == sdif))) 2650 break; 2651 } 2652 ret = inet->mc_all; 2653 if (!pmc) 2654 goto unlock; 2655 psl = rcu_dereference(pmc->sflist); 2656 ret = (pmc->sfmode == MCAST_EXCLUDE); 2657 if (!psl) 2658 goto unlock; 2659 2660 for (i = 0; i < psl->sl_count; i++) { 2661 if (psl->sl_addr[i] == rmt_addr) 2662 break; 2663 } 2664 ret = 0; 2665 if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count) 2666 goto unlock; 2667 if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count) 2668 goto unlock; 2669 ret = 1; 2670 unlock: 2671 rcu_read_unlock(); 2672 out: 2673 return ret; 2674 } 2675 2676 /* 2677 * A socket is closing. 2678 */ 2679 2680 void ip_mc_drop_socket(struct sock *sk) 2681 { 2682 struct inet_sock *inet = inet_sk(sk); 2683 struct ip_mc_socklist *iml; 2684 struct net *net = sock_net(sk); 2685 2686 if (!inet->mc_list) 2687 return; 2688 2689 rtnl_lock(); 2690 while ((iml = rtnl_dereference(inet->mc_list)) != NULL) { 2691 struct in_device *in_dev; 2692 2693 inet->mc_list = iml->next_rcu; 2694 in_dev = inetdev_by_index(net, iml->multi.imr_ifindex); 2695 (void) ip_mc_leave_src(sk, iml, in_dev); 2696 if (in_dev) 2697 ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr); 2698 /* decrease mem now to avoid the memleak warning */ 2699 atomic_sub(sizeof(*iml), &sk->sk_omem_alloc); 2700 kfree_rcu(iml, rcu); 2701 } 2702 rtnl_unlock(); 2703 } 2704 2705 /* called with rcu_read_lock() */ 2706 int ip_check_mc_rcu(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u8 proto) 2707 { 2708 struct ip_mc_list *im; 2709 struct ip_mc_list __rcu **mc_hash; 2710 struct ip_sf_list *psf; 2711 int rv = 0; 2712 2713 mc_hash = rcu_dereference(in_dev->mc_hash); 2714 if (mc_hash) { 2715 u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); 2716 2717 for (im = rcu_dereference(mc_hash[hash]); 2718 im != NULL; 2719 im = rcu_dereference(im->next_hash)) { 2720 if (im->multiaddr == mc_addr) 2721 break; 2722 } 2723 } else { 2724 for_each_pmc_rcu(in_dev, im) { 2725 if (im->multiaddr == mc_addr) 2726 break; 2727 } 2728 } 2729 if (im && proto == IPPROTO_IGMP) { 2730 rv = 1; 2731 } else if (im) { 2732 if (src_addr) { 2733 for (psf = im->sources; psf; psf = psf->sf_next) { 2734 if (psf->sf_inaddr == src_addr) 2735 break; 2736 } 2737 if (psf) 2738 rv = psf->sf_count[MCAST_INCLUDE] || 2739 psf->sf_count[MCAST_EXCLUDE] != 2740 im->sfcount[MCAST_EXCLUDE]; 2741 else 2742 rv = im->sfcount[MCAST_EXCLUDE] != 0; 2743 } else 2744 rv = 1; /* unspecified source; tentatively allow */ 2745 } 2746 return rv; 2747 } 2748 2749 #if defined(CONFIG_PROC_FS) 2750 struct igmp_mc_iter_state { 2751 struct seq_net_private p; 2752 struct net_device *dev; 2753 struct in_device *in_dev; 2754 }; 2755 2756 #define igmp_mc_seq_private(seq) ((struct igmp_mc_iter_state *)(seq)->private) 2757 2758 static inline struct ip_mc_list *igmp_mc_get_first(struct seq_file *seq) 2759 { 2760 struct net *net = seq_file_net(seq); 2761 struct ip_mc_list *im = NULL; 2762 struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 2763 2764 state->in_dev = NULL; 2765 for_each_netdev_rcu(net, state->dev) { 2766 struct in_device *in_dev; 2767 2768 in_dev = __in_dev_get_rcu(state->dev); 2769 if (!in_dev) 2770 continue; 2771 im = rcu_dereference(in_dev->mc_list); 2772 if (im) { 2773 state->in_dev = in_dev; 2774 break; 2775 } 2776 } 2777 return im; 2778 } 2779 2780 static struct ip_mc_list *igmp_mc_get_next(struct seq_file *seq, struct ip_mc_list *im) 2781 { 2782 struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 2783 2784 im = rcu_dereference(im->next_rcu); 2785 while (!im) { 2786 state->dev = next_net_device_rcu(state->dev); 2787 if (!state->dev) { 2788 state->in_dev = NULL; 2789 break; 2790 } 2791 state->in_dev = __in_dev_get_rcu(state->dev); 2792 if (!state->in_dev) 2793 continue; 2794 im = rcu_dereference(state->in_dev->mc_list); 2795 } 2796 return im; 2797 } 2798 2799 static struct ip_mc_list *igmp_mc_get_idx(struct seq_file *seq, loff_t pos) 2800 { 2801 struct ip_mc_list *im = igmp_mc_get_first(seq); 2802 if (im) 2803 while (pos && (im = igmp_mc_get_next(seq, im)) != NULL) 2804 --pos; 2805 return pos ? NULL : im; 2806 } 2807 2808 static void *igmp_mc_seq_start(struct seq_file *seq, loff_t *pos) 2809 __acquires(rcu) 2810 { 2811 rcu_read_lock(); 2812 return *pos ? igmp_mc_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 2813 } 2814 2815 static void *igmp_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2816 { 2817 struct ip_mc_list *im; 2818 if (v == SEQ_START_TOKEN) 2819 im = igmp_mc_get_first(seq); 2820 else 2821 im = igmp_mc_get_next(seq, v); 2822 ++*pos; 2823 return im; 2824 } 2825 2826 static void igmp_mc_seq_stop(struct seq_file *seq, void *v) 2827 __releases(rcu) 2828 { 2829 struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 2830 2831 state->in_dev = NULL; 2832 state->dev = NULL; 2833 rcu_read_unlock(); 2834 } 2835 2836 static int igmp_mc_seq_show(struct seq_file *seq, void *v) 2837 { 2838 if (v == SEQ_START_TOKEN) 2839 seq_puts(seq, 2840 "Idx\tDevice : Count Querier\tGroup Users Timer\tReporter\n"); 2841 else { 2842 struct ip_mc_list *im = (struct ip_mc_list *)v; 2843 struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); 2844 char *querier; 2845 long delta; 2846 2847 #ifdef CONFIG_IP_MULTICAST 2848 querier = IGMP_V1_SEEN(state->in_dev) ? "V1" : 2849 IGMP_V2_SEEN(state->in_dev) ? "V2" : 2850 "V3"; 2851 #else 2852 querier = "NONE"; 2853 #endif 2854 2855 if (rcu_access_pointer(state->in_dev->mc_list) == im) { 2856 seq_printf(seq, "%d\t%-10s: %5d %7s\n", 2857 state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier); 2858 } 2859 2860 delta = im->timer.expires - jiffies; 2861 seq_printf(seq, 2862 "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n", 2863 im->multiaddr, im->users, 2864 im->tm_running, 2865 im->tm_running ? jiffies_delta_to_clock_t(delta) : 0, 2866 im->reporter); 2867 } 2868 return 0; 2869 } 2870 2871 static const struct seq_operations igmp_mc_seq_ops = { 2872 .start = igmp_mc_seq_start, 2873 .next = igmp_mc_seq_next, 2874 .stop = igmp_mc_seq_stop, 2875 .show = igmp_mc_seq_show, 2876 }; 2877 2878 struct igmp_mcf_iter_state { 2879 struct seq_net_private p; 2880 struct net_device *dev; 2881 struct in_device *idev; 2882 struct ip_mc_list *im; 2883 }; 2884 2885 #define igmp_mcf_seq_private(seq) ((struct igmp_mcf_iter_state *)(seq)->private) 2886 2887 static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq) 2888 { 2889 struct net *net = seq_file_net(seq); 2890 struct ip_sf_list *psf = NULL; 2891 struct ip_mc_list *im = NULL; 2892 struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 2893 2894 state->idev = NULL; 2895 state->im = NULL; 2896 for_each_netdev_rcu(net, state->dev) { 2897 struct in_device *idev; 2898 idev = __in_dev_get_rcu(state->dev); 2899 if (unlikely(!idev)) 2900 continue; 2901 im = rcu_dereference(idev->mc_list); 2902 if (likely(im)) { 2903 spin_lock_bh(&im->lock); 2904 psf = im->sources; 2905 if (likely(psf)) { 2906 state->im = im; 2907 state->idev = idev; 2908 break; 2909 } 2910 spin_unlock_bh(&im->lock); 2911 } 2912 } 2913 return psf; 2914 } 2915 2916 static struct ip_sf_list *igmp_mcf_get_next(struct seq_file *seq, struct ip_sf_list *psf) 2917 { 2918 struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 2919 2920 psf = psf->sf_next; 2921 while (!psf) { 2922 spin_unlock_bh(&state->im->lock); 2923 state->im = state->im->next; 2924 while (!state->im) { 2925 state->dev = next_net_device_rcu(state->dev); 2926 if (!state->dev) { 2927 state->idev = NULL; 2928 goto out; 2929 } 2930 state->idev = __in_dev_get_rcu(state->dev); 2931 if (!state->idev) 2932 continue; 2933 state->im = rcu_dereference(state->idev->mc_list); 2934 } 2935 if (!state->im) 2936 break; 2937 spin_lock_bh(&state->im->lock); 2938 psf = state->im->sources; 2939 } 2940 out: 2941 return psf; 2942 } 2943 2944 static struct ip_sf_list *igmp_mcf_get_idx(struct seq_file *seq, loff_t pos) 2945 { 2946 struct ip_sf_list *psf = igmp_mcf_get_first(seq); 2947 if (psf) 2948 while (pos && (psf = igmp_mcf_get_next(seq, psf)) != NULL) 2949 --pos; 2950 return pos ? NULL : psf; 2951 } 2952 2953 static void *igmp_mcf_seq_start(struct seq_file *seq, loff_t *pos) 2954 __acquires(rcu) 2955 { 2956 rcu_read_lock(); 2957 return *pos ? igmp_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 2958 } 2959 2960 static void *igmp_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2961 { 2962 struct ip_sf_list *psf; 2963 if (v == SEQ_START_TOKEN) 2964 psf = igmp_mcf_get_first(seq); 2965 else 2966 psf = igmp_mcf_get_next(seq, v); 2967 ++*pos; 2968 return psf; 2969 } 2970 2971 static void igmp_mcf_seq_stop(struct seq_file *seq, void *v) 2972 __releases(rcu) 2973 { 2974 struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 2975 if (likely(state->im)) { 2976 spin_unlock_bh(&state->im->lock); 2977 state->im = NULL; 2978 } 2979 state->idev = NULL; 2980 state->dev = NULL; 2981 rcu_read_unlock(); 2982 } 2983 2984 static int igmp_mcf_seq_show(struct seq_file *seq, void *v) 2985 { 2986 struct ip_sf_list *psf = (struct ip_sf_list *)v; 2987 struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); 2988 2989 if (v == SEQ_START_TOKEN) { 2990 seq_puts(seq, "Idx Device MCA SRC INC EXC\n"); 2991 } else { 2992 seq_printf(seq, 2993 "%3d %6.6s 0x%08x " 2994 "0x%08x %6lu %6lu\n", 2995 state->dev->ifindex, state->dev->name, 2996 ntohl(state->im->multiaddr), 2997 ntohl(psf->sf_inaddr), 2998 psf->sf_count[MCAST_INCLUDE], 2999 psf->sf_count[MCAST_EXCLUDE]); 3000 } 3001 return 0; 3002 } 3003 3004 static const struct seq_operations igmp_mcf_seq_ops = { 3005 .start = igmp_mcf_seq_start, 3006 .next = igmp_mcf_seq_next, 3007 .stop = igmp_mcf_seq_stop, 3008 .show = igmp_mcf_seq_show, 3009 }; 3010 3011 static int __net_init igmp_net_init(struct net *net) 3012 { 3013 struct proc_dir_entry *pde; 3014 int err; 3015 3016 pde = proc_create_net("igmp", 0444, net->proc_net, &igmp_mc_seq_ops, 3017 sizeof(struct igmp_mc_iter_state)); 3018 if (!pde) 3019 goto out_igmp; 3020 pde = proc_create_net("mcfilter", 0444, net->proc_net, 3021 &igmp_mcf_seq_ops, sizeof(struct igmp_mcf_iter_state)); 3022 if (!pde) 3023 goto out_mcfilter; 3024 err = inet_ctl_sock_create(&net->ipv4.mc_autojoin_sk, AF_INET, 3025 SOCK_DGRAM, 0, net); 3026 if (err < 0) { 3027 pr_err("Failed to initialize the IGMP autojoin socket (err %d)\n", 3028 err); 3029 goto out_sock; 3030 } 3031 3032 return 0; 3033 3034 out_sock: 3035 remove_proc_entry("mcfilter", net->proc_net); 3036 out_mcfilter: 3037 remove_proc_entry("igmp", net->proc_net); 3038 out_igmp: 3039 return -ENOMEM; 3040 } 3041 3042 static void __net_exit igmp_net_exit(struct net *net) 3043 { 3044 remove_proc_entry("mcfilter", net->proc_net); 3045 remove_proc_entry("igmp", net->proc_net); 3046 inet_ctl_sock_destroy(net->ipv4.mc_autojoin_sk); 3047 } 3048 3049 static struct pernet_operations igmp_net_ops = { 3050 .init = igmp_net_init, 3051 .exit = igmp_net_exit, 3052 }; 3053 #endif 3054 3055 static int igmp_netdev_event(struct notifier_block *this, 3056 unsigned long event, void *ptr) 3057 { 3058 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 3059 struct in_device *in_dev; 3060 3061 switch (event) { 3062 case NETDEV_RESEND_IGMP: 3063 in_dev = __in_dev_get_rtnl(dev); 3064 if (in_dev) 3065 ip_mc_rejoin_groups(in_dev); 3066 break; 3067 default: 3068 break; 3069 } 3070 return NOTIFY_DONE; 3071 } 3072 3073 static struct notifier_block igmp_notifier = { 3074 .notifier_call = igmp_netdev_event, 3075 }; 3076 3077 int __init igmp_mc_init(void) 3078 { 3079 #if defined(CONFIG_PROC_FS) 3080 int err; 3081 3082 err = register_pernet_subsys(&igmp_net_ops); 3083 if (err) 3084 return err; 3085 err = register_netdevice_notifier(&igmp_notifier); 3086 if (err) 3087 goto reg_notif_fail; 3088 return 0; 3089 3090 reg_notif_fail: 3091 unregister_pernet_subsys(&igmp_net_ops); 3092 return err; 3093 #else 3094 return register_netdevice_notifier(&igmp_notifier); 3095 #endif 3096 } 3097