FreeBSD/Linux Kernel Cross Reference
sys/netinet6/mld6.c
1 /* $FreeBSD: releng/6.1/sys/netinet6/mld6.c 158179 2006-04-30 16:44:43Z cvs2svn $ */
2 /* $KAME: mld6.c,v 1.27 2001/04/04 05:17:30 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) 1988 Stephen Deering.
35 * Copyright (c) 1992, 1993
36 * The Regents of the University of California. All rights reserved.
37 *
38 * This code is derived from software contributed to Berkeley by
39 * Stephen Deering of Stanford University.
40 *
41 * Redistribution and use in source and binary forms, with or without
42 * modification, are permitted provided that the following conditions
43 * are met:
44 * 1. Redistributions of source code must retain the above copyright
45 * notice, this list of conditions and the following disclaimer.
46 * 2. Redistributions in binary form must reproduce the above copyright
47 * notice, this list of conditions and the following disclaimer in the
48 * documentation and/or other materials provided with the distribution.
49 * 4. Neither the name of the University nor the names of its contributors
50 * may be used to endorse or promote products derived from this software
51 * without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
63 * SUCH DAMAGE.
64 *
65 * @(#)igmp.c 8.1 (Berkeley) 7/19/93
66 */
67
68 #include "opt_inet.h"
69 #include "opt_inet6.h"
70
71 #include <sys/param.h>
72 #include <sys/systm.h>
73 #include <sys/mbuf.h>
74 #include <sys/socket.h>
75 #include <sys/protosw.h>
76 #include <sys/syslog.h>
77 #include <sys/kernel.h>
78 #include <sys/callout.h>
79 #include <sys/malloc.h>
80
81 #include <net/if.h>
82
83 #include <netinet/in.h>
84 #include <netinet/in_var.h>
85 #include <netinet6/in6_var.h>
86 #include <netinet/ip6.h>
87 #include <netinet6/ip6_var.h>
88 #include <netinet6/scope6_var.h>
89 #include <netinet/icmp6.h>
90 #include <netinet6/mld6_var.h>
91
92 #include <net/net_osdep.h>
93
94 /*
95 * Protocol constants
96 */
97
98 /* denotes that the MLD max response delay field specifies time in milliseconds */
99 #define MLD_TIMER_SCALE 1000
100 /*
101 * time between repetitions of a node's initial report of interest in a
102 * multicast address(in seconds)
103 */
104 #define MLD_UNSOLICITED_REPORT_INTERVAL 10
105
106 static struct ip6_pktopts ip6_opts;
107
108 static void mld6_sendpkt(struct in6_multi *, int, const struct in6_addr *);
109 static void mld_starttimer(struct in6_multi *);
110 static void mld_stoptimer(struct in6_multi *);
111 static void mld_timeo(struct in6_multi *);
112 static u_long mld_timerresid(struct in6_multi *);
113
114 void
115 mld6_init()
116 {
117 static u_int8_t hbh_buf[8];
118 struct ip6_hbh *hbh = (struct ip6_hbh *)hbh_buf;
119 u_int16_t rtalert_code = htons((u_int16_t)IP6OPT_RTALERT_MLD);
120
121 /* ip6h_nxt will be fill in later */
122 hbh->ip6h_len = 0; /* (8 >> 3) - 1 */
123
124 /* XXX: grotty hard coding... */
125 hbh_buf[2] = IP6OPT_PADN; /* 2 byte padding */
126 hbh_buf[3] = 0;
127 hbh_buf[4] = IP6OPT_ROUTER_ALERT;
128 hbh_buf[5] = IP6OPT_RTALERT_LEN - 2;
129 bcopy((caddr_t)&rtalert_code, &hbh_buf[6], sizeof(u_int16_t));
130
131 ip6_initpktopts(&ip6_opts);
132 ip6_opts.ip6po_hbh = hbh;
133 }
134
135 static void
136 mld_starttimer(in6m)
137 struct in6_multi *in6m;
138 {
139 struct timeval now;
140
141 microtime(&now);
142 in6m->in6m_timer_expire.tv_sec = now.tv_sec + in6m->in6m_timer / hz;
143 in6m->in6m_timer_expire.tv_usec = now.tv_usec +
144 (in6m->in6m_timer % hz) * (1000000 / hz);
145 if (in6m->in6m_timer_expire.tv_usec > 1000000) {
146 in6m->in6m_timer_expire.tv_sec++;
147 in6m->in6m_timer_expire.tv_usec -= 1000000;
148 }
149
150 /* start or restart the timer */
151 callout_reset(in6m->in6m_timer_ch, in6m->in6m_timer,
152 (void (*) __P((void *)))mld_timeo, in6m);
153 }
154
155 static void
156 mld_stoptimer(in6m)
157 struct in6_multi *in6m;
158 {
159 if (in6m->in6m_timer == IN6M_TIMER_UNDEF)
160 return;
161
162 callout_stop(in6m->in6m_timer_ch);
163 in6m->in6m_timer = IN6M_TIMER_UNDEF;
164 }
165
166 static void
167 mld_timeo(in6m)
168 struct in6_multi *in6m;
169 {
170 int s = splnet();
171
172 in6m->in6m_timer = IN6M_TIMER_UNDEF;
173
174 callout_stop(in6m->in6m_timer_ch);
175
176 switch (in6m->in6m_state) {
177 case MLD_REPORTPENDING:
178 mld6_start_listening(in6m);
179 break;
180 default:
181 mld6_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);
182 break;
183 }
184
185 splx(s);
186 }
187
188 static u_long
189 mld_timerresid(in6m)
190 struct in6_multi *in6m;
191 {
192 struct timeval now, diff;
193
194 microtime(&now);
195
196 if (now.tv_sec > in6m->in6m_timer_expire.tv_sec ||
197 (now.tv_sec == in6m->in6m_timer_expire.tv_sec &&
198 now.tv_usec > in6m->in6m_timer_expire.tv_usec)) {
199 return (0);
200 }
201 diff = in6m->in6m_timer_expire;
202 diff.tv_sec -= now.tv_sec;
203 diff.tv_usec -= now.tv_usec;
204 if (diff.tv_usec < 0) {
205 diff.tv_sec--;
206 diff.tv_usec += 1000000;
207 }
208
209 /* return the remaining time in milliseconds */
210 return (((u_long)(diff.tv_sec * 1000000 + diff.tv_usec)) / 1000);
211 }
212
213 void
214 mld6_start_listening(in6m)
215 struct in6_multi *in6m;
216 {
217 struct in6_addr all_in6;
218 int s = splnet();
219
220 /*
221 * RFC2710 page 10:
222 * The node never sends a Report or Done for the link-scope all-nodes
223 * address.
224 * MLD messages are never sent for multicast addresses whose scope is 0
225 * (reserved) or 1 (node-local).
226 */
227 all_in6 = in6addr_linklocal_allnodes;
228 if (in6_setscope(&all_in6, in6m->in6m_ifp, NULL)) {
229 /* XXX: this should not happen! */
230 in6m->in6m_timer = 0;
231 in6m->in6m_state = MLD_OTHERLISTENER;
232 }
233 if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) ||
234 IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <
235 IPV6_ADDR_SCOPE_LINKLOCAL) {
236 in6m->in6m_timer = 0;
237 in6m->in6m_state = MLD_OTHERLISTENER;
238 } else {
239 mld6_sendpkt(in6m, MLD_LISTENER_REPORT, NULL);
240 in6m->in6m_timer = arc4random() %
241 MLD_UNSOLICITED_REPORT_INTERVAL * hz;
242 in6m->in6m_state = MLD_IREPORTEDLAST;
243
244 mld_starttimer(in6m);
245 }
246 splx(s);
247 }
248
249 void
250 mld6_stop_listening(in6m)
251 struct in6_multi *in6m;
252 {
253 struct in6_addr allnode, allrouter;
254
255 allnode = in6addr_linklocal_allnodes;
256 if (in6_setscope(&allnode, in6m->in6m_ifp, NULL)) {
257 /* XXX: this should not happen! */
258 return;
259 }
260 allrouter = in6addr_linklocal_allrouters;
261 if (in6_setscope(&allrouter, in6m->in6m_ifp, NULL)) {
262 /* XXX impossible */
263 return;
264 }
265 if (in6m->in6m_state == MLD_IREPORTEDLAST &&
266 !IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &allnode) &&
267 IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) >
268 IPV6_ADDR_SCOPE_INTFACELOCAL) {
269 mld6_sendpkt(in6m, MLD_LISTENER_DONE, &allrouter);
270 }
271 }
272
273 void
274 mld6_input(m, off)
275 struct mbuf *m;
276 int off;
277 {
278 struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
279 struct mld_hdr *mldh;
280 struct ifnet *ifp = m->m_pkthdr.rcvif;
281 struct in6_multi *in6m;
282 struct in6_addr mld_addr, all_in6;
283 struct in6_ifaddr *ia;
284 struct ifmultiaddr *ifma;
285 int timer; /* timer value in the MLD query header */
286
287 #ifndef PULLDOWN_TEST
288 IP6_EXTHDR_CHECK(m, off, sizeof(*mldh),);
289 mldh = (struct mld_hdr *)(mtod(m, caddr_t) + off);
290 #else
291 IP6_EXTHDR_GET(mldh, struct mld_hdr *, m, off, sizeof(*mldh));
292 if (mldh == NULL) {
293 icmp6stat.icp6s_tooshort++;
294 return;
295 }
296 #endif
297
298 /* source address validation */
299 ip6 = mtod(m, struct ip6_hdr *); /* in case mpullup */
300 if (!IN6_IS_ADDR_LINKLOCAL(&ip6->ip6_src)) {
301 log(LOG_ERR,
302 "mld6_input: src %s is not link-local (grp=%s)\n",
303 ip6_sprintf(&ip6->ip6_src),
304 ip6_sprintf(&mldh->mld_addr));
305 /*
306 * spec (RFC2710) does not explicitly
307 * specify to discard the packet from a non link-local
308 * source address. But we believe it's expected to do so.
309 * XXX: do we have to allow :: as source?
310 */
311 m_freem(m);
312 return;
313 }
314
315 /*
316 * make a copy for local work (in6_setscope() may modify the 1st arg)
317 */
318 mld_addr = mldh->mld_addr;
319 if (in6_setscope(&mld_addr, ifp, NULL)) {
320 /* XXX: this should not happen! */
321 m_free(m);
322 return;
323 }
324
325 /*
326 * In the MLD6 specification, there are 3 states and a flag.
327 *
328 * In Non-Listener state, we simply don't have a membership record.
329 * In Delaying Listener state, our timer is running (in6m->in6m_timer)
330 * In Idle Listener state, our timer is not running
331 * (in6m->in6m_timer==IN6M_TIMER_UNDEF)
332 *
333 * The flag is in6m->in6m_state, it is set to MLD_OTHERLISTENER if
334 * we have heard a report from another member, or MLD_IREPORTEDLAST
335 * if we sent the last report.
336 */
337 switch(mldh->mld_type) {
338 case MLD_LISTENER_QUERY:
339 if (ifp->if_flags & IFF_LOOPBACK)
340 break;
341
342 if (!IN6_IS_ADDR_UNSPECIFIED(&mld_addr) &&
343 !IN6_IS_ADDR_MULTICAST(&mld_addr))
344 break; /* print error or log stat? */
345
346 all_in6 = in6addr_linklocal_allnodes;
347 if (in6_setscope(&all_in6, ifp, NULL)) {
348 /* XXX: this should not happen! */
349 break;
350 }
351
352 /*
353 * - Start the timers in all of our membership records
354 * that the query applies to for the interface on
355 * which the query arrived excl. those that belong
356 * to the "all-nodes" group (ff02::1).
357 * - Restart any timer that is already running but has
358 * A value longer than the requested timeout.
359 * - Use the value specified in the query message as
360 * the maximum timeout.
361 */
362 timer = ntohs(mldh->mld_maxdelay);
363
364 IFP_TO_IA6(ifp, ia);
365 if (ia == NULL)
366 break;
367
368 /*
369 * XXX: System timer resolution is too low to handle Max
370 * Response Delay, so set 1 to the internal timer even if
371 * the calculated value equals to zero when Max Response
372 * Delay is positive.
373 */
374 timer = ntohs(mldh->mld_maxdelay) * PR_FASTHZ / MLD_TIMER_SCALE;
375 if (timer == 0 && mldh->mld_maxdelay)
376 timer = 1;
377
378 IF_ADDR_LOCK(ifp);
379 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
380 if (ifma->ifma_addr->sa_family != AF_INET6)
381 continue;
382 in6m = (struct in6_multi *)ifma->ifma_protospec;
383
384 if (IN6_ARE_ADDR_EQUAL(&in6m->in6m_addr, &all_in6) ||
385 IPV6_ADDR_MC_SCOPE(&in6m->in6m_addr) <
386 IPV6_ADDR_SCOPE_LINKLOCAL)
387 continue;
388
389 if (IN6_IS_ADDR_UNSPECIFIED(&mld_addr) ||
390 IN6_ARE_ADDR_EQUAL(&mld_addr, &in6m->in6m_addr)) {
391 if (timer == 0) {
392 /* send a report immediately */
393 mld_stoptimer(in6m);
394 mld6_sendpkt(in6m, MLD_LISTENER_REPORT,
395 NULL);
396 in6m->in6m_timer = 0; /* reset timer */
397 in6m->in6m_state = MLD_IREPORTEDLAST;
398 }
399 else if (in6m->in6m_timer == IN6M_TIMER_UNDEF ||
400 mld_timerresid(in6m) > (u_long)timer) {
401 in6m->in6m_timer = arc4random() %
402 (int)((long)(timer * hz) / 1000);
403 mld_starttimer(in6m);
404 }
405 }
406 }
407 IF_ADDR_UNLOCK(ifp);
408 break;
409
410 case MLD_LISTENER_REPORT:
411 /*
412 * For fast leave to work, we have to know that we are the
413 * last person to send a report for this group. Reports
414 * can potentially get looped back if we are a multicast
415 * router, so discard reports sourced by me.
416 * Note that it is impossible to check IFF_LOOPBACK flag of
417 * ifp for this purpose, since ip6_mloopback pass the physical
418 * interface to looutput.
419 */
420 if (m->m_flags & M_LOOP) /* XXX: grotty flag, but efficient */
421 break;
422
423 if (!IN6_IS_ADDR_MULTICAST(&mld_addr))
424 break;
425
426 /*
427 * If we belong to the group being reported, stop
428 * our timer for that group.
429 */
430 IN6_LOOKUP_MULTI(mld_addr, ifp, in6m);
431 if (in6m) {
432 in6m->in6m_timer = 0; /* transit to idle state */
433 in6m->in6m_state = MLD_OTHERLISTENER; /* clear flag */
434 }
435 break;
436 default: /* this is impossible */
437 log(LOG_ERR, "mld6_input: illegal type(%d)", mldh->mld_type);
438 break;
439 }
440
441 m_freem(m);
442 }
443
444 static void
445 mld6_sendpkt(in6m, type, dst)
446 struct in6_multi *in6m;
447 int type;
448 const struct in6_addr *dst;
449 {
450 struct mbuf *mh, *md;
451 struct mld_hdr *mldh;
452 struct ip6_hdr *ip6;
453 struct ip6_moptions im6o;
454 struct in6_ifaddr *ia;
455 struct ifnet *ifp = in6m->in6m_ifp;
456 struct ifnet *outif = NULL;
457
458 /*
459 * At first, find a link local address on the outgoing interface
460 * to use as the source address of the MLD packet.
461 */
462 if ((ia = in6ifa_ifpforlinklocal(ifp, IN6_IFF_NOTREADY|IN6_IFF_ANYCAST))
463 == NULL)
464 return;
465
466 /*
467 * Allocate mbufs to store ip6 header and MLD header.
468 * We allocate 2 mbufs and make chain in advance because
469 * it is more convenient when inserting the hop-by-hop option later.
470 */
471 MGETHDR(mh, M_DONTWAIT, MT_HEADER);
472 if (mh == NULL)
473 return;
474 MGET(md, M_DONTWAIT, MT_DATA);
475 if (md == NULL) {
476 m_free(mh);
477 return;
478 }
479 mh->m_next = md;
480
481 mh->m_pkthdr.rcvif = NULL;
482 mh->m_pkthdr.len = sizeof(struct ip6_hdr) + sizeof(struct mld_hdr);
483 mh->m_len = sizeof(struct ip6_hdr);
484 MH_ALIGN(mh, sizeof(struct ip6_hdr));
485
486 /* fill in the ip6 header */
487 ip6 = mtod(mh, struct ip6_hdr *);
488 ip6->ip6_flow = 0;
489 ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
490 ip6->ip6_vfc |= IPV6_VERSION;
491 /* ip6_plen will be set later */
492 ip6->ip6_nxt = IPPROTO_ICMPV6;
493 /* ip6_hlim will be set by im6o.im6o_multicast_hlim */
494 ip6->ip6_src = ia->ia_addr.sin6_addr;
495 ip6->ip6_dst = dst ? *dst : in6m->in6m_addr;
496
497 /* fill in the MLD header */
498 md->m_len = sizeof(struct mld_hdr);
499 mldh = mtod(md, struct mld_hdr *);
500 mldh->mld_type = type;
501 mldh->mld_code = 0;
502 mldh->mld_cksum = 0;
503 /* XXX: we assume the function will not be called for query messages */
504 mldh->mld_maxdelay = 0;
505 mldh->mld_reserved = 0;
506 mldh->mld_addr = in6m->in6m_addr;
507 in6_clearscope(&mldh->mld_addr); /* XXX */
508 mldh->mld_cksum = in6_cksum(mh, IPPROTO_ICMPV6, sizeof(struct ip6_hdr),
509 sizeof(struct mld_hdr));
510
511 /* construct multicast option */
512 bzero(&im6o, sizeof(im6o));
513 im6o.im6o_multicast_ifp = ifp;
514 im6o.im6o_multicast_hlim = 1;
515
516 /*
517 * Request loopback of the report if we are acting as a multicast
518 * router, so that the process-level routing daemon can hear it.
519 */
520 im6o.im6o_multicast_loop = (ip6_mrouter != NULL);
521
522 /* increment output statictics */
523 icmp6stat.icp6s_outhist[type]++;
524
525 ip6_output(mh, &ip6_opts, NULL, 0, &im6o, &outif, NULL);
526 if (outif) {
527 icmp6_ifstat_inc(outif, ifs6_out_msg);
528 switch (type) {
529 case MLD_LISTENER_QUERY:
530 icmp6_ifstat_inc(outif, ifs6_out_mldquery);
531 break;
532 case MLD_LISTENER_REPORT:
533 icmp6_ifstat_inc(outif, ifs6_out_mldreport);
534 break;
535 case MLD_LISTENER_DONE:
536 icmp6_ifstat_inc(outif, ifs6_out_mlddone);
537 break;
538 }
539 }
540 }
541
542 /*
543 * Add an address to the list of IP6 multicast addresses for a given interface.
544 * Add source addresses to the list also, if upstream router is MLDv2 capable
545 * and the number of source is not 0.
546 */
547 struct in6_multi *
548 in6_addmulti(maddr6, ifp, errorp, delay)
549 struct in6_addr *maddr6;
550 struct ifnet *ifp;
551 int *errorp, delay;
552 {
553 struct in6_multi *in6m;
554 struct ifmultiaddr *ifma;
555 struct sockaddr_in6 sa6;
556 int s = splnet();
557
558 *errorp = 0;
559
560 /*
561 * Call generic routine to add membership or increment
562 * refcount. It wants addresses in the form of a sockaddr,
563 * so we build one here (being careful to zero the unused bytes).
564 */
565 bzero(&sa6, sizeof(sa6));
566 sa6.sin6_family = AF_INET6;
567 sa6.sin6_len = sizeof(struct sockaddr_in6);
568 sa6.sin6_addr = *maddr6;
569 *errorp = if_addmulti(ifp, (struct sockaddr *)&sa6, &ifma);
570 if (*errorp) {
571 splx(s);
572 return 0;
573 }
574
575 /*
576 * If ifma->ifma_protospec is null, then if_addmulti() created
577 * a new record. Otherwise, we are done.
578 */
579 if (ifma->ifma_protospec != NULL) {
580 splx(s);
581 return ifma->ifma_protospec;
582 }
583
584 /* XXX - if_addmulti uses M_WAITOK. Can this really be called
585 at interrupt time? If so, need to fix if_addmulti. XXX */
586 in6m = (struct in6_multi *)malloc(sizeof(*in6m), M_IP6MADDR, M_NOWAIT);
587 if (in6m == NULL) {
588 splx(s);
589 return (NULL);
590 }
591
592 bzero(in6m, sizeof *in6m);
593 in6m->in6m_addr = *maddr6;
594 in6m->in6m_ifp = ifp;
595 in6m->in6m_refcount = 1;
596 in6m->in6m_ifma = ifma;
597 ifma->ifma_protospec = in6m;
598 in6m->in6m_timer_ch = malloc(sizeof(*in6m->in6m_timer_ch), M_IP6MADDR,
599 M_NOWAIT);
600 if (in6m->in6m_timer_ch == NULL) {
601 free(in6m, M_IP6MADDR);
602 splx(s);
603 return (NULL);
604 }
605 LIST_INSERT_HEAD(&in6_multihead, in6m, in6m_entry);
606
607 callout_init(in6m->in6m_timer_ch, 0);
608 in6m->in6m_timer = delay;
609 if (in6m->in6m_timer > 0) {
610 in6m->in6m_state = MLD_REPORTPENDING;
611 mld_starttimer(in6m);
612
613 splx(s);
614 return (in6m);
615 }
616
617 /*
618 * Let MLD6 know that we have joined a new IPv6 multicast
619 * group.
620 */
621 mld6_start_listening(in6m);
622 splx(s);
623 return (in6m);
624 }
625
626 /*
627 * Delete a multicast address record.
628 */
629 void
630 in6_delmulti(in6m)
631 struct in6_multi *in6m;
632 {
633 struct ifmultiaddr *ifma = in6m->in6m_ifma;
634 int s = splnet();
635
636 if (ifma->ifma_refcount == 1) {
637 /*
638 * No remaining claims to this record; let MLD6 know
639 * that we are leaving the multicast group.
640 */
641 mld_stoptimer(in6m);
642 mld6_stop_listening(in6m);
643 ifma->ifma_protospec = NULL;
644 LIST_REMOVE(in6m, in6m_entry);
645 free(in6m->in6m_timer_ch, M_IP6MADDR);
646 free(in6m, M_IP6MADDR);
647 }
648 /* XXX - should be separate API for when we have an ifma? */
649 if_delmulti(ifma->ifma_ifp, ifma->ifma_addr);
650 splx(s);
651 }
Cache object: e8cf5c29694d0daa6ab9dfd38e406b47
|