sys/netinet6/mld6.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2009 Bruce Simpson.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote
  15  *    products derived from this software without specific prior written
  16  *    permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  *      $KAME: mld6.c,v 1.27 2001/04/04 05:17:30 itojun Exp $
  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  * 3. 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 <sys/cdefs.h>
  69 __FBSDID("$FreeBSD$");
  70
  71 #include "opt_inet.h"
  72 #include "opt_inet6.h"
  73
  74 #include <sys/param.h>
  75 #include <sys/systm.h>
  76 #include <sys/mbuf.h>
  77 #include <sys/socket.h>
  78 #include <sys/protosw.h>
  79 #include <sys/sysctl.h>
  80 #include <sys/kernel.h>
  81 #include <sys/callout.h>
  82 #include <sys/malloc.h>
  83 #include <sys/module.h>
  84 #include <sys/ktr.h>
  85
  86 #include <net/if.h>
  87 #include <net/if_var.h>
  88 #include <net/route.h>
  89 #include <net/vnet.h>
  90
  91 #include <netinet/in.h>
  92 #include <netinet/in_var.h>
  93 #include <netinet6/in6_var.h>
  94 #include <netinet/ip6.h>
  95 #include <netinet6/ip6_var.h>
  96 #include <netinet6/scope6_var.h>
  97 #include <netinet/icmp6.h>
  98 #include <netinet6/mld6.h>
  99 #include <netinet6/mld6_var.h>
 100
 101 #include <security/mac/mac_framework.h>
 102
 103 #ifndef KTR_MLD
 104 #define KTR_MLD KTR_INET6
 105 #endif
 106
 107 static void     mli_delete_locked(const struct ifnet *);
 108 static void     mld_dispatch_packet(struct mbuf *);
 109 static void     mld_dispatch_queue(struct mbufq *, int);
 110 static void     mld_final_leave(struct in6_multi *, struct mld_ifsoftc *);
 111 static void     mld_fasttimo_vnet(struct in6_multi_head *inmh);
 112 static int      mld_handle_state_change(struct in6_multi *,
 113                     struct mld_ifsoftc *);
 114 static int      mld_initial_join(struct in6_multi *, struct mld_ifsoftc *,
 115                     const int);
 116 #ifdef KTR
 117 static char *   mld_rec_type_to_str(const int);
 118 #endif
 119 static void     mld_set_version(struct mld_ifsoftc *, const int);
 120 static void     mld_slowtimo_vnet(void);
 121 static int      mld_v1_input_query(struct ifnet *, const struct ip6_hdr *,
 122                     /*const*/ struct mld_hdr *);
 123 static int      mld_v1_input_report(struct ifnet *, const struct ip6_hdr *,
 124                     /*const*/ struct mld_hdr *);
 125 static void     mld_v1_process_group_timer(struct in6_multi_head *,
 126                     struct in6_multi *);
 127 static void     mld_v1_process_querier_timers(struct mld_ifsoftc *);
 128 static int      mld_v1_transmit_report(struct in6_multi *, const int);
 129 static void     mld_v1_update_group(struct in6_multi *, const int);
 130 static void     mld_v2_cancel_link_timers(struct mld_ifsoftc *);
 131 static void     mld_v2_dispatch_general_query(struct mld_ifsoftc *);
 132 static struct mbuf *
 133                 mld_v2_encap_report(struct ifnet *, struct mbuf *);
 134 static int      mld_v2_enqueue_filter_change(struct mbufq *,
 135                     struct in6_multi *);
 136 static int      mld_v2_enqueue_group_record(struct mbufq *,
 137                     struct in6_multi *, const int, const int, const int,
 138                     const int);
 139 static int      mld_v2_input_query(struct ifnet *, const struct ip6_hdr *,
 140                     struct mbuf *, struct mldv2_query *, const int, const int);
 141 static int      mld_v2_merge_state_changes(struct in6_multi *,
 142                     struct mbufq *);
 143 static void     mld_v2_process_group_timers(struct in6_multi_head *,
 144                     struct mbufq *, struct mbufq *,
 145                     struct in6_multi *, const int);
 146 static int      mld_v2_process_group_query(struct in6_multi *,
 147                     struct mld_ifsoftc *mli, int, struct mbuf *,
 148                     struct mldv2_query *, const int);
 149 static int      sysctl_mld_gsr(SYSCTL_HANDLER_ARGS);
 150 static int      sysctl_mld_ifinfo(SYSCTL_HANDLER_ARGS);
 151
 152 /*
 153  * Normative references: RFC 2710, RFC 3590, RFC 3810.
 154  *
 155  * Locking:
 156  *  * The MLD subsystem lock ends up being system-wide for the moment,
 157  *    but could be per-VIMAGE later on.
 158  *  * The permitted lock order is: IN6_MULTI_LOCK, MLD_LOCK, IF_ADDR_LOCK.
 159  *    Any may be taken independently; if any are held at the same
 160  *    time, the above lock order must be followed.
 161  *  * IN6_MULTI_LOCK covers in_multi.
 162  *  * MLD_LOCK covers per-link state and any global variables in this file.
 163  *  * IF_ADDR_LOCK covers if_multiaddrs, which is used for a variety of
 164  *    per-link state iterators.
 165  *
 166  *  XXX LOR PREVENTION
 167  *  A special case for IPv6 is the in6_setscope() routine. ip6_output()
 168  *  will not accept an ifp; it wants an embedded scope ID, unlike
 169  *  ip_output(), which happily takes the ifp given to it. The embedded
 170  *  scope ID is only used by MLD to select the outgoing interface.
 171  *
 172  *  During interface attach and detach, MLD will take MLD_LOCK *after*
 173  *  the IF_AFDATA_LOCK.
 174  *  As in6_setscope() takes IF_AFDATA_LOCK then SCOPE_LOCK, we can't call
 175  *  it with MLD_LOCK held without triggering an LOR. A netisr with indirect
 176  *  dispatch could work around this, but we'd rather not do that, as it
 177  *  can introduce other races.
 178  *
 179  *  As such, we exploit the fact that the scope ID is just the interface
 180  *  index, and embed it in the IPv6 destination address accordingly.
 181  *  This is potentially NOT VALID for MLDv1 reports, as they
 182  *  are always sent to the multicast group itself; as MLDv2
 183  *  reports are always sent to ff02::16, this is not an issue
 184  *  when MLDv2 is in use.
 185  *
 186  *  This does not however eliminate the LOR when ip6_output() itself
 187  *  calls in6_setscope() internally whilst MLD_LOCK is held. This will
 188  *  trigger a LOR warning in WITNESS when the ifnet is detached.
 189  *
 190  *  The right answer is probably to make IF_AFDATA_LOCK an rwlock, given
 191  *  how it's used across the network stack. Here we're simply exploiting
 192  *  the fact that MLD runs at a similar layer in the stack to scope6.c.
 193  *
 194  * VIMAGE:
 195  *  * Each in6_multi corresponds to an ifp, and each ifp corresponds
 196  *    to a vnet in ifp->if_vnet.
 197  */
 198 static struct mtx                mld_mtx;
 199 static MALLOC_DEFINE(M_MLD, "mld", "mld state");
 200
 201 #define MLD_EMBEDSCOPE(pin6, zoneid)                                    \
 202         if (IN6_IS_SCOPE_LINKLOCAL(pin6) ||                             \
 203             IN6_IS_ADDR_MC_INTFACELOCAL(pin6))                          \
 204                 (pin6)->s6_addr16[1] = htons((zoneid) & 0xFFFF)         \
 205
 206 /*
 207  * VIMAGE-wide globals.
 208  */
 209 VNET_DEFINE_STATIC(struct timeval, mld_gsrdelay) = {10, 0};
 210 VNET_DEFINE_STATIC(LIST_HEAD(, mld_ifsoftc), mli_head);
 211 VNET_DEFINE_STATIC(int, interface_timers_running6);
 212 VNET_DEFINE_STATIC(int, state_change_timers_running6);
 213 VNET_DEFINE_STATIC(int, current_state_timers_running6);
 214
 215 #define V_mld_gsrdelay                  VNET(mld_gsrdelay)
 216 #define V_mli_head                      VNET(mli_head)
 217 #define V_interface_timers_running6     VNET(interface_timers_running6)
 218 #define V_state_change_timers_running6  VNET(state_change_timers_running6)
 219 #define V_current_state_timers_running6 VNET(current_state_timers_running6)
 220
 221 SYSCTL_DECL(_net_inet6);        /* Note: Not in any common header. */
 222
 223 SYSCTL_NODE(_net_inet6, OID_AUTO, mld, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
 224     "IPv6 Multicast Listener Discovery");
 225
 226 /*
 227  * Virtualized sysctls.
 228  */
 229 SYSCTL_PROC(_net_inet6_mld, OID_AUTO, gsrdelay,
 230     CTLFLAG_VNET | CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
 231     &VNET_NAME(mld_gsrdelay.tv_sec), 0, sysctl_mld_gsr, "I",
 232     "Rate limit for MLDv2 Group-and-Source queries in seconds");
 233
 234 /*
 235  * Non-virtualized sysctls.
 236  */
 237 static SYSCTL_NODE(_net_inet6_mld, OID_AUTO, ifinfo,
 238     CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_mld_ifinfo,
 239     "Per-interface MLDv2 state");
 240
 241 static int      mld_v1enable = 1;
 242 SYSCTL_INT(_net_inet6_mld, OID_AUTO, v1enable, CTLFLAG_RWTUN,
 243     &mld_v1enable, 0, "Enable fallback to MLDv1");
 244
 245 static int      mld_v2enable = 1;
 246 SYSCTL_INT(_net_inet6_mld, OID_AUTO, v2enable, CTLFLAG_RWTUN,
 247     &mld_v2enable, 0, "Enable MLDv2");
 248
 249 static int      mld_use_allow = 1;
 250 SYSCTL_INT(_net_inet6_mld, OID_AUTO, use_allow, CTLFLAG_RWTUN,
 251     &mld_use_allow, 0, "Use ALLOW/BLOCK for RFC 4604 SSM joins/leaves");
 252
 253 /*
 254  * Packed Router Alert option structure declaration.
 255  */
 256 struct mld_raopt {
 257         struct ip6_hbh          hbh;
 258         struct ip6_opt          pad;
 259         struct ip6_opt_router   ra;
 260 } __packed;
 261
 262 /*
 263  * Router Alert hop-by-hop option header.
 264  */
 265 static struct mld_raopt mld_ra = {
 266         .hbh = { 0, 0 },
 267         .pad = { .ip6o_type = IP6OPT_PADN, 0 },
 268         .ra = {
 269             .ip6or_type = IP6OPT_ROUTER_ALERT,
 270             .ip6or_len = IP6OPT_RTALERT_LEN - 2,
 271             .ip6or_value[0] = ((IP6OPT_RTALERT_MLD >> 8) & 0xFF),
 272             .ip6or_value[1] = (IP6OPT_RTALERT_MLD & 0xFF)
 273         }
 274 };
 275 static struct ip6_pktopts mld_po;
 276
 277 static __inline void
 278 mld_save_context(struct mbuf *m, struct ifnet *ifp)
 279 {
 280
 281 #ifdef VIMAGE
 282         m->m_pkthdr.PH_loc.ptr = ifp->if_vnet;
 283 #endif /* VIMAGE */
 284         m->m_pkthdr.rcvif = ifp;
 285         m->m_pkthdr.flowid = ifp->if_index;
 286 }
 287
 288 static __inline void
 289 mld_scrub_context(struct mbuf *m)
 290 {
 291
 292         m->m_pkthdr.PH_loc.ptr = NULL;
 293         m->m_pkthdr.flowid = 0;
 294 }
 295
 296 /*
 297  * Restore context from a queued output chain.
 298  * Return saved ifindex.
 299  *
 300  * VIMAGE: The assertion is there to make sure that we
 301  * actually called CURVNET_SET() with what's in the mbuf chain.
 302  */
 303 static __inline uint32_t
 304 mld_restore_context(struct mbuf *m)
 305 {
 306
 307 #if defined(VIMAGE) && defined(INVARIANTS)
 308         KASSERT(curvnet == m->m_pkthdr.PH_loc.ptr,
 309             ("%s: called when curvnet was not restored: cuvnet %p m ptr %p",
 310             __func__, curvnet, m->m_pkthdr.PH_loc.ptr));
 311 #endif
 312         return (m->m_pkthdr.flowid);
 313 }
 314
 315 /*
 316  * Retrieve or set threshold between group-source queries in seconds.
 317  *
 318  * VIMAGE: Assume curvnet set by caller.
 319  * SMPng: NOTE: Serialized by MLD lock.
 320  */
 321 static int
 322 sysctl_mld_gsr(SYSCTL_HANDLER_ARGS)
 323 {
 324         int error;
 325         int i;
 326
 327         error = sysctl_wire_old_buffer(req, sizeof(int));
 328         if (error)
 329                 return (error);
 330
 331         MLD_LOCK();
 332
 333         i = V_mld_gsrdelay.tv_sec;
 334
 335         error = sysctl_handle_int(oidp, &i, 0, req);
 336         if (error || !req->newptr)
 337                 goto out_locked;
 338
 339         if (i < -1 || i >= 60) {
 340                 error = EINVAL;
 341                 goto out_locked;
 342         }
 343
 344         CTR2(KTR_MLD, "change mld_gsrdelay from %d to %d",
 345              V_mld_gsrdelay.tv_sec, i);
 346         V_mld_gsrdelay.tv_sec = i;
 347
 348 out_locked:
 349         MLD_UNLOCK();
 350         return (error);
 351 }
 352
 353 /*
 354  * Expose struct mld_ifsoftc to userland, keyed by ifindex.
 355  * For use by ifmcstat(8).
 356  *
 357  * SMPng: NOTE: Does an unlocked ifindex space read.
 358  * VIMAGE: Assume curvnet set by caller. The node handler itself
 359  * is not directly virtualized.
 360  */
 361 static int
 362 sysctl_mld_ifinfo(SYSCTL_HANDLER_ARGS)
 363 {
 364         int                     *name;
 365         int                      error;
 366         u_int                    namelen;
 367         struct ifnet            *ifp;
 368         struct mld_ifsoftc      *mli;
 369
 370         name = (int *)arg1;
 371         namelen = arg2;
 372
 373         if (req->newptr != NULL)
 374                 return (EPERM);
 375
 376         if (namelen != 1)
 377                 return (EINVAL);
 378
 379         error = sysctl_wire_old_buffer(req, sizeof(struct mld_ifinfo));
 380         if (error)
 381                 return (error);
 382
 383         IN6_MULTI_LOCK();
 384         IN6_MULTI_LIST_LOCK();
 385         MLD_LOCK();
 386
 387         if (name[0] <= 0 || name[0] > V_if_index) {
 388                 error = ENOENT;
 389                 goto out_locked;
 390         }
 391
 392         error = ENOENT;
 393
 394         ifp = ifnet_byindex(name[0]);
 395         if (ifp == NULL)
 396                 goto out_locked;
 397
 398         LIST_FOREACH(mli, &V_mli_head, mli_link) {
 399                 if (ifp == mli->mli_ifp) {
 400                         struct mld_ifinfo info;
 401
 402                         info.mli_version = mli->mli_version;
 403                         info.mli_v1_timer = mli->mli_v1_timer;
 404                         info.mli_v2_timer = mli->mli_v2_timer;
 405                         info.mli_flags = mli->mli_flags;
 406                         info.mli_rv = mli->mli_rv;
 407                         info.mli_qi = mli->mli_qi;
 408                         info.mli_qri = mli->mli_qri;
 409                         info.mli_uri = mli->mli_uri;
 410                         error = SYSCTL_OUT(req, &info, sizeof(info));
 411                         break;
 412                 }
 413         }
 414
 415 out_locked:
 416         MLD_UNLOCK();
 417         IN6_MULTI_LIST_UNLOCK();
 418         IN6_MULTI_UNLOCK();
 419         return (error);
 420 }
 421
 422 /*
 423  * Dispatch an entire queue of pending packet chains.
 424  * VIMAGE: Assumes the vnet pointer has been set.
 425  */
 426 static void
 427 mld_dispatch_queue(struct mbufq *mq, int limit)
 428 {
 429         struct mbuf *m;
 430
 431         while ((m = mbufq_dequeue(mq)) != NULL) {
 432                 CTR3(KTR_MLD, "%s: dispatch %p from %p", __func__, mq, m);
 433                 mld_dispatch_packet(m);
 434                 if (--limit == 0)
 435                         break;
 436         }
 437 }
 438
 439 /*
 440  * Filter outgoing MLD report state by group.
 441  *
 442  * Reports are ALWAYS suppressed for ALL-HOSTS (ff02::1)
 443  * and node-local addresses. However, kernel and socket consumers
 444  * always embed the KAME scope ID in the address provided, so strip it
 445  * when performing comparison.
 446  * Note: This is not the same as the *multicast* scope.
 447  *
 448  * Return zero if the given group is one for which MLD reports
 449  * should be suppressed, or non-zero if reports should be issued.
 450  */
 451 static __inline int
 452 mld_is_addr_reported(const struct in6_addr *addr)
 453 {
 454
 455         KASSERT(IN6_IS_ADDR_MULTICAST(addr), ("%s: not multicast", __func__));
 456
 457         if (IPV6_ADDR_MC_SCOPE(addr) == IPV6_ADDR_SCOPE_NODELOCAL)
 458                 return (0);
 459
 460         if (IPV6_ADDR_MC_SCOPE(addr) == IPV6_ADDR_SCOPE_LINKLOCAL) {
 461                 struct in6_addr tmp = *addr;
 462                 in6_clearscope(&tmp);
 463                 if (IN6_ARE_ADDR_EQUAL(&tmp, &in6addr_linklocal_allnodes))
 464                         return (0);
 465         }
 466
 467         return (1);
 468 }
 469
 470 /*
 471  * Attach MLD when PF_INET6 is attached to an interface.  Assumes that the
 472  * current VNET is set by the caller.
 473  */
 474 struct mld_ifsoftc *
 475 mld_domifattach(struct ifnet *ifp)
 476 {
 477         struct mld_ifsoftc *mli;
 478
 479         CTR3(KTR_MLD, "%s: called for ifp %p(%s)", __func__, ifp, if_name(ifp));
 480
 481         mli = malloc(sizeof(struct mld_ifsoftc), M_MLD, M_WAITOK | M_ZERO);
 482         mli->mli_ifp = ifp;
 483         mli->mli_version = MLD_VERSION_2;
 484         mli->mli_flags = 0;
 485         mli->mli_rv = MLD_RV_INIT;
 486         mli->mli_qi = MLD_QI_INIT;
 487         mli->mli_qri = MLD_QRI_INIT;
 488         mli->mli_uri = MLD_URI_INIT;
 489         mbufq_init(&mli->mli_gq, MLD_MAX_RESPONSE_PACKETS);
 490         if ((ifp->if_flags & IFF_MULTICAST) == 0)
 491                 mli->mli_flags |= MLIF_SILENT;
 492         if (mld_use_allow)
 493                 mli->mli_flags |= MLIF_USEALLOW;
 494
 495         MLD_LOCK();
 496         LIST_INSERT_HEAD(&V_mli_head, mli, mli_link);
 497         MLD_UNLOCK();
 498
 499         return (mli);
 500 }
 501
 502 /*
 503  * Hook for ifdetach.
 504  *
 505  * NOTE: Some finalization tasks need to run before the protocol domain
 506  * is detached, but also before the link layer does its cleanup.
 507  * Run before link-layer cleanup; cleanup groups, but do not free MLD state.
 508  *
 509  * SMPng: Caller must hold IN6_MULTI_LOCK().
 510  * Must take IF_ADDR_LOCK() to cover if_multiaddrs iterator.
 511  * XXX This routine is also bitten by unlocked ifma_protospec access.
 512  */
 513 void
 514 mld_ifdetach(struct ifnet *ifp, struct in6_multi_head *inmh)
 515 {
 516         struct epoch_tracker     et;
 517         struct mld_ifsoftc      *mli;
 518         struct ifmultiaddr      *ifma;
 519         struct in6_multi        *inm;
 520
 521         CTR3(KTR_MLD, "%s: called for ifp %p(%s)", __func__, ifp,
 522             if_name(ifp));
 523
 524         IN6_MULTI_LIST_LOCK_ASSERT();
 525         MLD_LOCK();
 526
 527         mli = MLD_IFINFO(ifp);
 528         IF_ADDR_WLOCK(ifp);
 529         /*
 530          * Extract list of in6_multi associated with the detaching ifp
 531          * which the PF_INET6 layer is about to release.
 532          */
 533         NET_EPOCH_ENTER(et);
 534         CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 535                 inm = in6m_ifmultiaddr_get_inm(ifma);
 536                 if (inm == NULL)
 537                         continue;
 538                 in6m_disconnect_locked(inmh, inm);
 539
 540                 if (mli->mli_version == MLD_VERSION_2) {
 541                         in6m_clear_recorded(inm);
 542
 543                         /*
 544                          * We need to release the final reference held
 545                          * for issuing the INCLUDE {}.
 546                          */
 547                         if (inm->in6m_state == MLD_LEAVING_MEMBER) {
 548                                 inm->in6m_state = MLD_NOT_MEMBER;
 549                                 in6m_rele_locked(inmh, inm);
 550                         }
 551                 }
 552         }
 553         NET_EPOCH_EXIT(et);
 554         IF_ADDR_WUNLOCK(ifp);
 555         MLD_UNLOCK();
 556 }
 557
 558 /*
 559  * Hook for domifdetach.
 560  * Runs after link-layer cleanup; free MLD state.
 561  *
 562  * SMPng: Normally called with IF_AFDATA_LOCK held.
 563  */
 564 void
 565 mld_domifdetach(struct ifnet *ifp)
 566 {
 567
 568         CTR3(KTR_MLD, "%s: called for ifp %p(%s)",
 569             __func__, ifp, if_name(ifp));
 570
 571         MLD_LOCK();
 572         mli_delete_locked(ifp);
 573         MLD_UNLOCK();
 574 }
 575
 576 static void
 577 mli_delete_locked(const struct ifnet *ifp)
 578 {
 579         struct mld_ifsoftc *mli, *tmli;
 580
 581         CTR3(KTR_MLD, "%s: freeing mld_ifsoftc for ifp %p(%s)",
 582             __func__, ifp, if_name(ifp));
 583
 584         MLD_LOCK_ASSERT();
 585
 586         LIST_FOREACH_SAFE(mli, &V_mli_head, mli_link, tmli) {
 587                 if (mli->mli_ifp == ifp) {
 588                         /*
 589                          * Free deferred General Query responses.
 590                          */
 591                         mbufq_drain(&mli->mli_gq);
 592
 593                         LIST_REMOVE(mli, mli_link);
 594
 595                         free(mli, M_MLD);
 596                         return;
 597                 }
 598         }
 599 }
 600
 601 /*
 602  * Process a received MLDv1 general or address-specific query.
 603  * Assumes that the query header has been pulled up to sizeof(mld_hdr).
 604  *
 605  * NOTE: Can't be fully const correct as we temporarily embed scope ID in
 606  * mld_addr. This is OK as we own the mbuf chain.
 607  */
 608 static int
 609 mld_v1_input_query(struct ifnet *ifp, const struct ip6_hdr *ip6,
 610     /*const*/ struct mld_hdr *mld)
 611 {
 612         struct ifmultiaddr      *ifma;
 613         struct mld_ifsoftc      *mli;
 614         struct in6_multi        *inm;
 615         int                      is_general_query;
 616         uint16_t                 timer;
 617 #ifdef KTR
 618         char                     ip6tbuf[INET6_ADDRSTRLEN];
 619 #endif
 620
 621         NET_EPOCH_ASSERT();
 622
 623         is_general_query = 0;
 624
 625         if (!mld_v1enable) {
 626                 CTR3(KTR_MLD, "ignore v1 query %s on ifp %p(%s)",
 627                     ip6_sprintf(ip6tbuf, &mld->mld_addr),
 628                     ifp, if_name(ifp));
 629                 return (0);
 630         }
 631
 632         /*
 633          * RFC3810 Section 6.2: MLD queries must originate from
 634          * a router's link-local address.
 635          */
 636         if (!IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) {
 637                 CTR3(KTR_MLD, "ignore v1 query src %s on ifp %p(%s)",
 638                     ip6_sprintf(ip6tbuf, &ip6->ip6_src),
 639                     ifp, if_name(ifp));
 640                 return (0);
 641         }
 642
 643         /*
 644          * Do address field validation upfront before we accept
 645          * the query.
 646          */
 647         if (IN6_IS_ADDR_UNSPECIFIED(&mld->mld_addr)) {
 648                 /*
 649                  * MLDv1 General Query.
 650                  * If this was not sent to the all-nodes group, ignore it.
 651                  */
 652                 struct in6_addr          dst;
 653
 654                 dst = ip6->ip6_dst;
 655                 in6_clearscope(&dst);
 656                 if (!IN6_ARE_ADDR_EQUAL(&dst, &in6addr_linklocal_allnodes))
 657                         return (EINVAL);
 658                 is_general_query = 1;
 659         } else {
 660                 /*
 661                  * Embed scope ID of receiving interface in MLD query for
 662                  * lookup whilst we don't hold other locks.
 663                  */
 664                 in6_setscope(&mld->mld_addr, ifp, NULL);
 665         }
 666
 667         IN6_MULTI_LIST_LOCK();
 668         MLD_LOCK();
 669
 670         /*
 671          * Switch to MLDv1 host compatibility mode.
 672          */
 673         mli = MLD_IFINFO(ifp);
 674         KASSERT(mli != NULL, ("%s: no mld_ifsoftc for ifp %p", __func__, ifp));
 675         mld_set_version(mli, MLD_VERSION_1);
 676
 677         timer = (ntohs(mld->mld_maxdelay) * PR_FASTHZ) / MLD_TIMER_SCALE;
 678         if (timer == 0)
 679                 timer = 1;
 680
 681         if (is_general_query) {
 682                 /*
 683                  * For each reporting group joined on this
 684                  * interface, kick the report timer.
 685                  */
 686                 CTR2(KTR_MLD, "process v1 general query on ifp %p(%s)",
 687                          ifp, if_name(ifp));
 688                 CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 689                         inm = in6m_ifmultiaddr_get_inm(ifma);
 690                         if (inm == NULL)
 691                                 continue;
 692                         mld_v1_update_group(inm, timer);
 693                 }
 694         } else {
 695                 /*
 696                  * MLDv1 Group-Specific Query.
 697                  * If this is a group-specific MLDv1 query, we need only
 698                  * look up the single group to process it.
 699                  */
 700                 inm = in6m_lookup_locked(ifp, &mld->mld_addr);
 701                 if (inm != NULL) {
 702                         CTR3(KTR_MLD, "process v1 query %s on ifp %p(%s)",
 703                             ip6_sprintf(ip6tbuf, &mld->mld_addr),
 704                             ifp, if_name(ifp));
 705                         mld_v1_update_group(inm, timer);
 706                 }
 707                 /* XXX Clear embedded scope ID as userland won't expect it. */
 708                 in6_clearscope(&mld->mld_addr);
 709         }
 710
 711         MLD_UNLOCK();
 712         IN6_MULTI_LIST_UNLOCK();
 713
 714         return (0);
 715 }
 716
 717 /*
 718  * Update the report timer on a group in response to an MLDv1 query.
 719  *
 720  * If we are becoming the reporting member for this group, start the timer.
 721  * If we already are the reporting member for this group, and timer is
 722  * below the threshold, reset it.
 723  *
 724  * We may be updating the group for the first time since we switched
 725  * to MLDv2. If we are, then we must clear any recorded source lists,
 726  * and transition to REPORTING state; the group timer is overloaded
 727  * for group and group-source query responses.
 728  *
 729  * Unlike MLDv2, the delay per group should be jittered
 730  * to avoid bursts of MLDv1 reports.
 731  */
 732 static void
 733 mld_v1_update_group(struct in6_multi *inm, const int timer)
 734 {
 735 #ifdef KTR
 736         char                     ip6tbuf[INET6_ADDRSTRLEN];
 737 #endif
 738
 739         CTR4(KTR_MLD, "%s: %s/%s timer=%d", __func__,
 740             ip6_sprintf(ip6tbuf, &inm->in6m_addr),
 741             if_name(inm->in6m_ifp), timer);
 742
 743         IN6_MULTI_LIST_LOCK_ASSERT();
 744
 745         switch (inm->in6m_state) {
 746         case MLD_NOT_MEMBER:
 747         case MLD_SILENT_MEMBER:
 748                 break;
 749         case MLD_REPORTING_MEMBER:
 750                 if (inm->in6m_timer != 0 &&
 751                     inm->in6m_timer <= timer) {
 752                         CTR1(KTR_MLD, "%s: REPORTING and timer running, "
 753                             "skipping.", __func__);
 754                         break;
 755                 }
 756                 /* FALLTHROUGH */
 757         case MLD_SG_QUERY_PENDING_MEMBER:
 758         case MLD_G_QUERY_PENDING_MEMBER:
 759         case MLD_IDLE_MEMBER:
 760         case MLD_LAZY_MEMBER:
 761         case MLD_AWAKENING_MEMBER:
 762                 CTR1(KTR_MLD, "%s: ->REPORTING", __func__);
 763                 inm->in6m_state = MLD_REPORTING_MEMBER;
 764                 inm->in6m_timer = MLD_RANDOM_DELAY(timer);
 765                 V_current_state_timers_running6 = 1;
 766                 break;
 767         case MLD_SLEEPING_MEMBER:
 768                 CTR1(KTR_MLD, "%s: ->AWAKENING", __func__);
 769                 inm->in6m_state = MLD_AWAKENING_MEMBER;
 770                 break;
 771         case MLD_LEAVING_MEMBER:
 772                 break;
 773         }
 774 }
 775
 776 /*
 777  * Process a received MLDv2 general, group-specific or
 778  * group-and-source-specific query.
 779  *
 780  * Assumes that mld points to a struct mldv2_query which is stored in
 781  * contiguous memory.
 782  *
 783  * Return 0 if successful, otherwise an appropriate error code is returned.
 784  */
 785 static int
 786 mld_v2_input_query(struct ifnet *ifp, const struct ip6_hdr *ip6,
 787     struct mbuf *m, struct mldv2_query *mld, const int off, const int icmp6len)
 788 {
 789         struct mld_ifsoftc      *mli;
 790         struct in6_multi        *inm;
 791         uint32_t                 maxdelay, nsrc, qqi;
 792         int                      is_general_query;
 793         uint16_t                 timer;
 794         uint8_t                  qrv;
 795 #ifdef KTR
 796         char                     ip6tbuf[INET6_ADDRSTRLEN];
 797 #endif
 798
 799         NET_EPOCH_ASSERT();
 800
 801         if (!mld_v2enable) {
 802                 CTR3(KTR_MLD, "ignore v2 query src %s on ifp %p(%s)",
 803                     ip6_sprintf(ip6tbuf, &ip6->ip6_src),
 804                     ifp, if_name(ifp));
 805                 return (0);
 806         }
 807
 808         /*
 809          * RFC3810 Section 6.2: MLD queries must originate from
 810          * a router's link-local address.
 811          */
 812         if (!IN6_IS_SCOPE_LINKLOCAL(&ip6->ip6_src)) {
 813                 CTR3(KTR_MLD, "ignore v1 query src %s on ifp %p(%s)",
 814                     ip6_sprintf(ip6tbuf, &ip6->ip6_src),
 815                     ifp, if_name(ifp));
 816                 return (0);
 817         }
 818
 819         is_general_query = 0;
 820
 821         CTR2(KTR_MLD, "input v2 query on ifp %p(%s)", ifp, if_name(ifp));
 822
 823         maxdelay = ntohs(mld->mld_maxdelay);    /* in 1/10ths of a second */
 824         if (maxdelay >= 32768) {
 825                 maxdelay = (MLD_MRC_MANT(maxdelay) | 0x1000) <<
 826                            (MLD_MRC_EXP(maxdelay) + 3);
 827         }
 828         timer = (maxdelay * PR_FASTHZ) / MLD_TIMER_SCALE;
 829         if (timer == 0)
 830                 timer = 1;
 831
 832         qrv = MLD_QRV(mld->mld_misc);
 833         if (qrv < 2) {
 834                 CTR3(KTR_MLD, "%s: clamping qrv %d to %d", __func__,
 835                     qrv, MLD_RV_INIT);
 836                 qrv = MLD_RV_INIT;
 837         }
 838
 839         qqi = mld->mld_qqi;
 840         if (qqi >= 128) {
 841                 qqi = MLD_QQIC_MANT(mld->mld_qqi) <<
 842                      (MLD_QQIC_EXP(mld->mld_qqi) + 3);
 843         }
 844
 845         nsrc = ntohs(mld->mld_numsrc);
 846         if (nsrc > MLD_MAX_GS_SOURCES)
 847                 return (EMSGSIZE);
 848         if (icmp6len < sizeof(struct mldv2_query) +
 849             (nsrc * sizeof(struct in6_addr)))
 850                 return (EMSGSIZE);
 851
 852         /*
 853          * Do further input validation upfront to avoid resetting timers
 854          * should we need to discard this query.
 855          */
 856         if (IN6_IS_ADDR_UNSPECIFIED(&mld->mld_addr)) {
 857                 /*
 858                  * A general query with a source list has undefined
 859                  * behaviour; discard it.
 860                  */
 861                 if (nsrc > 0)
 862                         return (EINVAL);
 863                 is_general_query = 1;
 864         } else {
 865                 /*
 866                  * Embed scope ID of receiving interface in MLD query for
 867                  * lookup whilst we don't hold other locks (due to KAME
 868                  * locking lameness). We own this mbuf chain just now.
 869                  */
 870                 in6_setscope(&mld->mld_addr, ifp, NULL);
 871         }
 872
 873         IN6_MULTI_LIST_LOCK();
 874         MLD_LOCK();
 875
 876         mli = MLD_IFINFO(ifp);
 877         KASSERT(mli != NULL, ("%s: no mld_ifsoftc for ifp %p", __func__, ifp));
 878
 879         /*
 880          * Discard the v2 query if we're in Compatibility Mode.
 881          * The RFC is pretty clear that hosts need to stay in MLDv1 mode
 882          * until the Old Version Querier Present timer expires.
 883          */
 884         if (mli->mli_version != MLD_VERSION_2)
 885                 goto out_locked;
 886
 887         mld_set_version(mli, MLD_VERSION_2);
 888         mli->mli_rv = qrv;
 889         mli->mli_qi = qqi;
 890         mli->mli_qri = maxdelay;
 891
 892         CTR4(KTR_MLD, "%s: qrv %d qi %d maxdelay %d", __func__, qrv, qqi,
 893             maxdelay);
 894
 895         if (is_general_query) {
 896                 /*
 897                  * MLDv2 General Query.
 898                  *
 899                  * Schedule a current-state report on this ifp for
 900                  * all groups, possibly containing source lists.
 901                  *
 902                  * If there is a pending General Query response
 903                  * scheduled earlier than the selected delay, do
 904                  * not schedule any other reports.
 905                  * Otherwise, reset the interface timer.
 906                  */
 907                 CTR2(KTR_MLD, "process v2 general query on ifp %p(%s)",
 908                     ifp, if_name(ifp));
 909                 if (mli->mli_v2_timer == 0 || mli->mli_v2_timer >= timer) {
 910                         mli->mli_v2_timer = MLD_RANDOM_DELAY(timer);
 911                         V_interface_timers_running6 = 1;
 912                 }
 913         } else {
 914                 /*
 915                  * MLDv2 Group-specific or Group-and-source-specific Query.
 916                  *
 917                  * Group-source-specific queries are throttled on
 918                  * a per-group basis to defeat denial-of-service attempts.
 919                  * Queries for groups we are not a member of on this
 920                  * link are simply ignored.
 921                  */
 922                 inm = in6m_lookup_locked(ifp, &mld->mld_addr);
 923                 if (inm == NULL)
 924                         goto out_locked;
 925                 if (nsrc > 0) {
 926                         if (!ratecheck(&inm->in6m_lastgsrtv,
 927                             &V_mld_gsrdelay)) {
 928                                 CTR1(KTR_MLD, "%s: GS query throttled.",
 929                                     __func__);
 930                                 goto out_locked;
 931                         }
 932                 }
 933                 CTR2(KTR_MLD, "process v2 group query on ifp %p(%s)",
 934                      ifp, if_name(ifp));
 935                 /*
 936                  * If there is a pending General Query response
 937                  * scheduled sooner than the selected delay, no
 938                  * further report need be scheduled.
 939                  * Otherwise, prepare to respond to the
 940                  * group-specific or group-and-source query.
 941                  */
 942                 if (mli->mli_v2_timer == 0 || mli->mli_v2_timer >= timer)
 943                         mld_v2_process_group_query(inm, mli, timer, m, mld, off);
 944
 945                 /* XXX Clear embedded scope ID as userland won't expect it. */
 946                 in6_clearscope(&mld->mld_addr);
 947         }
 948
 949 out_locked:
 950         MLD_UNLOCK();
 951         IN6_MULTI_LIST_UNLOCK();
 952
 953         return (0);
 954 }
 955
 956 /*
 957  * Process a received MLDv2 group-specific or group-and-source-specific
 958  * query.
 959  * Return <0 if any error occurred. Currently this is ignored.
 960  */
 961 static int
 962 mld_v2_process_group_query(struct in6_multi *inm, struct mld_ifsoftc *mli,
 963     int timer, struct mbuf *m0, struct mldv2_query *mld, const int off)
 964 {
 965         int                      retval;
 966         uint16_t                 nsrc;
 967
 968         IN6_MULTI_LIST_LOCK_ASSERT();
 969         MLD_LOCK_ASSERT();
 970
 971         retval = 0;
 972
 973         switch (inm->in6m_state) {
 974         case MLD_NOT_MEMBER:
 975         case MLD_SILENT_MEMBER:
 976         case MLD_SLEEPING_MEMBER:
 977         case MLD_LAZY_MEMBER:
 978         case MLD_AWAKENING_MEMBER:
 979         case MLD_IDLE_MEMBER:
 980         case MLD_LEAVING_MEMBER:
 981                 return (retval);
 982                 break;
 983         case MLD_REPORTING_MEMBER:
 984         case MLD_G_QUERY_PENDING_MEMBER:
 985         case MLD_SG_QUERY_PENDING_MEMBER:
 986                 break;
 987         }
 988
 989         nsrc = ntohs(mld->mld_numsrc);
 990
 991         /* Length should be checked by calling function. */
 992         KASSERT((m0->m_flags & M_PKTHDR) == 0 ||
 993             m0->m_pkthdr.len >= off + sizeof(struct mldv2_query) +
 994             nsrc * sizeof(struct in6_addr),
 995             ("mldv2 packet is too short: (%d bytes < %zd bytes, m=%p)",
 996             m0->m_pkthdr.len, off + sizeof(struct mldv2_query) +
 997             nsrc * sizeof(struct in6_addr), m0));
 998
 999         /*
1000          * Deal with group-specific queries upfront.
1001          * If any group query is already pending, purge any recorded
1002          * source-list state if it exists, and schedule a query response
1003          * for this group-specific query.
1004          */
1005         if (nsrc == 0) {
1006                 if (inm->in6m_state == MLD_G_QUERY_PENDING_MEMBER ||
1007                     inm->in6m_state == MLD_SG_QUERY_PENDING_MEMBER) {
1008                         in6m_clear_recorded(inm);
1009                         timer = min(inm->in6m_timer, timer);
1010                 }
1011                 inm->in6m_state = MLD_G_QUERY_PENDING_MEMBER;
1012                 inm->in6m_timer = MLD_RANDOM_DELAY(timer);
1013                 V_current_state_timers_running6 = 1;
1014                 return (retval);
1015         }
1016
1017         /*
1018          * Deal with the case where a group-and-source-specific query has
1019          * been received but a group-specific query is already pending.
1020          */
1021         if (inm->in6m_state == MLD_G_QUERY_PENDING_MEMBER) {
1022                 timer = min(inm->in6m_timer, timer);
1023                 inm->in6m_timer = MLD_RANDOM_DELAY(timer);
1024                 V_current_state_timers_running6 = 1;
1025                 return (retval);
1026         }
1027
1028         /*
1029          * Finally, deal with the case where a group-and-source-specific
1030          * query has been received, where a response to a previous g-s-r
1031          * query exists, or none exists.
1032          * In this case, we need to parse the source-list which the Querier
1033          * has provided us with and check if we have any source list filter
1034          * entries at T1 for these sources. If we do not, there is no need
1035          * schedule a report and the query may be dropped.
1036          * If we do, we must record them and schedule a current-state
1037          * report for those sources.
1038          */
1039         if (inm->in6m_nsrc > 0) {
1040                 struct in6_addr          srcaddr;
1041                 int                      i, nrecorded;
1042                 int                      soff;
1043
1044                 soff = off + sizeof(struct mldv2_query);
1045                 nrecorded = 0;
1046                 for (i = 0; i < nsrc; i++) {
1047                         m_copydata(m0, soff, sizeof(struct in6_addr),
1048                             (caddr_t)&srcaddr);
1049                         retval = in6m_record_source(inm, &srcaddr);
1050                         if (retval < 0)
1051                                 break;
1052                         nrecorded += retval;
1053                         soff += sizeof(struct in6_addr);
1054                 }
1055                 if (nrecorded > 0) {
1056                         CTR1(KTR_MLD,
1057                             "%s: schedule response to SG query", __func__);
1058                         inm->in6m_state = MLD_SG_QUERY_PENDING_MEMBER;
1059                         inm->in6m_timer = MLD_RANDOM_DELAY(timer);
1060                         V_current_state_timers_running6 = 1;
1061                 }
1062         }
1063
1064         return (retval);
1065 }
1066
1067 /*
1068  * Process a received MLDv1 host membership report.
1069  * Assumes mld points to mld_hdr in pulled up mbuf chain.
1070  *
1071  * NOTE: Can't be fully const correct as we temporarily embed scope ID in
1072  * mld_addr. This is OK as we own the mbuf chain.
1073  */
1074 static int
1075 mld_v1_input_report(struct ifnet *ifp, const struct ip6_hdr *ip6,
1076     /*const*/ struct mld_hdr *mld)
1077 {
1078         struct in6_addr          src, dst;
1079         struct in6_ifaddr       *ia;
1080         struct in6_multi        *inm;
1081 #ifdef KTR
1082         char                     ip6tbuf[INET6_ADDRSTRLEN];
1083 #endif
1084
1085         NET_EPOCH_ASSERT();
1086
1087         if (!mld_v1enable) {
1088                 CTR3(KTR_MLD, "ignore v1 report %s on ifp %p(%s)",
1089                     ip6_sprintf(ip6tbuf, &mld->mld_addr),
1090                     ifp, if_name(ifp));
1091                 return (0);
1092         }
1093
1094         if (ifp->if_flags & IFF_LOOPBACK)
1095                 return (0);
1096
1097         /*
1098          * MLDv1 reports must originate from a host's link-local address,
1099          * or the unspecified address (when booting).
1100          */
1101         src = ip6->ip6_src;
1102         in6_clearscope(&src);
1103         if (!IN6_IS_SCOPE_LINKLOCAL(&src) && !IN6_IS_ADDR_UNSPECIFIED(&src)) {
1104                 CTR3(KTR_MLD, "ignore v1 query src %s on ifp %p(%s)",
1105                     ip6_sprintf(ip6tbuf, &ip6->ip6_src),
1106                     ifp, if_name(ifp));
1107                 return (EINVAL);
1108         }
1109
1110         /*
1111          * RFC2710 Section 4: MLDv1 reports must pertain to a multicast
1112          * group, and must be directed to the group itself.
1113          */
1114         dst = ip6->ip6_dst;
1115         in6_clearscope(&dst);
1116         if (!IN6_IS_ADDR_MULTICAST(&mld->mld_addr) ||
1117             !IN6_ARE_ADDR_EQUAL(&mld->mld_addr, &dst)) {
1118                 CTR3(KTR_MLD, "ignore v1 query dst %s on ifp %p(%s)",
1119                     ip6_sprintf(ip6tbuf, &ip6->ip6_dst),
1120                     ifp, if_name(ifp));
1121                 return (EINVAL);
1122         }
1123
1124         /*
1125          * Make sure we don't hear our own membership report, as fast
1126          * leave requires knowing that we are the only member of a
1127          * group. Assume we used the link-local address if available,
1128          * otherwise look for ::.
1129          *
1130          * XXX Note that scope ID comparison is needed for the address
1131          * returned by in6ifa_ifpforlinklocal(), but SHOULD NOT be
1132          * performed for the on-wire address.
1133          */
1134         ia = in6ifa_ifpforlinklocal(ifp, IN6_IFF_NOTREADY|IN6_IFF_ANYCAST);
1135         if ((ia && IN6_ARE_ADDR_EQUAL(&ip6->ip6_src, IA6_IN6(ia))) ||
1136             (ia == NULL && IN6_IS_ADDR_UNSPECIFIED(&src))) {
1137                 if (ia != NULL)
1138                         ifa_free(&ia->ia_ifa);
1139                 return (0);
1140         }
1141         if (ia != NULL)
1142                 ifa_free(&ia->ia_ifa);
1143
1144         CTR3(KTR_MLD, "process v1 report %s on ifp %p(%s)",
1145             ip6_sprintf(ip6tbuf, &mld->mld_addr), ifp, if_name(ifp));
1146
1147         /*
1148          * Embed scope ID of receiving interface in MLD query for lookup
1149          * whilst we don't hold other locks (due to KAME locking lameness).
1150          */
1151         if (!IN6_IS_ADDR_UNSPECIFIED(&mld->mld_addr))
1152                 in6_setscope(&mld->mld_addr, ifp, NULL);
1153
1154         IN6_MULTI_LIST_LOCK();
1155         MLD_LOCK();
1156
1157         /*
1158          * MLDv1 report suppression.
1159          * If we are a member of this group, and our membership should be
1160          * reported, and our group timer is pending or about to be reset,
1161          * stop our group timer by transitioning to the 'lazy' state.
1162          */
1163         inm = in6m_lookup_locked(ifp, &mld->mld_addr);
1164         if (inm != NULL) {
1165                 struct mld_ifsoftc *mli;
1166
1167                 mli = inm->in6m_mli;
1168                 KASSERT(mli != NULL,
1169                     ("%s: no mli for ifp %p", __func__, ifp));
1170
1171                 /*
1172                  * If we are in MLDv2 host mode, do not allow the
1173                  * other host's MLDv1 report to suppress our reports.
1174                  */
1175                 if (mli->mli_version == MLD_VERSION_2)
1176                         goto out_locked;
1177
1178                 inm->in6m_timer = 0;
1179
1180                 switch (inm->in6m_state) {
1181                 case MLD_NOT_MEMBER:
1182                 case MLD_SILENT_MEMBER:
1183                 case MLD_SLEEPING_MEMBER:
1184                         break;
1185                 case MLD_REPORTING_MEMBER:
1186                 case MLD_IDLE_MEMBER:
1187                 case MLD_AWAKENING_MEMBER:
1188                         CTR3(KTR_MLD,
1189                             "report suppressed for %s on ifp %p(%s)",
1190                             ip6_sprintf(ip6tbuf, &mld->mld_addr),
1191                             ifp, if_name(ifp));
1192                 case MLD_LAZY_MEMBER:
1193                         inm->in6m_state = MLD_LAZY_MEMBER;
1194                         break;
1195                 case MLD_G_QUERY_PENDING_MEMBER:
1196                 case MLD_SG_QUERY_PENDING_MEMBER:
1197                 case MLD_LEAVING_MEMBER:
1198                         break;
1199                 }
1200         }
1201
1202 out_locked:
1203         MLD_UNLOCK();
1204         IN6_MULTI_LIST_UNLOCK();
1205
1206         /* XXX Clear embedded scope ID as userland won't expect it. */
1207         in6_clearscope(&mld->mld_addr);
1208
1209         return (0);
1210 }
1211
1212 /*
1213  * MLD input path.
1214  *
1215  * Assume query messages which fit in a single ICMPv6 message header
1216  * have been pulled up.
1217  * Assume that userland will want to see the message, even if it
1218  * otherwise fails kernel input validation; do not free it.
1219  * Pullup may however free the mbuf chain m if it fails.
1220  *
1221  * Return IPPROTO_DONE if we freed m. Otherwise, return 0.
1222  */
1223 int
1224 mld_input(struct mbuf **mp, int off, int icmp6len)
1225 {
1226         struct ifnet    *ifp;
1227         struct ip6_hdr  *ip6;
1228         struct mbuf     *m;
1229         struct mld_hdr  *mld;
1230         int              mldlen;
1231
1232         m = *mp;
1233         CTR3(KTR_MLD, "%s: called w/mbuf (%p,%d)", __func__, m, off);
1234
1235         ifp = m->m_pkthdr.rcvif;
1236
1237         /* Pullup to appropriate size. */
1238         if (m->m_len < off + sizeof(*mld)) {
1239                 m = m_pullup(m, off + sizeof(*mld));
1240                 if (m == NULL) {
1241                         ICMP6STAT_INC(icp6s_badlen);
1242                         return (IPPROTO_DONE);
1243                 }
1244         }
1245         mld = (struct mld_hdr *)(mtod(m, uint8_t *) + off);
1246         if (mld->mld_type == MLD_LISTENER_QUERY &&
1247             icmp6len >= sizeof(struct mldv2_query)) {
1248                 mldlen = sizeof(struct mldv2_query);
1249         } else {
1250                 mldlen = sizeof(struct mld_hdr);
1251         }
1252         if (m->m_len < off + mldlen) {
1253                 m = m_pullup(m, off + mldlen);
1254                 if (m == NULL) {
1255                         ICMP6STAT_INC(icp6s_badlen);
1256                         return (IPPROTO_DONE);
1257                 }
1258         }
1259         *mp = m;
1260         ip6 = mtod(m, struct ip6_hdr *);
1261         mld = (struct mld_hdr *)(mtod(m, uint8_t *) + off);
1262
1263         /*
1264          * Userland needs to see all of this traffic for implementing
1265          * the endpoint discovery portion of multicast routing.
1266          */
1267         switch (mld->mld_type) {
1268         case MLD_LISTENER_QUERY:
1269                 icmp6_ifstat_inc(ifp, ifs6_in_mldquery);
1270                 if (icmp6len == sizeof(struct mld_hdr)) {
1271                         if (mld_v1_input_query(ifp, ip6, mld) != 0)
1272                                 return (0);
1273                 } else if (icmp6len >= sizeof(struct mldv2_query)) {
1274                         if (mld_v2_input_query(ifp, ip6, m,
1275                             (struct mldv2_query *)mld, off, icmp6len) != 0)
1276                                 return (0);
1277                 }
1278                 break;
1279         case MLD_LISTENER_REPORT:
1280                 icmp6_ifstat_inc(ifp, ifs6_in_mldreport);
1281                 if (mld_v1_input_report(ifp, ip6, mld) != 0)
1282                         return (0);
1283                 break;
1284         case MLDV2_LISTENER_REPORT:
1285                 icmp6_ifstat_inc(ifp, ifs6_in_mldreport);
1286                 break;
1287         case MLD_LISTENER_DONE:
1288                 icmp6_ifstat_inc(ifp, ifs6_in_mlddone);
1289                 break;
1290         default:
1291                 break;
1292         }
1293
1294         return (0);
1295 }
1296
1297 /*
1298  * Fast timeout handler (global).
1299  * VIMAGE: Timeout handlers are expected to service all vimages.
1300  */
1301 void
1302 mld_fasttimo(void)
1303 {
1304         struct in6_multi_head inmh;
1305         VNET_ITERATOR_DECL(vnet_iter);
1306
1307         SLIST_INIT(&inmh);
1308
1309         VNET_LIST_RLOCK_NOSLEEP();
1310         VNET_FOREACH(vnet_iter) {
1311                 CURVNET_SET(vnet_iter);
1312                 mld_fasttimo_vnet(&inmh);
1313                 CURVNET_RESTORE();
1314         }
1315         VNET_LIST_RUNLOCK_NOSLEEP();
1316         in6m_release_list_deferred(&inmh);
1317 }
1318
1319 /*
1320  * Fast timeout handler (per-vnet).
1321  *
1322  * VIMAGE: Assume caller has set up our curvnet.
1323  */
1324 static void
1325 mld_fasttimo_vnet(struct in6_multi_head *inmh)
1326 {
1327         struct epoch_tracker     et;
1328         struct mbufq             scq;   /* State-change packets */
1329         struct mbufq             qrq;   /* Query response packets */
1330         struct ifnet            *ifp;
1331         struct mld_ifsoftc      *mli;
1332         struct ifmultiaddr      *ifma;
1333         struct in6_multi        *inm;
1334         int                      uri_fasthz;
1335
1336         uri_fasthz = 0;
1337
1338         /*
1339          * Quick check to see if any work needs to be done, in order to
1340          * minimize the overhead of fasttimo processing.
1341          * SMPng: XXX Unlocked reads.
1342          */
1343         if (!V_current_state_timers_running6 &&
1344             !V_interface_timers_running6 &&
1345             !V_state_change_timers_running6)
1346                 return;
1347
1348         IN6_MULTI_LIST_LOCK();
1349         MLD_LOCK();
1350
1351         /*
1352          * MLDv2 General Query response timer processing.
1353          */
1354         if (V_interface_timers_running6) {
1355                 CTR1(KTR_MLD, "%s: interface timers running", __func__);
1356
1357                 V_interface_timers_running6 = 0;
1358                 LIST_FOREACH(mli, &V_mli_head, mli_link) {
1359                         if (mli->mli_v2_timer == 0) {
1360                                 /* Do nothing. */
1361                         } else if (--mli->mli_v2_timer == 0) {
1362                                 mld_v2_dispatch_general_query(mli);
1363                         } else {
1364                                 V_interface_timers_running6 = 1;
1365                         }
1366                 }
1367         }
1368
1369         if (!V_current_state_timers_running6 &&
1370             !V_state_change_timers_running6)
1371                 goto out_locked;
1372
1373         V_current_state_timers_running6 = 0;
1374         V_state_change_timers_running6 = 0;
1375
1376         CTR1(KTR_MLD, "%s: state change timers running", __func__);
1377
1378         /*
1379          * MLD host report and state-change timer processing.
1380          * Note: Processing a v2 group timer may remove a node.
1381          */
1382         LIST_FOREACH(mli, &V_mli_head, mli_link) {
1383                 ifp = mli->mli_ifp;
1384
1385                 if (mli->mli_version == MLD_VERSION_2) {
1386                         uri_fasthz = MLD_RANDOM_DELAY(mli->mli_uri *
1387                             PR_FASTHZ);
1388                         mbufq_init(&qrq, MLD_MAX_G_GS_PACKETS);
1389                         mbufq_init(&scq, MLD_MAX_STATE_CHANGE_PACKETS);
1390                 }
1391
1392                 NET_EPOCH_ENTER(et);
1393                 IF_ADDR_WLOCK(ifp);
1394                 CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1395                         inm = in6m_ifmultiaddr_get_inm(ifma);
1396                         if (inm == NULL)
1397                                 continue;
1398                         switch (mli->mli_version) {
1399                         case MLD_VERSION_1:
1400                                 mld_v1_process_group_timer(inmh, inm);
1401                                 break;
1402                         case MLD_VERSION_2:
1403                                 mld_v2_process_group_timers(inmh, &qrq,
1404                                     &scq, inm, uri_fasthz);
1405                                 break;
1406                         }
1407                 }
1408                 IF_ADDR_WUNLOCK(ifp);
1409
1410                 switch (mli->mli_version) {
1411                 case MLD_VERSION_1:
1412                         /*
1413                          * Transmit reports for this lifecycle.  This
1414                          * is done while not holding IF_ADDR_LOCK
1415                          * since this can call
1416                          * in6ifa_ifpforlinklocal() which locks
1417                          * IF_ADDR_LOCK internally as well as
1418                          * ip6_output() to transmit a packet.
1419                          */
1420                         while ((inm = SLIST_FIRST(inmh)) != NULL) {
1421                                 SLIST_REMOVE_HEAD(inmh, in6m_defer);
1422                                 (void)mld_v1_transmit_report(inm,
1423                                     MLD_LISTENER_REPORT);
1424                         }
1425                         break;
1426                 case MLD_VERSION_2:
1427                         mld_dispatch_queue(&qrq, 0);
1428                         mld_dispatch_queue(&scq, 0);
1429                         break;
1430                 }
1431                 NET_EPOCH_EXIT(et);
1432         }
1433
1434 out_locked:
1435         MLD_UNLOCK();
1436         IN6_MULTI_LIST_UNLOCK();
1437 }
1438
1439 /*
1440  * Update host report group timer.
1441  * Will update the global pending timer flags.
1442  */
1443 static void
1444 mld_v1_process_group_timer(struct in6_multi_head *inmh, struct in6_multi *inm)
1445 {
1446         int report_timer_expired;
1447
1448         IN6_MULTI_LIST_LOCK_ASSERT();
1449         MLD_LOCK_ASSERT();
1450
1451         if (inm->in6m_timer == 0) {
1452                 report_timer_expired = 0;
1453         } else if (--inm->in6m_timer == 0) {
1454                 report_timer_expired = 1;
1455         } else {
1456                 V_current_state_timers_running6 = 1;
1457                 return;
1458         }
1459
1460         switch (inm->in6m_state) {
1461         case MLD_NOT_MEMBER:
1462         case MLD_SILENT_MEMBER:
1463         case MLD_IDLE_MEMBER:
1464         case MLD_LAZY_MEMBER:
1465         case MLD_SLEEPING_MEMBER:
1466         case MLD_AWAKENING_MEMBER:
1467                 break;
1468         case MLD_REPORTING_MEMBER:
1469                 if (report_timer_expired) {
1470                         inm->in6m_state = MLD_IDLE_MEMBER;
1471                         SLIST_INSERT_HEAD(inmh, inm, in6m_defer);
1472                 }
1473                 break;
1474         case MLD_G_QUERY_PENDING_MEMBER:
1475         case MLD_SG_QUERY_PENDING_MEMBER:
1476         case MLD_LEAVING_MEMBER:
1477                 break;
1478         }
1479 }
1480
1481 /*
1482  * Update a group's timers for MLDv2.
1483  * Will update the global pending timer flags.
1484  * Note: Unlocked read from mli.
1485  */
1486 static void
1487 mld_v2_process_group_timers(struct in6_multi_head *inmh,
1488     struct mbufq *qrq, struct mbufq *scq,
1489     struct in6_multi *inm, const int uri_fasthz)
1490 {
1491         int query_response_timer_expired;
1492         int state_change_retransmit_timer_expired;
1493 #ifdef KTR
1494         char ip6tbuf[INET6_ADDRSTRLEN];
1495 #endif
1496
1497         IN6_MULTI_LIST_LOCK_ASSERT();
1498         MLD_LOCK_ASSERT();
1499
1500         query_response_timer_expired = 0;
1501         state_change_retransmit_timer_expired = 0;
1502
1503         /*
1504          * During a transition from compatibility mode back to MLDv2,
1505          * a group record in REPORTING state may still have its group
1506          * timer active. This is a no-op in this function; it is easier
1507          * to deal with it here than to complicate the slow-timeout path.
1508          */
1509         if (inm->in6m_timer == 0) {
1510                 query_response_timer_expired = 0;
1511         } else if (--inm->in6m_timer == 0) {
1512                 query_response_timer_expired = 1;
1513         } else {
1514                 V_current_state_timers_running6 = 1;
1515         }
1516
1517         if (inm->in6m_sctimer == 0) {
1518                 state_change_retransmit_timer_expired = 0;
1519         } else if (--inm->in6m_sctimer == 0) {
1520                 state_change_retransmit_timer_expired = 1;
1521         } else {
1522                 V_state_change_timers_running6 = 1;
1523         }
1524
1525         /* We are in fasttimo, so be quick about it. */
1526         if (!state_change_retransmit_timer_expired &&
1527             !query_response_timer_expired)
1528                 return;
1529
1530         switch (inm->in6m_state) {
1531         case MLD_NOT_MEMBER:
1532         case MLD_SILENT_MEMBER:
1533         case MLD_SLEEPING_MEMBER:
1534         case MLD_LAZY_MEMBER:
1535         case MLD_AWAKENING_MEMBER:
1536         case MLD_IDLE_MEMBER:
1537                 break;
1538         case MLD_G_QUERY_PENDING_MEMBER:
1539         case MLD_SG_QUERY_PENDING_MEMBER:
1540                 /*
1541                  * Respond to a previously pending Group-Specific
1542                  * or Group-and-Source-Specific query by enqueueing
1543                  * the appropriate Current-State report for
1544                  * immediate transmission.
1545                  */
1546                 if (query_response_timer_expired) {
1547                         int retval;
1548
1549                         retval = mld_v2_enqueue_group_record(qrq, inm, 0, 1,
1550                             (inm->in6m_state == MLD_SG_QUERY_PENDING_MEMBER),
1551                             0);
1552                         CTR2(KTR_MLD, "%s: enqueue record = %d",
1553                             __func__, retval);
1554                         inm->in6m_state = MLD_REPORTING_MEMBER;
1555                         in6m_clear_recorded(inm);
1556                 }
1557                 /* FALLTHROUGH */
1558         case MLD_REPORTING_MEMBER:
1559         case MLD_LEAVING_MEMBER:
1560                 if (state_change_retransmit_timer_expired) {
1561                         /*
1562                          * State-change retransmission timer fired.
1563                          * If there are any further pending retransmissions,
1564                          * set the global pending state-change flag, and
1565                          * reset the timer.
1566                          */
1567                         if (--inm->in6m_scrv > 0) {
1568                                 inm->in6m_sctimer = uri_fasthz;
1569                                 V_state_change_timers_running6 = 1;
1570                         }
1571                         /*
1572                          * Retransmit the previously computed state-change
1573                          * report. If there are no further pending
1574                          * retransmissions, the mbuf queue will be consumed.
1575                          * Update T0 state to T1 as we have now sent
1576                          * a state-change.
1577                          */
1578                         (void)mld_v2_merge_state_changes(inm, scq);
1579
1580                         in6m_commit(inm);
1581                         CTR3(KTR_MLD, "%s: T1 -> T0 for %s/%s", __func__,
1582                             ip6_sprintf(ip6tbuf, &inm->in6m_addr),
1583                             if_name(inm->in6m_ifp));
1584
1585                         /*
1586                          * If we are leaving the group for good, make sure
1587                          * we release MLD's reference to it.
1588                          * This release must be deferred using a SLIST,
1589                          * as we are called from a loop which traverses
1590                          * the in_ifmultiaddr TAILQ.
1591                          */
1592                         if (inm->in6m_state == MLD_LEAVING_MEMBER &&
1593                             inm->in6m_scrv == 0) {
1594                                 inm->in6m_state = MLD_NOT_MEMBER;
1595                                 in6m_disconnect_locked(inmh, inm);
1596                                 in6m_rele_locked(inmh, inm);
1597                         }
1598                 }
1599                 break;
1600         }
1601 }
1602
1603 /*
1604  * Switch to a different version on the given interface,
1605  * as per Section 9.12.
1606  */
1607 static void
1608 mld_set_version(struct mld_ifsoftc *mli, const int version)
1609 {
1610         int old_version_timer;
1611
1612         MLD_LOCK_ASSERT();
1613
1614         CTR4(KTR_MLD, "%s: switching to v%d on ifp %p(%s)", __func__,
1615             version, mli->mli_ifp, if_name(mli->mli_ifp));
1616
1617         if (version == MLD_VERSION_1) {
1618                 /*
1619                  * Compute the "Older Version Querier Present" timer as per
1620                  * Section 9.12.
1621                  */
1622                 old_version_timer = (mli->mli_rv * mli->mli_qi) + mli->mli_qri;
1623                 old_version_timer *= PR_SLOWHZ;
1624                 mli->mli_v1_timer = old_version_timer;
1625         }
1626
1627         if (mli->mli_v1_timer > 0 && mli->mli_version != MLD_VERSION_1) {
1628                 mli->mli_version = MLD_VERSION_1;
1629                 mld_v2_cancel_link_timers(mli);
1630         }
1631 }
1632
1633 /*
1634  * Cancel pending MLDv2 timers for the given link and all groups
1635  * joined on it; state-change, general-query, and group-query timers.
1636  */
1637 static void
1638 mld_v2_cancel_link_timers(struct mld_ifsoftc *mli)
1639 {
1640         struct epoch_tracker     et;
1641         struct in6_multi_head    inmh;
1642         struct ifmultiaddr      *ifma;
1643         struct ifnet            *ifp;
1644         struct in6_multi        *inm;
1645
1646         CTR3(KTR_MLD, "%s: cancel v2 timers on ifp %p(%s)", __func__,
1647             mli->mli_ifp, if_name(mli->mli_ifp));
1648
1649         SLIST_INIT(&inmh);
1650         IN6_MULTI_LIST_LOCK_ASSERT();
1651         MLD_LOCK_ASSERT();
1652
1653         /*
1654          * Fast-track this potentially expensive operation
1655          * by checking all the global 'timer pending' flags.
1656          */
1657         if (!V_interface_timers_running6 &&
1658             !V_state_change_timers_running6 &&
1659             !V_current_state_timers_running6)
1660                 return;
1661
1662         mli->mli_v2_timer = 0;
1663
1664         ifp = mli->mli_ifp;
1665
1666         IF_ADDR_WLOCK(ifp);
1667         NET_EPOCH_ENTER(et);
1668         CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1669                 inm = in6m_ifmultiaddr_get_inm(ifma);
1670                 if (inm == NULL)
1671                         continue;
1672                 switch (inm->in6m_state) {
1673                 case MLD_NOT_MEMBER:
1674                 case MLD_SILENT_MEMBER:
1675                 case MLD_IDLE_MEMBER:
1676                 case MLD_LAZY_MEMBER:
1677                 case MLD_SLEEPING_MEMBER:
1678                 case MLD_AWAKENING_MEMBER:
1679                         break;
1680                 case MLD_LEAVING_MEMBER:
1681                         /*
1682                          * If we are leaving the group and switching
1683                          * version, we need to release the final
1684                          * reference held for issuing the INCLUDE {}.
1685                          */
1686                         if (inm->in6m_refcount == 1)
1687                                 in6m_disconnect_locked(&inmh, inm);
1688                         in6m_rele_locked(&inmh, inm);
1689                         /* FALLTHROUGH */
1690                 case MLD_G_QUERY_PENDING_MEMBER:
1691                 case MLD_SG_QUERY_PENDING_MEMBER:
1692                         in6m_clear_recorded(inm);
1693                         /* FALLTHROUGH */
1694                 case MLD_REPORTING_MEMBER:
1695                         inm->in6m_sctimer = 0;
1696                         inm->in6m_timer = 0;
1697                         inm->in6m_state = MLD_REPORTING_MEMBER;
1698                         /*
1699                          * Free any pending MLDv2 state-change records.
1700                          */
1701                         mbufq_drain(&inm->in6m_scq);
1702                         break;
1703                 }
1704         }
1705         NET_EPOCH_EXIT(et);
1706         IF_ADDR_WUNLOCK(ifp);
1707         in6m_release_list_deferred(&inmh);
1708 }
1709
1710 /*
1711  * Global slowtimo handler.
1712  * VIMAGE: Timeout handlers are expected to service all vimages.
1713  */
1714 void
1715 mld_slowtimo(void)
1716 {
1717         VNET_ITERATOR_DECL(vnet_iter);
1718
1719         VNET_LIST_RLOCK_NOSLEEP();
1720         VNET_FOREACH(vnet_iter) {
1721                 CURVNET_SET(vnet_iter);
1722                 mld_slowtimo_vnet();
1723                 CURVNET_RESTORE();
1724         }
1725         VNET_LIST_RUNLOCK_NOSLEEP();
1726 }
1727
1728 /*
1729  * Per-vnet slowtimo handler.
1730  */
1731 static void
1732 mld_slowtimo_vnet(void)
1733 {
1734         struct mld_ifsoftc *mli;
1735
1736         MLD_LOCK();
1737
1738         LIST_FOREACH(mli, &V_mli_head, mli_link) {
1739                 mld_v1_process_querier_timers(mli);
1740         }
1741
1742         MLD_UNLOCK();
1743 }
1744
1745 /*
1746  * Update the Older Version Querier Present timers for a link.
1747  * See Section 9.12 of RFC 3810.
1748  */
1749 static void
1750 mld_v1_process_querier_timers(struct mld_ifsoftc *mli)
1751 {
1752
1753         MLD_LOCK_ASSERT();
1754
1755         if (mli->mli_version != MLD_VERSION_2 && --mli->mli_v1_timer == 0) {
1756                 /*
1757                  * MLDv1 Querier Present timer expired; revert to MLDv2.
1758                  */
1759                 CTR5(KTR_MLD,
1760                     "%s: transition from v%d -> v%d on %p(%s)",
1761                     __func__, mli->mli_version, MLD_VERSION_2,
1762                     mli->mli_ifp, if_name(mli->mli_ifp));
1763                 mli->mli_version = MLD_VERSION_2;
1764         }
1765 }
1766
1767 /*
1768  * Transmit an MLDv1 report immediately.
1769  */
1770 static int
1771 mld_v1_transmit_report(struct in6_multi *in6m, const int type)
1772 {
1773         struct ifnet            *ifp;
1774         struct in6_ifaddr       *ia;
1775         struct ip6_hdr          *ip6;
1776         struct mbuf             *mh, *md;
1777         struct mld_hdr          *mld;
1778
1779         NET_EPOCH_ASSERT();
1780         IN6_MULTI_LIST_LOCK_ASSERT();
1781         MLD_LOCK_ASSERT();
1782
1783         ifp = in6m->in6m_ifp;
1784         /* in process of being freed */
1785         if (ifp == NULL)
1786                 return (0);
1787         ia = in6ifa_ifpforlinklocal(ifp, IN6_IFF_NOTREADY|IN6_IFF_ANYCAST);
1788         /* ia may be NULL if link-local address is tentative. */
1789
1790         mh = m_gethdr(M_NOWAIT, MT_DATA);
1791         if (mh == NULL) {
1792                 if (ia != NULL)
1793                         ifa_free(&ia->ia_ifa);
1794                 return (ENOMEM);
1795         }
1796         md = m_get(M_NOWAIT, MT_DATA);
1797         if (md == NULL) {
1798                 m_free(mh);
1799                 if (ia != NULL)
1800                         ifa_free(&ia->ia_ifa);
1801                 return (ENOMEM);
1802         }
1803         mh->m_next = md;
1804
1805         /*
1806          * FUTURE: Consider increasing alignment by ETHER_HDR_LEN, so
1807          * that ether_output() does not need to allocate another mbuf
1808          * for the header in the most common case.
1809          */
1810         M_ALIGN(mh, sizeof(struct ip6_hdr));
1811         mh->m_pkthdr.len = sizeof(struct ip6_hdr) + sizeof(struct mld_hdr);
1812         mh->m_len = sizeof(struct ip6_hdr);
1813
1814         ip6 = mtod(mh, struct ip6_hdr *);
1815         ip6->ip6_flow = 0;
1816         ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
1817         ip6->ip6_vfc |= IPV6_VERSION;
1818         ip6->ip6_nxt = IPPROTO_ICMPV6;
1819         ip6->ip6_src = ia ? ia->ia_addr.sin6_addr : in6addr_any;
1820         ip6->ip6_dst = in6m->in6m_addr;
1821
1822         md->m_len = sizeof(struct mld_hdr);
1823         mld = mtod(md, struct mld_hdr *);
1824         mld->mld_type = type;
1825         mld->mld_code = 0;
1826         mld->mld_cksum = 0;
1827         mld->mld_maxdelay = 0;
1828         mld->mld_reserved = 0;
1829         mld->mld_addr = in6m->in6m_addr;
1830         in6_clearscope(&mld->mld_addr);
1831         mld->mld_cksum = in6_cksum(mh, IPPROTO_ICMPV6,
1832             sizeof(struct ip6_hdr), sizeof(struct mld_hdr));
1833
1834         mld_save_context(mh, ifp);
1835         mh->m_flags |= M_MLDV1;
1836
1837         mld_dispatch_packet(mh);
1838
1839         if (ia != NULL)
1840                 ifa_free(&ia->ia_ifa);
1841         return (0);
1842 }
1843
1844 /*
1845  * Process a state change from the upper layer for the given IPv6 group.
1846  *
1847  * Each socket holds a reference on the in_multi in its own ip_moptions.
1848  * The socket layer will have made the necessary updates to.the group
1849  * state, it is now up to MLD to issue a state change report if there
1850  * has been any change between T0 (when the last state-change was issued)
1851  * and T1 (now).
1852  *
1853  * We use the MLDv2 state machine at group level. The MLd module
1854  * however makes the decision as to which MLD protocol version to speak.
1855  * A state change *from* INCLUDE {} always means an initial join.
1856  * A state change *to* INCLUDE {} always means a final leave.
1857  *
1858  * If delay is non-zero, and the state change is an initial multicast
1859  * join, the state change report will be delayed by 'delay' ticks
1860  * in units of PR_FASTHZ if MLDv1 is active on the link; otherwise
1861  * the initial MLDv2 state change report will be delayed by whichever
1862  * is sooner, a pending state-change timer or delay itself.
1863  *
1864  * VIMAGE: curvnet should have been set by caller, as this routine
1865  * is called from the socket option handlers.
1866  */
1867 int
1868 mld_change_state(struct in6_multi *inm, const int delay)
1869 {
1870         struct mld_ifsoftc *mli;
1871         struct ifnet *ifp;
1872         int error;
1873
1874         IN6_MULTI_LIST_LOCK_ASSERT();
1875
1876         error = 0;
1877
1878         /*
1879          * Check if the in6_multi has already been disconnected.
1880          */
1881         if (inm->in6m_ifp == NULL) {
1882                 CTR1(KTR_MLD, "%s: inm is disconnected", __func__);
1883                 return (0);
1884         }
1885
1886         /*
1887          * Try to detect if the upper layer just asked us to change state
1888          * for an interface which has now gone away.
1889          */
1890         KASSERT(inm->in6m_ifma != NULL, ("%s: no ifma", __func__));
1891         ifp = inm->in6m_ifma->ifma_ifp;
1892         if (ifp == NULL)
1893                 return (0);
1894         /*
1895          * Sanity check that netinet6's notion of ifp is the
1896          * same as net's.
1897          */
1898         KASSERT(inm->in6m_ifp == ifp, ("%s: bad ifp", __func__));
1899
1900         MLD_LOCK();
1901         mli = MLD_IFINFO(ifp);
1902         KASSERT(mli != NULL, ("%s: no mld_ifsoftc for ifp %p", __func__, ifp));
1903
1904         /*
1905          * If we detect a state transition to or from MCAST_UNDEFINED
1906          * for this group, then we are starting or finishing an MLD
1907          * life cycle for this group.
1908          */
1909         if (inm->in6m_st[1].iss_fmode != inm->in6m_st[0].iss_fmode) {
1910                 CTR3(KTR_MLD, "%s: inm transition %d -> %d", __func__,
1911                     inm->in6m_st[0].iss_fmode, inm->in6m_st[1].iss_fmode);
1912                 if (inm->in6m_st[0].iss_fmode == MCAST_UNDEFINED) {
1913                         CTR1(KTR_MLD, "%s: initial join", __func__);
1914                         error = mld_initial_join(inm, mli, delay);
1915                         goto out_locked;
1916                 } else if (inm->in6m_st[1].iss_fmode == MCAST_UNDEFINED) {
1917                         CTR1(KTR_MLD, "%s: final leave", __func__);
1918                         mld_final_leave(inm, mli);
1919                         goto out_locked;
1920                 }
1921         } else {
1922                 CTR1(KTR_MLD, "%s: filter set change", __func__);
1923         }
1924
1925         error = mld_handle_state_change(inm, mli);
1926
1927 out_locked:
1928         MLD_UNLOCK();
1929         return (error);
1930 }
1931
1932 /*
1933  * Perform the initial join for an MLD group.
1934  *
1935  * When joining a group:
1936  *  If the group should have its MLD traffic suppressed, do nothing.
1937  *  MLDv1 starts sending MLDv1 host membership reports.
1938  *  MLDv2 will schedule an MLDv2 state-change report containing the
1939  *  initial state of the membership.
1940  *
1941  * If the delay argument is non-zero, then we must delay sending the
1942  * initial state change for delay ticks (in units of PR_FASTHZ).
1943  */
1944 static int
1945 mld_initial_join(struct in6_multi *inm, struct mld_ifsoftc *mli,
1946     const int delay)
1947 {
1948         struct epoch_tracker     et;
1949         struct ifnet            *ifp;
1950         struct mbufq            *mq;
1951         int                      error, retval, syncstates;
1952         int                      odelay;
1953 #ifdef KTR
1954         char                     ip6tbuf[INET6_ADDRSTRLEN];
1955 #endif
1956
1957         CTR4(KTR_MLD, "%s: initial join %s on ifp %p(%s)",
1958             __func__, ip6_sprintf(ip6tbuf, &inm->in6m_addr),
1959             inm->in6m_ifp, if_name(inm->in6m_ifp));
1960
1961         error = 0;
1962         syncstates = 1;
1963
1964         ifp = inm->in6m_ifp;
1965
1966         IN6_MULTI_LIST_LOCK_ASSERT();
1967         MLD_LOCK_ASSERT();
1968
1969         KASSERT(mli && mli->mli_ifp == ifp, ("%s: inconsistent ifp", __func__));
1970
1971         /*
1972          * Groups joined on loopback or marked as 'not reported',
1973          * enter the MLD_SILENT_MEMBER state and
1974          * are never reported in any protocol exchanges.
1975          * All other groups enter the appropriate state machine
1976          * for the version in use on this link.
1977          * A link marked as MLIF_SILENT causes MLD to be completely
1978          * disabled for the link.
1979          */
1980         if ((ifp->if_flags & IFF_LOOPBACK) ||
1981             (mli->mli_flags & MLIF_SILENT) ||
1982             !mld_is_addr_reported(&inm->in6m_addr)) {
1983                 CTR1(KTR_MLD,
1984 "%s: not kicking state machine for silent group", __func__);
1985                 inm->in6m_state = MLD_SILENT_MEMBER;
1986                 inm->in6m_timer = 0;
1987         } else {
1988                 /*
1989                  * Deal with overlapping in_multi lifecycle.
1990                  * If this group was LEAVING, then make sure
1991                  * we drop the reference we picked up to keep the
1992                  * group around for the final INCLUDE {} enqueue.
1993                  */
1994                 if (mli->mli_version == MLD_VERSION_2 &&
1995                     inm->in6m_state == MLD_LEAVING_MEMBER) {
1996                         inm->in6m_refcount--;
1997                         MPASS(inm->in6m_refcount > 0);
1998                 }
1999                 inm->in6m_state = MLD_REPORTING_MEMBER;
2000
2001                 switch (mli->mli_version) {
2002                 case MLD_VERSION_1:
2003                         /*
2004                          * If a delay was provided, only use it if
2005                          * it is greater than the delay normally
2006                          * used for an MLDv1 state change report,
2007                          * and delay sending the initial MLDv1 report
2008                          * by not transitioning to the IDLE state.
2009                          */
2010                         odelay = MLD_RANDOM_DELAY(MLD_V1_MAX_RI * PR_FASTHZ);
2011                         if (delay) {
2012                                 inm->in6m_timer = max(delay, odelay);
2013                                 V_current_state_timers_running6 = 1;
2014                         } else {
2015                                 inm->in6m_state = MLD_IDLE_MEMBER;
2016                                 NET_EPOCH_ENTER(et);
2017                                 error = mld_v1_transmit_report(inm,
2018                                      MLD_LISTENER_REPORT);
2019                                 NET_EPOCH_EXIT(et);
2020                                 if (error == 0) {
2021                                         inm->in6m_timer = odelay;
2022                                         V_current_state_timers_running6 = 1;
2023                                 }
2024                         }
2025                         break;
2026
2027                 case MLD_VERSION_2:
2028                         /*
2029                          * Defer update of T0 to T1, until the first copy
2030                          * of the state change has been transmitted.
2031                          */
2032                         syncstates = 0;
2033
2034                         /*
2035                          * Immediately enqueue a State-Change Report for
2036                          * this interface, freeing any previous reports.
2037                          * Don't kick the timers if there is nothing to do,
2038                          * or if an error occurred.
2039                          */
2040                         mq = &inm->in6m_scq;
2041                         mbufq_drain(mq);
2042                         retval = mld_v2_enqueue_group_record(mq, inm, 1,
2043                             0, 0, (mli->mli_flags & MLIF_USEALLOW));
2044                         CTR2(KTR_MLD, "%s: enqueue record = %d",
2045                             __func__, retval);
2046                         if (retval <= 0) {
2047                                 error = retval * -1;
2048                                 break;
2049                         }
2050
2051                         /*
2052                          * Schedule transmission of pending state-change
2053                          * report up to RV times for this link. The timer
2054                          * will fire at the next mld_fasttimo (~200ms),
2055                          * giving us an opportunity to merge the reports.
2056                          *
2057                          * If a delay was provided to this function, only
2058                          * use this delay if sooner than the existing one.
2059                          */
2060                         KASSERT(mli->mli_rv > 1,
2061                            ("%s: invalid robustness %d", __func__,
2062                             mli->mli_rv));
2063                         inm->in6m_scrv = mli->mli_rv;
2064                         if (delay) {
2065                                 if (inm->in6m_sctimer > 1) {
2066                                         inm->in6m_sctimer =
2067                                             min(inm->in6m_sctimer, delay);
2068                                 } else
2069                                         inm->in6m_sctimer = delay;
2070                         } else
2071                                 inm->in6m_sctimer = 1;
2072                         V_state_change_timers_running6 = 1;
2073
2074                         error = 0;
2075                         break;
2076                 }
2077         }
2078
2079         /*
2080          * Only update the T0 state if state change is atomic,
2081          * i.e. we don't need to wait for a timer to fire before we
2082          * can consider the state change to have been communicated.
2083          */
2084         if (syncstates) {
2085                 in6m_commit(inm);
2086                 CTR3(KTR_MLD, "%s: T1 -> T0 for %s/%s", __func__,
2087                     ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2088                     if_name(inm->in6m_ifp));
2089         }
2090
2091         return (error);
2092 }
2093
2094 /*
2095  * Issue an intermediate state change during the life-cycle.
2096  */
2097 static int
2098 mld_handle_state_change(struct in6_multi *inm, struct mld_ifsoftc *mli)
2099 {
2100         struct ifnet            *ifp;
2101         int                      retval;
2102 #ifdef KTR
2103         char                     ip6tbuf[INET6_ADDRSTRLEN];
2104 #endif
2105
2106         CTR4(KTR_MLD, "%s: state change for %s on ifp %p(%s)",
2107             __func__, ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2108             inm->in6m_ifp, if_name(inm->in6m_ifp));
2109
2110         ifp = inm->in6m_ifp;
2111
2112         IN6_MULTI_LIST_LOCK_ASSERT();
2113         MLD_LOCK_ASSERT();
2114
2115         KASSERT(mli && mli->mli_ifp == ifp,
2116             ("%s: inconsistent ifp", __func__));
2117
2118         if ((ifp->if_flags & IFF_LOOPBACK) ||
2119             (mli->mli_flags & MLIF_SILENT) ||
2120             !mld_is_addr_reported(&inm->in6m_addr) ||
2121             (mli->mli_version != MLD_VERSION_2)) {
2122                 if (!mld_is_addr_reported(&inm->in6m_addr)) {
2123                         CTR1(KTR_MLD,
2124 "%s: not kicking state machine for silent group", __func__);
2125                 }
2126                 CTR1(KTR_MLD, "%s: nothing to do", __func__);
2127                 in6m_commit(inm);
2128                 CTR3(KTR_MLD, "%s: T1 -> T0 for %s/%s", __func__,
2129                     ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2130                     if_name(inm->in6m_ifp));
2131                 return (0);
2132         }
2133
2134         mbufq_drain(&inm->in6m_scq);
2135
2136         retval = mld_v2_enqueue_group_record(&inm->in6m_scq, inm, 1, 0, 0,
2137             (mli->mli_flags & MLIF_USEALLOW));
2138         CTR2(KTR_MLD, "%s: enqueue record = %d", __func__, retval);
2139         if (retval <= 0)
2140                 return (-retval);
2141
2142         /*
2143          * If record(s) were enqueued, start the state-change
2144          * report timer for this group.
2145          */
2146         inm->in6m_scrv = mli->mli_rv;
2147         inm->in6m_sctimer = 1;
2148         V_state_change_timers_running6 = 1;
2149
2150         return (0);
2151 }
2152
2153 /*
2154  * Perform the final leave for a multicast address.
2155  *
2156  * When leaving a group:
2157  *  MLDv1 sends a DONE message, if and only if we are the reporter.
2158  *  MLDv2 enqueues a state-change report containing a transition
2159  *  to INCLUDE {} for immediate transmission.
2160  */
2161 static void
2162 mld_final_leave(struct in6_multi *inm, struct mld_ifsoftc *mli)
2163 {
2164         struct epoch_tracker     et;
2165         int syncstates;
2166 #ifdef KTR
2167         char ip6tbuf[INET6_ADDRSTRLEN];
2168 #endif
2169
2170         syncstates = 1;
2171
2172         CTR4(KTR_MLD, "%s: final leave %s on ifp %p(%s)",
2173             __func__, ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2174             inm->in6m_ifp, if_name(inm->in6m_ifp));
2175
2176         IN6_MULTI_LIST_LOCK_ASSERT();
2177         MLD_LOCK_ASSERT();
2178
2179         switch (inm->in6m_state) {
2180         case MLD_NOT_MEMBER:
2181         case MLD_SILENT_MEMBER:
2182         case MLD_LEAVING_MEMBER:
2183                 /* Already leaving or left; do nothing. */
2184                 CTR1(KTR_MLD,
2185 "%s: not kicking state machine for silent group", __func__);
2186                 break;
2187         case MLD_REPORTING_MEMBER:
2188         case MLD_IDLE_MEMBER:
2189         case MLD_G_QUERY_PENDING_MEMBER:
2190         case MLD_SG_QUERY_PENDING_MEMBER:
2191                 if (mli->mli_version == MLD_VERSION_1) {
2192 #ifdef INVARIANTS
2193                         if (inm->in6m_state == MLD_G_QUERY_PENDING_MEMBER ||
2194                             inm->in6m_state == MLD_SG_QUERY_PENDING_MEMBER)
2195                         panic("%s: MLDv2 state reached, not MLDv2 mode",
2196                              __func__);
2197 #endif
2198                         NET_EPOCH_ENTER(et);
2199                         mld_v1_transmit_report(inm, MLD_LISTENER_DONE);
2200                         NET_EPOCH_EXIT(et);
2201                         inm->in6m_state = MLD_NOT_MEMBER;
2202                         V_current_state_timers_running6 = 1;
2203                 } else if (mli->mli_version == MLD_VERSION_2) {
2204                         /*
2205                          * Stop group timer and all pending reports.
2206                          * Immediately enqueue a state-change report
2207                          * TO_IN {} to be sent on the next fast timeout,
2208                          * giving us an opportunity to merge reports.
2209                          */
2210                         mbufq_drain(&inm->in6m_scq);
2211                         inm->in6m_timer = 0;
2212                         inm->in6m_scrv = mli->mli_rv;
2213                         CTR4(KTR_MLD, "%s: Leaving %s/%s with %d "
2214                             "pending retransmissions.", __func__,
2215                             ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2216                             if_name(inm->in6m_ifp), inm->in6m_scrv);
2217                         if (inm->in6m_scrv == 0) {
2218                                 inm->in6m_state = MLD_NOT_MEMBER;
2219                                 inm->in6m_sctimer = 0;
2220                         } else {
2221                                 int retval;
2222
2223                                 in6m_acquire_locked(inm);
2224
2225                                 retval = mld_v2_enqueue_group_record(
2226                                     &inm->in6m_scq, inm, 1, 0, 0,
2227                                     (mli->mli_flags & MLIF_USEALLOW));
2228                                 KASSERT(retval != 0,
2229                                     ("%s: enqueue record = %d", __func__,
2230                                      retval));
2231
2232                                 inm->in6m_state = MLD_LEAVING_MEMBER;
2233                                 inm->in6m_sctimer = 1;
2234                                 V_state_change_timers_running6 = 1;
2235                                 syncstates = 0;
2236                         }
2237                         break;
2238                 }
2239                 break;
2240         case MLD_LAZY_MEMBER:
2241         case MLD_SLEEPING_MEMBER:
2242         case MLD_AWAKENING_MEMBER:
2243                 /* Our reports are suppressed; do nothing. */
2244                 break;
2245         }
2246
2247         if (syncstates) {
2248                 in6m_commit(inm);
2249                 CTR3(KTR_MLD, "%s: T1 -> T0 for %s/%s", __func__,
2250                     ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2251                     if_name(inm->in6m_ifp));
2252                 inm->in6m_st[1].iss_fmode = MCAST_UNDEFINED;
2253                 CTR3(KTR_MLD, "%s: T1 now MCAST_UNDEFINED for %p/%s",
2254                     __func__, &inm->in6m_addr, if_name(inm->in6m_ifp));
2255         }
2256 }
2257
2258 /*
2259  * Enqueue an MLDv2 group record to the given output queue.
2260  *
2261  * If is_state_change is zero, a current-state record is appended.
2262  * If is_state_change is non-zero, a state-change report is appended.
2263  *
2264  * If is_group_query is non-zero, an mbuf packet chain is allocated.
2265  * If is_group_query is zero, and if there is a packet with free space
2266  * at the tail of the queue, it will be appended to providing there
2267  * is enough free space.
2268  * Otherwise a new mbuf packet chain is allocated.
2269  *
2270  * If is_source_query is non-zero, each source is checked to see if
2271  * it was recorded for a Group-Source query, and will be omitted if
2272  * it is not both in-mode and recorded.
2273  *
2274  * If use_block_allow is non-zero, state change reports for initial join
2275  * and final leave, on an inclusive mode group with a source list, will be
2276  * rewritten to use the ALLOW_NEW and BLOCK_OLD record types, respectively.
2277  *
2278  * The function will attempt to allocate leading space in the packet
2279  * for the IPv6+ICMP headers to be prepended without fragmenting the chain.
2280  *
2281  * If successful the size of all data appended to the queue is returned,
2282  * otherwise an error code less than zero is returned, or zero if
2283  * no record(s) were appended.
2284  */
2285 static int
2286 mld_v2_enqueue_group_record(struct mbufq *mq, struct in6_multi *inm,
2287     const int is_state_change, const int is_group_query,
2288     const int is_source_query, const int use_block_allow)
2289 {
2290         struct mldv2_record      mr;
2291         struct mldv2_record     *pmr;
2292         struct ifnet            *ifp;
2293         struct ip6_msource      *ims, *nims;
2294         struct mbuf             *m0, *m, *md;
2295         int                      is_filter_list_change;
2296         int                      minrec0len, m0srcs, msrcs, nbytes, off;
2297         int                      record_has_sources;
2298         int                      now;
2299         int                      type;
2300         uint8_t                  mode;
2301 #ifdef KTR
2302         char                     ip6tbuf[INET6_ADDRSTRLEN];
2303 #endif
2304
2305         IN6_MULTI_LIST_LOCK_ASSERT();
2306
2307         ifp = inm->in6m_ifp;
2308         is_filter_list_change = 0;
2309         m = NULL;
2310         m0 = NULL;
2311         m0srcs = 0;
2312         msrcs = 0;
2313         nbytes = 0;
2314         nims = NULL;
2315         record_has_sources = 1;
2316         pmr = NULL;
2317         type = MLD_DO_NOTHING;
2318         mode = inm->in6m_st[1].iss_fmode;
2319
2320         /*
2321          * If we did not transition out of ASM mode during t0->t1,
2322          * and there are no source nodes to process, we can skip
2323          * the generation of source records.
2324          */
2325         if (inm->in6m_st[0].iss_asm > 0 && inm->in6m_st[1].iss_asm > 0 &&
2326             inm->in6m_nsrc == 0)
2327                 record_has_sources = 0;
2328
2329         if (is_state_change) {
2330                 /*
2331                  * Queue a state change record.
2332                  * If the mode did not change, and there are non-ASM
2333                  * listeners or source filters present,
2334                  * we potentially need to issue two records for the group.
2335                  * If there are ASM listeners, and there was no filter
2336                  * mode transition of any kind, do nothing.
2337                  *
2338                  * If we are transitioning to MCAST_UNDEFINED, we need
2339                  * not send any sources. A transition to/from this state is
2340                  * considered inclusive with some special treatment.
2341                  *
2342                  * If we are rewriting initial joins/leaves to use
2343                  * ALLOW/BLOCK, and the group's membership is inclusive,
2344                  * we need to send sources in all cases.
2345                  */
2346                 if (mode != inm->in6m_st[0].iss_fmode) {
2347                         if (mode == MCAST_EXCLUDE) {
2348                                 CTR1(KTR_MLD, "%s: change to EXCLUDE",
2349                                     __func__);
2350                                 type = MLD_CHANGE_TO_EXCLUDE_MODE;
2351                         } else {
2352                                 CTR1(KTR_MLD, "%s: change to INCLUDE",
2353                                     __func__);
2354                                 if (use_block_allow) {
2355                                         /*
2356                                          * XXX
2357                                          * Here we're interested in state
2358                                          * edges either direction between
2359                                          * MCAST_UNDEFINED and MCAST_INCLUDE.
2360                                          * Perhaps we should just check
2361                                          * the group state, rather than
2362                                          * the filter mode.
2363                                          */
2364                                         if (mode == MCAST_UNDEFINED) {
2365                                                 type = MLD_BLOCK_OLD_SOURCES;
2366                                         } else {
2367                                                 type = MLD_ALLOW_NEW_SOURCES;
2368                                         }
2369                                 } else {
2370                                         type = MLD_CHANGE_TO_INCLUDE_MODE;
2371                                         if (mode == MCAST_UNDEFINED)
2372                                                 record_has_sources = 0;
2373                                 }
2374                         }
2375                 } else {
2376                         if (record_has_sources) {
2377                                 is_filter_list_change = 1;
2378                         } else {
2379                                 type = MLD_DO_NOTHING;
2380                         }
2381                 }
2382         } else {
2383                 /*
2384                  * Queue a current state record.
2385                  */
2386                 if (mode == MCAST_EXCLUDE) {
2387                         type = MLD_MODE_IS_EXCLUDE;
2388                 } else if (mode == MCAST_INCLUDE) {
2389                         type = MLD_MODE_IS_INCLUDE;
2390                         KASSERT(inm->in6m_st[1].iss_asm == 0,
2391                             ("%s: inm %p is INCLUDE but ASM count is %d",
2392                              __func__, inm, inm->in6m_st[1].iss_asm));
2393                 }
2394         }
2395
2396         /*
2397          * Generate the filter list changes using a separate function.
2398          */
2399         if (is_filter_list_change)
2400                 return (mld_v2_enqueue_filter_change(mq, inm));
2401
2402         if (type == MLD_DO_NOTHING) {
2403                 CTR3(KTR_MLD, "%s: nothing to do for %s/%s",
2404                     __func__, ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2405                     if_name(inm->in6m_ifp));
2406                 return (0);
2407         }
2408
2409         /*
2410          * If any sources are present, we must be able to fit at least
2411          * one in the trailing space of the tail packet's mbuf,
2412          * ideally more.
2413          */
2414         minrec0len = sizeof(struct mldv2_record);
2415         if (record_has_sources)
2416                 minrec0len += sizeof(struct in6_addr);
2417
2418         CTR4(KTR_MLD, "%s: queueing %s for %s/%s", __func__,
2419             mld_rec_type_to_str(type),
2420             ip6_sprintf(ip6tbuf, &inm->in6m_addr),
2421             if_name(inm->in6m_ifp));
2422
2423         /*
2424          * Check if we have a packet in the tail of the queue for this
2425          * group into which the first group record for this group will fit.
2426          * Otherwise allocate a new packet.
2427          * Always allocate leading space for IP6+RA+ICMPV6+REPORT.
2428          * Note: Group records for G/GSR query responses MUST be sent
2429          * in their own packet.
2430          */
2431         m0 = mbufq_last(mq);
2432         if (!is_group_query &&
2433             m0 != NULL &&
2434             (m0->m_pkthdr.PH_vt.vt_nrecs + 1 <= MLD_V2_REPORT_MAXRECS) &&
2435             (m0->m_pkthdr.len + minrec0len) <
2436              (ifp->if_mtu - MLD_MTUSPACE)) {
2437                 m0srcs = (ifp->if_mtu - m0->m_pkthdr.len -
2438                             sizeof(struct mldv2_record)) /
2439                             sizeof(struct in6_addr);
2440                 m = m0;
2441                 CTR1(KTR_MLD, "%s: use existing packet", __func__);
2442         } else {
2443                 if (mbufq_full(mq)) {
2444                         CTR1(KTR_MLD, "%s: outbound queue full", __func__);
2445                         return (-ENOMEM);
2446                 }
2447                 m = NULL;
2448                 m0srcs = (ifp->if_mtu - MLD_MTUSPACE -
2449                     sizeof(struct mldv2_record)) / sizeof(struct in6_addr);
2450                 if (!is_state_change && !is_group_query)
2451                         m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
2452                 if (m == NULL)
2453                         m = m_gethdr(M_NOWAIT, MT_DATA);
2454                 if (m == NULL)
2455                         return (-ENOMEM);
2456
2457                 mld_save_context(m, ifp);
2458
2459                 CTR1(KTR_MLD, "%s: allocated first packet", __func__);
2460         }
2461
2462         /*
2463          * Append group record.
2464          * If we have sources, we don't know how many yet.
2465          */
2466         mr.mr_type = type;
2467         mr.mr_datalen = 0;
2468         mr.mr_numsrc = 0;
2469         mr.mr_addr = inm->in6m_addr;
2470         in6_clearscope(&mr.mr_addr);
2471         if (!m_append(m, sizeof(struct mldv2_record), (void *)&mr)) {
2472                 if (m != m0)
2473                         m_freem(m);
2474                 CTR1(KTR_MLD, "%s: m_append() failed.", __func__);
2475                 return (-ENOMEM);
2476         }
2477         nbytes += sizeof(struct mldv2_record);
2478
2479         /*
2480          * Append as many sources as will fit in the first packet.
2481          * If we are appending to a new packet, the chain allocation
2482          * may potentially use clusters; use m_getptr() in this case.
2483          * If we are appending to an existing packet, we need to obtain
2484          * a pointer to the group record after m_append(), in case a new
2485          * mbuf was allocated.
2486          *
2487          * Only append sources which are in-mode at t1. If we are
2488          * transitioning to MCAST_UNDEFINED state on the group, and
2489          * use_block_allow is zero, do not include source entries.
2490          * Otherwise, we need to include this source in the report.
2491          *
2492          * Only report recorded sources in our filter set when responding
2493          * to a group-source query.
2494          */
2495         if (record_has_sources) {
2496                 if (m == m0) {
2497                         md = m_last(m);
2498                         pmr = (struct mldv2_record *)(mtod(md, uint8_t *) +
2499                             md->m_len - nbytes);
2500                 } else {
2501                         md = m_getptr(m, 0, &off);
2502                         pmr = (struct mldv2_record *)(mtod(md, uint8_t *) +
2503                             off);
2504                 }
2505                 msrcs = 0;
2506                 RB_FOREACH_SAFE(ims, ip6_msource_tree, &inm->in6m_srcs,
2507                     nims) {
2508                         CTR2(KTR_MLD, "%s: visit node %s", __func__,
2509                             ip6_sprintf(ip6tbuf, &ims->im6s_addr));
2510                         now = im6s_get_mode(inm, ims, 1);
2511                         CTR2(KTR_MLD, "%s: node is %d", __func__, now);
2512                         if ((now != mode) ||
2513                             (now == mode &&
2514                              (!use_block_allow && mode == MCAST_UNDEFINED))) {
2515                                 CTR1(KTR_MLD, "%s: skip node", __func__);
2516                                 continue;
2517                         }
2518                         if (is_source_query && ims->im6s_stp == 0) {
2519                                 CTR1(KTR_MLD, "%s: skip unrecorded node",
2520                                     __func__);
2521                                 continue;
2522                         }
2523                         CTR1(KTR_MLD, "%s: append node", __func__);
2524                         if (!m_append(m, sizeof(struct in6_addr),
2525                             (void *)&ims->im6s_addr)) {
2526                                 if (m != m0)
2527                                         m_freem(m);
2528                                 CTR1(KTR_MLD, "%s: m_append() failed.",
2529                                     __func__);
2530                                 return (-ENOMEM);
2531                         }
2532                         nbytes += sizeof(struct in6_addr);
2533                         ++msrcs;
2534                         if (msrcs == m0srcs)
2535                                 break;
2536                 }
2537                 CTR2(KTR_MLD, "%s: msrcs is %d this packet", __func__,
2538                     msrcs);
2539                 pmr->mr_numsrc = htons(msrcs);
2540                 nbytes += (msrcs * sizeof(struct in6_addr));
2541         }
2542
2543         if (is_source_query && msrcs == 0) {
2544                 CTR1(KTR_MLD, "%s: no recorded sources to report", __func__);
2545                 if (m != m0)
2546                         m_freem(m);
2547                 return (0);
2548         }
2549
2550         /*
2551          * We are good to go with first packet.
2552          */
2553         if (m != m0) {
2554                 CTR1(KTR_MLD, "%s: enqueueing first packet", __func__);
2555                 m->m_pkthdr.PH_vt.vt_nrecs = 1;
2556                 mbufq_enqueue(mq, m);
2557         } else
2558                 m->m_pkthdr.PH_vt.vt_nrecs++;
2559
2560         /*
2561          * No further work needed if no source list in packet(s).
2562          */
2563         if (!record_has_sources)
2564                 return (nbytes);
2565
2566         /*
2567          * Whilst sources remain to be announced, we need to allocate
2568          * a new packet and fill out as many sources as will fit.
2569          * Always try for a cluster first.
2570          */
2571         while (nims != NULL) {
2572                 if (mbufq_full(mq)) {
2573                         CTR1(KTR_MLD, "%s: outbound queue full", __func__);
2574                         return (-ENOMEM);
2575                 }
2576                 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
2577                 if (m == NULL)
2578                         m = m_gethdr(M_NOWAIT, MT_DATA);
2579                 if (m == NULL)
2580                         return (-ENOMEM);
2581                 mld_save_context(m, ifp);
2582                 md = m_getptr(m, 0, &off);
2583                 pmr = (struct mldv2_record *)(mtod(md, uint8_t *) + off);
2584                 CTR1(KTR_MLD, "%s: allocated next packet", __func__);
2585
2586                 if (!m_append(m, sizeof(struct mldv2_record), (void *)&mr)) {
2587                         if (m != m0)
2588                                 m_freem(m);
2589                         CTR1(KTR_MLD, "%s: m_append() failed.", __func__);
2590                         return (-ENOMEM);
2591                 }
2592                 m->m_pkthdr.PH_vt.vt_nrecs = 1;
2593                 nbytes += sizeof(struct mldv2_record);
2594
2595                 m0srcs = (ifp->if_mtu - MLD_MTUSPACE -
2596                     sizeof(struct mldv2_record)) / sizeof(struct in6_addr);
2597
2598                 msrcs = 0;
2599                 RB_FOREACH_FROM(ims, ip6_msource_tree, nims) {
2600                         CTR2(KTR_MLD, "%s: visit node %s",
2601                             __func__, ip6_sprintf(ip6tbuf, &ims->im6s_addr));
2602                         now = im6s_get_mode(inm, ims, 1);
2603                         if ((now != mode) ||
2604                             (now == mode &&
2605                              (!use_block_allow && mode == MCAST_UNDEFINED))) {
2606                                 CTR1(KTR_MLD, "%s: skip node", __func__);
2607                                 continue;
2608                         }
2609                         if (is_source_query && ims->im6s_stp == 0) {
2610                                 CTR1(KTR_MLD, "%s: skip unrecorded node",
2611                                     __func__);
2612                                 continue;
2613                         }
2614                         CTR1(KTR_MLD, "%s: append node", __func__);
2615                         if (!m_append(m, sizeof(struct in6_addr),
2616                             (void *)&ims->im6s_addr)) {
2617                                 if (m != m0)
2618                                         m_freem(m);
2619                                 CTR1(KTR_MLD, "%s: m_append() failed.",
2620                                     __func__);
2621                                 return (-ENOMEM);
2622                         }
2623                         ++msrcs;
2624                         if (msrcs == m0srcs)
2625                                 break;
2626                 }
2627                 pmr->mr_numsrc = htons(msrcs);
2628                 nbytes += (msrcs * sizeof(struct in6_addr));
2629
2630                 CTR1(KTR_MLD, "%s: enqueueing next packet", __func__);
2631                 mbufq_enqueue(mq, m);
2632         }
2633
2634         return (nbytes);
2635 }
2636
2637 /*
2638  * Type used to mark record pass completion.
2639  * We exploit the fact we can cast to this easily from the
2640  * current filter modes on each ip_msource node.
2641  */
2642 typedef enum {
2643         REC_NONE = 0x00,        /* MCAST_UNDEFINED */
2644         REC_ALLOW = 0x01,       /* MCAST_INCLUDE */
2645         REC_BLOCK = 0x02,       /* MCAST_EXCLUDE */
2646         REC_FULL = REC_ALLOW | REC_BLOCK
2647 } rectype_t;
2648
2649 /*
2650  * Enqueue an MLDv2 filter list change to the given output queue.
2651  *
2652  * Source list filter state is held in an RB-tree. When the filter list
2653  * for a group is changed without changing its mode, we need to compute
2654  * the deltas between T0 and T1 for each source in the filter set,
2655  * and enqueue the appropriate ALLOW_NEW/BLOCK_OLD records.
2656  *
2657  * As we may potentially queue two record types, and the entire R-B tree
2658  * needs to be walked at once, we break this out into its own function
2659  * so we can generate a tightly packed queue of packets.
2660  *
2661  * XXX This could be written to only use one tree walk, although that makes
2662  * serializing into the mbuf chains a bit harder. For now we do two walks
2663  * which makes things easier on us, and it may or may not be harder on
2664  * the L2 cache.
2665  *
2666  * If successful the size of all data appended to the queue is returned,
2667  * otherwise an error code less than zero is returned, or zero if
2668  * no record(s) were appended.
2669  */
2670 static int
2671 mld_v2_enqueue_filter_change(struct mbufq *mq, struct in6_multi *inm)
2672 {
2673         static const int MINRECLEN =
2674             sizeof(struct mldv2_record) + sizeof(struct in6_addr);
2675         struct ifnet            *ifp;
2676         struct mldv2_record      mr;
2677         struct mldv2_record     *pmr;
2678         struct ip6_msource      *ims, *nims;
2679         struct mbuf             *m, *m0, *md;
2680         int                      m0srcs, nbytes, npbytes, off, rsrcs, schanged;
2681         int                      nallow, nblock;
2682         uint8_t                  mode, now, then;
2683         rectype_t                crt, drt, nrt;
2684 #ifdef KTR
2685         char                     ip6tbuf[INET6_ADDRSTRLEN];
2686 #endif
2687
2688         IN6_MULTI_LIST_LOCK_ASSERT();
2689
2690         if (inm->in6m_nsrc == 0 ||
2691             (inm->in6m_st[0].iss_asm > 0 && inm->in6m_st[1].iss_asm > 0))
2692                 return (0);
2693
2694         ifp = inm->in6m_ifp;                    /* interface */
2695         mode = inm->in6m_st[1].iss_fmode;       /* filter mode at t1 */
2696         crt = REC_NONE; /* current group record type */
2697         drt = REC_NONE; /* mask of completed group record types */
2698         nrt = REC_NONE; /* record type for current node */
2699         m0srcs = 0;     /* # source which will fit in current mbuf chain */
2700         npbytes = 0;    /* # of bytes appended this packet */
2701         nbytes = 0;     /* # of bytes appended to group's state-change queue */
2702         rsrcs = 0;      /* # sources encoded in current record */
2703         schanged = 0;   /* # nodes encoded in overall filter change */
2704         nallow = 0;     /* # of source entries in ALLOW_NEW */
2705         nblock = 0;     /* # of source entries in BLOCK_OLD */
2706         nims = NULL;    /* next tree node pointer */
2707
2708         /*
2709          * For each possible filter record mode.
2710          * The first kind of source we encounter tells us which
2711          * is the first kind of record we start appending.
2712          * If a node transitioned to UNDEFINED at t1, its mode is treated
2713          * as the inverse of the group's filter mode.
2714          */
2715         while (drt != REC_FULL) {
2716                 do {
2717                         m0 = mbufq_last(mq);
2718                         if (m0 != NULL &&
2719                             (m0->m_pkthdr.PH_vt.vt_nrecs + 1 <=
2720                              MLD_V2_REPORT_MAXRECS) &&
2721                             (m0->m_pkthdr.len + MINRECLEN) <
2722                              (ifp->if_mtu - MLD_MTUSPACE)) {
2723                                 m = m0;
2724                                 m0srcs = (ifp->if_mtu - m0->m_pkthdr.len -
2725                                             sizeof(struct mldv2_record)) /
2726                                             sizeof(struct in6_addr);
2727                                 CTR1(KTR_MLD,
2728                                     "%s: use previous packet", __func__);
2729                         } else {
2730                                 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
2731                                 if (m == NULL)
2732                                         m = m_gethdr(M_NOWAIT, MT_DATA);
2733                                 if (m == NULL) {
2734                                         CTR1(KTR_MLD,
2735                                             "%s: m_get*() failed", __func__);
2736                                         return (-ENOMEM);
2737                                 }
2738                                 m->m_pkthdr.PH_vt.vt_nrecs = 0;
2739                                 mld_save_context(m, ifp);
2740                                 m0srcs = (ifp->if_mtu - MLD_MTUSPACE -
2741                                     sizeof(struct mldv2_record)) /
2742                                     sizeof(struct in6_addr);
2743                                 npbytes = 0;
2744                                 CTR1(KTR_MLD,
2745                                     "%s: allocated new packet", __func__);
2746                         }
2747                         /*
2748                          * Append the MLD group record header to the
2749                          * current packet's data area.
2750                          * Recalculate pointer to free space for next
2751                          * group record, in case m_append() allocated
2752                          * a new mbuf or cluster.
2753                          */
2754                         memset(&mr, 0, sizeof(mr));
2755                         mr.mr_addr = inm->in6m_addr;
2756                         in6_clearscope(&mr.mr_addr);
2757                         if (!m_append(m, sizeof(mr), (void *)&mr)) {
2758                                 if (m != m0)
2759                                         m_freem(m);
2760                                 CTR1(KTR_MLD,
2761                                     "%s: m_append() failed", __func__);
2762                                 return (-ENOMEM);
2763                         }
2764                         npbytes += sizeof(struct mldv2_record);
2765                         if (m != m0) {
2766                                 /* new packet; offset in chain */
2767                                 md = m_getptr(m, npbytes -
2768                                     sizeof(struct mldv2_record), &off);
2769                                 pmr = (struct mldv2_record *)(mtod(md,
2770                                     uint8_t *) + off);
2771                         } else {
2772                                 /* current packet; offset from last append */
2773                                 md = m_last(m);
2774                                 pmr = (struct mldv2_record *)(mtod(md,
2775                                     uint8_t *) + md->m_len -
2776                                     sizeof(struct mldv2_record));
2777                         }
2778                         /*
2779                          * Begin walking the tree for this record type
2780                          * pass, or continue from where we left off
2781                          * previously if we had to allocate a new packet.
2782                          * Only report deltas in-mode at t1.
2783                          * We need not report included sources as allowed
2784                          * if we are in inclusive mode on the group,
2785                          * however the converse is not true.
2786                          */
2787                         rsrcs = 0;
2788                         if (nims == NULL) {
2789                                 nims = RB_MIN(ip6_msource_tree,
2790                                     &inm->in6m_srcs);
2791                         }
2792                         RB_FOREACH_FROM(ims, ip6_msource_tree, nims) {
2793                                 CTR2(KTR_MLD, "%s: visit node %s", __func__,
2794                                     ip6_sprintf(ip6tbuf, &ims->im6s_addr));
2795                                 now = im6s_get_mode(inm, ims, 1);
2796                                 then = im6s_get_mode(inm, ims, 0);
2797                                 CTR3(KTR_MLD, "%s: mode: t0 %d, t1 %d",
2798                                     __func__, then, now);
2799                                 if (now == then) {
2800                                         CTR1(KTR_MLD,
2801                                             "%s: skip unchanged", __func__);
2802                                         continue;
2803                                 }
2804                                 if (mode == MCAST_EXCLUDE &&
2805                                     now == MCAST_INCLUDE) {
2806                                         CTR1(KTR_MLD,
2807                                             "%s: skip IN src on EX group",
2808                                             __func__);
2809                                         continue;
2810                                 }
2811                                 nrt = (rectype_t)now;
2812                                 if (nrt == REC_NONE)
2813                                         nrt = (rectype_t)(~mode & REC_FULL);
2814                                 if (schanged++ == 0) {
2815                                         crt = nrt;
2816                                 } else if (crt != nrt)
2817                                         continue;
2818                                 if (!m_append(m, sizeof(struct in6_addr),
2819                                     (void *)&ims->im6s_addr)) {
2820                                         if (m != m0)
2821                                                 m_freem(m);
2822                                         CTR1(KTR_MLD,
2823                                             "%s: m_append() failed", __func__);
2824                                         return (-ENOMEM);
2825                                 }
2826                                 nallow += !!(crt == REC_ALLOW);
2827                                 nblock += !!(crt == REC_BLOCK);
2828                                 if (++rsrcs == m0srcs)
2829                                         break;
2830                         }
2831                         /*
2832                          * If we did not append any tree nodes on this
2833                          * pass, back out of allocations.
2834                          */
2835                         if (rsrcs == 0) {
2836                                 npbytes -= sizeof(struct mldv2_record);
2837                                 if (m != m0) {
2838                                         CTR1(KTR_MLD,
2839                                             "%s: m_free(m)", __func__);
2840                                         m_freem(m);
2841                                 } else {
2842                                         CTR1(KTR_MLD,
2843                                             "%s: m_adj(m, -mr)", __func__);
2844                                         m_adj(m, -((int)sizeof(
2845                                             struct mldv2_record)));
2846                                 }
2847                                 continue;
2848                         }
2849                         npbytes += (rsrcs * sizeof(struct in6_addr));
2850                         if (crt == REC_ALLOW)
2851                                 pmr->mr_type = MLD_ALLOW_NEW_SOURCES;
2852                         else if (crt == REC_BLOCK)
2853                                 pmr->mr_type = MLD_BLOCK_OLD_SOURCES;
2854                         pmr->mr_numsrc = htons(rsrcs);
2855                         /*
2856                          * Count the new group record, and enqueue this
2857                          * packet if it wasn't already queued.
2858                          */
2859                         m->m_pkthdr.PH_vt.vt_nrecs++;
2860                         if (m != m0)
2861                                 mbufq_enqueue(mq, m);
2862                         nbytes += npbytes;
2863                 } while (nims != NULL);
2864                 drt |= crt;
2865                 crt = (~crt & REC_FULL);
2866         }
2867
2868         CTR3(KTR_MLD, "%s: queued %d ALLOW_NEW, %d BLOCK_OLD", __func__,
2869             nallow, nblock);
2870
2871         return (nbytes);
2872 }
2873
2874 static int
2875 mld_v2_merge_state_changes(struct in6_multi *inm, struct mbufq *scq)
2876 {
2877         struct mbufq    *gq;
2878         struct mbuf     *m;             /* pending state-change */
2879         struct mbuf     *m0;            /* copy of pending state-change */
2880         struct mbuf     *mt;            /* last state-change in packet */
2881         int              docopy, domerge;
2882         u_int            recslen;
2883
2884         docopy = 0;
2885         domerge = 0;
2886         recslen = 0;
2887
2888         IN6_MULTI_LIST_LOCK_ASSERT();
2889         MLD_LOCK_ASSERT();
2890
2891         /*
2892          * If there are further pending retransmissions, make a writable
2893          * copy of each queued state-change message before merging.
2894          */
2895         if (inm->in6m_scrv > 0)
2896                 docopy = 1;
2897
2898         gq = &inm->in6m_scq;
2899 #ifdef KTR
2900         if (mbufq_first(gq) == NULL) {
2901                 CTR2(KTR_MLD, "%s: WARNING: queue for inm %p is empty",
2902                     __func__, inm);
2903         }
2904 #endif
2905
2906         m = mbufq_first(gq);
2907         while (m != NULL) {
2908                 /*
2909                  * Only merge the report into the current packet if
2910                  * there is sufficient space to do so; an MLDv2 report
2911                  * packet may only contain 65,535 group records.
2912                  * Always use a simple mbuf chain concatentation to do this,
2913                  * as large state changes for single groups may have
2914                  * allocated clusters.
2915                  */
2916                 domerge = 0;
2917                 mt = mbufq_last(scq);
2918                 if (mt != NULL) {
2919                         recslen = m_length(m, NULL);
2920
2921                         if ((mt->m_pkthdr.PH_vt.vt_nrecs +
2922                             m->m_pkthdr.PH_vt.vt_nrecs <=
2923                             MLD_V2_REPORT_MAXRECS) &&
2924                             (mt->m_pkthdr.len + recslen <=
2925                             (inm->in6m_ifp->if_mtu - MLD_MTUSPACE)))
2926                                 domerge = 1;
2927                 }
2928
2929                 if (!domerge && mbufq_full(gq)) {
2930                         CTR2(KTR_MLD,
2931                             "%s: outbound queue full, skipping whole packet %p",
2932                             __func__, m);
2933                         mt = m->m_nextpkt;
2934                         if (!docopy)
2935                                 m_freem(m);
2936                         m = mt;
2937                         continue;
2938                 }
2939
2940                 if (!docopy) {
2941                         CTR2(KTR_MLD, "%s: dequeueing %p", __func__, m);
2942                         m0 = mbufq_dequeue(gq);
2943                         m = m0->m_nextpkt;
2944                 } else {
2945                         CTR2(KTR_MLD, "%s: copying %p", __func__, m);
2946                         m0 = m_dup(m, M_NOWAIT);
2947                         if (m0 == NULL)
2948                                 return (ENOMEM);
2949                         m0->m_nextpkt = NULL;
2950                         m = m->m_nextpkt;
2951                 }
2952
2953                 if (!domerge) {
2954                         CTR3(KTR_MLD, "%s: queueing %p to scq %p)",
2955                             __func__, m0, scq);
2956                         mbufq_enqueue(scq, m0);
2957                 } else {
2958                         struct mbuf *mtl;       /* last mbuf of packet mt */
2959
2960                         CTR3(KTR_MLD, "%s: merging %p with ifscq tail %p)",
2961                             __func__, m0, mt);
2962
2963                         mtl = m_last(mt);
2964                         m0->m_flags &= ~M_PKTHDR;
2965                         mt->m_pkthdr.len += recslen;
2966                         mt->m_pkthdr.PH_vt.vt_nrecs +=
2967                             m0->m_pkthdr.PH_vt.vt_nrecs;
2968
2969                         mtl->m_next = m0;
2970                 }
2971         }
2972
2973         return (0);
2974 }
2975
2976 /*
2977  * Respond to a pending MLDv2 General Query.
2978  */
2979 static void
2980 mld_v2_dispatch_general_query(struct mld_ifsoftc *mli)
2981 {
2982         struct ifmultiaddr      *ifma;
2983         struct ifnet            *ifp;
2984         struct in6_multi        *inm;
2985         int                      retval;
2986
2987         NET_EPOCH_ASSERT();
2988         IN6_MULTI_LIST_LOCK_ASSERT();
2989         MLD_LOCK_ASSERT();
2990
2991         KASSERT(mli->mli_version == MLD_VERSION_2,
2992             ("%s: called when version %d", __func__, mli->mli_version));
2993
2994         /*
2995          * Check that there are some packets queued. If so, send them first.
2996          * For large number of groups the reply to general query can take
2997          * many packets, we should finish sending them before starting of
2998          * queuing the new reply.
2999          */
3000         if (mbufq_len(&mli->mli_gq) != 0)
3001                 goto send;
3002
3003         ifp = mli->mli_ifp;
3004
3005         CK_STAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
3006                 inm = in6m_ifmultiaddr_get_inm(ifma);
3007                 if (inm == NULL)
3008                         continue;
3009                 KASSERT(ifp == inm->in6m_ifp,
3010                     ("%s: inconsistent ifp", __func__));
3011
3012                 switch (inm->in6m_state) {
3013                 case MLD_NOT_MEMBER:
3014                 case MLD_SILENT_MEMBER:
3015                         break;
3016                 case MLD_REPORTING_MEMBER:
3017                 case MLD_IDLE_MEMBER:
3018                 case MLD_LAZY_MEMBER:
3019                 case MLD_SLEEPING_MEMBER:
3020                 case MLD_AWAKENING_MEMBER:
3021                         inm->in6m_state = MLD_REPORTING_MEMBER;
3022                         retval = mld_v2_enqueue_group_record(&mli->mli_gq,
3023                             inm, 0, 0, 0, 0);
3024                         CTR2(KTR_MLD, "%s: enqueue record = %d",
3025                             __func__, retval);
3026                         break;
3027                 case MLD_G_QUERY_PENDING_MEMBER:
3028                 case MLD_SG_QUERY_PENDING_MEMBER:
3029                 case MLD_LEAVING_MEMBER:
3030                         break;
3031                 }
3032         }
3033
3034 send:
3035         mld_dispatch_queue(&mli->mli_gq, MLD_MAX_RESPONSE_BURST);
3036
3037         /*
3038          * Slew transmission of bursts over 500ms intervals.
3039          */
3040         if (mbufq_first(&mli->mli_gq) != NULL) {
3041                 mli->mli_v2_timer = 1 + MLD_RANDOM_DELAY(
3042                     MLD_RESPONSE_BURST_INTERVAL);
3043                 V_interface_timers_running6 = 1;
3044         }
3045 }
3046
3047 /*
3048  * Transmit the next pending message in the output queue.
3049  *
3050  * VIMAGE: Needs to store/restore vnet pointer on a per-mbuf-chain basis.
3051  * MRT: Nothing needs to be done, as MLD traffic is always local to
3052  * a link and uses a link-scope multicast address.
3053  */
3054 static void
3055 mld_dispatch_packet(struct mbuf *m)
3056 {
3057         struct ip6_moptions      im6o;
3058         struct ifnet            *ifp;
3059         struct ifnet            *oifp;
3060         struct mbuf             *m0;
3061         struct mbuf             *md;
3062         struct ip6_hdr          *ip6;
3063         struct mld_hdr          *mld;
3064         int                      error;
3065         int                      off;
3066         int                      type;
3067         uint32_t                 ifindex;
3068
3069         CTR2(KTR_MLD, "%s: transmit %p", __func__, m);
3070         NET_EPOCH_ASSERT();
3071
3072         /*
3073          * Set VNET image pointer from enqueued mbuf chain
3074          * before doing anything else. Whilst we use interface
3075          * indexes to guard against interface detach, they are
3076          * unique to each VIMAGE and must be retrieved.
3077          */
3078         ifindex = mld_restore_context(m);
3079
3080         /*
3081          * Check if the ifnet still exists. This limits the scope of
3082          * any race in the absence of a global ifp lock for low cost
3083          * (an array lookup).
3084          */
3085         ifp = ifnet_byindex(ifindex);
3086         if (ifp == NULL) {
3087                 CTR3(KTR_MLD, "%s: dropped %p as ifindex %u went away.",
3088                     __func__, m, ifindex);
3089                 m_freem(m);
3090                 IP6STAT_INC(ip6s_noroute);
3091                 goto out;
3092         }
3093
3094         im6o.im6o_multicast_hlim  = 1;
3095         im6o.im6o_multicast_loop = (V_ip6_mrouter != NULL);
3096         im6o.im6o_multicast_ifp = ifp;
3097
3098         if (m->m_flags & M_MLDV1) {
3099                 m0 = m;
3100         } else {
3101                 m0 = mld_v2_encap_report(ifp, m);
3102                 if (m0 == NULL) {
3103                         CTR2(KTR_MLD, "%s: dropped %p", __func__, m);
3104                         IP6STAT_INC(ip6s_odropped);
3105                         goto out;
3106                 }
3107         }
3108
3109         mld_scrub_context(m0);
3110         m_clrprotoflags(m);
3111         m0->m_pkthdr.rcvif = V_loif;
3112
3113         ip6 = mtod(m0, struct ip6_hdr *);
3114 #if 0
3115         (void)in6_setscope(&ip6->ip6_dst, ifp, NULL);   /* XXX LOR */
3116 #else
3117         /*
3118          * XXX XXX Break some KPI rules to prevent an LOR which would
3119          * occur if we called in6_setscope() at transmission.
3120          * See comments at top of file.
3121          */
3122         MLD_EMBEDSCOPE(&ip6->ip6_dst, ifp->if_index);
3123 #endif
3124
3125         /*
3126          * Retrieve the ICMPv6 type before handoff to ip6_output(),
3127          * so we can bump the stats.
3128          */
3129         md = m_getptr(m0, sizeof(struct ip6_hdr), &off);
3130         mld = (struct mld_hdr *)(mtod(md, uint8_t *) + off);
3131         type = mld->mld_type;
3132
3133         oifp = NULL;
3134         error = ip6_output(m0, &mld_po, NULL, IPV6_UNSPECSRC, &im6o,
3135             &oifp, NULL);
3136         if (error) {
3137                 CTR3(KTR_MLD, "%s: ip6_output(%p) = %d", __func__, m0, error);
3138                 goto out;
3139         }
3140         ICMP6STAT_INC(icp6s_outhist[type]);
3141         if (oifp != NULL) {
3142                 icmp6_ifstat_inc(oifp, ifs6_out_msg);
3143                 switch (type) {
3144                 case MLD_LISTENER_REPORT:
3145                 case MLDV2_LISTENER_REPORT:
3146                         icmp6_ifstat_inc(oifp, ifs6_out_mldreport);
3147                         break;
3148                 case MLD_LISTENER_DONE:
3149                         icmp6_ifstat_inc(oifp, ifs6_out_mlddone);
3150                         break;
3151                 }
3152         }
3153 out:
3154         return;
3155 }
3156
3157 /*
3158  * Encapsulate an MLDv2 report.
3159  *
3160  * KAME IPv6 requires that hop-by-hop options be passed separately,
3161  * and that the IPv6 header be prepended in a separate mbuf.
3162  *
3163  * Returns a pointer to the new mbuf chain head, or NULL if the
3164  * allocation failed.
3165  */
3166 static struct mbuf *
3167 mld_v2_encap_report(struct ifnet *ifp, struct mbuf *m)
3168 {
3169         struct mbuf             *mh;
3170         struct mldv2_report     *mld;
3171         struct ip6_hdr          *ip6;
3172         struct in6_ifaddr       *ia;
3173         int                      mldreclen;
3174
3175         KASSERT(ifp != NULL, ("%s: null ifp", __func__));
3176         KASSERT((m->m_flags & M_PKTHDR),
3177             ("%s: mbuf chain %p is !M_PKTHDR", __func__, m));
3178
3179         /*
3180          * RFC3590: OK to send as :: or tentative during DAD.
3181          */
3182         NET_EPOCH_ASSERT();
3183         ia = in6ifa_ifpforlinklocal(ifp, IN6_IFF_NOTREADY|IN6_IFF_ANYCAST);
3184         if (ia == NULL)
3185                 CTR1(KTR_MLD, "%s: warning: ia is NULL", __func__);
3186
3187         mh = m_gethdr(M_NOWAIT, MT_DATA);
3188         if (mh == NULL) {
3189                 if (ia != NULL)
3190                         ifa_free(&ia->ia_ifa);
3191                 m_freem(m);
3192                 return (NULL);
3193         }
3194         M_ALIGN(mh, sizeof(struct ip6_hdr) + sizeof(struct mldv2_report));
3195
3196         mldreclen = m_length(m, NULL);
3197         CTR2(KTR_MLD, "%s: mldreclen is %d", __func__, mldreclen);
3198
3199         mh->m_len = sizeof(struct ip6_hdr) + sizeof(struct mldv2_report);
3200         mh->m_pkthdr.len = sizeof(struct ip6_hdr) +
3201             sizeof(struct mldv2_report) + mldreclen;
3202
3203         ip6 = mtod(mh, struct ip6_hdr *);
3204         ip6->ip6_flow = 0;
3205         ip6->ip6_vfc &= ~IPV6_VERSION_MASK;
3206         ip6->ip6_vfc |= IPV6_VERSION;
3207         ip6->ip6_nxt = IPPROTO_ICMPV6;
3208         ip6->ip6_src = ia ? ia->ia_addr.sin6_addr : in6addr_any;
3209         if (ia != NULL)
3210                 ifa_free(&ia->ia_ifa);
3211         ip6->ip6_dst = in6addr_linklocal_allv2routers;
3212         /* scope ID will be set in netisr */
3213
3214         mld = (struct mldv2_report *)(ip6 + 1);
3215         mld->mld_type = MLDV2_LISTENER_REPORT;
3216         mld->mld_code = 0;
3217         mld->mld_cksum = 0;
3218         mld->mld_v2_reserved = 0;
3219         mld->mld_v2_numrecs = htons(m->m_pkthdr.PH_vt.vt_nrecs);
3220         m->m_pkthdr.PH_vt.vt_nrecs = 0;
3221
3222         mh->m_next = m;
3223         mld->mld_cksum = in6_cksum(mh, IPPROTO_ICMPV6,
3224             sizeof(struct ip6_hdr), sizeof(struct mldv2_report) + mldreclen);
3225         return (mh);
3226 }
3227
3228 #ifdef KTR
3229 static char *
3230 mld_rec_type_to_str(const int type)
3231 {
3232
3233         switch (type) {
3234                 case MLD_CHANGE_TO_EXCLUDE_MODE:
3235                         return "TO_EX";
3236                         break;
3237                 case MLD_CHANGE_TO_INCLUDE_MODE:
3238                         return "TO_IN";
3239                         break;
3240                 case MLD_MODE_IS_EXCLUDE:
3241                         return "MODE_EX";
3242                         break;
3243                 case MLD_MODE_IS_INCLUDE:
3244                         return "MODE_IN";
3245                         break;
3246                 case MLD_ALLOW_NEW_SOURCES:
3247                         return "ALLOW_NEW";
3248                         break;
3249                 case MLD_BLOCK_OLD_SOURCES:
3250                         return "BLOCK_OLD";
3251                         break;
3252                 default:
3253                         break;
3254         }
3255         return "unknown";
3256 }
3257 #endif
3258
3259 static void
3260 mld_init(void *unused __unused)
3261 {
3262
3263         CTR1(KTR_MLD, "%s: initializing", __func__);
3264         MLD_LOCK_INIT();
3265
3266         ip6_initpktopts(&mld_po);
3267         mld_po.ip6po_hlim = 1;
3268         mld_po.ip6po_hbh = &mld_ra.hbh;
3269         mld_po.ip6po_prefer_tempaddr = IP6PO_TEMPADDR_NOTPREFER;
3270         mld_po.ip6po_flags = IP6PO_DONTFRAG;
3271 }
3272 SYSINIT(mld_init, SI_SUB_PROTO_MC, SI_ORDER_MIDDLE, mld_init, NULL);
3273
3274 static void
3275 mld_uninit(void *unused __unused)
3276 {
3277
3278         CTR1(KTR_MLD, "%s: tearing down", __func__);
3279         MLD_LOCK_DESTROY();
3280 }
3281 SYSUNINIT(mld_uninit, SI_SUB_PROTO_MC, SI_ORDER_MIDDLE, mld_uninit, NULL);
3282
3283 static void
3284 vnet_mld_init(const void *unused __unused)
3285 {
3286
3287         CTR1(KTR_MLD, "%s: initializing", __func__);
3288
3289         LIST_INIT(&V_mli_head);
3290 }
3291 VNET_SYSINIT(vnet_mld_init, SI_SUB_PROTO_MC, SI_ORDER_ANY, vnet_mld_init,
3292     NULL);
3293
3294 static void
3295 vnet_mld_uninit(const void *unused __unused)
3296 {
3297
3298         /* This can happen if we shutdown the network stack. */
3299         CTR1(KTR_MLD, "%s: tearing down", __func__);
3300 }
3301 VNET_SYSUNINIT(vnet_mld_uninit, SI_SUB_PROTO_MC, SI_ORDER_ANY, vnet_mld_uninit,
3302     NULL);
3303
3304 static int
3305 mld_modevent(module_t mod, int type, void *unused __unused)
3306 {
3307
3308     switch (type) {
3309     case MOD_LOAD:
3310     case MOD_UNLOAD:
3311         break;
3312     default:
3313         return (EOPNOTSUPP);
3314     }
3315     return (0);
3316 }
3317
3318 static moduledata_t mld_mod = {
3319     "mld",
3320     mld_modevent,
3321     0
3322 };
3323 DECLARE_MODULE(mld, mld_mod, SI_SUB_PROTO_MC, SI_ORDER_ANY);