Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/netinet6/mld6.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: mld6.c,v 1.47 2008/08/22 17:11:39 adrianp Exp $ */ 2 /* $KAME: mld6.c,v 1.25 2001/01/16 14:14:18 itojun Exp $ */ 3 4 /* 5 * Copyright (C) 1998 WIDE Project. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the project nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 1992, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * This code is derived from software contributed to Berkeley by 38 * Stephen Deering of Stanford University. 39 * 40 * Redistribution and use in source and binary forms, with or without 41 * modification, are permitted provided that the following conditions 42 * are met: 43 * 1. Redistributions of source code must retain the above copyright 44 * notice, this list of conditions and the following disclaimer. 45 * 2. Redistributions in binary form must reproduce the above copyright 46 * notice, this list of conditions and the following disclaimer in the 47 * documentation and/or other materials provided with the distribution. 48 * 3. Neither the name of the University nor the names of its contributors 49 * may be used to endorse or promote products derived from this software 50 * without specific prior written permission. 51 * 52 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 55 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 62 * SUCH DAMAGE. 63 * 64 * @(#)igmp.c 8.1 (Berkeley) 7/19/93 65 */ 66 67 /* 68 * Copyright (c) 1988 Stephen Deering. 69 * 70 * This code is derived from software contributed to Berkeley by 71 * Stephen Deering of Stanford University. 72 * 73 * Redistribution and use in source and binary forms, with or without 74 * modification, are permitted provided that the following conditions 75 * are met: 76 * 1. Redistributions of source code must retain the above copyright 77 * notice, this list of conditions and the following disclaimer. 78 * 2. Redistributions in binary form must reproduce the above copyright 79 * notice, this list of conditions and the following disclaimer in the 80 * documentation and/or other materials provided with the distribution. 81 * 3. All advertising materials mentioning features or use of this software 82 * must display the following acknowledgement: 83 * This product includes software developed by the University of 84 * California, Berkeley and its contributors. 85 * 4. Neither the name of the University nor the names of its contributors 86 * may be used to endorse or promote products derived from this software 87 * without specific prior written permission. 88 * 89 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 90 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 92 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 93 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 94 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 95 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 96 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 97 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 98 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 99 * SUCH DAMAGE. 100 * 101 * @(#)igmp.c 8.1 (Berkeley) 7/19/93 102 */ 103 104 #include <sys/cdefs.h> 105 __KERNEL_RCSID(0, "$NetBSD: mld6.c,v 1.47 2008/08/22 17:11:39 adrianp Exp $"); 106 107 #include "opt_inet.h" 108 109 #include <sys/param.h> 110 #include <sys/systm.h> 111 #include <sys/mbuf.h> 112 #include <sys/socket.h> 113 #include <sys/socketvar.h> 114 #include <sys/protosw.h> 115 #include <sys/syslog.h> 116 #include <sys/sysctl.h> 117 #include <sys/kernel.h> 118 #include <sys/callout.h> 119 120 #include <net/if.h> 121 122 #include <netinet/in.h> 123 #include <netinet/in_var.h> 124 #include <netinet6/in6_var.h> 125 #include <netinet/ip6.h> 126 #include <netinet6/ip6_var.h> 127 #include <netinet6/scope6_var.h> 128 #include <netinet/icmp6.h> 129 #include <netinet6/icmp6_private.h> 130 #include <netinet6/mld6_var.h> 131 132 #include <net/net_osdep.h> 133 134 135 /* 136 * This structure is used to keep track of in6_multi chains which belong to 137 * deleted interface addresses. 138 */ 139 static LIST_HEAD(, multi6_kludge) in6_mk; /* XXX BSS initialization */ 140 141 struct multi6_kludge { 142 LIST_ENTRY(multi6_kludge) mk_entry; 143 struct ifnet *mk_ifp; 144 struct in6_multihead mk_head; 145 }; 146 147 148 /* 149 * Protocol constants 150 */ 151 152 /* 153 * time between repetitions of a node's initial report of interest in a 154 * multicast address(in seconds) 155 */ 156 #define MLD_UNSOLICITED_REPORT_INTERVAL 10 157 158 static struct ip6_pktopts ip6_opts; 159 160 static void mld_start_listening(struct in6_multi *); 161 static void mld_stop_listening(struct in6_multi *); 162 163 static struct mld_hdr * mld_allocbuf(struct mbuf **, int, struct in6_multi *, 164 int); 165 static void mld_sendpkt(struct in6_multi *, int, const struct in6_addr *); 166 static void mld_starttimer(struct in6_multi *); 167 static void mld_stoptimer(struct in6_multi *); 168 static u_long mld_timerresid(struct in6_multi *); 169 170 void 171 mld_init(void) 172 { 173 static u_int8_t hbh_buf[8]; 174 struct ip6_hbh *hbh = (struct ip6_hbh *)hbh_buf; 175 u_int16_t rtalert_code = htons((u_int16_t)IP6OPT_RTALERT_MLD); 176 177 /* ip6h_nxt will be fill in later */ 178 hbh->ip6h_len = 0; /* (8 >> 3) - 1 */ 179 180 /* XXX: grotty hard coding... */ 181 hbh_buf[2] = IP6OPT_PADN; /* 2 byte padding */ 182 hbh_buf[3] = 0; 183 hbh_buf[4] = IP6OPT_RTALERT; 184 hbh_buf[5] = IP6OPT_RTALERT_LEN - 2; 185 bcopy((void *)&rtalert_code, &hbh_buf[6], sizeof(u_int16_t)); 186 187 ip6_opts.ip6po_hbh = hbh; 188 /* We will specify the hoplimit by a multicast option. */ 189 ip6_opts.ip6po_hlim = -1; 190 } 191 192 static void 193 mld_starttimer(struct in6_multi *in6m) 194 { 195 struct timeval now; 196 197 microtime(&now); 198 in6m->in6m_timer_expire.tv_sec = now.tv_sec + in6m->in6m_timer / hz; 199 in6m->in6m_timer_expire.tv_usec = now.tv_usec + 200 (in6m->in6m_timer % hz) * (1000000 / hz); 201 if (in6m->in6m_timer_expire.tv_usec > 1000000) { 202 in6m->in6m_timer_expire.tv_sec++; 203 in6m->in6m_timer_expire.tv_usec -= 1000000; 204 } 205 206 /* start or restart the timer */ 207 callout_schedule(&in6m->in6m_timer_ch, in6m->in6m_timer); 208 } 209 210 static void 211 mld_stoptimer(struct in6_multi *in6m) 212 { 213 if (in6m->in6m_timer == IN6M_TIMER_UNDEF) 214 return; 215 216 callout_stop(&in6m->in6m_timer_ch); 217 218 in6m->in6m_timer = IN6M_TIMER_UNDEF; 219 } 220 221 static void 222 mld_timeo(void *arg) 223 { 224 struct in6_multi *in6m = arg; 225 226 mutex_enter(softnet_lock); 227 KERNEL_LOCK(1, NULL); 228 229 in6m->in6m_timer = IN6M_TIMER_UNDEF; 230 231 switch (in6m->in6m_state) { 232 case MLD_REPORTPENDING: 233 mld_start_listening(in6m); 234 break; 235 default: 236 mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL); 237 break; 238 } 239 240 KERNEL_UNLOCK_ONE(NULL); 241 mutex_exit(softnet_lock); 242 } 243 244 static u_long 245 mld_timerresid(struct in6_multi *in6m) 246 { 247 struct timeval now, diff; 248 249 microtime(&now); 250 251 if (now.tv_sec > in6m->in6m_timer_expire.tv_sec || 252 (now.tv_sec == in6m->in6m_timer_expire.tv_sec && 253 now.tv_usec > in6m->in6m_timer_expire.tv_usec)) { 254 return (0); 255 } 256 diff = in6m->in6m_timer_expire; 257 diff.tv_sec -= now.tv_sec; 258 diff.tv_usec -= now.tv_usec; 259 if (diff.tv_usec < 0) { 260 diff.tv_sec--; 261 diff.tv_usec += 1000000; 262 } 263 264 /* return the remaining time in milliseconds */ 265 return diff.tv_sec * 1000 + diff.tv_usec / 1000; 266 } 267 268 static void 269 mld_start_listening(struct in6_multi *in6m) 270 { 271 struct in6_addr all_in6; 272 273 /* 274 * RFC2710 page 10: 275 * The node never sends a Report or Done for the link-scope all-nodes 276 * address. 277 * MLD messages are never sent for multicast addresses whose scope is 0 278 * (reserved) or 1 (node-local). 279 */ 280 all_in6 = in6addr_linklocal_allnodes; 281 if (in6_setscope(&all_in6, in6m->in6m_ifp, NULL)) { 282 /* XXX: this should not happen! */ 283 in6m->in6m_timer = 0; 284 in6m->in6m_state = MLD_OTHERLISTENER; 285 } 286 if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) || 287 IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) < IPV6_ADDR_SCOPE_LINKLOCAL) { 288 in6m->in6m_timer = IN6M_TIMER_UNDEF; 289 in6m->in6m_state = MLD_OTHERLISTENER; 290 } else { 291 mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL); 292 in6m->in6m_timer = arc4random() % 293 (MLD_UNSOLICITED_REPORT_INTERVAL * hz); 294 in6m->in6m_state = MLD_IREPORTEDLAST; 295 296 mld_starttimer(in6m); 297 } 298 } 299 300 static void 301 mld_stop_listening(struct in6_multi *in6m) 302 { 303 struct in6_addr allnode, allrouter; 304 305 allnode = in6addr_linklocal_allnodes; 306 if (in6_setscope(&allnode, in6m->in6m_ifp, NULL)) { 307 /* XXX: this should not happen! */ 308 return; 309 } 310 allrouter = in6addr_linklocal_allrouters; 311 if (in6_setscope(&allrouter, in6m->in6m_ifp, NULL)) { 312 /* XXX impossible */ 313 return; 314 } 315 316 if (in6m->in6m_state == MLD_IREPORTEDLAST && 317 (!IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &allnode)) && 318 IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) > 319 IPV6_ADDR_SCOPE_INTFACELOCAL) { 320 mld_sendpkt(in6m, MLD_LISTENER_DONE, &allrouter); 321 } 322 } 323 324 void 325 mld_input(struct mbuf *m, int off) 326 { 327 struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *); 328 struct mld_hdr *mldh; 329 struct ifnet *ifp = m->m_pkthdr.rcvif; 330 struct in6_multi *in6m = NULL; 331 struct in6_addr mld_addr, all_in6; 332 struct in6_ifaddr *ia; 333 u_long timer = 0; /* timer value in the MLD query header */ 334 335 IP6_EXTHDR_GET(mldh, struct mld_hdr *, m, off, sizeof(*mldh)); 336 if (mldh == NULL) { 337 ICMP6_STATINC(ICMP6_STAT_TOOSHORT); 338 return; 339 } 340 341 /* source address validation */ 342 ip6 = mtod(m, struct ip6_hdr *);/* in case mpullup */ 343 if (!IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_src)) { 344 /* 345 * RFC3590 allows the IPv6 unspecified address as the source 346 * address of MLD report and done messages. However, as this 347 * same document says, this special rule is for snooping 348 * switches and the RFC requires routers to discard MLD packets 349 * with the unspecified source address. The RFC only talks 350 * about hosts receiving an MLD query or report in Security 351 * Considerations, but this is probably the correct intention. 352 * RFC3590 does not talk about other cases than link-local and 353 * the unspecified source addresses, but we believe the same 354 * rule should be applied. 355 * As a result, we only allow link-local addresses as the 356 * source address; otherwise, simply discard the packet. 357 */ 358 #if 0 359 /* 360 * XXX: do not log in an input path to avoid log flooding, 361 * though RFC3590 says "SHOULD log" if the source of a query 362 * is the unspecified address. 363 */ 364 log(LOG_INFO, 365 "mld_input: src %s is not link-local (grp=%s)\n", 366 ip6_sprintf(&ip6->ip6_src), ip6_sprintf(&mldh->mld_addr)); 367 #endif 368 m_freem(m); 369 return; 370 } 371 372 /* 373 * make a copy for local work (in6_setscope() may modify the 1st arg) 374 */ 375 mld_addr = mldh->mld_addr; 376 if (in6_setscope(&mld_addr, ifp, NULL)) { 377 /* XXX: this should not happen! */ 378 m_free(m); 379 return; 380 } 381 382 /* 383 * In the MLD specification, there are 3 states and a flag. 384 * 385 * In Non-Listener state, we simply don't have a membership record. 386 * In Delaying Listener state, our timer is running (in6m->in6m_timer) 387 * In Idle Listener state, our timer is not running 388 * (in6m->in6m_timer==IN6M_TIMER_UNDEF) 389 * 390 * The flag is in6m->in6m_state, it is set to MLD_OTHERLISTENER if 391 * we have heard a report from another member, or MLD_IREPORTEDLAST 392 * if we sent the last report. 393 */ 394 switch (mldh->mld_type) { 395 case MLD_LISTENER_QUERY: 396 if (ifp->if_flags & IFF_LOOPBACK) 397 break; 398 399 if (!IN6_IS_ADDR_UNSPECIFIED(&mld_addr) && 400 !IN6_IS_ADDR_MULTICAST(&mld_addr)) 401 break; /* print error or log stat? */ 402 403 all_in6 = in6addr_linklocal_allnodes; 404 if (in6_setscope(&all_in6, ifp, NULL)) { 405 /* XXX: this should not happen! */ 406 break; 407 } 408 409 /* 410 * - Start the timers in all of our membership records 411 * that the query applies to for the interface on 412 * which the query arrived excl. those that belong 413 * to the "all-nodes" group (ff02::1). 414 * - Restart any timer that is already running but has 415 * a value longer than the requested timeout. 416 * - Use the value specified in the query message as 417 * the maximum timeout. 418 */ 419 timer = ntohs(mldh->mld_maxdelay); 420 421 IFP_TO_IA6(ifp, ia); 422 if (ia == NULL) 423 break; 424 425 LIST_FOREACH(in6m, &ia->ia6_multiaddrs, in6m_entry) { 426 if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) || 427 IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) < 428 IPV6_ADDR_SCOPE_LINKLOCAL) 429 continue; 430 431 if (in6m->in6m_state == MLD_REPORTPENDING) 432 continue; /* we are not yet ready */ 433 434 if (!IN6_IS_ADDR_UNSPECIFIED(&mld_addr) && 435 !IN6_ARE_ADDR_EQUAL(&mld_addr, &in6m->in6m_addr)) 436 continue; 437 438 if (timer == 0) { 439 /* send a report immediately */ 440 mld_stoptimer(in6m); 441 mld_sendpkt(in6m, MLD_LISTENER_REPORT, NULL); 442 in6m->in6m_state = MLD_IREPORTEDLAST; 443 } else if (in6m->in6m_timer == IN6M_TIMER_UNDEF || 444 mld_timerresid(in6m) > timer) { 445 in6m->in6m_timer = 446 1 + (arc4random() % timer) * hz / 1000; 447 mld_starttimer(in6m); 448 } 449 } 450 break; 451 452 case MLD_LISTENER_REPORT: 453 /* 454 * For fast leave to work, we have to know that we are the 455 * last person to send a report for this group. Reports 456 * can potentially get looped back if we are a multicast 457 * router, so discard reports sourced by me. 458 * Note that it is impossible to check IFF_LOOPBACK flag of 459 * ifp for this purpose, since ip6_mloopback pass the physical 460 * interface to looutput. 461 */ 462 if (m->m_flags & M_LOOP) /* XXX: grotty flag, but efficient */ 463 break; 464 465 if (!IN6_IS_ADDR_MULTICAST(&mldh->mld_addr)) 466 break; 467 468 /* 469 * If we belong to the group being reported, stop 470 * our timer for that group. 471 */ 472 IN6_LOOKUP_MULTI(mld_addr, ifp, in6m); 473 if (in6m) { 474 mld_stoptimer(in6m); /* transit to idle state */ 475 in6m->in6m_state = MLD_OTHERLISTENER; /* clear flag */ 476 } 477 break; 478 default: /* this is impossible */ 479 #if 0 480 /* 481 * this case should be impossible because of filtering in 482 * icmp6_input(). But we explicitly disabled this part 483 * just in case. 484 */ 485 log(LOG_ERR, "mld_input: illegal type(%d)", mldh->mld_type); 486 #endif 487 break; 488 } 489 490 m_freem(m); 491 } 492 493 static void 494 mld_sendpkt(struct in6_multi *in6m, int type, 495 const struct in6_addr *dst) 496 { 497 struct mbuf *mh; 498 struct mld_hdr *mldh; 499 struct ip6_hdr *ip6 = NULL; 500 struct ip6_moptions im6o; 501 struct in6_ifaddr *ia = NULL; 502 struct ifnet *ifp = in6m->in6m_ifp; 503 int ignflags; 504 505 /* 506 * At first, find a link local address on the outgoing interface 507 * to use as the source address of the MLD packet. 508 * We do not reject tentative addresses for MLD report to deal with 509 * the case where we first join a link-local address. 510 */ 511 ignflags = (IN6_IFF_NOTREADY|IN6_IFF_ANYCAST) & ~IN6_IFF_TENTATIVE; 512 if ((ia = in6ifa_ifpforlinklocal(ifp, ignflags)) == NULL) 513 return; 514 if ((ia->ia6_flags & IN6_IFF_TENTATIVE)) 515 ia = NULL; 516 517 /* Allocate two mbufs to store IPv6 header and MLD header */ 518 mldh = mld_allocbuf(&mh, sizeof(struct mld_hdr), in6m, type); 519 if (mldh == NULL) 520 return; 521 522 /* fill src/dst here */ 523 ip6 = mtod(mh, struct ip6_hdr *); 524 ip6->ip6_src = ia ? ia->ia_addr.sin6_addr : in6addr_any; 525 ip6->ip6_dst = dst ? *dst : in6m->in6m_addr; 526 527 mldh->mld_addr = in6m->in6m_addr; 528 in6_clearscope(&mldh->mld_addr); /* XXX */ 529 mldh->mld_cksum = in6_cksum(mh, IPPROTO_ICMPV6, sizeof(struct ip6_hdr), 530 sizeof(struct mld_hdr)); 531 532 /* construct multicast option */ 533 memset(&im6o, 0, sizeof(im6o)); 534 im6o.im6o_multicast_ifp = ifp; 535 im6o.im6o_multicast_hlim = 1; 536 537 /* 538 * Request loopback of the report if we are acting as a multicast 539 * router, so that the process-level routing daemon can hear it. 540 */ 541 im6o.im6o_multicast_loop = (ip6_mrouter != NULL); 542 543 /* increment output statictics */ 544 ICMP6_STATINC(ICMP6_STAT_OUTHIST + type); 545 icmp6_ifstat_inc(ifp, ifs6_out_msg); 546 switch (type) { 547 case MLD_LISTENER_QUERY: 548 icmp6_ifstat_inc(ifp, ifs6_out_mldquery); 549 break; 550 case MLD_LISTENER_REPORT: 551 icmp6_ifstat_inc(ifp, ifs6_out_mldreport); 552 break; 553 case MLD_LISTENER_DONE: 554 icmp6_ifstat_inc(ifp, ifs6_out_mlddone); 555 break; 556 } 557 558 ip6_output(mh, &ip6_opts, NULL, ia ? 0 : IPV6_UNSPECSRC, 559 &im6o, (struct socket *)NULL, NULL); 560 } 561 562 static struct mld_hdr * 563 mld_allocbuf(struct mbuf **mh, int len, struct in6_multi *in6m, 564 int type) 565 { 566 struct mbuf *md; 567 struct mld_hdr *mldh; 568 struct ip6_hdr *ip6; 569 570 /* 571 * Allocate mbufs to store ip6 header and MLD header. 572 * We allocate 2 mbufs and make chain in advance because 573 * it is more convenient when inserting the hop-by-hop option later. 574 */ 575 MGETHDR(*mh, M_DONTWAIT, MT_HEADER); 576 if (*mh == NULL) 577 return NULL; 578 MGET(md, M_DONTWAIT, MT_DATA); 579 if (md == NULL) { 580 m_free(*mh); 581 *mh = NULL; 582 return NULL; 583 } 584 (*mh)->m_next = md; 585 md->m_next = NULL; 586 587 (*mh)->m_pkthdr.rcvif = NULL; 588 (*mh)->m_pkthdr.len = sizeof(struct ip6_hdr) + len; 589 (*mh)->m_len = sizeof(struct ip6_hdr); 590 MH_ALIGN(*mh, sizeof(struct ip6_hdr)); 591 592 /* fill in the ip6 header */ 593 ip6 = mtod(*mh, struct ip6_hdr *); 594 memset(ip6, 0, sizeof(*ip6)); 595 ip6->ip6_flow = 0; 596 ip6->ip6_vfc &= ~IPV6_VERSION_MASK; 597 ip6->ip6_vfc |= IPV6_VERSION; 598 /* ip6_plen will be set later */ 599 ip6->ip6_nxt = IPPROTO_ICMPV6; 600 /* ip6_hlim will be set by im6o.im6o_multicast_hlim */ 601 /* ip6_src/dst will be set by mld_sendpkt() or mld_sendbuf() */ 602 603 /* fill in the MLD header as much as possible */ 604 md->m_len = len; 605 mldh = mtod(md, struct mld_hdr *); 606 memset(mldh, 0, len); 607 mldh->mld_type = type; 608 return mldh; 609 } 610 611 /* 612 * Add an address to the list of IP6 multicast addresses for a given interface. 613 */ 614 struct in6_multi * 615 in6_addmulti(struct in6_addr *maddr6, struct ifnet *ifp, 616 int *errorp, int timer) 617 { 618 struct in6_ifaddr *ia; 619 struct in6_ifreq ifr; 620 struct in6_multi *in6m; 621 int s = splsoftnet(); 622 623 *errorp = 0; 624 625 /* 626 * See if address already in list. 627 */ 628 IN6_LOOKUP_MULTI(*maddr6, ifp, in6m); 629 if (in6m != NULL) { 630 /* 631 * Found it; just increment the refrence count. 632 */ 633 in6m->in6m_refcount++; 634 } else { 635 /* 636 * New address; allocate a new multicast record 637 * and link it into the interface's multicast list. 638 */ 639 in6m = (struct in6_multi *) 640 malloc(sizeof(*in6m), M_IPMADDR, M_NOWAIT); 641 if (in6m == NULL) { 642 splx(s); 643 *errorp = ENOBUFS; 644 return (NULL); 645 } 646 647 memset(in6m, 0, sizeof(*in6m)); 648 in6m->in6m_addr = *maddr6; 649 in6m->in6m_ifp = ifp; 650 in6m->in6m_refcount = 1; 651 in6m->in6m_timer = IN6M_TIMER_UNDEF; 652 IFP_TO_IA6(ifp, ia); 653 if (ia == NULL) { 654 free(in6m, M_IPMADDR); 655 splx(s); 656 *errorp = EADDRNOTAVAIL; /* appropriate? */ 657 return (NULL); 658 } 659 in6m->in6m_ia = ia; 660 IFAREF(&ia->ia_ifa); /* gain a reference */ 661 LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry); 662 663 /* 664 * Ask the network driver to update its multicast reception 665 * filter appropriately for the new address. 666 */ 667 sockaddr_in6_init(&ifr.ifr_addr, maddr6, 0, 0, 0); 668 if (ifp->if_ioctl == NULL) 669 *errorp = ENXIO; /* XXX: appropriate? */ 670 else 671 *errorp = (*ifp->if_ioctl)(ifp, SIOCADDMULTI, &ifr); 672 if (*errorp) { 673 LIST_REMOVE(in6m, in6m_entry); 674 free(in6m, M_IPMADDR); 675 IFAFREE(&ia->ia_ifa); 676 splx(s); 677 return (NULL); 678 } 679 680 callout_init(&in6m->in6m_timer_ch, CALLOUT_MPSAFE); 681 callout_setfunc(&in6m->in6m_timer_ch, mld_timeo, in6m); 682 in6m->in6m_timer = timer; 683 if (in6m->in6m_timer > 0) { 684 in6m->in6m_state = MLD_REPORTPENDING; 685 mld_starttimer(in6m); 686 687 splx(s); 688 return (in6m); 689 } 690 691 /* 692 * Let MLD6 know that we have joined a new IP6 multicast 693 * group. 694 */ 695 mld_start_listening(in6m); 696 } 697 splx(s); 698 return (in6m); 699 } 700 701 /* 702 * Delete a multicast address record. 703 */ 704 void 705 in6_delmulti(struct in6_multi *in6m) 706 { 707 struct in6_ifreq ifr; 708 struct in6_ifaddr *ia; 709 int s = splsoftnet(); 710 711 mld_stoptimer(in6m); 712 713 if (--in6m->in6m_refcount == 0) { 714 /* 715 * No remaining claims to this record; let MLD6 know 716 * that we are leaving the multicast group. 717 */ 718 mld_stop_listening(in6m); 719 720 /* 721 * Unlink from list. 722 */ 723 LIST_REMOVE(in6m, in6m_entry); 724 if (in6m->in6m_ia != NULL) { 725 IFAFREE(&in6m->in6m_ia->ia_ifa); /* release reference */ 726 in6m->in6m_ia = NULL; 727 } 728 729 /* 730 * Delete all references of this multicasting group from 731 * the membership arrays 732 */ 733 for (ia = in6_ifaddr; ia; ia = ia->ia_next) { 734 struct in6_multi_mship *imm; 735 LIST_FOREACH(imm, &ia->ia6_memberships, i6mm_chain) { 736 if (imm->i6mm_maddr == in6m) 737 imm->i6mm_maddr = NULL; 738 } 739 } 740 741 /* 742 * Notify the network driver to update its multicast 743 * reception filter. 744 */ 745 sockaddr_in6_init(&ifr.ifr_addr, &in6m->in6m_addr, 0, 0, 0); 746 (*in6m->in6m_ifp->if_ioctl)(in6m->in6m_ifp, SIOCDELMULTI, &ifr); 747 callout_destroy(&in6m->in6m_timer_ch); 748 free(in6m, M_IPMADDR); 749 } 750 splx(s); 751 } 752 753 754 struct in6_multi_mship * 755 in6_joingroup(struct ifnet *ifp, struct in6_addr *addr, 756 int *errorp, int timer) 757 { 758 struct in6_multi_mship *imm; 759 760 imm = malloc(sizeof(*imm), M_IPMADDR, M_NOWAIT); 761 if (!imm) { 762 *errorp = ENOBUFS; 763 return NULL; 764 } 765 766 memset(imm, 0, sizeof(*imm)); 767 imm->i6mm_maddr = in6_addmulti(addr, ifp, errorp, timer); 768 if (!imm->i6mm_maddr) { 769 /* *errorp is already set */ 770 free(imm, M_IPMADDR); 771 return NULL; 772 } 773 return imm; 774 } 775 776 int 777 in6_leavegroup(struct in6_multi_mship *imm) 778 { 779 780 if (imm->i6mm_maddr) { 781 in6_delmulti(imm->i6mm_maddr); 782 } 783 free(imm, M_IPMADDR); 784 return 0; 785 } 786 787 788 /* 789 * Multicast address kludge: 790 * If there were any multicast addresses attached to this interface address, 791 * either move them to another address on this interface, or save them until 792 * such time as this interface is reconfigured for IPv6. 793 */ 794 void 795 in6_savemkludge(struct in6_ifaddr *oia) 796 { 797 struct in6_ifaddr *ia; 798 struct in6_multi *in6m; 799 800 IFP_TO_IA6(oia->ia_ifp, ia); 801 if (ia) { /* there is another address */ 802 KASSERT(ia != oia); 803 while ((in6m = LIST_FIRST(&oia->ia6_multiaddrs)) != NULL) { 804 LIST_REMOVE(in6m, in6m_entry); 805 IFAREF(&ia->ia_ifa); 806 IFAFREE(&in6m->in6m_ia->ia_ifa); 807 in6m->in6m_ia = ia; 808 LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry); 809 } 810 } else { /* last address on this if deleted, save */ 811 struct multi6_kludge *mk; 812 813 LIST_FOREACH(mk, &in6_mk, mk_entry) { 814 if (mk->mk_ifp == oia->ia_ifp) 815 break; 816 } 817 if (mk == NULL) /* this should not happen! */ 818 panic("in6_savemkludge: no kludge space"); 819 820 while ((in6m = LIST_FIRST(&oia->ia6_multiaddrs)) != NULL) { 821 LIST_REMOVE(in6m, in6m_entry); 822 IFAFREE(&in6m->in6m_ia->ia_ifa); /* release reference */ 823 in6m->in6m_ia = NULL; 824 LIST_INSERT_HEAD(&mk->mk_head, in6m, in6m_entry); 825 } 826 } 827 } 828 829 /* 830 * Continuation of multicast address hack: 831 * If there was a multicast group list previously saved for this interface, 832 * then we re-attach it to the first address configured on the i/f. 833 */ 834 void 835 in6_restoremkludge(struct in6_ifaddr *ia, struct ifnet *ifp) 836 { 837 struct multi6_kludge *mk; 838 struct in6_multi *in6m; 839 840 LIST_FOREACH(mk, &in6_mk, mk_entry) { 841 if (mk->mk_ifp == ifp) 842 break; 843 } 844 if (mk == NULL) 845 return; 846 while ((in6m = LIST_FIRST(&mk->mk_head)) != NULL) { 847 LIST_REMOVE(in6m, in6m_entry); 848 in6m->in6m_ia = ia; 849 IFAREF(&ia->ia_ifa); 850 LIST_INSERT_HEAD(&ia->ia6_multiaddrs, in6m, in6m_entry); 851 } 852 } 853 854 /* 855 * Allocate space for the kludge at interface initialization time. 856 * Formerly, we dynamically allocated the space in in6_savemkludge() with 857 * malloc(M_WAITOK). However, it was wrong since the function could be called 858 * under an interrupt context (software timer on address lifetime expiration). 859 * Also, we cannot just give up allocating the strucutre, since the group 860 * membership structure is very complex and we need to keep it anyway. 861 * Of course, this function MUST NOT be called under an interrupt context. 862 * Specifically, it is expected to be called only from in6_ifattach(), though 863 * it is a global function. 864 */ 865 void 866 in6_createmkludge(struct ifnet *ifp) 867 { 868 struct multi6_kludge *mk; 869 870 LIST_FOREACH(mk, &in6_mk, mk_entry) { 871 /* If we've already had one, do not allocate. */ 872 if (mk->mk_ifp == ifp) 873 return; 874 } 875 876 mk = malloc(sizeof(*mk), M_IPMADDR, M_WAITOK); 877 878 memset(mk, 0, sizeof(*mk)); 879 LIST_INIT(&mk->mk_head); 880 mk->mk_ifp = ifp; 881 LIST_INSERT_HEAD(&in6_mk, mk, mk_entry); 882 } 883 884 void 885 in6_purgemkludge(struct ifnet *ifp) 886 { 887 struct multi6_kludge *mk; 888 struct in6_multi *in6m, *next; 889 890 LIST_FOREACH(mk, &in6_mk, mk_entry) { 891 if (mk->mk_ifp == ifp) 892 break; 893 } 894 if (mk == NULL) 895 return; 896 897 /* leave from all multicast groups joined */ 898 for (in6m = LIST_FIRST(&mk->mk_head); in6m != NULL; in6m = next) { 899 next = LIST_NEXT(in6m, in6m_entry); 900 in6_delmulti(in6m); 901 } 902 LIST_REMOVE(mk, mk_entry); 903 free(mk, M_IPMADDR); 904 }
Cache object: aa164ec4d9549d929a6fa1a2934e3e32
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]