1 /* 2 * Multicast support for IPv6 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * 8 * Based on linux/ipv4/igmp.c and linux/ipv4/ip_sockglue.c 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 */ 15 16 /* Changes: 17 * 18 * yoshfuji : fix format of router-alert option 19 * YOSHIFUJI Hideaki @USAGI: 20 * Fixed source address for MLD message based on 21 * <draft-ietf-magma-mld-source-05.txt>. 22 * YOSHIFUJI Hideaki @USAGI: 23 * - Ignore Queries for invalid addresses. 24 * - MLD for link-local addresses. 25 * David L Stevens <dlstevens@us.ibm.com>: 26 * - MLDv2 support 27 */ 28 29 #include <linux/module.h> 30 #include <linux/errno.h> 31 #include <linux/types.h> 32 #include <linux/string.h> 33 #include <linux/socket.h> 34 #include <linux/sockios.h> 35 #include <linux/jiffies.h> 36 #include <linux/times.h> 37 #include <linux/net.h> 38 #include <linux/in.h> 39 #include <linux/in6.h> 40 #include <linux/netdevice.h> 41 #include <linux/if_arp.h> 42 #include <linux/route.h> 43 #include <linux/init.h> 44 #include <linux/proc_fs.h> 45 #include <linux/seq_file.h> 46 #include <linux/slab.h> 47 #include <net/mld.h> 48 49 #include <linux/netfilter.h> 50 #include <linux/netfilter_ipv6.h> 51 52 #include <net/net_namespace.h> 53 #include <net/sock.h> 54 #include <net/snmp.h> 55 56 #include <net/ipv6.h> 57 #include <net/protocol.h> 58 #include <net/if_inet6.h> 59 #include <net/ndisc.h> 60 #include <net/addrconf.h> 61 #include <net/ip6_route.h> 62 #include <net/inet_common.h> 63 64 #include <net/ip6_checksum.h> 65 66 /* Set to 3 to get tracing... */ 67 #define MCAST_DEBUG 2 68 69 #if MCAST_DEBUG >= 3 70 #define MDBG(x) printk x 71 #else 72 #define MDBG(x) 73 #endif 74 75 /* Ensure that we have struct in6_addr aligned on 32bit word. */ 76 static void *__mld2_query_bugs[] __attribute__((__unused__)) = { 77 BUILD_BUG_ON_NULL(offsetof(struct mld2_query, mld2q_srcs) % 4), 78 BUILD_BUG_ON_NULL(offsetof(struct mld2_report, mld2r_grec) % 4), 79 BUILD_BUG_ON_NULL(offsetof(struct mld2_grec, grec_mca) % 4) 80 }; 81 82 static struct in6_addr mld2_all_mcr = MLD2_ALL_MCR_INIT; 83 84 /* Big mc list lock for all the sockets */ 85 static DEFINE_SPINLOCK(ipv6_sk_mc_lock); 86 87 static void igmp6_join_group(struct ifmcaddr6 *ma); 88 static void igmp6_leave_group(struct ifmcaddr6 *ma); 89 static void igmp6_timer_handler(unsigned long data); 90 91 static void mld_gq_timer_expire(unsigned long data); 92 static void mld_ifc_timer_expire(unsigned long data); 93 static void mld_ifc_event(struct inet6_dev *idev); 94 static void mld_add_delrec(struct inet6_dev *idev, struct ifmcaddr6 *pmc); 95 static void mld_del_delrec(struct inet6_dev *idev, const struct in6_addr *addr); 96 static void mld_clear_delrec(struct inet6_dev *idev); 97 static int sf_setstate(struct ifmcaddr6 *pmc); 98 static void sf_markstate(struct ifmcaddr6 *pmc); 99 static void ip6_mc_clear_src(struct ifmcaddr6 *pmc); 100 static int ip6_mc_del_src(struct inet6_dev *idev, const struct in6_addr *pmca, 101 int sfmode, int sfcount, const struct in6_addr *psfsrc, 102 int delta); 103 static int ip6_mc_add_src(struct inet6_dev *idev, const struct in6_addr *pmca, 104 int sfmode, int sfcount, const struct in6_addr *psfsrc, 105 int delta); 106 static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml, 107 struct inet6_dev *idev); 108 109 110 #define IGMP6_UNSOLICITED_IVAL (10*HZ) 111 #define MLD_QRV_DEFAULT 2 112 113 #define MLD_V1_SEEN(idev) (dev_net((idev)->dev)->ipv6.devconf_all->force_mld_version == 1 || \ 114 (idev)->cnf.force_mld_version == 1 || \ 115 ((idev)->mc_v1_seen && \ 116 time_before(jiffies, (idev)->mc_v1_seen))) 117 118 #define IPV6_MLD_MAX_MSF 64 119 120 int sysctl_mld_max_msf __read_mostly = IPV6_MLD_MAX_MSF; 121 122 /* 123 * socket join on multicast group 124 */ 125 126 #define for_each_pmc_rcu(np, pmc) \ 127 for (pmc = rcu_dereference(np->ipv6_mc_list); \ 128 pmc != NULL; \ 129 pmc = rcu_dereference(pmc->next)) 130 131 int ipv6_sock_mc_join(struct sock *sk, int ifindex, const struct in6_addr *addr) 132 { 133 struct net_device *dev = NULL; 134 struct ipv6_mc_socklist *mc_lst; 135 struct ipv6_pinfo *np = inet6_sk(sk); 136 struct net *net = sock_net(sk); 137 int err; 138 139 if (!ipv6_addr_is_multicast(addr)) 140 return -EINVAL; 141 142 rcu_read_lock(); 143 for_each_pmc_rcu(np, mc_lst) { 144 if ((ifindex == 0 || mc_lst->ifindex == ifindex) && 145 ipv6_addr_equal(&mc_lst->addr, addr)) { 146 rcu_read_unlock(); 147 return -EADDRINUSE; 148 } 149 } 150 rcu_read_unlock(); 151 152 mc_lst = sock_kmalloc(sk, sizeof(struct ipv6_mc_socklist), GFP_KERNEL); 153 154 if (mc_lst == NULL) 155 return -ENOMEM; 156 157 mc_lst->next = NULL; 158 mc_lst->addr = *addr; 159 160 rcu_read_lock(); 161 if (ifindex == 0) { 162 struct rt6_info *rt; 163 rt = rt6_lookup(net, addr, NULL, 0, 0); 164 if (rt) { 165 dev = rt->dst.dev; 166 dst_release(&rt->dst); 167 } 168 } else 169 dev = dev_get_by_index_rcu(net, ifindex); 170 171 if (dev == NULL) { 172 rcu_read_unlock(); 173 sock_kfree_s(sk, mc_lst, sizeof(*mc_lst)); 174 return -ENODEV; 175 } 176 177 mc_lst->ifindex = dev->ifindex; 178 mc_lst->sfmode = MCAST_EXCLUDE; 179 rwlock_init(&mc_lst->sflock); 180 mc_lst->sflist = NULL; 181 182 /* 183 * now add/increase the group membership on the device 184 */ 185 186 err = ipv6_dev_mc_inc(dev, addr); 187 188 if (err) { 189 rcu_read_unlock(); 190 sock_kfree_s(sk, mc_lst, sizeof(*mc_lst)); 191 return err; 192 } 193 194 spin_lock(&ipv6_sk_mc_lock); 195 mc_lst->next = np->ipv6_mc_list; 196 rcu_assign_pointer(np->ipv6_mc_list, mc_lst); 197 spin_unlock(&ipv6_sk_mc_lock); 198 199 rcu_read_unlock(); 200 201 return 0; 202 } 203 204 /* 205 * socket leave on multicast group 206 */ 207 int ipv6_sock_mc_drop(struct sock *sk, int ifindex, const struct in6_addr *addr) 208 { 209 struct ipv6_pinfo *np = inet6_sk(sk); 210 struct ipv6_mc_socklist *mc_lst; 211 struct ipv6_mc_socklist __rcu **lnk; 212 struct net *net = sock_net(sk); 213 214 spin_lock(&ipv6_sk_mc_lock); 215 for (lnk = &np->ipv6_mc_list; 216 (mc_lst = rcu_dereference_protected(*lnk, 217 lockdep_is_held(&ipv6_sk_mc_lock))) !=NULL ; 218 lnk = &mc_lst->next) { 219 if ((ifindex == 0 || mc_lst->ifindex == ifindex) && 220 ipv6_addr_equal(&mc_lst->addr, addr)) { 221 struct net_device *dev; 222 223 *lnk = mc_lst->next; 224 spin_unlock(&ipv6_sk_mc_lock); 225 226 rcu_read_lock(); 227 dev = dev_get_by_index_rcu(net, mc_lst->ifindex); 228 if (dev != NULL) { 229 struct inet6_dev *idev = __in6_dev_get(dev); 230 231 (void) ip6_mc_leave_src(sk, mc_lst, idev); 232 if (idev) 233 __ipv6_dev_mc_dec(idev, &mc_lst->addr); 234 } else 235 (void) ip6_mc_leave_src(sk, mc_lst, NULL); 236 rcu_read_unlock(); 237 atomic_sub(sizeof(*mc_lst), &sk->sk_omem_alloc); 238 kfree_rcu(mc_lst, rcu); 239 return 0; 240 } 241 } 242 spin_unlock(&ipv6_sk_mc_lock); 243 244 return -EADDRNOTAVAIL; 245 } 246 247 /* called with rcu_read_lock() */ 248 static struct inet6_dev *ip6_mc_find_dev_rcu(struct net *net, 249 const struct in6_addr *group, 250 int ifindex) 251 { 252 struct net_device *dev = NULL; 253 struct inet6_dev *idev = NULL; 254 255 if (ifindex == 0) { 256 struct rt6_info *rt = rt6_lookup(net, group, NULL, 0, 0); 257 258 if (rt) { 259 dev = rt->dst.dev; 260 dst_release(&rt->dst); 261 } 262 } else 263 dev = dev_get_by_index_rcu(net, ifindex); 264 265 if (!dev) 266 return NULL; 267 idev = __in6_dev_get(dev); 268 if (!idev) 269 return NULL; 270 read_lock_bh(&idev->lock); 271 if (idev->dead) { 272 read_unlock_bh(&idev->lock); 273 return NULL; 274 } 275 return idev; 276 } 277 278 void ipv6_sock_mc_close(struct sock *sk) 279 { 280 struct ipv6_pinfo *np = inet6_sk(sk); 281 struct ipv6_mc_socklist *mc_lst; 282 struct net *net = sock_net(sk); 283 284 spin_lock(&ipv6_sk_mc_lock); 285 while ((mc_lst = rcu_dereference_protected(np->ipv6_mc_list, 286 lockdep_is_held(&ipv6_sk_mc_lock))) != NULL) { 287 struct net_device *dev; 288 289 np->ipv6_mc_list = mc_lst->next; 290 spin_unlock(&ipv6_sk_mc_lock); 291 292 rcu_read_lock(); 293 dev = dev_get_by_index_rcu(net, mc_lst->ifindex); 294 if (dev) { 295 struct inet6_dev *idev = __in6_dev_get(dev); 296 297 (void) ip6_mc_leave_src(sk, mc_lst, idev); 298 if (idev) 299 __ipv6_dev_mc_dec(idev, &mc_lst->addr); 300 } else 301 (void) ip6_mc_leave_src(sk, mc_lst, NULL); 302 rcu_read_unlock(); 303 304 atomic_sub(sizeof(*mc_lst), &sk->sk_omem_alloc); 305 kfree_rcu(mc_lst, rcu); 306 307 spin_lock(&ipv6_sk_mc_lock); 308 } 309 spin_unlock(&ipv6_sk_mc_lock); 310 } 311 312 int ip6_mc_source(int add, int omode, struct sock *sk, 313 struct group_source_req *pgsr) 314 { 315 struct in6_addr *source, *group; 316 struct ipv6_mc_socklist *pmc; 317 struct inet6_dev *idev; 318 struct ipv6_pinfo *inet6 = inet6_sk(sk); 319 struct ip6_sf_socklist *psl; 320 struct net *net = sock_net(sk); 321 int i, j, rv; 322 int leavegroup = 0; 323 int pmclocked = 0; 324 int err; 325 326 source = &((struct sockaddr_in6 *)&pgsr->gsr_source)->sin6_addr; 327 group = &((struct sockaddr_in6 *)&pgsr->gsr_group)->sin6_addr; 328 329 if (!ipv6_addr_is_multicast(group)) 330 return -EINVAL; 331 332 rcu_read_lock(); 333 idev = ip6_mc_find_dev_rcu(net, group, pgsr->gsr_interface); 334 if (!idev) { 335 rcu_read_unlock(); 336 return -ENODEV; 337 } 338 339 err = -EADDRNOTAVAIL; 340 341 for_each_pmc_rcu(inet6, pmc) { 342 if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface) 343 continue; 344 if (ipv6_addr_equal(&pmc->addr, group)) 345 break; 346 } 347 if (!pmc) { /* must have a prior join */ 348 err = -EINVAL; 349 goto done; 350 } 351 /* if a source filter was set, must be the same mode as before */ 352 if (pmc->sflist) { 353 if (pmc->sfmode != omode) { 354 err = -EINVAL; 355 goto done; 356 } 357 } else if (pmc->sfmode != omode) { 358 /* allow mode switches for empty-set filters */ 359 ip6_mc_add_src(idev, group, omode, 0, NULL, 0); 360 ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0); 361 pmc->sfmode = omode; 362 } 363 364 write_lock(&pmc->sflock); 365 pmclocked = 1; 366 367 psl = pmc->sflist; 368 if (!add) { 369 if (!psl) 370 goto done; /* err = -EADDRNOTAVAIL */ 371 rv = !0; 372 for (i=0; i<psl->sl_count; i++) { 373 rv = memcmp(&psl->sl_addr[i], source, 374 sizeof(struct in6_addr)); 375 if (rv == 0) 376 break; 377 } 378 if (rv) /* source not found */ 379 goto done; /* err = -EADDRNOTAVAIL */ 380 381 /* special case - (INCLUDE, empty) == LEAVE_GROUP */ 382 if (psl->sl_count == 1 && omode == MCAST_INCLUDE) { 383 leavegroup = 1; 384 goto done; 385 } 386 387 /* update the interface filter */ 388 ip6_mc_del_src(idev, group, omode, 1, source, 1); 389 390 for (j=i+1; j<psl->sl_count; j++) 391 psl->sl_addr[j-1] = psl->sl_addr[j]; 392 psl->sl_count--; 393 err = 0; 394 goto done; 395 } 396 /* else, add a new source to the filter */ 397 398 if (psl && psl->sl_count >= sysctl_mld_max_msf) { 399 err = -ENOBUFS; 400 goto done; 401 } 402 if (!psl || psl->sl_count == psl->sl_max) { 403 struct ip6_sf_socklist *newpsl; 404 int count = IP6_SFBLOCK; 405 406 if (psl) 407 count += psl->sl_max; 408 newpsl = sock_kmalloc(sk, IP6_SFLSIZE(count), GFP_ATOMIC); 409 if (!newpsl) { 410 err = -ENOBUFS; 411 goto done; 412 } 413 newpsl->sl_max = count; 414 newpsl->sl_count = count - IP6_SFBLOCK; 415 if (psl) { 416 for (i=0; i<psl->sl_count; i++) 417 newpsl->sl_addr[i] = psl->sl_addr[i]; 418 sock_kfree_s(sk, psl, IP6_SFLSIZE(psl->sl_max)); 419 } 420 pmc->sflist = psl = newpsl; 421 } 422 rv = 1; /* > 0 for insert logic below if sl_count is 0 */ 423 for (i=0; i<psl->sl_count; i++) { 424 rv = memcmp(&psl->sl_addr[i], source, sizeof(struct in6_addr)); 425 if (rv == 0) 426 break; 427 } 428 if (rv == 0) /* address already there is an error */ 429 goto done; 430 for (j=psl->sl_count-1; j>=i; j--) 431 psl->sl_addr[j+1] = psl->sl_addr[j]; 432 psl->sl_addr[i] = *source; 433 psl->sl_count++; 434 err = 0; 435 /* update the interface list */ 436 ip6_mc_add_src(idev, group, omode, 1, source, 1); 437 done: 438 if (pmclocked) 439 write_unlock(&pmc->sflock); 440 read_unlock_bh(&idev->lock); 441 rcu_read_unlock(); 442 if (leavegroup) 443 return ipv6_sock_mc_drop(sk, pgsr->gsr_interface, group); 444 return err; 445 } 446 447 int ip6_mc_msfilter(struct sock *sk, struct group_filter *gsf) 448 { 449 const struct in6_addr *group; 450 struct ipv6_mc_socklist *pmc; 451 struct inet6_dev *idev; 452 struct ipv6_pinfo *inet6 = inet6_sk(sk); 453 struct ip6_sf_socklist *newpsl, *psl; 454 struct net *net = sock_net(sk); 455 int leavegroup = 0; 456 int i, err; 457 458 group = &((struct sockaddr_in6 *)&gsf->gf_group)->sin6_addr; 459 460 if (!ipv6_addr_is_multicast(group)) 461 return -EINVAL; 462 if (gsf->gf_fmode != MCAST_INCLUDE && 463 gsf->gf_fmode != MCAST_EXCLUDE) 464 return -EINVAL; 465 466 rcu_read_lock(); 467 idev = ip6_mc_find_dev_rcu(net, group, gsf->gf_interface); 468 469 if (!idev) { 470 rcu_read_unlock(); 471 return -ENODEV; 472 } 473 474 err = 0; 475 476 if (gsf->gf_fmode == MCAST_INCLUDE && gsf->gf_numsrc == 0) { 477 leavegroup = 1; 478 goto done; 479 } 480 481 for_each_pmc_rcu(inet6, pmc) { 482 if (pmc->ifindex != gsf->gf_interface) 483 continue; 484 if (ipv6_addr_equal(&pmc->addr, group)) 485 break; 486 } 487 if (!pmc) { /* must have a prior join */ 488 err = -EINVAL; 489 goto done; 490 } 491 if (gsf->gf_numsrc) { 492 newpsl = sock_kmalloc(sk, IP6_SFLSIZE(gsf->gf_numsrc), 493 GFP_ATOMIC); 494 if (!newpsl) { 495 err = -ENOBUFS; 496 goto done; 497 } 498 newpsl->sl_max = newpsl->sl_count = gsf->gf_numsrc; 499 for (i=0; i<newpsl->sl_count; ++i) { 500 struct sockaddr_in6 *psin6; 501 502 psin6 = (struct sockaddr_in6 *)&gsf->gf_slist[i]; 503 newpsl->sl_addr[i] = psin6->sin6_addr; 504 } 505 err = ip6_mc_add_src(idev, group, gsf->gf_fmode, 506 newpsl->sl_count, newpsl->sl_addr, 0); 507 if (err) { 508 sock_kfree_s(sk, newpsl, IP6_SFLSIZE(newpsl->sl_max)); 509 goto done; 510 } 511 } else { 512 newpsl = NULL; 513 (void) ip6_mc_add_src(idev, group, gsf->gf_fmode, 0, NULL, 0); 514 } 515 516 write_lock(&pmc->sflock); 517 psl = pmc->sflist; 518 if (psl) { 519 (void) ip6_mc_del_src(idev, group, pmc->sfmode, 520 psl->sl_count, psl->sl_addr, 0); 521 sock_kfree_s(sk, psl, IP6_SFLSIZE(psl->sl_max)); 522 } else 523 (void) ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0); 524 pmc->sflist = newpsl; 525 pmc->sfmode = gsf->gf_fmode; 526 write_unlock(&pmc->sflock); 527 err = 0; 528 done: 529 read_unlock_bh(&idev->lock); 530 rcu_read_unlock(); 531 if (leavegroup) 532 err = ipv6_sock_mc_drop(sk, gsf->gf_interface, group); 533 return err; 534 } 535 536 int ip6_mc_msfget(struct sock *sk, struct group_filter *gsf, 537 struct group_filter __user *optval, int __user *optlen) 538 { 539 int err, i, count, copycount; 540 const struct in6_addr *group; 541 struct ipv6_mc_socklist *pmc; 542 struct inet6_dev *idev; 543 struct ipv6_pinfo *inet6 = inet6_sk(sk); 544 struct ip6_sf_socklist *psl; 545 struct net *net = sock_net(sk); 546 547 group = &((struct sockaddr_in6 *)&gsf->gf_group)->sin6_addr; 548 549 if (!ipv6_addr_is_multicast(group)) 550 return -EINVAL; 551 552 rcu_read_lock(); 553 idev = ip6_mc_find_dev_rcu(net, group, gsf->gf_interface); 554 555 if (!idev) { 556 rcu_read_unlock(); 557 return -ENODEV; 558 } 559 560 err = -EADDRNOTAVAIL; 561 /* 562 * changes to the ipv6_mc_list require the socket lock and 563 * a read lock on ip6_sk_mc_lock. We have the socket lock, 564 * so reading the list is safe. 565 */ 566 567 for_each_pmc_rcu(inet6, pmc) { 568 if (pmc->ifindex != gsf->gf_interface) 569 continue; 570 if (ipv6_addr_equal(group, &pmc->addr)) 571 break; 572 } 573 if (!pmc) /* must have a prior join */ 574 goto done; 575 gsf->gf_fmode = pmc->sfmode; 576 psl = pmc->sflist; 577 count = psl ? psl->sl_count : 0; 578 read_unlock_bh(&idev->lock); 579 rcu_read_unlock(); 580 581 copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc; 582 gsf->gf_numsrc = count; 583 if (put_user(GROUP_FILTER_SIZE(copycount), optlen) || 584 copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) { 585 return -EFAULT; 586 } 587 /* changes to psl require the socket lock, a read lock on 588 * on ipv6_sk_mc_lock and a write lock on pmc->sflock. We 589 * have the socket lock, so reading here is safe. 590 */ 591 for (i=0; i<copycount; i++) { 592 struct sockaddr_in6 *psin6; 593 struct sockaddr_storage ss; 594 595 psin6 = (struct sockaddr_in6 *)&ss; 596 memset(&ss, 0, sizeof(ss)); 597 psin6->sin6_family = AF_INET6; 598 psin6->sin6_addr = psl->sl_addr[i]; 599 if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss))) 600 return -EFAULT; 601 } 602 return 0; 603 done: 604 read_unlock_bh(&idev->lock); 605 rcu_read_unlock(); 606 return err; 607 } 608 609 int inet6_mc_check(struct sock *sk, const struct in6_addr *mc_addr, 610 const struct in6_addr *src_addr) 611 { 612 struct ipv6_pinfo *np = inet6_sk(sk); 613 struct ipv6_mc_socklist *mc; 614 struct ip6_sf_socklist *psl; 615 int rv = 1; 616 617 rcu_read_lock(); 618 for_each_pmc_rcu(np, mc) { 619 if (ipv6_addr_equal(&mc->addr, mc_addr)) 620 break; 621 } 622 if (!mc) { 623 rcu_read_unlock(); 624 return 1; 625 } 626 read_lock(&mc->sflock); 627 psl = mc->sflist; 628 if (!psl) { 629 rv = mc->sfmode == MCAST_EXCLUDE; 630 } else { 631 int i; 632 633 for (i=0; i<psl->sl_count; i++) { 634 if (ipv6_addr_equal(&psl->sl_addr[i], src_addr)) 635 break; 636 } 637 if (mc->sfmode == MCAST_INCLUDE && i >= psl->sl_count) 638 rv = 0; 639 if (mc->sfmode == MCAST_EXCLUDE && i < psl->sl_count) 640 rv = 0; 641 } 642 read_unlock(&mc->sflock); 643 rcu_read_unlock(); 644 645 return rv; 646 } 647 648 static void ma_put(struct ifmcaddr6 *mc) 649 { 650 if (atomic_dec_and_test(&mc->mca_refcnt)) { 651 in6_dev_put(mc->idev); 652 kfree(mc); 653 } 654 } 655 656 static void igmp6_group_added(struct ifmcaddr6 *mc) 657 { 658 struct net_device *dev = mc->idev->dev; 659 char buf[MAX_ADDR_LEN]; 660 661 spin_lock_bh(&mc->mca_lock); 662 if (!(mc->mca_flags&MAF_LOADED)) { 663 mc->mca_flags |= MAF_LOADED; 664 if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0) 665 dev_mc_add(dev, buf); 666 } 667 spin_unlock_bh(&mc->mca_lock); 668 669 if (!(dev->flags & IFF_UP) || (mc->mca_flags & MAF_NOREPORT)) 670 return; 671 672 if (MLD_V1_SEEN(mc->idev)) { 673 igmp6_join_group(mc); 674 return; 675 } 676 /* else v2 */ 677 678 mc->mca_crcount = mc->idev->mc_qrv; 679 mld_ifc_event(mc->idev); 680 } 681 682 static void igmp6_group_dropped(struct ifmcaddr6 *mc) 683 { 684 struct net_device *dev = mc->idev->dev; 685 char buf[MAX_ADDR_LEN]; 686 687 spin_lock_bh(&mc->mca_lock); 688 if (mc->mca_flags&MAF_LOADED) { 689 mc->mca_flags &= ~MAF_LOADED; 690 if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0) 691 dev_mc_del(dev, buf); 692 } 693 694 if (mc->mca_flags & MAF_NOREPORT) 695 goto done; 696 spin_unlock_bh(&mc->mca_lock); 697 698 if (!mc->idev->dead) 699 igmp6_leave_group(mc); 700 701 spin_lock_bh(&mc->mca_lock); 702 if (del_timer(&mc->mca_timer)) 703 atomic_dec(&mc->mca_refcnt); 704 done: 705 ip6_mc_clear_src(mc); 706 spin_unlock_bh(&mc->mca_lock); 707 } 708 709 /* 710 * deleted ifmcaddr6 manipulation 711 */ 712 static void mld_add_delrec(struct inet6_dev *idev, struct ifmcaddr6 *im) 713 { 714 struct ifmcaddr6 *pmc; 715 716 /* this is an "ifmcaddr6" for convenience; only the fields below 717 * are actually used. In particular, the refcnt and users are not 718 * used for management of the delete list. Using the same structure 719 * for deleted items allows change reports to use common code with 720 * non-deleted or query-response MCA's. 721 */ 722 pmc = kzalloc(sizeof(*pmc), GFP_ATOMIC); 723 if (!pmc) 724 return; 725 726 spin_lock_bh(&im->mca_lock); 727 spin_lock_init(&pmc->mca_lock); 728 pmc->idev = im->idev; 729 in6_dev_hold(idev); 730 pmc->mca_addr = im->mca_addr; 731 pmc->mca_crcount = idev->mc_qrv; 732 pmc->mca_sfmode = im->mca_sfmode; 733 if (pmc->mca_sfmode == MCAST_INCLUDE) { 734 struct ip6_sf_list *psf; 735 736 pmc->mca_tomb = im->mca_tomb; 737 pmc->mca_sources = im->mca_sources; 738 im->mca_tomb = im->mca_sources = NULL; 739 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) 740 psf->sf_crcount = pmc->mca_crcount; 741 } 742 spin_unlock_bh(&im->mca_lock); 743 744 spin_lock_bh(&idev->mc_lock); 745 pmc->next = idev->mc_tomb; 746 idev->mc_tomb = pmc; 747 spin_unlock_bh(&idev->mc_lock); 748 } 749 750 static void mld_del_delrec(struct inet6_dev *idev, const struct in6_addr *pmca) 751 { 752 struct ifmcaddr6 *pmc, *pmc_prev; 753 struct ip6_sf_list *psf, *psf_next; 754 755 spin_lock_bh(&idev->mc_lock); 756 pmc_prev = NULL; 757 for (pmc=idev->mc_tomb; pmc; pmc=pmc->next) { 758 if (ipv6_addr_equal(&pmc->mca_addr, pmca)) 759 break; 760 pmc_prev = pmc; 761 } 762 if (pmc) { 763 if (pmc_prev) 764 pmc_prev->next = pmc->next; 765 else 766 idev->mc_tomb = pmc->next; 767 } 768 spin_unlock_bh(&idev->mc_lock); 769 770 if (pmc) { 771 for (psf=pmc->mca_tomb; psf; psf=psf_next) { 772 psf_next = psf->sf_next; 773 kfree(psf); 774 } 775 in6_dev_put(pmc->idev); 776 kfree(pmc); 777 } 778 } 779 780 static void mld_clear_delrec(struct inet6_dev *idev) 781 { 782 struct ifmcaddr6 *pmc, *nextpmc; 783 784 spin_lock_bh(&idev->mc_lock); 785 pmc = idev->mc_tomb; 786 idev->mc_tomb = NULL; 787 spin_unlock_bh(&idev->mc_lock); 788 789 for (; pmc; pmc = nextpmc) { 790 nextpmc = pmc->next; 791 ip6_mc_clear_src(pmc); 792 in6_dev_put(pmc->idev); 793 kfree(pmc); 794 } 795 796 /* clear dead sources, too */ 797 read_lock_bh(&idev->lock); 798 for (pmc=idev->mc_list; pmc; pmc=pmc->next) { 799 struct ip6_sf_list *psf, *psf_next; 800 801 spin_lock_bh(&pmc->mca_lock); 802 psf = pmc->mca_tomb; 803 pmc->mca_tomb = NULL; 804 spin_unlock_bh(&pmc->mca_lock); 805 for (; psf; psf=psf_next) { 806 psf_next = psf->sf_next; 807 kfree(psf); 808 } 809 } 810 read_unlock_bh(&idev->lock); 811 } 812 813 814 /* 815 * device multicast group inc (add if not found) 816 */ 817 int ipv6_dev_mc_inc(struct net_device *dev, const struct in6_addr *addr) 818 { 819 struct ifmcaddr6 *mc; 820 struct inet6_dev *idev; 821 822 /* we need to take a reference on idev */ 823 idev = in6_dev_get(dev); 824 825 if (idev == NULL) 826 return -EINVAL; 827 828 write_lock_bh(&idev->lock); 829 if (idev->dead) { 830 write_unlock_bh(&idev->lock); 831 in6_dev_put(idev); 832 return -ENODEV; 833 } 834 835 for (mc = idev->mc_list; mc; mc = mc->next) { 836 if (ipv6_addr_equal(&mc->mca_addr, addr)) { 837 mc->mca_users++; 838 write_unlock_bh(&idev->lock); 839 ip6_mc_add_src(idev, &mc->mca_addr, MCAST_EXCLUDE, 0, 840 NULL, 0); 841 in6_dev_put(idev); 842 return 0; 843 } 844 } 845 846 /* 847 * not found: create a new one. 848 */ 849 850 mc = kzalloc(sizeof(struct ifmcaddr6), GFP_ATOMIC); 851 852 if (mc == NULL) { 853 write_unlock_bh(&idev->lock); 854 in6_dev_put(idev); 855 return -ENOMEM; 856 } 857 858 setup_timer(&mc->mca_timer, igmp6_timer_handler, (unsigned long)mc); 859 860 mc->mca_addr = *addr; 861 mc->idev = idev; /* (reference taken) */ 862 mc->mca_users = 1; 863 /* mca_stamp should be updated upon changes */ 864 mc->mca_cstamp = mc->mca_tstamp = jiffies; 865 atomic_set(&mc->mca_refcnt, 2); 866 spin_lock_init(&mc->mca_lock); 867 868 /* initial mode is (EX, empty) */ 869 mc->mca_sfmode = MCAST_EXCLUDE; 870 mc->mca_sfcount[MCAST_EXCLUDE] = 1; 871 872 if (ipv6_addr_is_ll_all_nodes(&mc->mca_addr) || 873 IPV6_ADDR_MC_SCOPE(&mc->mca_addr) < IPV6_ADDR_SCOPE_LINKLOCAL) 874 mc->mca_flags |= MAF_NOREPORT; 875 876 mc->next = idev->mc_list; 877 idev->mc_list = mc; 878 write_unlock_bh(&idev->lock); 879 880 mld_del_delrec(idev, &mc->mca_addr); 881 igmp6_group_added(mc); 882 ma_put(mc); 883 return 0; 884 } 885 886 /* 887 * device multicast group del 888 */ 889 int __ipv6_dev_mc_dec(struct inet6_dev *idev, const struct in6_addr *addr) 890 { 891 struct ifmcaddr6 *ma, **map; 892 893 write_lock_bh(&idev->lock); 894 for (map = &idev->mc_list; (ma=*map) != NULL; map = &ma->next) { 895 if (ipv6_addr_equal(&ma->mca_addr, addr)) { 896 if (--ma->mca_users == 0) { 897 *map = ma->next; 898 write_unlock_bh(&idev->lock); 899 900 igmp6_group_dropped(ma); 901 902 ma_put(ma); 903 return 0; 904 } 905 write_unlock_bh(&idev->lock); 906 return 0; 907 } 908 } 909 write_unlock_bh(&idev->lock); 910 911 return -ENOENT; 912 } 913 914 int ipv6_dev_mc_dec(struct net_device *dev, const struct in6_addr *addr) 915 { 916 struct inet6_dev *idev; 917 int err; 918 919 rcu_read_lock(); 920 921 idev = __in6_dev_get(dev); 922 if (!idev) 923 err = -ENODEV; 924 else 925 err = __ipv6_dev_mc_dec(idev, addr); 926 927 rcu_read_unlock(); 928 return err; 929 } 930 931 /* 932 * identify MLD packets for MLD filter exceptions 933 */ 934 int ipv6_is_mld(struct sk_buff *skb, int nexthdr) 935 { 936 struct icmp6hdr *pic; 937 938 if (nexthdr != IPPROTO_ICMPV6) 939 return 0; 940 941 if (!pskb_may_pull(skb, sizeof(struct icmp6hdr))) 942 return 0; 943 944 pic = icmp6_hdr(skb); 945 946 switch (pic->icmp6_type) { 947 case ICMPV6_MGM_QUERY: 948 case ICMPV6_MGM_REPORT: 949 case ICMPV6_MGM_REDUCTION: 950 case ICMPV6_MLD2_REPORT: 951 return 1; 952 default: 953 break; 954 } 955 return 0; 956 } 957 958 /* 959 * check if the interface/address pair is valid 960 */ 961 int ipv6_chk_mcast_addr(struct net_device *dev, const struct in6_addr *group, 962 const struct in6_addr *src_addr) 963 { 964 struct inet6_dev *idev; 965 struct ifmcaddr6 *mc; 966 int rv = 0; 967 968 rcu_read_lock(); 969 idev = __in6_dev_get(dev); 970 if (idev) { 971 read_lock_bh(&idev->lock); 972 for (mc = idev->mc_list; mc; mc=mc->next) { 973 if (ipv6_addr_equal(&mc->mca_addr, group)) 974 break; 975 } 976 if (mc) { 977 if (src_addr && !ipv6_addr_any(src_addr)) { 978 struct ip6_sf_list *psf; 979 980 spin_lock_bh(&mc->mca_lock); 981 for (psf=mc->mca_sources;psf;psf=psf->sf_next) { 982 if (ipv6_addr_equal(&psf->sf_addr, src_addr)) 983 break; 984 } 985 if (psf) 986 rv = psf->sf_count[MCAST_INCLUDE] || 987 psf->sf_count[MCAST_EXCLUDE] != 988 mc->mca_sfcount[MCAST_EXCLUDE]; 989 else 990 rv = mc->mca_sfcount[MCAST_EXCLUDE] !=0; 991 spin_unlock_bh(&mc->mca_lock); 992 } else 993 rv = 1; /* don't filter unspecified source */ 994 } 995 read_unlock_bh(&idev->lock); 996 } 997 rcu_read_unlock(); 998 return rv; 999 } 1000 1001 static void mld_gq_start_timer(struct inet6_dev *idev) 1002 { 1003 int tv = net_random() % idev->mc_maxdelay; 1004 1005 idev->mc_gq_running = 1; 1006 if (!mod_timer(&idev->mc_gq_timer, jiffies+tv+2)) 1007 in6_dev_hold(idev); 1008 } 1009 1010 static void mld_ifc_start_timer(struct inet6_dev *idev, int delay) 1011 { 1012 int tv = net_random() % delay; 1013 1014 if (!mod_timer(&idev->mc_ifc_timer, jiffies+tv+2)) 1015 in6_dev_hold(idev); 1016 } 1017 1018 /* 1019 * IGMP handling (alias multicast ICMPv6 messages) 1020 */ 1021 1022 static void igmp6_group_queried(struct ifmcaddr6 *ma, unsigned long resptime) 1023 { 1024 unsigned long delay = resptime; 1025 1026 /* Do not start timer for these addresses */ 1027 if (ipv6_addr_is_ll_all_nodes(&ma->mca_addr) || 1028 IPV6_ADDR_MC_SCOPE(&ma->mca_addr) < IPV6_ADDR_SCOPE_LINKLOCAL) 1029 return; 1030 1031 if (del_timer(&ma->mca_timer)) { 1032 atomic_dec(&ma->mca_refcnt); 1033 delay = ma->mca_timer.expires - jiffies; 1034 } 1035 1036 if (delay >= resptime) { 1037 if (resptime) 1038 delay = net_random() % resptime; 1039 else 1040 delay = 1; 1041 } 1042 ma->mca_timer.expires = jiffies + delay; 1043 if (!mod_timer(&ma->mca_timer, jiffies + delay)) 1044 atomic_inc(&ma->mca_refcnt); 1045 ma->mca_flags |= MAF_TIMER_RUNNING; 1046 } 1047 1048 /* mark EXCLUDE-mode sources */ 1049 static int mld_xmarksources(struct ifmcaddr6 *pmc, int nsrcs, 1050 const struct in6_addr *srcs) 1051 { 1052 struct ip6_sf_list *psf; 1053 int i, scount; 1054 1055 scount = 0; 1056 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) { 1057 if (scount == nsrcs) 1058 break; 1059 for (i=0; i<nsrcs; i++) { 1060 /* skip inactive filters */ 1061 if (psf->sf_count[MCAST_INCLUDE] || 1062 pmc->mca_sfcount[MCAST_EXCLUDE] != 1063 psf->sf_count[MCAST_EXCLUDE]) 1064 continue; 1065 if (ipv6_addr_equal(&srcs[i], &psf->sf_addr)) { 1066 scount++; 1067 break; 1068 } 1069 } 1070 } 1071 pmc->mca_flags &= ~MAF_GSQUERY; 1072 if (scount == nsrcs) /* all sources excluded */ 1073 return 0; 1074 return 1; 1075 } 1076 1077 static int mld_marksources(struct ifmcaddr6 *pmc, int nsrcs, 1078 const struct in6_addr *srcs) 1079 { 1080 struct ip6_sf_list *psf; 1081 int i, scount; 1082 1083 if (pmc->mca_sfmode == MCAST_EXCLUDE) 1084 return mld_xmarksources(pmc, nsrcs, srcs); 1085 1086 /* mark INCLUDE-mode sources */ 1087 1088 scount = 0; 1089 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) { 1090 if (scount == nsrcs) 1091 break; 1092 for (i=0; i<nsrcs; i++) { 1093 if (ipv6_addr_equal(&srcs[i], &psf->sf_addr)) { 1094 psf->sf_gsresp = 1; 1095 scount++; 1096 break; 1097 } 1098 } 1099 } 1100 if (!scount) { 1101 pmc->mca_flags &= ~MAF_GSQUERY; 1102 return 0; 1103 } 1104 pmc->mca_flags |= MAF_GSQUERY; 1105 return 1; 1106 } 1107 1108 /* called with rcu_read_lock() */ 1109 int igmp6_event_query(struct sk_buff *skb) 1110 { 1111 struct mld2_query *mlh2 = NULL; 1112 struct ifmcaddr6 *ma; 1113 const struct in6_addr *group; 1114 unsigned long max_delay; 1115 struct inet6_dev *idev; 1116 struct mld_msg *mld; 1117 int group_type; 1118 int mark = 0; 1119 int len; 1120 1121 if (!pskb_may_pull(skb, sizeof(struct in6_addr))) 1122 return -EINVAL; 1123 1124 /* compute payload length excluding extension headers */ 1125 len = ntohs(ipv6_hdr(skb)->payload_len) + sizeof(struct ipv6hdr); 1126 len -= skb_network_header_len(skb); 1127 1128 /* Drop queries with not link local source */ 1129 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) 1130 return -EINVAL; 1131 1132 idev = __in6_dev_get(skb->dev); 1133 1134 if (idev == NULL) 1135 return 0; 1136 1137 mld = (struct mld_msg *)icmp6_hdr(skb); 1138 group = &mld->mld_mca; 1139 group_type = ipv6_addr_type(group); 1140 1141 if (group_type != IPV6_ADDR_ANY && 1142 !(group_type&IPV6_ADDR_MULTICAST)) 1143 return -EINVAL; 1144 1145 if (len == 24) { 1146 int switchback; 1147 /* MLDv1 router present */ 1148 1149 /* Translate milliseconds to jiffies */ 1150 max_delay = (ntohs(mld->mld_maxdelay)*HZ)/1000; 1151 1152 switchback = (idev->mc_qrv + 1) * max_delay; 1153 idev->mc_v1_seen = jiffies + switchback; 1154 1155 /* cancel the interface change timer */ 1156 idev->mc_ifc_count = 0; 1157 if (del_timer(&idev->mc_ifc_timer)) 1158 __in6_dev_put(idev); 1159 /* clear deleted report items */ 1160 mld_clear_delrec(idev); 1161 } else if (len >= 28) { 1162 int srcs_offset = sizeof(struct mld2_query) - 1163 sizeof(struct icmp6hdr); 1164 if (!pskb_may_pull(skb, srcs_offset)) 1165 return -EINVAL; 1166 1167 mlh2 = (struct mld2_query *)skb_transport_header(skb); 1168 max_delay = (MLDV2_MRC(ntohs(mlh2->mld2q_mrc))*HZ)/1000; 1169 if (!max_delay) 1170 max_delay = 1; 1171 idev->mc_maxdelay = max_delay; 1172 if (mlh2->mld2q_qrv) 1173 idev->mc_qrv = mlh2->mld2q_qrv; 1174 if (group_type == IPV6_ADDR_ANY) { /* general query */ 1175 if (mlh2->mld2q_nsrcs) 1176 return -EINVAL; /* no sources allowed */ 1177 1178 mld_gq_start_timer(idev); 1179 return 0; 1180 } 1181 /* mark sources to include, if group & source-specific */ 1182 if (mlh2->mld2q_nsrcs != 0) { 1183 if (!pskb_may_pull(skb, srcs_offset + 1184 ntohs(mlh2->mld2q_nsrcs) * sizeof(struct in6_addr))) 1185 return -EINVAL; 1186 1187 mlh2 = (struct mld2_query *)skb_transport_header(skb); 1188 mark = 1; 1189 } 1190 } else 1191 return -EINVAL; 1192 1193 read_lock_bh(&idev->lock); 1194 if (group_type == IPV6_ADDR_ANY) { 1195 for (ma = idev->mc_list; ma; ma=ma->next) { 1196 spin_lock_bh(&ma->mca_lock); 1197 igmp6_group_queried(ma, max_delay); 1198 spin_unlock_bh(&ma->mca_lock); 1199 } 1200 } else { 1201 for (ma = idev->mc_list; ma; ma=ma->next) { 1202 if (!ipv6_addr_equal(group, &ma->mca_addr)) 1203 continue; 1204 spin_lock_bh(&ma->mca_lock); 1205 if (ma->mca_flags & MAF_TIMER_RUNNING) { 1206 /* gsquery <- gsquery && mark */ 1207 if (!mark) 1208 ma->mca_flags &= ~MAF_GSQUERY; 1209 } else { 1210 /* gsquery <- mark */ 1211 if (mark) 1212 ma->mca_flags |= MAF_GSQUERY; 1213 else 1214 ma->mca_flags &= ~MAF_GSQUERY; 1215 } 1216 if (!(ma->mca_flags & MAF_GSQUERY) || 1217 mld_marksources(ma, ntohs(mlh2->mld2q_nsrcs), mlh2->mld2q_srcs)) 1218 igmp6_group_queried(ma, max_delay); 1219 spin_unlock_bh(&ma->mca_lock); 1220 break; 1221 } 1222 } 1223 read_unlock_bh(&idev->lock); 1224 1225 return 0; 1226 } 1227 1228 /* called with rcu_read_lock() */ 1229 int igmp6_event_report(struct sk_buff *skb) 1230 { 1231 struct ifmcaddr6 *ma; 1232 struct inet6_dev *idev; 1233 struct mld_msg *mld; 1234 int addr_type; 1235 1236 /* Our own report looped back. Ignore it. */ 1237 if (skb->pkt_type == PACKET_LOOPBACK) 1238 return 0; 1239 1240 /* send our report if the MC router may not have heard this report */ 1241 if (skb->pkt_type != PACKET_MULTICAST && 1242 skb->pkt_type != PACKET_BROADCAST) 1243 return 0; 1244 1245 if (!pskb_may_pull(skb, sizeof(*mld) - sizeof(struct icmp6hdr))) 1246 return -EINVAL; 1247 1248 mld = (struct mld_msg *)icmp6_hdr(skb); 1249 1250 /* Drop reports with not link local source */ 1251 addr_type = ipv6_addr_type(&ipv6_hdr(skb)->saddr); 1252 if (addr_type != IPV6_ADDR_ANY && 1253 !(addr_type&IPV6_ADDR_LINKLOCAL)) 1254 return -EINVAL; 1255 1256 idev = __in6_dev_get(skb->dev); 1257 if (idev == NULL) 1258 return -ENODEV; 1259 1260 /* 1261 * Cancel the timer for this group 1262 */ 1263 1264 read_lock_bh(&idev->lock); 1265 for (ma = idev->mc_list; ma; ma=ma->next) { 1266 if (ipv6_addr_equal(&ma->mca_addr, &mld->mld_mca)) { 1267 spin_lock(&ma->mca_lock); 1268 if (del_timer(&ma->mca_timer)) 1269 atomic_dec(&ma->mca_refcnt); 1270 ma->mca_flags &= ~(MAF_LAST_REPORTER|MAF_TIMER_RUNNING); 1271 spin_unlock(&ma->mca_lock); 1272 break; 1273 } 1274 } 1275 read_unlock_bh(&idev->lock); 1276 return 0; 1277 } 1278 1279 static int is_in(struct ifmcaddr6 *pmc, struct ip6_sf_list *psf, int type, 1280 int gdeleted, int sdeleted) 1281 { 1282 switch (type) { 1283 case MLD2_MODE_IS_INCLUDE: 1284 case MLD2_MODE_IS_EXCLUDE: 1285 if (gdeleted || sdeleted) 1286 return 0; 1287 if (!((pmc->mca_flags & MAF_GSQUERY) && !psf->sf_gsresp)) { 1288 if (pmc->mca_sfmode == MCAST_INCLUDE) 1289 return 1; 1290 /* don't include if this source is excluded 1291 * in all filters 1292 */ 1293 if (psf->sf_count[MCAST_INCLUDE]) 1294 return type == MLD2_MODE_IS_INCLUDE; 1295 return pmc->mca_sfcount[MCAST_EXCLUDE] == 1296 psf->sf_count[MCAST_EXCLUDE]; 1297 } 1298 return 0; 1299 case MLD2_CHANGE_TO_INCLUDE: 1300 if (gdeleted || sdeleted) 1301 return 0; 1302 return psf->sf_count[MCAST_INCLUDE] != 0; 1303 case MLD2_CHANGE_TO_EXCLUDE: 1304 if (gdeleted || sdeleted) 1305 return 0; 1306 if (pmc->mca_sfcount[MCAST_EXCLUDE] == 0 || 1307 psf->sf_count[MCAST_INCLUDE]) 1308 return 0; 1309 return pmc->mca_sfcount[MCAST_EXCLUDE] == 1310 psf->sf_count[MCAST_EXCLUDE]; 1311 case MLD2_ALLOW_NEW_SOURCES: 1312 if (gdeleted || !psf->sf_crcount) 1313 return 0; 1314 return (pmc->mca_sfmode == MCAST_INCLUDE) ^ sdeleted; 1315 case MLD2_BLOCK_OLD_SOURCES: 1316 if (pmc->mca_sfmode == MCAST_INCLUDE) 1317 return gdeleted || (psf->sf_crcount && sdeleted); 1318 return psf->sf_crcount && !gdeleted && !sdeleted; 1319 } 1320 return 0; 1321 } 1322 1323 static int 1324 mld_scount(struct ifmcaddr6 *pmc, int type, int gdeleted, int sdeleted) 1325 { 1326 struct ip6_sf_list *psf; 1327 int scount = 0; 1328 1329 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) { 1330 if (!is_in(pmc, psf, type, gdeleted, sdeleted)) 1331 continue; 1332 scount++; 1333 } 1334 return scount; 1335 } 1336 1337 static struct sk_buff *mld_newpack(struct net_device *dev, int size) 1338 { 1339 struct net *net = dev_net(dev); 1340 struct sock *sk = net->ipv6.igmp_sk; 1341 struct sk_buff *skb; 1342 struct mld2_report *pmr; 1343 struct in6_addr addr_buf; 1344 const struct in6_addr *saddr; 1345 int hlen = LL_RESERVED_SPACE(dev); 1346 int tlen = dev->needed_tailroom; 1347 int err; 1348 u8 ra[8] = { IPPROTO_ICMPV6, 0, 1349 IPV6_TLV_ROUTERALERT, 2, 0, 0, 1350 IPV6_TLV_PADN, 0 }; 1351 1352 /* we assume size > sizeof(ra) here */ 1353 size += hlen + tlen; 1354 /* limit our allocations to order-0 page */ 1355 size = min_t(int, size, SKB_MAX_ORDER(0, 0)); 1356 skb = sock_alloc_send_skb(sk, size, 1, &err); 1357 1358 if (!skb) 1359 return NULL; 1360 1361 skb_reserve(skb, hlen); 1362 1363 if (ipv6_get_lladdr(dev, &addr_buf, IFA_F_TENTATIVE)) { 1364 /* <draft-ietf-magma-mld-source-05.txt>: 1365 * use unspecified address as the source address 1366 * when a valid link-local address is not available. 1367 */ 1368 saddr = &in6addr_any; 1369 } else 1370 saddr = &addr_buf; 1371 1372 ip6_nd_hdr(sk, skb, dev, saddr, &mld2_all_mcr, NEXTHDR_HOP, 0); 1373 1374 memcpy(skb_put(skb, sizeof(ra)), ra, sizeof(ra)); 1375 1376 skb_set_transport_header(skb, skb_tail_pointer(skb) - skb->data); 1377 skb_put(skb, sizeof(*pmr)); 1378 pmr = (struct mld2_report *)skb_transport_header(skb); 1379 pmr->mld2r_type = ICMPV6_MLD2_REPORT; 1380 pmr->mld2r_resv1 = 0; 1381 pmr->mld2r_cksum = 0; 1382 pmr->mld2r_resv2 = 0; 1383 pmr->mld2r_ngrec = 0; 1384 return skb; 1385 } 1386 1387 static void mld_sendpack(struct sk_buff *skb) 1388 { 1389 struct ipv6hdr *pip6 = ipv6_hdr(skb); 1390 struct mld2_report *pmr = 1391 (struct mld2_report *)skb_transport_header(skb); 1392 int payload_len, mldlen; 1393 struct inet6_dev *idev; 1394 struct net *net = dev_net(skb->dev); 1395 int err; 1396 struct flowi6 fl6; 1397 struct dst_entry *dst; 1398 1399 rcu_read_lock(); 1400 idev = __in6_dev_get(skb->dev); 1401 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len); 1402 1403 payload_len = (skb->tail - skb->network_header) - sizeof(*pip6); 1404 mldlen = skb->tail - skb->transport_header; 1405 pip6->payload_len = htons(payload_len); 1406 1407 pmr->mld2r_cksum = csum_ipv6_magic(&pip6->saddr, &pip6->daddr, mldlen, 1408 IPPROTO_ICMPV6, 1409 csum_partial(skb_transport_header(skb), 1410 mldlen, 0)); 1411 1412 icmpv6_flow_init(net->ipv6.igmp_sk, &fl6, ICMPV6_MLD2_REPORT, 1413 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr, 1414 skb->dev->ifindex); 1415 dst = icmp6_dst_alloc(skb->dev, NULL, &fl6); 1416 1417 err = 0; 1418 if (IS_ERR(dst)) { 1419 err = PTR_ERR(dst); 1420 dst = NULL; 1421 } 1422 skb_dst_set(skb, dst); 1423 if (err) 1424 goto err_out; 1425 1426 payload_len = skb->len; 1427 1428 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev, 1429 dst_output); 1430 out: 1431 if (!err) { 1432 ICMP6MSGOUT_INC_STATS_BH(net, idev, ICMPV6_MLD2_REPORT); 1433 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTMSGS); 1434 IP6_UPD_PO_STATS_BH(net, idev, IPSTATS_MIB_OUTMCAST, payload_len); 1435 } else 1436 IP6_INC_STATS_BH(net, idev, IPSTATS_MIB_OUTDISCARDS); 1437 1438 rcu_read_unlock(); 1439 return; 1440 1441 err_out: 1442 kfree_skb(skb); 1443 goto out; 1444 } 1445 1446 static int grec_size(struct ifmcaddr6 *pmc, int type, int gdel, int sdel) 1447 { 1448 return sizeof(struct mld2_grec) + 16 * mld_scount(pmc,type,gdel,sdel); 1449 } 1450 1451 static struct sk_buff *add_grhead(struct sk_buff *skb, struct ifmcaddr6 *pmc, 1452 int type, struct mld2_grec **ppgr) 1453 { 1454 struct net_device *dev = pmc->idev->dev; 1455 struct mld2_report *pmr; 1456 struct mld2_grec *pgr; 1457 1458 if (!skb) 1459 skb = mld_newpack(dev, dev->mtu); 1460 if (!skb) 1461 return NULL; 1462 pgr = (struct mld2_grec *)skb_put(skb, sizeof(struct mld2_grec)); 1463 pgr->grec_type = type; 1464 pgr->grec_auxwords = 0; 1465 pgr->grec_nsrcs = 0; 1466 pgr->grec_mca = pmc->mca_addr; /* structure copy */ 1467 pmr = (struct mld2_report *)skb_transport_header(skb); 1468 pmr->mld2r_ngrec = htons(ntohs(pmr->mld2r_ngrec)+1); 1469 *ppgr = pgr; 1470 return skb; 1471 } 1472 1473 #define AVAILABLE(skb) ((skb) ? ((skb)->dev ? (skb)->dev->mtu - (skb)->len : \ 1474 skb_tailroom(skb)) : 0) 1475 1476 static struct sk_buff *add_grec(struct sk_buff *skb, struct ifmcaddr6 *pmc, 1477 int type, int gdeleted, int sdeleted) 1478 { 1479 struct net_device *dev = pmc->idev->dev; 1480 struct mld2_report *pmr; 1481 struct mld2_grec *pgr = NULL; 1482 struct ip6_sf_list *psf, *psf_next, *psf_prev, **psf_list; 1483 int scount, stotal, first, isquery, truncate; 1484 1485 if (pmc->mca_flags & MAF_NOREPORT) 1486 return skb; 1487 1488 isquery = type == MLD2_MODE_IS_INCLUDE || 1489 type == MLD2_MODE_IS_EXCLUDE; 1490 truncate = type == MLD2_MODE_IS_EXCLUDE || 1491 type == MLD2_CHANGE_TO_EXCLUDE; 1492 1493 stotal = scount = 0; 1494 1495 psf_list = sdeleted ? &pmc->mca_tomb : &pmc->mca_sources; 1496 1497 if (!*psf_list) 1498 goto empty_source; 1499 1500 pmr = skb ? (struct mld2_report *)skb_transport_header(skb) : NULL; 1501 1502 /* EX and TO_EX get a fresh packet, if needed */ 1503 if (truncate) { 1504 if (pmr && pmr->mld2r_ngrec && 1505 AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) { 1506 if (skb) 1507 mld_sendpack(skb); 1508 skb = mld_newpack(dev, dev->mtu); 1509 } 1510 } 1511 first = 1; 1512 psf_prev = NULL; 1513 for (psf=*psf_list; psf; psf=psf_next) { 1514 struct in6_addr *psrc; 1515 1516 psf_next = psf->sf_next; 1517 1518 if (!is_in(pmc, psf, type, gdeleted, sdeleted)) { 1519 psf_prev = psf; 1520 continue; 1521 } 1522 1523 /* clear marks on query responses */ 1524 if (isquery) 1525 psf->sf_gsresp = 0; 1526 1527 if (AVAILABLE(skb) < sizeof(*psrc) + 1528 first*sizeof(struct mld2_grec)) { 1529 if (truncate && !first) 1530 break; /* truncate these */ 1531 if (pgr) 1532 pgr->grec_nsrcs = htons(scount); 1533 if (skb) 1534 mld_sendpack(skb); 1535 skb = mld_newpack(dev, dev->mtu); 1536 first = 1; 1537 scount = 0; 1538 } 1539 if (first) { 1540 skb = add_grhead(skb, pmc, type, &pgr); 1541 first = 0; 1542 } 1543 if (!skb) 1544 return NULL; 1545 psrc = (struct in6_addr *)skb_put(skb, sizeof(*psrc)); 1546 *psrc = psf->sf_addr; 1547 scount++; stotal++; 1548 if ((type == MLD2_ALLOW_NEW_SOURCES || 1549 type == MLD2_BLOCK_OLD_SOURCES) && psf->sf_crcount) { 1550 psf->sf_crcount--; 1551 if ((sdeleted || gdeleted) && psf->sf_crcount == 0) { 1552 if (psf_prev) 1553 psf_prev->sf_next = psf->sf_next; 1554 else 1555 *psf_list = psf->sf_next; 1556 kfree(psf); 1557 continue; 1558 } 1559 } 1560 psf_prev = psf; 1561 } 1562 1563 empty_source: 1564 if (!stotal) { 1565 if (type == MLD2_ALLOW_NEW_SOURCES || 1566 type == MLD2_BLOCK_OLD_SOURCES) 1567 return skb; 1568 if (pmc->mca_crcount || isquery) { 1569 /* make sure we have room for group header */ 1570 if (skb && AVAILABLE(skb) < sizeof(struct mld2_grec)) { 1571 mld_sendpack(skb); 1572 skb = NULL; /* add_grhead will get a new one */ 1573 } 1574 skb = add_grhead(skb, pmc, type, &pgr); 1575 } 1576 } 1577 if (pgr) 1578 pgr->grec_nsrcs = htons(scount); 1579 1580 if (isquery) 1581 pmc->mca_flags &= ~MAF_GSQUERY; /* clear query state */ 1582 return skb; 1583 } 1584 1585 static void mld_send_report(struct inet6_dev *idev, struct ifmcaddr6 *pmc) 1586 { 1587 struct sk_buff *skb = NULL; 1588 int type; 1589 1590 if (!pmc) { 1591 read_lock_bh(&idev->lock); 1592 for (pmc=idev->mc_list; pmc; pmc=pmc->next) { 1593 if (pmc->mca_flags & MAF_NOREPORT) 1594 continue; 1595 spin_lock_bh(&pmc->mca_lock); 1596 if (pmc->mca_sfcount[MCAST_EXCLUDE]) 1597 type = MLD2_MODE_IS_EXCLUDE; 1598 else 1599 type = MLD2_MODE_IS_INCLUDE; 1600 skb = add_grec(skb, pmc, type, 0, 0); 1601 spin_unlock_bh(&pmc->mca_lock); 1602 } 1603 read_unlock_bh(&idev->lock); 1604 } else { 1605 spin_lock_bh(&pmc->mca_lock); 1606 if (pmc->mca_sfcount[MCAST_EXCLUDE]) 1607 type = MLD2_MODE_IS_EXCLUDE; 1608 else 1609 type = MLD2_MODE_IS_INCLUDE; 1610 skb = add_grec(skb, pmc, type, 0, 0); 1611 spin_unlock_bh(&pmc->mca_lock); 1612 } 1613 if (skb) 1614 mld_sendpack(skb); 1615 } 1616 1617 /* 1618 * remove zero-count source records from a source filter list 1619 */ 1620 static void mld_clear_zeros(struct ip6_sf_list **ppsf) 1621 { 1622 struct ip6_sf_list *psf_prev, *psf_next, *psf; 1623 1624 psf_prev = NULL; 1625 for (psf=*ppsf; psf; psf = psf_next) { 1626 psf_next = psf->sf_next; 1627 if (psf->sf_crcount == 0) { 1628 if (psf_prev) 1629 psf_prev->sf_next = psf->sf_next; 1630 else 1631 *ppsf = psf->sf_next; 1632 kfree(psf); 1633 } else 1634 psf_prev = psf; 1635 } 1636 } 1637 1638 static void mld_send_cr(struct inet6_dev *idev) 1639 { 1640 struct ifmcaddr6 *pmc, *pmc_prev, *pmc_next; 1641 struct sk_buff *skb = NULL; 1642 int type, dtype; 1643 1644 read_lock_bh(&idev->lock); 1645 spin_lock(&idev->mc_lock); 1646 1647 /* deleted MCA's */ 1648 pmc_prev = NULL; 1649 for (pmc=idev->mc_tomb; pmc; pmc=pmc_next) { 1650 pmc_next = pmc->next; 1651 if (pmc->mca_sfmode == MCAST_INCLUDE) { 1652 type = MLD2_BLOCK_OLD_SOURCES; 1653 dtype = MLD2_BLOCK_OLD_SOURCES; 1654 skb = add_grec(skb, pmc, type, 1, 0); 1655 skb = add_grec(skb, pmc, dtype, 1, 1); 1656 } 1657 if (pmc->mca_crcount) { 1658 if (pmc->mca_sfmode == MCAST_EXCLUDE) { 1659 type = MLD2_CHANGE_TO_INCLUDE; 1660 skb = add_grec(skb, pmc, type, 1, 0); 1661 } 1662 pmc->mca_crcount--; 1663 if (pmc->mca_crcount == 0) { 1664 mld_clear_zeros(&pmc->mca_tomb); 1665 mld_clear_zeros(&pmc->mca_sources); 1666 } 1667 } 1668 if (pmc->mca_crcount == 0 && !pmc->mca_tomb && 1669 !pmc->mca_sources) { 1670 if (pmc_prev) 1671 pmc_prev->next = pmc_next; 1672 else 1673 idev->mc_tomb = pmc_next; 1674 in6_dev_put(pmc->idev); 1675 kfree(pmc); 1676 } else 1677 pmc_prev = pmc; 1678 } 1679 spin_unlock(&idev->mc_lock); 1680 1681 /* change recs */ 1682 for (pmc=idev->mc_list; pmc; pmc=pmc->next) { 1683 spin_lock_bh(&pmc->mca_lock); 1684 if (pmc->mca_sfcount[MCAST_EXCLUDE]) { 1685 type = MLD2_BLOCK_OLD_SOURCES; 1686 dtype = MLD2_ALLOW_NEW_SOURCES; 1687 } else { 1688 type = MLD2_ALLOW_NEW_SOURCES; 1689 dtype = MLD2_BLOCK_OLD_SOURCES; 1690 } 1691 skb = add_grec(skb, pmc, type, 0, 0); 1692 skb = add_grec(skb, pmc, dtype, 0, 1); /* deleted sources */ 1693 1694 /* filter mode changes */ 1695 if (pmc->mca_crcount) { 1696 if (pmc->mca_sfmode == MCAST_EXCLUDE) 1697 type = MLD2_CHANGE_TO_EXCLUDE; 1698 else 1699 type = MLD2_CHANGE_TO_INCLUDE; 1700 skb = add_grec(skb, pmc, type, 0, 0); 1701 pmc->mca_crcount--; 1702 } 1703 spin_unlock_bh(&pmc->mca_lock); 1704 } 1705 read_unlock_bh(&idev->lock); 1706 if (!skb) 1707 return; 1708 (void) mld_sendpack(skb); 1709 } 1710 1711 static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type) 1712 { 1713 struct net *net = dev_net(dev); 1714 struct sock *sk = net->ipv6.igmp_sk; 1715 struct inet6_dev *idev; 1716 struct sk_buff *skb; 1717 struct mld_msg *hdr; 1718 const struct in6_addr *snd_addr, *saddr; 1719 struct in6_addr addr_buf; 1720 int hlen = LL_RESERVED_SPACE(dev); 1721 int tlen = dev->needed_tailroom; 1722 int err, len, payload_len, full_len; 1723 u8 ra[8] = { IPPROTO_ICMPV6, 0, 1724 IPV6_TLV_ROUTERALERT, 2, 0, 0, 1725 IPV6_TLV_PADN, 0 }; 1726 struct flowi6 fl6; 1727 struct dst_entry *dst; 1728 1729 if (type == ICMPV6_MGM_REDUCTION) 1730 snd_addr = &in6addr_linklocal_allrouters; 1731 else 1732 snd_addr = addr; 1733 1734 len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr); 1735 payload_len = len + sizeof(ra); 1736 full_len = sizeof(struct ipv6hdr) + payload_len; 1737 1738 rcu_read_lock(); 1739 IP6_UPD_PO_STATS(net, __in6_dev_get(dev), 1740 IPSTATS_MIB_OUT, full_len); 1741 rcu_read_unlock(); 1742 1743 skb = sock_alloc_send_skb(sk, hlen + tlen + full_len, 1, &err); 1744 1745 if (skb == NULL) { 1746 rcu_read_lock(); 1747 IP6_INC_STATS(net, __in6_dev_get(dev), 1748 IPSTATS_MIB_OUTDISCARDS); 1749 rcu_read_unlock(); 1750 return; 1751 } 1752 1753 skb_reserve(skb, hlen); 1754 1755 if (ipv6_get_lladdr(dev, &addr_buf, IFA_F_TENTATIVE)) { 1756 /* <draft-ietf-magma-mld-source-05.txt>: 1757 * use unspecified address as the source address 1758 * when a valid link-local address is not available. 1759 */ 1760 saddr = &in6addr_any; 1761 } else 1762 saddr = &addr_buf; 1763 1764 ip6_nd_hdr(sk, skb, dev, saddr, snd_addr, NEXTHDR_HOP, payload_len); 1765 1766 memcpy(skb_put(skb, sizeof(ra)), ra, sizeof(ra)); 1767 1768 hdr = (struct mld_msg *) skb_put(skb, sizeof(struct mld_msg)); 1769 memset(hdr, 0, sizeof(struct mld_msg)); 1770 hdr->mld_type = type; 1771 hdr->mld_mca = *addr; 1772 1773 hdr->mld_cksum = csum_ipv6_magic(saddr, snd_addr, len, 1774 IPPROTO_ICMPV6, 1775 csum_partial(hdr, len, 0)); 1776 1777 rcu_read_lock(); 1778 idev = __in6_dev_get(skb->dev); 1779 1780 icmpv6_flow_init(sk, &fl6, type, 1781 &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr, 1782 skb->dev->ifindex); 1783 dst = icmp6_dst_alloc(skb->dev, NULL, &fl6); 1784 if (IS_ERR(dst)) { 1785 err = PTR_ERR(dst); 1786 goto err_out; 1787 } 1788 1789 skb_dst_set(skb, dst); 1790 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, skb->dev, 1791 dst_output); 1792 out: 1793 if (!err) { 1794 ICMP6MSGOUT_INC_STATS(net, idev, type); 1795 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 1796 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUTMCAST, full_len); 1797 } else 1798 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS); 1799 1800 rcu_read_unlock(); 1801 return; 1802 1803 err_out: 1804 kfree_skb(skb); 1805 goto out; 1806 } 1807 1808 static int ip6_mc_del1_src(struct ifmcaddr6 *pmc, int sfmode, 1809 const struct in6_addr *psfsrc) 1810 { 1811 struct ip6_sf_list *psf, *psf_prev; 1812 int rv = 0; 1813 1814 psf_prev = NULL; 1815 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) { 1816 if (ipv6_addr_equal(&psf->sf_addr, psfsrc)) 1817 break; 1818 psf_prev = psf; 1819 } 1820 if (!psf || psf->sf_count[sfmode] == 0) { 1821 /* source filter not found, or count wrong => bug */ 1822 return -ESRCH; 1823 } 1824 psf->sf_count[sfmode]--; 1825 if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) { 1826 struct inet6_dev *idev = pmc->idev; 1827 1828 /* no more filters for this source */ 1829 if (psf_prev) 1830 psf_prev->sf_next = psf->sf_next; 1831 else 1832 pmc->mca_sources = psf->sf_next; 1833 if (psf->sf_oldin && !(pmc->mca_flags & MAF_NOREPORT) && 1834 !MLD_V1_SEEN(idev)) { 1835 psf->sf_crcount = idev->mc_qrv; 1836 psf->sf_next = pmc->mca_tomb; 1837 pmc->mca_tomb = psf; 1838 rv = 1; 1839 } else 1840 kfree(psf); 1841 } 1842 return rv; 1843 } 1844 1845 static int ip6_mc_del_src(struct inet6_dev *idev, const struct in6_addr *pmca, 1846 int sfmode, int sfcount, const struct in6_addr *psfsrc, 1847 int delta) 1848 { 1849 struct ifmcaddr6 *pmc; 1850 int changerec = 0; 1851 int i, err; 1852 1853 if (!idev) 1854 return -ENODEV; 1855 read_lock_bh(&idev->lock); 1856 for (pmc=idev->mc_list; pmc; pmc=pmc->next) { 1857 if (ipv6_addr_equal(pmca, &pmc->mca_addr)) 1858 break; 1859 } 1860 if (!pmc) { 1861 /* MCA not found?? bug */ 1862 read_unlock_bh(&idev->lock); 1863 return -ESRCH; 1864 } 1865 spin_lock_bh(&pmc->mca_lock); 1866 sf_markstate(pmc); 1867 if (!delta) { 1868 if (!pmc->mca_sfcount[sfmode]) { 1869 spin_unlock_bh(&pmc->mca_lock); 1870 read_unlock_bh(&idev->lock); 1871 return -EINVAL; 1872 } 1873 pmc->mca_sfcount[sfmode]--; 1874 } 1875 err = 0; 1876 for (i=0; i<sfcount; i++) { 1877 int rv = ip6_mc_del1_src(pmc, sfmode, &psfsrc[i]); 1878 1879 changerec |= rv > 0; 1880 if (!err && rv < 0) 1881 err = rv; 1882 } 1883 if (pmc->mca_sfmode == MCAST_EXCLUDE && 1884 pmc->mca_sfcount[MCAST_EXCLUDE] == 0 && 1885 pmc->mca_sfcount[MCAST_INCLUDE]) { 1886 struct ip6_sf_list *psf; 1887 1888 /* filter mode change */ 1889 pmc->mca_sfmode = MCAST_INCLUDE; 1890 pmc->mca_crcount = idev->mc_qrv; 1891 idev->mc_ifc_count = pmc->mca_crcount; 1892 for (psf=pmc->mca_sources; psf; psf = psf->sf_next) 1893 psf->sf_crcount = 0; 1894 mld_ifc_event(pmc->idev); 1895 } else if (sf_setstate(pmc) || changerec) 1896 mld_ifc_event(pmc->idev); 1897 spin_unlock_bh(&pmc->mca_lock); 1898 read_unlock_bh(&idev->lock); 1899 return err; 1900 } 1901 1902 /* 1903 * Add multicast single-source filter to the interface list 1904 */ 1905 static int ip6_mc_add1_src(struct ifmcaddr6 *pmc, int sfmode, 1906 const struct in6_addr *psfsrc) 1907 { 1908 struct ip6_sf_list *psf, *psf_prev; 1909 1910 psf_prev = NULL; 1911 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) { 1912 if (ipv6_addr_equal(&psf->sf_addr, psfsrc)) 1913 break; 1914 psf_prev = psf; 1915 } 1916 if (!psf) { 1917 psf = kzalloc(sizeof(*psf), GFP_ATOMIC); 1918 if (!psf) 1919 return -ENOBUFS; 1920 1921 psf->sf_addr = *psfsrc; 1922 if (psf_prev) { 1923 psf_prev->sf_next = psf; 1924 } else 1925 pmc->mca_sources = psf; 1926 } 1927 psf->sf_count[sfmode]++; 1928 return 0; 1929 } 1930 1931 static void sf_markstate(struct ifmcaddr6 *pmc) 1932 { 1933 struct ip6_sf_list *psf; 1934 int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE]; 1935 1936 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) 1937 if (pmc->mca_sfcount[MCAST_EXCLUDE]) { 1938 psf->sf_oldin = mca_xcount == 1939 psf->sf_count[MCAST_EXCLUDE] && 1940 !psf->sf_count[MCAST_INCLUDE]; 1941 } else 1942 psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0; 1943 } 1944 1945 static int sf_setstate(struct ifmcaddr6 *pmc) 1946 { 1947 struct ip6_sf_list *psf, *dpsf; 1948 int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE]; 1949 int qrv = pmc->idev->mc_qrv; 1950 int new_in, rv; 1951 1952 rv = 0; 1953 for (psf=pmc->mca_sources; psf; psf=psf->sf_next) { 1954 if (pmc->mca_sfcount[MCAST_EXCLUDE]) { 1955 new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] && 1956 !psf->sf_count[MCAST_INCLUDE]; 1957 } else 1958 new_in = psf->sf_count[MCAST_INCLUDE] != 0; 1959 if (new_in) { 1960 if (!psf->sf_oldin) { 1961 struct ip6_sf_list *prev = NULL; 1962 1963 for (dpsf=pmc->mca_tomb; dpsf; 1964 dpsf=dpsf->sf_next) { 1965 if (ipv6_addr_equal(&dpsf->sf_addr, 1966 &psf->sf_addr)) 1967 break; 1968 prev = dpsf; 1969 } 1970 if (dpsf) { 1971 if (prev) 1972 prev->sf_next = dpsf->sf_next; 1973 else 1974 pmc->mca_tomb = dpsf->sf_next; 1975 kfree(dpsf); 1976 } 1977 psf->sf_crcount = qrv; 1978 rv++; 1979 } 1980 } else if (psf->sf_oldin) { 1981 psf->sf_crcount = 0; 1982 /* 1983 * add or update "delete" records if an active filter 1984 * is now inactive 1985 */ 1986 for (dpsf=pmc->mca_tomb; dpsf; dpsf=dpsf->sf_next) 1987 if (ipv6_addr_equal(&dpsf->sf_addr, 1988 &psf->sf_addr)) 1989 break; 1990 if (!dpsf) { 1991 dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC); 1992 if (!dpsf) 1993 continue; 1994 *dpsf = *psf; 1995 /* pmc->mca_lock held by callers */ 1996 dpsf->sf_next = pmc->mca_tomb; 1997 pmc->mca_tomb = dpsf; 1998 } 1999 dpsf->sf_crcount = qrv; 2000 rv++; 2001 } 2002 } 2003 return rv; 2004 } 2005 2006 /* 2007 * Add multicast source filter list to the interface list 2008 */ 2009 static int ip6_mc_add_src(struct inet6_dev *idev, const struct in6_addr *pmca, 2010 int sfmode, int sfcount, const struct in6_addr *psfsrc, 2011 int delta) 2012 { 2013 struct ifmcaddr6 *pmc; 2014 int isexclude; 2015 int i, err; 2016 2017 if (!idev) 2018 return -ENODEV; 2019 read_lock_bh(&idev->lock); 2020 for (pmc=idev->mc_list; pmc; pmc=pmc->next) { 2021 if (ipv6_addr_equal(pmca, &pmc->mca_addr)) 2022 break; 2023 } 2024 if (!pmc) { 2025 /* MCA not found?? bug */ 2026 read_unlock_bh(&idev->lock); 2027 return -ESRCH; 2028 } 2029 spin_lock_bh(&pmc->mca_lock); 2030 2031 sf_markstate(pmc); 2032 isexclude = pmc->mca_sfmode == MCAST_EXCLUDE; 2033 if (!delta) 2034 pmc->mca_sfcount[sfmode]++; 2035 err = 0; 2036 for (i=0; i<sfcount; i++) { 2037 err = ip6_mc_add1_src(pmc, sfmode, &psfsrc[i]); 2038 if (err) 2039 break; 2040 } 2041 if (err) { 2042 int j; 2043 2044 if (!delta) 2045 pmc->mca_sfcount[sfmode]--; 2046 for (j=0; j<i; j++) 2047 ip6_mc_del1_src(pmc, sfmode, &psfsrc[j]); 2048 } else if (isexclude != (pmc->mca_sfcount[MCAST_EXCLUDE] != 0)) { 2049 struct ip6_sf_list *psf; 2050 2051 /* filter mode change */ 2052 if (pmc->mca_sfcount[MCAST_EXCLUDE]) 2053 pmc->mca_sfmode = MCAST_EXCLUDE; 2054 else if (pmc->mca_sfcount[MCAST_INCLUDE]) 2055 pmc->mca_sfmode = MCAST_INCLUDE; 2056 /* else no filters; keep old mode for reports */ 2057 2058 pmc->mca_crcount = idev->mc_qrv; 2059 idev->mc_ifc_count = pmc->mca_crcount; 2060 for (psf=pmc->mca_sources; psf; psf = psf->sf_next) 2061 psf->sf_crcount = 0; 2062 mld_ifc_event(idev); 2063 } else if (sf_setstate(pmc)) 2064 mld_ifc_event(idev); 2065 spin_unlock_bh(&pmc->mca_lock); 2066 read_unlock_bh(&idev->lock); 2067 return err; 2068 } 2069 2070 static void ip6_mc_clear_src(struct ifmcaddr6 *pmc) 2071 { 2072 struct ip6_sf_list *psf, *nextpsf; 2073 2074 for (psf=pmc->mca_tomb; psf; psf=nextpsf) { 2075 nextpsf = psf->sf_next; 2076 kfree(psf); 2077 } 2078 pmc->mca_tomb = NULL; 2079 for (psf=pmc->mca_sources; psf; psf=nextpsf) { 2080 nextpsf = psf->sf_next; 2081 kfree(psf); 2082 } 2083 pmc->mca_sources = NULL; 2084 pmc->mca_sfmode = MCAST_EXCLUDE; 2085 pmc->mca_sfcount[MCAST_INCLUDE] = 0; 2086 pmc->mca_sfcount[MCAST_EXCLUDE] = 1; 2087 } 2088 2089 2090 static void igmp6_join_group(struct ifmcaddr6 *ma) 2091 { 2092 unsigned long delay; 2093 2094 if (ma->mca_flags & MAF_NOREPORT) 2095 return; 2096 2097 igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT); 2098 2099 delay = net_random() % IGMP6_UNSOLICITED_IVAL; 2100 2101 spin_lock_bh(&ma->mca_lock); 2102 if (del_timer(&ma->mca_timer)) { 2103 atomic_dec(&ma->mca_refcnt); 2104 delay = ma->mca_timer.expires - jiffies; 2105 } 2106 2107 if (!mod_timer(&ma->mca_timer, jiffies + delay)) 2108 atomic_inc(&ma->mca_refcnt); 2109 ma->mca_flags |= MAF_TIMER_RUNNING | MAF_LAST_REPORTER; 2110 spin_unlock_bh(&ma->mca_lock); 2111 } 2112 2113 static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml, 2114 struct inet6_dev *idev) 2115 { 2116 int err; 2117 2118 /* callers have the socket lock and a write lock on ipv6_sk_mc_lock, 2119 * so no other readers or writers of iml or its sflist 2120 */ 2121 if (!iml->sflist) { 2122 /* any-source empty exclude case */ 2123 return ip6_mc_del_src(idev, &iml->addr, iml->sfmode, 0, NULL, 0); 2124 } 2125 err = ip6_mc_del_src(idev, &iml->addr, iml->sfmode, 2126 iml->sflist->sl_count, iml->sflist->sl_addr, 0); 2127 sock_kfree_s(sk, iml->sflist, IP6_SFLSIZE(iml->sflist->sl_max)); 2128 iml->sflist = NULL; 2129 return err; 2130 } 2131 2132 static void igmp6_leave_group(struct ifmcaddr6 *ma) 2133 { 2134 if (MLD_V1_SEEN(ma->idev)) { 2135 if (ma->mca_flags & MAF_LAST_REPORTER) 2136 igmp6_send(&ma->mca_addr, ma->idev->dev, 2137 ICMPV6_MGM_REDUCTION); 2138 } else { 2139 mld_add_delrec(ma->idev, ma); 2140 mld_ifc_event(ma->idev); 2141 } 2142 } 2143 2144 static void mld_gq_timer_expire(unsigned long data) 2145 { 2146 struct inet6_dev *idev = (struct inet6_dev *)data; 2147 2148 idev->mc_gq_running = 0; 2149 mld_send_report(idev, NULL); 2150 __in6_dev_put(idev); 2151 } 2152 2153 static void mld_ifc_timer_expire(unsigned long data) 2154 { 2155 struct inet6_dev *idev = (struct inet6_dev *)data; 2156 2157 mld_send_cr(idev); 2158 if (idev->mc_ifc_count) { 2159 idev->mc_ifc_count--; 2160 if (idev->mc_ifc_count) 2161 mld_ifc_start_timer(idev, idev->mc_maxdelay); 2162 } 2163 __in6_dev_put(idev); 2164 } 2165 2166 static void mld_ifc_event(struct inet6_dev *idev) 2167 { 2168 if (MLD_V1_SEEN(idev)) 2169 return; 2170 idev->mc_ifc_count = idev->mc_qrv; 2171 mld_ifc_start_timer(idev, 1); 2172 } 2173 2174 2175 static void igmp6_timer_handler(unsigned long data) 2176 { 2177 struct ifmcaddr6 *ma = (struct ifmcaddr6 *) data; 2178 2179 if (MLD_V1_SEEN(ma->idev)) 2180 igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT); 2181 else 2182 mld_send_report(ma->idev, ma); 2183 2184 spin_lock(&ma->mca_lock); 2185 ma->mca_flags |= MAF_LAST_REPORTER; 2186 ma->mca_flags &= ~MAF_TIMER_RUNNING; 2187 spin_unlock(&ma->mca_lock); 2188 ma_put(ma); 2189 } 2190 2191 /* Device changing type */ 2192 2193 void ipv6_mc_unmap(struct inet6_dev *idev) 2194 { 2195 struct ifmcaddr6 *i; 2196 2197 /* Install multicast list, except for all-nodes (already installed) */ 2198 2199 read_lock_bh(&idev->lock); 2200 for (i = idev->mc_list; i; i = i->next) 2201 igmp6_group_dropped(i); 2202 read_unlock_bh(&idev->lock); 2203 } 2204 2205 void ipv6_mc_remap(struct inet6_dev *idev) 2206 { 2207 ipv6_mc_up(idev); 2208 } 2209 2210 /* Device going down */ 2211 2212 void ipv6_mc_down(struct inet6_dev *idev) 2213 { 2214 struct ifmcaddr6 *i; 2215 2216 /* Withdraw multicast list */ 2217 2218 read_lock_bh(&idev->lock); 2219 idev->mc_ifc_count = 0; 2220 if (del_timer(&idev->mc_ifc_timer)) 2221 __in6_dev_put(idev); 2222 idev->mc_gq_running = 0; 2223 if (del_timer(&idev->mc_gq_timer)) 2224 __in6_dev_put(idev); 2225 2226 for (i = idev->mc_list; i; i=i->next) 2227 igmp6_group_dropped(i); 2228 read_unlock_bh(&idev->lock); 2229 2230 mld_clear_delrec(idev); 2231 } 2232 2233 2234 /* Device going up */ 2235 2236 void ipv6_mc_up(struct inet6_dev *idev) 2237 { 2238 struct ifmcaddr6 *i; 2239 2240 /* Install multicast list, except for all-nodes (already installed) */ 2241 2242 read_lock_bh(&idev->lock); 2243 for (i = idev->mc_list; i; i=i->next) 2244 igmp6_group_added(i); 2245 read_unlock_bh(&idev->lock); 2246 } 2247 2248 /* IPv6 device initialization. */ 2249 2250 void ipv6_mc_init_dev(struct inet6_dev *idev) 2251 { 2252 write_lock_bh(&idev->lock); 2253 spin_lock_init(&idev->mc_lock); 2254 idev->mc_gq_running = 0; 2255 setup_timer(&idev->mc_gq_timer, mld_gq_timer_expire, 2256 (unsigned long)idev); 2257 idev->mc_tomb = NULL; 2258 idev->mc_ifc_count = 0; 2259 setup_timer(&idev->mc_ifc_timer, mld_ifc_timer_expire, 2260 (unsigned long)idev); 2261 idev->mc_qrv = MLD_QRV_DEFAULT; 2262 idev->mc_maxdelay = IGMP6_UNSOLICITED_IVAL; 2263 idev->mc_v1_seen = 0; 2264 write_unlock_bh(&idev->lock); 2265 } 2266 2267 /* 2268 * Device is about to be destroyed: clean up. 2269 */ 2270 2271 void ipv6_mc_destroy_dev(struct inet6_dev *idev) 2272 { 2273 struct ifmcaddr6 *i; 2274 2275 /* Deactivate timers */ 2276 ipv6_mc_down(idev); 2277 2278 /* Delete all-nodes address. */ 2279 /* We cannot call ipv6_dev_mc_dec() directly, our caller in 2280 * addrconf.c has NULL'd out dev->ip6_ptr so in6_dev_get() will 2281 * fail. 2282 */ 2283 __ipv6_dev_mc_dec(idev, &in6addr_linklocal_allnodes); 2284 2285 if (idev->cnf.forwarding) 2286 __ipv6_dev_mc_dec(idev, &in6addr_linklocal_allrouters); 2287 2288 write_lock_bh(&idev->lock); 2289 while ((i = idev->mc_list) != NULL) { 2290 idev->mc_list = i->next; 2291 write_unlock_bh(&idev->lock); 2292 2293 igmp6_group_dropped(i); 2294 ma_put(i); 2295 2296 write_lock_bh(&idev->lock); 2297 } 2298 write_unlock_bh(&idev->lock); 2299 } 2300 2301 #ifdef CONFIG_PROC_FS 2302 struct igmp6_mc_iter_state { 2303 struct seq_net_private p; 2304 struct net_device *dev; 2305 struct inet6_dev *idev; 2306 }; 2307 2308 #define igmp6_mc_seq_private(seq) ((struct igmp6_mc_iter_state *)(seq)->private) 2309 2310 static inline struct ifmcaddr6 *igmp6_mc_get_first(struct seq_file *seq) 2311 { 2312 struct ifmcaddr6 *im = NULL; 2313 struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq); 2314 struct net *net = seq_file_net(seq); 2315 2316 state->idev = NULL; 2317 for_each_netdev_rcu(net, state->dev) { 2318 struct inet6_dev *idev; 2319 idev = __in6_dev_get(state->dev); 2320 if (!idev) 2321 continue; 2322 read_lock_bh(&idev->lock); 2323 im = idev->mc_list; 2324 if (im) { 2325 state->idev = idev; 2326 break; 2327 } 2328 read_unlock_bh(&idev->lock); 2329 } 2330 return im; 2331 } 2332 2333 static struct ifmcaddr6 *igmp6_mc_get_next(struct seq_file *seq, struct ifmcaddr6 *im) 2334 { 2335 struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq); 2336 2337 im = im->next; 2338 while (!im) { 2339 if (likely(state->idev != NULL)) 2340 read_unlock_bh(&state->idev->lock); 2341 2342 state->dev = next_net_device_rcu(state->dev); 2343 if (!state->dev) { 2344 state->idev = NULL; 2345 break; 2346 } 2347 state->idev = __in6_dev_get(state->dev); 2348 if (!state->idev) 2349 continue; 2350 read_lock_bh(&state->idev->lock); 2351 im = state->idev->mc_list; 2352 } 2353 return im; 2354 } 2355 2356 static struct ifmcaddr6 *igmp6_mc_get_idx(struct seq_file *seq, loff_t pos) 2357 { 2358 struct ifmcaddr6 *im = igmp6_mc_get_first(seq); 2359 if (im) 2360 while (pos && (im = igmp6_mc_get_next(seq, im)) != NULL) 2361 --pos; 2362 return pos ? NULL : im; 2363 } 2364 2365 static void *igmp6_mc_seq_start(struct seq_file *seq, loff_t *pos) 2366 __acquires(RCU) 2367 { 2368 rcu_read_lock(); 2369 return igmp6_mc_get_idx(seq, *pos); 2370 } 2371 2372 static void *igmp6_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2373 { 2374 struct ifmcaddr6 *im = igmp6_mc_get_next(seq, v); 2375 2376 ++*pos; 2377 return im; 2378 } 2379 2380 static void igmp6_mc_seq_stop(struct seq_file *seq, void *v) 2381 __releases(RCU) 2382 { 2383 struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq); 2384 2385 if (likely(state->idev != NULL)) { 2386 read_unlock_bh(&state->idev->lock); 2387 state->idev = NULL; 2388 } 2389 state->dev = NULL; 2390 rcu_read_unlock(); 2391 } 2392 2393 static int igmp6_mc_seq_show(struct seq_file *seq, void *v) 2394 { 2395 struct ifmcaddr6 *im = (struct ifmcaddr6 *)v; 2396 struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq); 2397 2398 seq_printf(seq, 2399 "%-4d %-15s %pi6 %5d %08X %ld\n", 2400 state->dev->ifindex, state->dev->name, 2401 &im->mca_addr, 2402 im->mca_users, im->mca_flags, 2403 (im->mca_flags&MAF_TIMER_RUNNING) ? 2404 jiffies_to_clock_t(im->mca_timer.expires-jiffies) : 0); 2405 return 0; 2406 } 2407 2408 static const struct seq_operations igmp6_mc_seq_ops = { 2409 .start = igmp6_mc_seq_start, 2410 .next = igmp6_mc_seq_next, 2411 .stop = igmp6_mc_seq_stop, 2412 .show = igmp6_mc_seq_show, 2413 }; 2414 2415 static int igmp6_mc_seq_open(struct inode *inode, struct file *file) 2416 { 2417 return seq_open_net(inode, file, &igmp6_mc_seq_ops, 2418 sizeof(struct igmp6_mc_iter_state)); 2419 } 2420 2421 static const struct file_operations igmp6_mc_seq_fops = { 2422 .owner = THIS_MODULE, 2423 .open = igmp6_mc_seq_open, 2424 .read = seq_read, 2425 .llseek = seq_lseek, 2426 .release = seq_release_net, 2427 }; 2428 2429 struct igmp6_mcf_iter_state { 2430 struct seq_net_private p; 2431 struct net_device *dev; 2432 struct inet6_dev *idev; 2433 struct ifmcaddr6 *im; 2434 }; 2435 2436 #define igmp6_mcf_seq_private(seq) ((struct igmp6_mcf_iter_state *)(seq)->private) 2437 2438 static inline struct ip6_sf_list *igmp6_mcf_get_first(struct seq_file *seq) 2439 { 2440 struct ip6_sf_list *psf = NULL; 2441 struct ifmcaddr6 *im = NULL; 2442 struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq); 2443 struct net *net = seq_file_net(seq); 2444 2445 state->idev = NULL; 2446 state->im = NULL; 2447 for_each_netdev_rcu(net, state->dev) { 2448 struct inet6_dev *idev; 2449 idev = __in6_dev_get(state->dev); 2450 if (unlikely(idev == NULL)) 2451 continue; 2452 read_lock_bh(&idev->lock); 2453 im = idev->mc_list; 2454 if (likely(im != NULL)) { 2455 spin_lock_bh(&im->mca_lock); 2456 psf = im->mca_sources; 2457 if (likely(psf != NULL)) { 2458 state->im = im; 2459 state->idev = idev; 2460 break; 2461 } 2462 spin_unlock_bh(&im->mca_lock); 2463 } 2464 read_unlock_bh(&idev->lock); 2465 } 2466 return psf; 2467 } 2468 2469 static struct ip6_sf_list *igmp6_mcf_get_next(struct seq_file *seq, struct ip6_sf_list *psf) 2470 { 2471 struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq); 2472 2473 psf = psf->sf_next; 2474 while (!psf) { 2475 spin_unlock_bh(&state->im->mca_lock); 2476 state->im = state->im->next; 2477 while (!state->im) { 2478 if (likely(state->idev != NULL)) 2479 read_unlock_bh(&state->idev->lock); 2480 2481 state->dev = next_net_device_rcu(state->dev); 2482 if (!state->dev) { 2483 state->idev = NULL; 2484 goto out; 2485 } 2486 state->idev = __in6_dev_get(state->dev); 2487 if (!state->idev) 2488 continue; 2489 read_lock_bh(&state->idev->lock); 2490 state->im = state->idev->mc_list; 2491 } 2492 if (!state->im) 2493 break; 2494 spin_lock_bh(&state->im->mca_lock); 2495 psf = state->im->mca_sources; 2496 } 2497 out: 2498 return psf; 2499 } 2500 2501 static struct ip6_sf_list *igmp6_mcf_get_idx(struct seq_file *seq, loff_t pos) 2502 { 2503 struct ip6_sf_list *psf = igmp6_mcf_get_first(seq); 2504 if (psf) 2505 while (pos && (psf = igmp6_mcf_get_next(seq, psf)) != NULL) 2506 --pos; 2507 return pos ? NULL : psf; 2508 } 2509 2510 static void *igmp6_mcf_seq_start(struct seq_file *seq, loff_t *pos) 2511 __acquires(RCU) 2512 { 2513 rcu_read_lock(); 2514 return *pos ? igmp6_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 2515 } 2516 2517 static void *igmp6_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos) 2518 { 2519 struct ip6_sf_list *psf; 2520 if (v == SEQ_START_TOKEN) 2521 psf = igmp6_mcf_get_first(seq); 2522 else 2523 psf = igmp6_mcf_get_next(seq, v); 2524 ++*pos; 2525 return psf; 2526 } 2527 2528 static void igmp6_mcf_seq_stop(struct seq_file *seq, void *v) 2529 __releases(RCU) 2530 { 2531 struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq); 2532 if (likely(state->im != NULL)) { 2533 spin_unlock_bh(&state->im->mca_lock); 2534 state->im = NULL; 2535 } 2536 if (likely(state->idev != NULL)) { 2537 read_unlock_bh(&state->idev->lock); 2538 state->idev = NULL; 2539 } 2540 state->dev = NULL; 2541 rcu_read_unlock(); 2542 } 2543 2544 static int igmp6_mcf_seq_show(struct seq_file *seq, void *v) 2545 { 2546 struct ip6_sf_list *psf = (struct ip6_sf_list *)v; 2547 struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq); 2548 2549 if (v == SEQ_START_TOKEN) { 2550 seq_printf(seq, 2551 "%3s %6s " 2552 "%32s %32s %6s %6s\n", "Idx", 2553 "Device", "Multicast Address", 2554 "Source Address", "INC", "EXC"); 2555 } else { 2556 seq_printf(seq, 2557 "%3d %6.6s %pi6 %pi6 %6lu %6lu\n", 2558 state->dev->ifindex, state->dev->name, 2559 &state->im->mca_addr, 2560 &psf->sf_addr, 2561 psf->sf_count[MCAST_INCLUDE], 2562 psf->sf_count[MCAST_EXCLUDE]); 2563 } 2564 return 0; 2565 } 2566 2567 static const struct seq_operations igmp6_mcf_seq_ops = { 2568 .start = igmp6_mcf_seq_start, 2569 .next = igmp6_mcf_seq_next, 2570 .stop = igmp6_mcf_seq_stop, 2571 .show = igmp6_mcf_seq_show, 2572 }; 2573 2574 static int igmp6_mcf_seq_open(struct inode *inode, struct file *file) 2575 { 2576 return seq_open_net(inode, file, &igmp6_mcf_seq_ops, 2577 sizeof(struct igmp6_mcf_iter_state)); 2578 } 2579 2580 static const struct file_operations igmp6_mcf_seq_fops = { 2581 .owner = THIS_MODULE, 2582 .open = igmp6_mcf_seq_open, 2583 .read = seq_read, 2584 .llseek = seq_lseek, 2585 .release = seq_release_net, 2586 }; 2587 2588 static int __net_init igmp6_proc_init(struct net *net) 2589 { 2590 int err; 2591 2592 err = -ENOMEM; 2593 if (!proc_net_fops_create(net, "igmp6", S_IRUGO, &igmp6_mc_seq_fops)) 2594 goto out; 2595 if (!proc_net_fops_create(net, "mcfilter6", S_IRUGO, 2596 &igmp6_mcf_seq_fops)) 2597 goto out_proc_net_igmp6; 2598 2599 err = 0; 2600 out: 2601 return err; 2602 2603 out_proc_net_igmp6: 2604 proc_net_remove(net, "igmp6"); 2605 goto out; 2606 } 2607 2608 static void __net_exit igmp6_proc_exit(struct net *net) 2609 { 2610 proc_net_remove(net, "mcfilter6"); 2611 proc_net_remove(net, "igmp6"); 2612 } 2613 #else 2614 static inline int igmp6_proc_init(struct net *net) 2615 { 2616 return 0; 2617 } 2618 static inline void igmp6_proc_exit(struct net *net) 2619 { 2620 } 2621 #endif 2622 2623 static int __net_init igmp6_net_init(struct net *net) 2624 { 2625 int err; 2626 2627 err = inet_ctl_sock_create(&net->ipv6.igmp_sk, PF_INET6, 2628 SOCK_RAW, IPPROTO_ICMPV6, net); 2629 if (err < 0) { 2630 printk(KERN_ERR 2631 "Failed to initialize the IGMP6 control socket (err %d).\n", 2632 err); 2633 goto out; 2634 } 2635 2636 inet6_sk(net->ipv6.igmp_sk)->hop_limit = 1; 2637 2638 err = igmp6_proc_init(net); 2639 if (err) 2640 goto out_sock_create; 2641 out: 2642 return err; 2643 2644 out_sock_create: 2645 inet_ctl_sock_destroy(net->ipv6.igmp_sk); 2646 goto out; 2647 } 2648 2649 static void __net_exit igmp6_net_exit(struct net *net) 2650 { 2651 inet_ctl_sock_destroy(net->ipv6.igmp_sk); 2652 igmp6_proc_exit(net); 2653 } 2654 2655 static struct pernet_operations igmp6_net_ops = { 2656 .init = igmp6_net_init, 2657 .exit = igmp6_net_exit, 2658 }; 2659 2660 int __init igmp6_init(void) 2661 { 2662 return register_pernet_subsys(&igmp6_net_ops); 2663 } 2664 2665 void igmp6_cleanup(void) 2666 { 2667 unregister_pernet_subsys(&igmp6_net_ops); 2668 } 2669