sys/netinet/in_mcast.c

   1 /*-
   2  * Copyright (c) 2007 Bruce M. Simpson.
   3  * Copyright (c) 2005 Robert N. M. Watson.
   4  * All rights reserved.
   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
  31 /*
  32  * IPv4 multicast socket, group, and socket option processing module.
  33  * Until further notice, this file requires INET to compile.
  34  * TODO: Make this infrastructure independent of address family.
  35  * TODO: Teach netinet6 to use this code.
  36  * TODO: Hook up SSM logic to IGMPv3/MLDv2.
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/malloc.h>
  46 #include <sys/mbuf.h>
  47 #include <sys/protosw.h>
  48 #include <sys/socket.h>
  49 #include <sys/socketvar.h>
  50 #include <sys/sysctl.h>
  51
  52 #include <net/if.h>
  53 #include <net/if_dl.h>
  54 #include <net/route.h>
  55
  56 #include <netinet/in.h>
  57 #include <netinet/in_systm.h>
  58 #include <netinet/in_pcb.h>
  59 #include <netinet/in_var.h>
  60 #include <netinet/ip_var.h>
  61 #include <netinet/igmp_var.h>
  62
  63 #ifndef __SOCKUNION_DECLARED
  64 union sockunion {
  65         struct sockaddr_storage ss;
  66         struct sockaddr         sa;
  67         struct sockaddr_dl      sdl;
  68         struct sockaddr_in      sin;
  69 #ifdef INET6
  70         struct sockaddr_in6     sin6;
  71 #endif
  72 };
  73 typedef union sockunion sockunion_t;
  74 #define __SOCKUNION_DECLARED
  75 #endif /* __SOCKUNION_DECLARED */
  76
  77 static MALLOC_DEFINE(M_IPMADDR, "in_multi", "IPv4 multicast group");
  78 static MALLOC_DEFINE(M_IPMOPTS, "ip_moptions", "IPv4 multicast options");
  79 static MALLOC_DEFINE(M_IPMSOURCE, "in_msource", "IPv4 multicast source filter");
  80
  81 /*
  82  * The IPv4 multicast list (in_multihead and associated structures) are
  83  * protected by the global in_multi_mtx.  See in_var.h for more details.  For
  84  * now, in_multi_mtx is marked as recursible due to IGMP's calling back into
  85  * ip_output() to send IGMP packets while holding the lock; this probably is
  86  * not quite desirable.
  87  */
  88 struct in_multihead in_multihead;       /* XXX BSS initialization */
  89 struct mtx in_multi_mtx;
  90 MTX_SYSINIT(in_multi_mtx, &in_multi_mtx, "in_multi_mtx", MTX_DEF | MTX_RECURSE);
  91
  92 /*
  93  * Functions with non-static linkage defined in this file should be
  94  * declared in in_var.h:
  95  *  imo_match_group()
  96  *  imo_match_source()
  97  *  in_addmulti()
  98  *  in_delmulti()
  99  *  in_delmulti_locked()
 100  * and ip_var.h:
 101  *  inp_freemoptions()
 102  *  inp_getmoptions()
 103  *  inp_setmoptions()
 104  */
 105 static int      imo_grow(struct ip_moptions *);
 106 static int      imo_join_source(struct ip_moptions *, size_t, sockunion_t *);
 107 static int      imo_leave_source(struct ip_moptions *, size_t, sockunion_t *);
 108 static int      inp_change_source_filter(struct inpcb *, struct sockopt *);
 109 static struct ip_moptions *
 110                 inp_findmoptions(struct inpcb *);
 111 static int      inp_get_source_filters(struct inpcb *, struct sockopt *);
 112 static int      inp_join_group(struct inpcb *, struct sockopt *);
 113 static int      inp_leave_group(struct inpcb *, struct sockopt *);
 114 static int      inp_set_multicast_if(struct inpcb *, struct sockopt *);
 115 static int      inp_set_source_filters(struct inpcb *, struct sockopt *);
 116 static struct ifnet *
 117                 ip_multicast_if(struct in_addr *a);
 118
 119 /*
 120  * Resize the ip_moptions vector to the next power-of-two minus 1.
 121  * May be called with locks held; do not sleep.
 122  */
 123 static int
 124 imo_grow(struct ip_moptions *imo)
 125 {
 126         struct in_multi         **nmships;
 127         struct in_multi         **omships;
 128         struct in_mfilter        *nmfilters;
 129         struct in_mfilter        *omfilters;
 130         size_t                    idx;
 131         size_t                    newmax;
 132         size_t                    oldmax;
 133
 134         nmships = NULL;
 135         nmfilters = NULL;
 136         omships = imo->imo_membership;
 137         omfilters = imo->imo_mfilters;
 138         oldmax = imo->imo_max_memberships;
 139         newmax = ((oldmax + 1) * 2) - 1;
 140
 141         if (newmax <= IP_MAX_MEMBERSHIPS) {
 142                 nmships = (struct in_multi **)realloc(omships,
 143                     sizeof(struct in_multi *) * newmax, M_IPMOPTS, M_NOWAIT);
 144                 nmfilters = (struct in_mfilter *)realloc(omfilters,
 145                     sizeof(struct in_mfilter) * newmax, M_IPMSOURCE, M_NOWAIT);
 146                 if (nmships != NULL && nmfilters != NULL) {
 147                         /* Initialize newly allocated source filter heads. */
 148                         for (idx = oldmax; idx < newmax; idx++) {
 149                                 nmfilters[idx].imf_fmode = MCAST_EXCLUDE;
 150                                 nmfilters[idx].imf_nsources = 0;
 151                                 TAILQ_INIT(&nmfilters[idx].imf_sources);
 152                         }
 153                         imo->imo_max_memberships = newmax;
 154                         imo->imo_membership = nmships;
 155                         imo->imo_mfilters = nmfilters;
 156                 }
 157         }
 158
 159         if (nmships == NULL || nmfilters == NULL) {
 160                 if (nmships != NULL)
 161                         free(nmships, M_IPMOPTS);
 162                 if (nmfilters != NULL)
 163                         free(nmfilters, M_IPMSOURCE);
 164                 return (ETOOMANYREFS);
 165         }
 166
 167         return (0);
 168 }
 169
 170 /*
 171  * Add a source to a multicast filter list.
 172  * Assumes the associated inpcb is locked.
 173  */
 174 static int
 175 imo_join_source(struct ip_moptions *imo, size_t gidx, sockunion_t *src)
 176 {
 177         struct in_msource       *ims, *nims;
 178         struct in_mfilter       *imf;
 179
 180         KASSERT(src->ss.ss_family == AF_INET, ("%s: !AF_INET", __func__));
 181         KASSERT(imo->imo_mfilters != NULL,
 182             ("%s: imo_mfilters vector not allocated", __func__));
 183
 184         imf = &imo->imo_mfilters[gidx];
 185         if (imf->imf_nsources == IP_MAX_SOURCE_FILTER)
 186                 return (ENOBUFS);
 187
 188         ims = imo_match_source(imo, gidx, &src->sa);
 189         if (ims != NULL)
 190                 return (EADDRNOTAVAIL);
 191
 192         /* Do not sleep with inp lock held. */
 193         MALLOC(nims, struct in_msource *, sizeof(struct in_msource),
 194             M_IPMSOURCE, M_NOWAIT | M_ZERO);
 195         if (nims == NULL)
 196                 return (ENOBUFS);
 197
 198         nims->ims_addr = src->ss;
 199         TAILQ_INSERT_TAIL(&imf->imf_sources, nims, ims_next);
 200         imf->imf_nsources++;
 201
 202         return (0);
 203 }
 204
 205 static int
 206 imo_leave_source(struct ip_moptions *imo, size_t gidx, sockunion_t *src)
 207 {
 208         struct in_msource       *ims;
 209         struct in_mfilter       *imf;
 210
 211         KASSERT(src->ss.ss_family == AF_INET, ("%s: !AF_INET", __func__));
 212         KASSERT(imo->imo_mfilters != NULL,
 213             ("%s: imo_mfilters vector not allocated", __func__));
 214
 215         imf = &imo->imo_mfilters[gidx];
 216         if (imf->imf_nsources == IP_MAX_SOURCE_FILTER)
 217                 return (ENOBUFS);
 218
 219         ims = imo_match_source(imo, gidx, &src->sa);
 220         if (ims == NULL)
 221                 return (EADDRNOTAVAIL);
 222
 223         TAILQ_REMOVE(&imf->imf_sources, ims, ims_next);
 224         FREE(ims, M_IPMSOURCE);
 225         imf->imf_nsources--;
 226
 227         return (0);
 228 }
 229
 230 /*
 231  * Find an IPv4 multicast group entry for this ip_moptions instance
 232  * which matches the specified group, and optionally an interface.
 233  * Return its index into the array, or -1 if not found.
 234  */
 235 size_t
 236 imo_match_group(struct ip_moptions *imo, struct ifnet *ifp,
 237     struct sockaddr *group)
 238 {
 239         sockunion_t      *gsa;
 240         struct in_multi **pinm;
 241         int               idx;
 242         int               nmships;
 243
 244         gsa = (sockunion_t *)group;
 245
 246         /* The imo_membership array may be lazy allocated. */
 247         if (imo->imo_membership == NULL || imo->imo_num_memberships == 0)
 248                 return (-1);
 249
 250         nmships = imo->imo_num_memberships;
 251         pinm = &imo->imo_membership[0];
 252         for (idx = 0; idx < nmships; idx++, pinm++) {
 253                 if (*pinm == NULL)
 254                         continue;
 255 #if 0
 256                 printf("%s: trying ifp = %p, inaddr = %s ", __func__,
 257                     ifp, inet_ntoa(gsa->sin.sin_addr));
 258                 printf("against %p, %s\n",
 259                     (*pinm)->inm_ifp, inet_ntoa((*pinm)->inm_addr));
 260 #endif
 261                 if ((ifp == NULL || ((*pinm)->inm_ifp == ifp)) &&
 262                     (*pinm)->inm_addr.s_addr == gsa->sin.sin_addr.s_addr) {
 263                         break;
 264                 }
 265         }
 266         if (idx >= nmships)
 267                 idx = -1;
 268
 269         return (idx);
 270 }
 271
 272 /*
 273  * Find a multicast source entry for this imo which matches
 274  * the given group index for this socket, and source address.
 275  */
 276 struct in_msource *
 277 imo_match_source(struct ip_moptions *imo, size_t gidx, struct sockaddr *src)
 278 {
 279         struct in_mfilter       *imf;
 280         struct in_msource       *ims, *pims;
 281
 282         KASSERT(src->sa_family == AF_INET, ("%s: !AF_INET", __func__));
 283         KASSERT(gidx != -1 && gidx < imo->imo_num_memberships,
 284             ("%s: invalid index %d\n", __func__, (int)gidx));
 285
 286         /* The imo_mfilters array may be lazy allocated. */
 287         if (imo->imo_mfilters == NULL)
 288                 return (NULL);
 289
 290         pims = NULL;
 291         imf = &imo->imo_mfilters[gidx];
 292         TAILQ_FOREACH(ims, &imf->imf_sources, ims_next) {
 293                 /*
 294                  * Perform bitwise comparison of two IPv4 addresses.
 295                  * TODO: Do the same for IPv6.
 296                  * Do not use sa_equal() for this as it is not aware of
 297                  * deeper structure in sockaddr_in or sockaddr_in6.
 298                  */
 299                 if (((struct sockaddr_in *)&ims->ims_addr)->sin_addr.s_addr ==
 300                     ((struct sockaddr_in *)src)->sin_addr.s_addr) {
 301                         pims = ims;
 302                         break;
 303                 }
 304         }
 305
 306         return (pims);
 307 }
 308
 309 /*
 310  * Join an IPv4 multicast group.
 311  */
 312 struct in_multi *
 313 in_addmulti(struct in_addr *ap, struct ifnet *ifp)
 314 {
 315         struct in_multi *inm;
 316
 317         inm = NULL;
 318
 319         IFF_LOCKGIANT(ifp);
 320         IN_MULTI_LOCK();
 321
 322         IN_LOOKUP_MULTI(*ap, ifp, inm);
 323         if (inm != NULL) {
 324                 /*
 325                  * If we already joined this group, just bump the
 326                  * refcount and return it.
 327                  */
 328                 KASSERT(inm->inm_refcount >= 1,
 329                     ("%s: bad refcount %d", __func__, inm->inm_refcount));
 330                 ++inm->inm_refcount;
 331         } else do {
 332                 sockunion_t              gsa;
 333                 struct ifmultiaddr      *ifma;
 334                 struct in_multi         *ninm;
 335                 int                      error;
 336
 337                 memset(&gsa, 0, sizeof(gsa));
 338                 gsa.sin.sin_family = AF_INET;
 339                 gsa.sin.sin_len = sizeof(struct sockaddr_in);
 340                 gsa.sin.sin_addr = *ap;
 341
 342                 /*
 343                  * Check if a link-layer group is already associated
 344                  * with this network-layer group on the given ifnet.
 345                  * If so, bump the refcount on the existing network-layer
 346                  * group association and return it.
 347                  */
 348                 error = if_addmulti(ifp, &gsa.sa, &ifma);
 349                 if (error)
 350                         break;
 351                 if (ifma->ifma_protospec != NULL) {
 352                         inm = (struct in_multi *)ifma->ifma_protospec;
 353 #ifdef INVARIANTS
 354                         if (inm->inm_ifma != ifma || inm->inm_ifp != ifp ||
 355                             inm->inm_addr.s_addr != ap->s_addr)
 356                                 panic("%s: ifma is inconsistent", __func__);
 357 #endif
 358                         ++inm->inm_refcount;
 359                         break;
 360                 }
 361
 362                 /*
 363                  * A new membership is needed; construct it and
 364                  * perform the IGMP join.
 365                  */
 366                 ninm = malloc(sizeof(*ninm), M_IPMADDR, M_NOWAIT | M_ZERO);
 367                 if (ninm == NULL) {
 368                         if_delmulti_ifma(ifma);
 369                         break;
 370                 }
 371                 ninm->inm_addr = *ap;
 372                 ninm->inm_ifp = ifp;
 373                 ninm->inm_ifma = ifma;
 374                 ninm->inm_refcount = 1;
 375                 ifma->ifma_protospec = ninm;
 376                 LIST_INSERT_HEAD(&in_multihead, ninm, inm_link);
 377
 378                 igmp_joingroup(ninm);
 379
 380                 inm = ninm;
 381         } while (0);
 382
 383         IN_MULTI_UNLOCK();
 384         IFF_UNLOCKGIANT(ifp);
 385
 386         return (inm);
 387 }
 388
 389 /*
 390  * Leave an IPv4 multicast group.
 391  * It is OK to call this routine if the underlying ifnet went away.
 392  *
 393  * XXX: To deal with the ifp going away, we cheat; the link-layer code in net
 394  * will set ifma_ifp to NULL when the associated ifnet instance is detached
 395  * from the system.
 396  *
 397  * The only reason we need to violate layers and check ifma_ifp here at all
 398  * is because certain hardware drivers still require Giant to be held,
 399  * and it must always be taken before other locks.
 400  */
 401 void
 402 in_delmulti(struct in_multi *inm)
 403 {
 404         struct ifnet *ifp;
 405
 406         KASSERT(inm != NULL, ("%s: inm is NULL", __func__));
 407         KASSERT(inm->inm_ifma != NULL, ("%s: no ifma", __func__));
 408         ifp = inm->inm_ifma->ifma_ifp;
 409
 410         if (ifp != NULL) {
 411                 /*
 412                  * Sanity check that netinet's notion of ifp is the
 413                  * same as net's.
 414                  */
 415                 KASSERT(inm->inm_ifp == ifp, ("%s: bad ifp", __func__));
 416                 IFF_LOCKGIANT(ifp);
 417         }
 418
 419         IN_MULTI_LOCK();
 420         in_delmulti_locked(inm);
 421         IN_MULTI_UNLOCK();
 422
 423         if (ifp != NULL)
 424                 IFF_UNLOCKGIANT(ifp);
 425 }
 426
 427 /*
 428  * Delete a multicast address record, with locks held.
 429  *
 430  * It is OK to call this routine if the ifp went away.
 431  * Assumes that caller holds the IN_MULTI lock, and that
 432  * Giant was taken before other locks if required by the hardware.
 433  */
 434 void
 435 in_delmulti_locked(struct in_multi *inm)
 436 {
 437         struct ifmultiaddr *ifma;
 438
 439         IN_MULTI_LOCK_ASSERT();
 440         KASSERT(inm->inm_refcount >= 1, ("%s: freeing freed inm", __func__));
 441
 442         if (--inm->inm_refcount == 0) {
 443                 igmp_leavegroup(inm);
 444
 445                 ifma = inm->inm_ifma;
 446 #ifdef DIAGNOSTIC
 447                 if (bootverbose)
 448                         printf("%s: purging ifma %p\n", __func__, ifma);
 449 #endif
 450                 KASSERT(ifma->ifma_protospec == inm,
 451                     ("%s: ifma_protospec != inm", __func__));
 452                 ifma->ifma_protospec = NULL;
 453
 454                 LIST_REMOVE(inm, inm_link);
 455                 free(inm, M_IPMADDR);
 456
 457                 if_delmulti_ifma(ifma);
 458         }
 459 }
 460
 461 /*
 462  * Block or unblock an ASM/SSM multicast source on an inpcb.
 463  */
 464 static int
 465 inp_change_source_filter(struct inpcb *inp, struct sockopt *sopt)
 466 {
 467         struct group_source_req          gsr;
 468         sockunion_t                     *gsa, *ssa;
 469         struct ifnet                    *ifp;
 470         struct in_mfilter               *imf;
 471         struct ip_moptions              *imo;
 472         struct in_msource               *ims;
 473         size_t                           idx;
 474         int                              error;
 475         int                              block;
 476
 477         ifp = NULL;
 478         error = 0;
 479         block = 0;
 480
 481         memset(&gsr, 0, sizeof(struct group_source_req));
 482         gsa = (sockunion_t *)&gsr.gsr_group;
 483         ssa = (sockunion_t *)&gsr.gsr_source;
 484
 485         switch (sopt->sopt_name) {
 486         case IP_BLOCK_SOURCE:
 487         case IP_UNBLOCK_SOURCE: {
 488                 struct ip_mreq_source    mreqs;
 489
 490                 error = sooptcopyin(sopt, &mreqs,
 491                     sizeof(struct ip_mreq_source),
 492                     sizeof(struct ip_mreq_source));
 493                 if (error)
 494                         return (error);
 495
 496                 gsa->sin.sin_family = AF_INET;
 497                 gsa->sin.sin_len = sizeof(struct sockaddr_in);
 498                 gsa->sin.sin_addr = mreqs.imr_multiaddr;
 499
 500                 ssa->sin.sin_family = AF_INET;
 501                 ssa->sin.sin_len = sizeof(struct sockaddr_in);
 502                 ssa->sin.sin_addr = mreqs.imr_sourceaddr;
 503
 504                 if (mreqs.imr_interface.s_addr != INADDR_ANY)
 505                         INADDR_TO_IFP(mreqs.imr_interface, ifp);
 506
 507                 if (sopt->sopt_name == IP_BLOCK_SOURCE)
 508                         block = 1;
 509
 510 #ifdef DIAGNOSTIC
 511                 if (bootverbose) {
 512                         printf("%s: imr_interface = %s, ifp = %p\n",
 513                             __func__, inet_ntoa(mreqs.imr_interface), ifp);
 514                 }
 515 #endif
 516                 break;
 517             }
 518
 519         case MCAST_BLOCK_SOURCE:
 520         case MCAST_UNBLOCK_SOURCE:
 521                 error = sooptcopyin(sopt, &gsr,
 522                     sizeof(struct group_source_req),
 523                     sizeof(struct group_source_req));
 524                 if (error)
 525                         return (error);
 526
 527                 if (gsa->sin.sin_family != AF_INET ||
 528                     gsa->sin.sin_len != sizeof(struct sockaddr_in))
 529                         return (EINVAL);
 530
 531                 if (ssa->sin.sin_family != AF_INET ||
 532                     ssa->sin.sin_len != sizeof(struct sockaddr_in))
 533                         return (EINVAL);
 534
 535                 if (gsr.gsr_interface == 0 || if_index < gsr.gsr_interface)
 536                         return (EADDRNOTAVAIL);
 537
 538                 ifp = ifnet_byindex(gsr.gsr_interface);
 539
 540                 if (sopt->sopt_name == MCAST_BLOCK_SOURCE)
 541                         block = 1;
 542                 break;
 543
 544         default:
 545 #ifdef DIAGNOSTIC
 546                 if (bootverbose) {
 547                         printf("%s: unknown sopt_name %d\n", __func__,
 548                             sopt->sopt_name);
 549                 }
 550 #endif
 551                 return (EOPNOTSUPP);
 552                 break;
 553         }
 554
 555         /* XXX INET6 */
 556         if (!IN_MULTICAST(ntohl(gsa->sin.sin_addr.s_addr)))
 557                 return (EINVAL);
 558
 559         /*
 560          * Check if we are actually a member of this group.
 561          */
 562         imo = inp_findmoptions(inp);
 563         idx = imo_match_group(imo, ifp, &gsa->sa);
 564         if (idx == -1 || imo->imo_mfilters == NULL) {
 565                 error = EADDRNOTAVAIL;
 566                 goto out_locked;
 567         }
 568
 569         KASSERT(imo->imo_mfilters != NULL,
 570             ("%s: imo_mfilters not allocated", __func__));
 571         imf = &imo->imo_mfilters[idx];
 572
 573         /*
 574          * SSM multicast truth table for block/unblock operations.
 575          *
 576          * Operation   Filter Mode  Entry exists?   Action
 577          *
 578          * block       exclude      no              add source to filter
 579          * unblock     include      no              add source to filter
 580          * block       include      no              EINVAL
 581          * unblock     exclude      no              EINVAL
 582          * block       exclude      yes             EADDRNOTAVAIL
 583          * unblock     include      yes             EADDRNOTAVAIL
 584          * block       include      yes             remove source from filter
 585          * unblock     exclude      yes             remove source from filter
 586          *
 587          * FreeBSD does not explicitly distinguish between ASM and SSM
 588          * mode sockets; all sockets are assumed to have a filter list.
 589          */
 590 #ifdef DIAGNOSTIC
 591         if (bootverbose) {
 592                 printf("%s: imf_fmode is %s\n", __func__,
 593                     imf->imf_fmode == MCAST_INCLUDE ? "include" : "exclude");
 594         }
 595 #endif
 596         ims = imo_match_source(imo, idx, &ssa->sa);
 597         if (ims == NULL) {
 598                 if ((block == 1 && imf->imf_fmode == MCAST_EXCLUDE) ||
 599                     (block == 0 && imf->imf_fmode == MCAST_INCLUDE)) {
 600 #ifdef DIAGNOSTIC
 601                         if (bootverbose) {
 602                                 printf("%s: adding %s to filter list\n",
 603                                     __func__, inet_ntoa(ssa->sin.sin_addr));
 604                         }
 605 #endif
 606                         error = imo_join_source(imo, idx, ssa);
 607                 }
 608                 if ((block == 1 && imf->imf_fmode == MCAST_INCLUDE) ||
 609                     (block == 0 && imf->imf_fmode == MCAST_EXCLUDE)) {
 610                         /*
 611                          * If the socket is in inclusive mode:
 612                          *  the source is already blocked as it has no entry.
 613                          * If the socket is in exclusive mode:
 614                          *  the source is already unblocked as it has no entry.
 615                          */
 616 #ifdef DIAGNOSTIC
 617                         if (bootverbose) {
 618                                 printf("%s: ims %p; %s already [un]blocked\n",
 619                                     __func__, ims,
 620                                     inet_ntoa(ssa->sin.sin_addr));
 621                         }
 622 #endif
 623                         error = EINVAL;
 624                 }
 625         } else {
 626                 if ((block == 1 && imf->imf_fmode == MCAST_EXCLUDE) ||
 627                     (block == 0 && imf->imf_fmode == MCAST_INCLUDE)) {
 628                         /*
 629                          * If the socket is in exclusive mode:
 630                          *  the source is already blocked as it has an entry.
 631                          * If the socket is in inclusive mode:
 632                          *  the source is already unblocked as it has an entry.
 633                          */
 634 #ifdef DIAGNOSTIC
 635                         if (bootverbose) {
 636                                 printf("%s: ims %p; %s already [un]blocked\n",
 637                                     __func__, ims,
 638                                     inet_ntoa(ssa->sin.sin_addr));
 639                         }
 640 #endif
 641                         error = EADDRNOTAVAIL;
 642                 }
 643                 if ((block == 1 && imf->imf_fmode == MCAST_INCLUDE) ||
 644                     (block == 0 && imf->imf_fmode == MCAST_EXCLUDE)) {
 645 #ifdef DIAGNOSTIC
 646                         if (bootverbose) {
 647                                 printf("%s: removing %s from filter list\n",
 648                                     __func__, inet_ntoa(ssa->sin.sin_addr));
 649                         }
 650 #endif
 651                         error = imo_leave_source(imo, idx, ssa);
 652                 }
 653         }
 654
 655 out_locked:
 656         INP_WUNLOCK(inp);
 657         return (error);
 658 }
 659
 660 /*
 661  * Given an inpcb, return its multicast options structure pointer.  Accepts
 662  * an unlocked inpcb pointer, but will return it locked.  May sleep.
 663  */
 664 static struct ip_moptions *
 665 inp_findmoptions(struct inpcb *inp)
 666 {
 667         struct ip_moptions       *imo;
 668         struct in_multi         **immp;
 669         struct in_mfilter        *imfp;
 670         size_t                    idx;
 671
 672         INP_WLOCK(inp);
 673         if (inp->inp_moptions != NULL)
 674                 return (inp->inp_moptions);
 675
 676         INP_WUNLOCK(inp);
 677
 678         imo = (struct ip_moptions *)malloc(sizeof(*imo), M_IPMOPTS,
 679             M_WAITOK);
 680         immp = (struct in_multi **)malloc(sizeof(*immp) * IP_MIN_MEMBERSHIPS,
 681             M_IPMOPTS, M_WAITOK | M_ZERO);
 682         imfp = (struct in_mfilter *)malloc(
 683             sizeof(struct in_mfilter) * IP_MIN_MEMBERSHIPS,
 684             M_IPMSOURCE, M_WAITOK);
 685
 686         imo->imo_multicast_ifp = NULL;
 687         imo->imo_multicast_addr.s_addr = INADDR_ANY;
 688         imo->imo_multicast_vif = -1;
 689         imo->imo_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
 690         imo->imo_multicast_loop = IP_DEFAULT_MULTICAST_LOOP;
 691         imo->imo_num_memberships = 0;
 692         imo->imo_max_memberships = IP_MIN_MEMBERSHIPS;
 693         imo->imo_membership = immp;
 694
 695         /* Initialize per-group source filters. */
 696         for (idx = 0; idx < IP_MIN_MEMBERSHIPS; idx++) {
 697                 imfp[idx].imf_fmode = MCAST_EXCLUDE;
 698                 imfp[idx].imf_nsources = 0;
 699                 TAILQ_INIT(&imfp[idx].imf_sources);
 700         }
 701         imo->imo_mfilters = imfp;
 702
 703         INP_WLOCK(inp);
 704         if (inp->inp_moptions != NULL) {
 705                 free(imfp, M_IPMSOURCE);
 706                 free(immp, M_IPMOPTS);
 707                 free(imo, M_IPMOPTS);
 708                 return (inp->inp_moptions);
 709         }
 710         inp->inp_moptions = imo;
 711         return (imo);
 712 }
 713
 714 /*
 715  * Discard the IP multicast options (and source filters).
 716  */
 717 void
 718 inp_freemoptions(struct ip_moptions *imo)
 719 {
 720         struct in_mfilter       *imf;
 721         struct in_msource       *ims, *tims;
 722         size_t                   idx, nmships;
 723
 724         KASSERT(imo != NULL, ("%s: ip_moptions is NULL", __func__));
 725
 726         nmships = imo->imo_num_memberships;
 727         for (idx = 0; idx < nmships; ++idx) {
 728                 in_delmulti(imo->imo_membership[idx]);
 729
 730                 if (imo->imo_mfilters != NULL) {
 731                         imf = &imo->imo_mfilters[idx];
 732                         TAILQ_FOREACH_SAFE(ims, &imf->imf_sources,
 733                             ims_next, tims) {
 734                                 TAILQ_REMOVE(&imf->imf_sources, ims, ims_next);
 735                                 FREE(ims, M_IPMSOURCE);
 736                                 imf->imf_nsources--;
 737                         }
 738                         KASSERT(imf->imf_nsources == 0,
 739                             ("%s: did not free all imf_nsources", __func__));
 740                 }
 741         }
 742
 743         if (imo->imo_mfilters != NULL)
 744                 free(imo->imo_mfilters, M_IPMSOURCE);
 745         free(imo->imo_membership, M_IPMOPTS);
 746         free(imo, M_IPMOPTS);
 747 }
 748
 749 /*
 750  * Atomically get source filters on a socket for an IPv4 multicast group.
 751  * Called with INP lock held; returns with lock released.
 752  */
 753 static int
 754 inp_get_source_filters(struct inpcb *inp, struct sockopt *sopt)
 755 {
 756         struct __msfilterreq     msfr;
 757         sockunion_t             *gsa;
 758         struct ifnet            *ifp;
 759         struct ip_moptions      *imo;
 760         struct in_mfilter       *imf;
 761         struct in_msource       *ims;
 762         struct sockaddr_storage *ptss;
 763         struct sockaddr_storage *tss;
 764         int                      error;
 765         size_t                   idx;
 766
 767         INP_WLOCK_ASSERT(inp);
 768
 769         imo = inp->inp_moptions;
 770         KASSERT(imo != NULL, ("%s: null ip_moptions", __func__));
 771
 772         INP_WUNLOCK(inp);
 773
 774         error = sooptcopyin(sopt, &msfr, sizeof(struct __msfilterreq),
 775             sizeof(struct __msfilterreq));
 776         if (error)
 777                 return (error);
 778
 779         if (msfr.msfr_ifindex == 0 || if_index < msfr.msfr_ifindex)
 780                 return (EINVAL);
 781
 782         ifp = ifnet_byindex(msfr.msfr_ifindex);
 783         if (ifp == NULL)
 784                 return (EINVAL);
 785
 786         INP_WLOCK(inp);
 787
 788         /*
 789          * Lookup group on the socket.
 790          */
 791         gsa = (sockunion_t *)&msfr.msfr_group;
 792         idx = imo_match_group(imo, ifp, &gsa->sa);
 793         if (idx == -1 || imo->imo_mfilters == NULL) {
 794                 INP_WUNLOCK(inp);
 795                 return (EADDRNOTAVAIL);
 796         }
 797
 798         imf = &imo->imo_mfilters[idx];
 799         msfr.msfr_fmode = imf->imf_fmode;
 800         msfr.msfr_nsrcs = imf->imf_nsources;
 801
 802         /*
 803          * If the user specified a buffer, copy out the source filter
 804          * entries to userland gracefully.
 805          * msfr.msfr_nsrcs is always set to the total number of filter
 806          * entries which the kernel currently has for this group.
 807          */
 808         tss = NULL;
 809         if (msfr.msfr_srcs != NULL && msfr.msfr_nsrcs > 0) {
 810                 /*
 811                  * Make a copy of the source vector so that we do not
 812                  * thrash the inpcb lock whilst copying it out.
 813                  * We only copy out the number of entries which userland
 814                  * has asked for, but we always tell userland how big the
 815                  * buffer really needs to be.
 816                  */
 817                 MALLOC(tss, struct sockaddr_storage *,
 818                     sizeof(struct sockaddr_storage) * msfr.msfr_nsrcs,
 819                     M_TEMP, M_NOWAIT);
 820                 if (tss == NULL) {
 821                         error = ENOBUFS;
 822                 } else {
 823                         ptss = tss;
 824                         TAILQ_FOREACH(ims, &imf->imf_sources, ims_next) {
 825                                 memcpy(ptss++, &ims->ims_addr,
 826                                     sizeof(struct sockaddr_storage));
 827                         }
 828                 }
 829         }
 830
 831         INP_WUNLOCK(inp);
 832
 833         if (tss != NULL) {
 834                 error = copyout(tss, msfr.msfr_srcs,
 835                     sizeof(struct sockaddr_storage) * msfr.msfr_nsrcs);
 836                 FREE(tss, M_TEMP);
 837         }
 838
 839         if (error)
 840                 return (error);
 841
 842         error = sooptcopyout(sopt, &msfr, sizeof(struct __msfilterreq));
 843
 844         return (error);
 845 }
 846
 847 /*
 848  * Return the IP multicast options in response to user getsockopt().
 849  */
 850 int
 851 inp_getmoptions(struct inpcb *inp, struct sockopt *sopt)
 852 {
 853         struct ip_mreqn          mreqn;
 854         struct ip_moptions      *imo;
 855         struct ifnet            *ifp;
 856         struct in_ifaddr        *ia;
 857         int                      error, optval;
 858         u_char                   coptval;
 859
 860         INP_WLOCK(inp);
 861         imo = inp->inp_moptions;
 862         /*
 863          * If socket is neither of type SOCK_RAW or SOCK_DGRAM,
 864          * or is a divert socket, reject it.
 865          */
 866         if (inp->inp_socket->so_proto->pr_protocol == IPPROTO_DIVERT ||
 867             (inp->inp_socket->so_proto->pr_type != SOCK_RAW &&
 868             inp->inp_socket->so_proto->pr_type != SOCK_DGRAM)) {
 869                 INP_WUNLOCK(inp);
 870                 return (EOPNOTSUPP);
 871         }
 872
 873         error = 0;
 874         switch (sopt->sopt_name) {
 875         case IP_MULTICAST_VIF:
 876                 if (imo != NULL)
 877                         optval = imo->imo_multicast_vif;
 878                 else
 879                         optval = -1;
 880                 INP_WUNLOCK(inp);
 881                 error = sooptcopyout(sopt, &optval, sizeof(int));
 882                 break;
 883
 884         case IP_MULTICAST_IF:
 885                 memset(&mreqn, 0, sizeof(struct ip_mreqn));
 886                 if (imo != NULL) {
 887                         ifp = imo->imo_multicast_ifp;
 888                         if (imo->imo_multicast_addr.s_addr != INADDR_ANY) {
 889                                 mreqn.imr_address = imo->imo_multicast_addr;
 890                         } else if (ifp != NULL) {
 891                                 mreqn.imr_ifindex = ifp->if_index;
 892                                 IFP_TO_IA(ifp, ia);
 893                                 if (ia != NULL) {
 894                                         mreqn.imr_address =
 895                                             IA_SIN(ia)->sin_addr;
 896                                 }
 897                         }
 898                 }
 899                 INP_WUNLOCK(inp);
 900                 if (sopt->sopt_valsize == sizeof(struct ip_mreqn)) {
 901                         error = sooptcopyout(sopt, &mreqn,
 902                             sizeof(struct ip_mreqn));
 903                 } else {
 904                         error = sooptcopyout(sopt, &mreqn.imr_address,
 905                             sizeof(struct in_addr));
 906                 }
 907                 break;
 908
 909         case IP_MULTICAST_TTL:
 910                 if (imo == 0)
 911                         optval = coptval = IP_DEFAULT_MULTICAST_TTL;
 912                 else
 913                         optval = coptval = imo->imo_multicast_ttl;
 914                 INP_WUNLOCK(inp);
 915                 if (sopt->sopt_valsize == sizeof(u_char))
 916                         error = sooptcopyout(sopt, &coptval, sizeof(u_char));
 917                 else
 918                         error = sooptcopyout(sopt, &optval, sizeof(int));
 919                 break;
 920
 921         case IP_MULTICAST_LOOP:
 922                 if (imo == 0)
 923                         optval = coptval = IP_DEFAULT_MULTICAST_LOOP;
 924                 else
 925                         optval = coptval = imo->imo_multicast_loop;
 926                 INP_WUNLOCK(inp);
 927                 if (sopt->sopt_valsize == sizeof(u_char))
 928                         error = sooptcopyout(sopt, &coptval, sizeof(u_char));
 929                 else
 930                         error = sooptcopyout(sopt, &optval, sizeof(int));
 931                 break;
 932
 933         case IP_MSFILTER:
 934                 if (imo == NULL) {
 935                         error = EADDRNOTAVAIL;
 936                         INP_WUNLOCK(inp);
 937                 } else {
 938                         error = inp_get_source_filters(inp, sopt);
 939                 }
 940                 break;
 941
 942         default:
 943                 INP_WUNLOCK(inp);
 944                 error = ENOPROTOOPT;
 945                 break;
 946         }
 947
 948         INP_UNLOCK_ASSERT(inp);
 949
 950         return (error);
 951 }
 952
 953 /*
 954  * Join an IPv4 multicast group, possibly with a source.
 955  */
 956 static int
 957 inp_join_group(struct inpcb *inp, struct sockopt *sopt)
 958 {
 959         struct group_source_req          gsr;
 960         sockunion_t                     *gsa, *ssa;
 961         struct ifnet                    *ifp;
 962         struct in_mfilter               *imf;
 963         struct ip_moptions              *imo;
 964         struct in_multi                 *inm;
 965         size_t                           idx;
 966         int                              error;
 967
 968         ifp = NULL;
 969         error = 0;
 970
 971         memset(&gsr, 0, sizeof(struct group_source_req));
 972         gsa = (sockunion_t *)&gsr.gsr_group;
 973         gsa->ss.ss_family = AF_UNSPEC;
 974         ssa = (sockunion_t *)&gsr.gsr_source;
 975         ssa->ss.ss_family = AF_UNSPEC;
 976
 977         switch (sopt->sopt_name) {
 978         case IP_ADD_MEMBERSHIP:
 979         case IP_ADD_SOURCE_MEMBERSHIP: {
 980                 struct ip_mreq_source    mreqs;
 981
 982                 if (sopt->sopt_name == IP_ADD_MEMBERSHIP) {
 983                         error = sooptcopyin(sopt, &mreqs,
 984                             sizeof(struct ip_mreq),
 985                             sizeof(struct ip_mreq));
 986                         /*
 987                          * Do argument switcharoo from ip_mreq into
 988                          * ip_mreq_source to avoid using two instances.
 989                          */
 990                         mreqs.imr_interface = mreqs.imr_sourceaddr;
 991                         mreqs.imr_sourceaddr.s_addr = INADDR_ANY;
 992                 } else if (sopt->sopt_name == IP_ADD_SOURCE_MEMBERSHIP) {
 993                         error = sooptcopyin(sopt, &mreqs,
 994                             sizeof(struct ip_mreq_source),
 995                             sizeof(struct ip_mreq_source));
 996                 }
 997                 if (error)
 998                         return (error);
 999
1000                 gsa->sin.sin_family = AF_INET;
1001                 gsa->sin.sin_len = sizeof(struct sockaddr_in);
1002                 gsa->sin.sin_addr = mreqs.imr_multiaddr;
1003
1004                 if (sopt->sopt_name == IP_ADD_SOURCE_MEMBERSHIP) {
1005                         ssa->sin.sin_family = AF_INET;
1006                         ssa->sin.sin_len = sizeof(struct sockaddr_in);
1007                         ssa->sin.sin_addr = mreqs.imr_sourceaddr;
1008                 }
1009
1010                 /*
1011                  * Obtain ifp. If no interface address was provided,
1012                  * use the interface of the route in the unicast FIB for
1013                  * the given multicast destination; usually, this is the
1014                  * default route.
1015                  * If this lookup fails, attempt to use the first non-loopback
1016                  * interface with multicast capability in the system as a
1017                  * last resort. The legacy IPv4 ASM API requires that we do
1018                  * this in order to allow groups to be joined when the routing
1019                  * table has not yet been populated during boot.
1020                  * If all of these conditions fail, return EADDRNOTAVAIL, and
1021                  * reject the IPv4 multicast join.
1022                  */
1023                 if (mreqs.imr_interface.s_addr != INADDR_ANY) {
1024                         ifp = ip_multicast_if(&mreqs.imr_interface);
1025                 } else {
1026                         struct route ro;
1027
1028                         ro.ro_rt = NULL;
1029                         *(struct sockaddr_in *)&ro.ro_dst = gsa->sin;
1030                         in_rtalloc_ign(&ro, RTF_CLONING,
1031                            inp->inp_inc.inc_fibnum);
1032                         if (ro.ro_rt != NULL) {
1033                                 ifp = ro.ro_rt->rt_ifp;
1034                                 KASSERT(ifp != NULL, ("%s: null ifp",
1035                                     __func__));
1036                                 RTFREE(ro.ro_rt);
1037                         } else {
1038                                 struct in_ifaddr *ia;
1039                                 struct ifnet *mfp = NULL;
1040                                 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_link) {
1041                                         mfp = ia->ia_ifp;
1042                                         if (!(mfp->if_flags & IFF_LOOPBACK) &&
1043                                              (mfp->if_flags & IFF_MULTICAST)) {
1044                                                 ifp = mfp;
1045                                                 break;
1046                                         }
1047                                 }
1048                         }
1049                 }
1050 #ifdef DIAGNOSTIC
1051                 if (bootverbose) {
1052                         printf("%s: imr_interface = %s, ifp = %p\n",
1053                             __func__, inet_ntoa(mreqs.imr_interface), ifp);
1054                 }
1055 #endif
1056                 break;
1057         }
1058
1059         case MCAST_JOIN_GROUP:
1060         case MCAST_JOIN_SOURCE_GROUP:
1061                 if (sopt->sopt_name == MCAST_JOIN_GROUP) {
1062                         error = sooptcopyin(sopt, &gsr,
1063                             sizeof(struct group_req),
1064                             sizeof(struct group_req));
1065                 } else if (sopt->sopt_name == MCAST_JOIN_SOURCE_GROUP) {
1066                         error = sooptcopyin(sopt, &gsr,
1067                             sizeof(struct group_source_req),
1068                             sizeof(struct group_source_req));
1069                 }
1070                 if (error)
1071                         return (error);
1072
1073                 if (gsa->sin.sin_family != AF_INET ||
1074                     gsa->sin.sin_len != sizeof(struct sockaddr_in))
1075                         return (EINVAL);
1076
1077                 /*
1078                  * Overwrite the port field if present, as the sockaddr
1079                  * being copied in may be matched with a binary comparison.
1080                  * XXX INET6
1081                  */
1082                 gsa->sin.sin_port = 0;
1083                 if (sopt->sopt_name == MCAST_JOIN_SOURCE_GROUP) {
1084                         if (ssa->sin.sin_family != AF_INET ||
1085                             ssa->sin.sin_len != sizeof(struct sockaddr_in))
1086                                 return (EINVAL);
1087                         ssa->sin.sin_port = 0;
1088                 }
1089
1090                 /*
1091                  * Obtain the ifp.
1092                  */
1093                 if (gsr.gsr_interface == 0 || if_index < gsr.gsr_interface)
1094                         return (EADDRNOTAVAIL);
1095                 ifp = ifnet_byindex(gsr.gsr_interface);
1096
1097                 break;
1098
1099         default:
1100 #ifdef DIAGNOSTIC
1101                 if (bootverbose) {
1102                         printf("%s: unknown sopt_name %d\n", __func__,
1103                             sopt->sopt_name);
1104                 }
1105 #endif
1106                 return (EOPNOTSUPP);
1107                 break;
1108         }
1109
1110         if (!IN_MULTICAST(ntohl(gsa->sin.sin_addr.s_addr)))
1111                 return (EINVAL);
1112
1113         if (ifp == NULL || (ifp->if_flags & IFF_MULTICAST) == 0)
1114                 return (EADDRNOTAVAIL);
1115
1116         /*
1117          * Check if we already hold membership of this group for this inpcb.
1118          * If so, we do not need to perform the initial join.
1119          */
1120         imo = inp_findmoptions(inp);
1121         idx = imo_match_group(imo, ifp, &gsa->sa);
1122         if (idx != -1) {
1123                 if (ssa->ss.ss_family != AF_UNSPEC) {
1124                         /*
1125                          * Attempting to join an ASM group (when already
1126                          * an ASM or SSM member) is an error.
1127                          */
1128                         error = EADDRNOTAVAIL;
1129                 } else {
1130                         imf = &imo->imo_mfilters[idx];
1131                         if (imf->imf_nsources == 0) {
1132                                 /*
1133                                  * Attempting to join an SSM group (when
1134                                  * already an ASM member) is an error.
1135                                  */
1136                                 error = EINVAL;
1137                         } else {
1138                                 /*
1139                                  * Attempting to join an SSM group (when
1140                                  * already an SSM member) means "add this
1141                                  * source to the inclusive filter list".
1142                                  */
1143                                 error = imo_join_source(imo, idx, ssa);
1144                         }
1145                 }
1146                 goto out_locked;
1147         }
1148
1149         /*
1150          * Call imo_grow() to reallocate the membership and source filter
1151          * vectors if they are full. If the size would exceed the hard limit,
1152          * then we know we've really run out of entries. We keep the INP
1153          * lock held to avoid introducing a race condition.
1154          */
1155         if (imo->imo_num_memberships == imo->imo_max_memberships) {
1156                 error = imo_grow(imo);
1157                 if (error)
1158                         goto out_locked;
1159         }
1160
1161         /*
1162          * So far, so good: perform the layer 3 join, layer 2 join,
1163          * and make an IGMP announcement if needed.
1164          */
1165         inm = in_addmulti(&gsa->sin.sin_addr, ifp);
1166         if (inm == NULL) {
1167                 error = ENOBUFS;
1168                 goto out_locked;
1169         }
1170         idx = imo->imo_num_memberships;
1171         imo->imo_membership[idx] = inm;
1172         imo->imo_num_memberships++;
1173
1174         KASSERT(imo->imo_mfilters != NULL,
1175             ("%s: imf_mfilters vector was not allocated", __func__));
1176         imf = &imo->imo_mfilters[idx];
1177         KASSERT(TAILQ_EMPTY(&imf->imf_sources),
1178             ("%s: imf_sources not empty", __func__));
1179
1180         /*
1181          * If this is a new SSM group join (i.e. a source was specified
1182          * with this group), add this source to the filter list.
1183          */
1184         if (ssa->ss.ss_family != AF_UNSPEC) {
1185                 /*
1186                  * An initial SSM join implies that this socket's membership
1187                  * of the multicast group is now in inclusive mode.
1188                  */
1189                 imf->imf_fmode = MCAST_INCLUDE;
1190
1191                 error = imo_join_source(imo, idx, ssa);
1192                 if (error) {
1193                         /*
1194                          * Drop inp lock before calling in_delmulti(),
1195                          * to prevent a lock order reversal.
1196                          */
1197                         --imo->imo_num_memberships;
1198                         INP_WUNLOCK(inp);
1199                         in_delmulti(inm);
1200                         return (error);
1201                 }
1202         }
1203
1204 out_locked:
1205         INP_WUNLOCK(inp);
1206         return (error);
1207 }
1208
1209 /*
1210  * Leave an IPv4 multicast group on an inpcb, possibly with a source.
1211  */
1212 static int
1213 inp_leave_group(struct inpcb *inp, struct sockopt *sopt)
1214 {
1215         struct group_source_req          gsr;
1216         struct ip_mreq_source            mreqs;
1217         sockunion_t                     *gsa, *ssa;
1218         struct ifnet                    *ifp;
1219         struct in_mfilter               *imf;
1220         struct ip_moptions              *imo;
1221         struct in_msource               *ims, *tims;
1222         struct in_multi                 *inm;
1223         size_t                           idx;
1224         int                              error;
1225
1226         ifp = NULL;
1227         error = 0;
1228
1229         memset(&gsr, 0, sizeof(struct group_source_req));
1230         gsa = (sockunion_t *)&gsr.gsr_group;
1231         gsa->ss.ss_family = AF_UNSPEC;
1232         ssa = (sockunion_t *)&gsr.gsr_source;
1233         ssa->ss.ss_family = AF_UNSPEC;
1234
1235         switch (sopt->sopt_name) {
1236         case IP_DROP_MEMBERSHIP:
1237         case IP_DROP_SOURCE_MEMBERSHIP:
1238                 if (sopt->sopt_name == IP_DROP_MEMBERSHIP) {
1239                         error = sooptcopyin(sopt, &mreqs,
1240                             sizeof(struct ip_mreq),
1241                             sizeof(struct ip_mreq));
1242                         /*
1243                          * Swap interface and sourceaddr arguments,
1244                          * as ip_mreq and ip_mreq_source are laid
1245                          * out differently.
1246                          */
1247                         mreqs.imr_interface = mreqs.imr_sourceaddr;
1248                         mreqs.imr_sourceaddr.s_addr = INADDR_ANY;
1249                 } else if (sopt->sopt_name == IP_DROP_SOURCE_MEMBERSHIP) {
1250                         error = sooptcopyin(sopt, &mreqs,
1251                             sizeof(struct ip_mreq_source),
1252                             sizeof(struct ip_mreq_source));
1253                 }
1254                 if (error)
1255                         return (error);
1256
1257                 gsa->sin.sin_family = AF_INET;
1258                 gsa->sin.sin_len = sizeof(struct sockaddr_in);
1259                 gsa->sin.sin_addr = mreqs.imr_multiaddr;
1260
1261                 if (sopt->sopt_name == IP_DROP_SOURCE_MEMBERSHIP) {
1262                         ssa->sin.sin_family = AF_INET;
1263                         ssa->sin.sin_len = sizeof(struct sockaddr_in);
1264                         ssa->sin.sin_addr = mreqs.imr_sourceaddr;
1265                 }
1266
1267                 if (gsa->sin.sin_addr.s_addr != INADDR_ANY)
1268                         INADDR_TO_IFP(mreqs.imr_interface, ifp);
1269
1270 #ifdef DIAGNOSTIC
1271                 if (bootverbose) {
1272                         printf("%s: imr_interface = %s, ifp = %p\n",
1273                             __func__, inet_ntoa(mreqs.imr_interface), ifp);
1274                 }
1275 #endif
1276                 break;
1277
1278         case MCAST_LEAVE_GROUP:
1279         case MCAST_LEAVE_SOURCE_GROUP:
1280                 if (sopt->sopt_name == MCAST_LEAVE_GROUP) {
1281                         error = sooptcopyin(sopt, &gsr,
1282                             sizeof(struct group_req),
1283                             sizeof(struct group_req));
1284                 } else if (sopt->sopt_name == MCAST_LEAVE_SOURCE_GROUP) {
1285                         error = sooptcopyin(sopt, &gsr,
1286                             sizeof(struct group_source_req),
1287                             sizeof(struct group_source_req));
1288                 }
1289                 if (error)
1290                         return (error);
1291
1292                 if (gsa->sin.sin_family != AF_INET ||
1293                     gsa->sin.sin_len != sizeof(struct sockaddr_in))
1294                         return (EINVAL);
1295
1296                 if (sopt->sopt_name == MCAST_LEAVE_SOURCE_GROUP) {
1297                         if (ssa->sin.sin_family != AF_INET ||
1298                             ssa->sin.sin_len != sizeof(struct sockaddr_in))
1299                                 return (EINVAL);
1300                 }
1301
1302                 if (gsr.gsr_interface == 0 || if_index < gsr.gsr_interface)
1303                         return (EADDRNOTAVAIL);
1304
1305                 ifp = ifnet_byindex(gsr.gsr_interface);
1306                 break;
1307
1308         default:
1309 #ifdef DIAGNOSTIC
1310                 if (bootverbose) {
1311                         printf("%s: unknown sopt_name %d\n", __func__,
1312                             sopt->sopt_name);
1313                 }
1314 #endif
1315                 return (EOPNOTSUPP);
1316                 break;
1317         }
1318
1319         if (!IN_MULTICAST(ntohl(gsa->sin.sin_addr.s_addr)))
1320                 return (EINVAL);
1321
1322         /*
1323          * Find the membership in the membership array.
1324          */
1325         imo = inp_findmoptions(inp);
1326         idx = imo_match_group(imo, ifp, &gsa->sa);
1327         if (idx == -1) {
1328                 error = EADDRNOTAVAIL;
1329                 goto out_locked;
1330         }
1331         imf = &imo->imo_mfilters[idx];
1332
1333         /*
1334          * If we were instructed only to leave a given source, do so.
1335          */
1336         if (ssa->ss.ss_family != AF_UNSPEC) {
1337                 if (imf->imf_nsources == 0 ||
1338                     imf->imf_fmode == MCAST_EXCLUDE) {
1339                         /*
1340                          * Attempting to SSM leave an ASM group
1341                          * is an error; should use *_BLOCK_SOURCE instead.
1342                          * Attempting to SSM leave a source in a group when
1343                          * the socket is in 'exclude mode' is also an error.
1344                          */
1345                         error = EINVAL;
1346                 } else {
1347                         error = imo_leave_source(imo, idx, ssa);
1348                 }
1349                 /*
1350                  * If an error occurred, or this source is not the last
1351                  * source in the group, do not leave the whole group.
1352                  */
1353                 if (error || imf->imf_nsources > 0)
1354                         goto out_locked;
1355         }
1356
1357         /*
1358          * Give up the multicast address record to which the membership points.
1359          */
1360         inm = imo->imo_membership[idx];
1361         in_delmulti(inm);
1362
1363         /*
1364          * Free any source filters for this group if they exist.
1365          * Revert inpcb to the default MCAST_EXCLUDE state.
1366          */
1367         if (imo->imo_mfilters != NULL) {
1368                 TAILQ_FOREACH_SAFE(ims, &imf->imf_sources, ims_next, tims) {
1369                         TAILQ_REMOVE(&imf->imf_sources, ims, ims_next);
1370                         FREE(ims, M_IPMSOURCE);
1371                         imf->imf_nsources--;
1372                 }
1373                 KASSERT(imf->imf_nsources == 0,
1374                     ("%s: imf_nsources not 0", __func__));
1375                 KASSERT(TAILQ_EMPTY(&imf->imf_sources),
1376                     ("%s: imf_sources not empty", __func__));
1377                 imf->imf_fmode = MCAST_EXCLUDE;
1378         }
1379
1380         /*
1381          * Remove the gap in the membership array.
1382          */
1383         for (++idx; idx < imo->imo_num_memberships; ++idx)
1384                 imo->imo_membership[idx-1] = imo->imo_membership[idx];
1385         imo->imo_num_memberships--;
1386
1387 out_locked:
1388         INP_WUNLOCK(inp);
1389         return (error);
1390 }
1391
1392 /*
1393  * Select the interface for transmitting IPv4 multicast datagrams.
1394  *
1395  * Either an instance of struct in_addr or an instance of struct ip_mreqn
1396  * may be passed to this socket option. An address of INADDR_ANY or an
1397  * interface index of 0 is used to remove a previous selection.
1398  * When no interface is selected, one is chosen for every send.
1399  */
1400 static int
1401 inp_set_multicast_if(struct inpcb *inp, struct sockopt *sopt)
1402 {
1403         struct in_addr           addr;
1404         struct ip_mreqn          mreqn;
1405         struct ifnet            *ifp;
1406         struct ip_moptions      *imo;
1407         int                      error;
1408
1409         if (sopt->sopt_valsize == sizeof(struct ip_mreqn)) {
1410                 /*
1411                  * An interface index was specified using the
1412                  * Linux-derived ip_mreqn structure.
1413                  */
1414                 error = sooptcopyin(sopt, &mreqn, sizeof(struct ip_mreqn),
1415                     sizeof(struct ip_mreqn));
1416                 if (error)
1417                         return (error);
1418
1419                 if (mreqn.imr_ifindex < 0 || if_index < mreqn.imr_ifindex)
1420                         return (EINVAL);
1421
1422                 if (mreqn.imr_ifindex == 0) {
1423                         ifp = NULL;
1424                 } else {
1425                         ifp = ifnet_byindex(mreqn.imr_ifindex);
1426                         if (ifp == NULL)
1427                                 return (EADDRNOTAVAIL);
1428                 }
1429         } else {
1430                 /*
1431                  * An interface was specified by IPv4 address.
1432                  * This is the traditional BSD usage.
1433                  */
1434                 error = sooptcopyin(sopt, &addr, sizeof(struct in_addr),
1435                     sizeof(struct in_addr));
1436                 if (error)
1437                         return (error);
1438                 if (addr.s_addr == INADDR_ANY) {
1439                         ifp = NULL;
1440                 } else {
1441                         ifp = ip_multicast_if(&addr);
1442                         if (ifp == NULL)
1443                                 return (EADDRNOTAVAIL);
1444                 }
1445 #ifdef DIAGNOSTIC
1446                 if (bootverbose) {
1447                         printf("%s: ifp = %p, addr = %s\n",
1448                             __func__, ifp, inet_ntoa(addr)); /* XXX INET6 */
1449                 }
1450 #endif
1451         }
1452
1453         /* Reject interfaces which do not support multicast. */
1454         if (ifp != NULL && (ifp->if_flags & IFF_MULTICAST) == 0)
1455                 return (EOPNOTSUPP);
1456
1457         imo = inp_findmoptions(inp);
1458         imo->imo_multicast_ifp = ifp;
1459         imo->imo_multicast_addr.s_addr = INADDR_ANY;
1460         INP_WUNLOCK(inp);
1461
1462         return (0);
1463 }
1464
1465 /*
1466  * Atomically set source filters on a socket for an IPv4 multicast group.
1467  */
1468 static int
1469 inp_set_source_filters(struct inpcb *inp, struct sockopt *sopt)
1470 {
1471         struct __msfilterreq     msfr;
1472         sockunion_t             *gsa;
1473         struct ifnet            *ifp;
1474         struct in_mfilter       *imf;
1475         struct ip_moptions      *imo;
1476         struct in_msource       *ims, *tims;
1477         size_t                   idx;
1478         int                      error;
1479
1480         error = sooptcopyin(sopt, &msfr, sizeof(struct __msfilterreq),
1481             sizeof(struct __msfilterreq));
1482         if (error)
1483                 return (error);
1484
1485         if (msfr.msfr_nsrcs > IP_MAX_SOURCE_FILTER ||
1486             (msfr.msfr_fmode != MCAST_EXCLUDE &&
1487              msfr.msfr_fmode != MCAST_INCLUDE))
1488                 return (EINVAL);
1489
1490         if (msfr.msfr_group.ss_family != AF_INET ||
1491             msfr.msfr_group.ss_len != sizeof(struct sockaddr_in))
1492                 return (EINVAL);
1493
1494         gsa = (sockunion_t *)&msfr.msfr_group;
1495         if (!IN_MULTICAST(ntohl(gsa->sin.sin_addr.s_addr)))
1496                 return (EINVAL);
1497
1498         gsa->sin.sin_port = 0;  /* ignore port */
1499
1500         if (msfr.msfr_ifindex == 0 || if_index < msfr.msfr_ifindex)
1501                 return (EADDRNOTAVAIL);
1502
1503         ifp = ifnet_byindex(msfr.msfr_ifindex);
1504         if (ifp == NULL)
1505                 return (EADDRNOTAVAIL);
1506
1507         /*
1508          * Take the INP lock.
1509          * Check if this socket is a member of this group.
1510          */
1511         imo = inp_findmoptions(inp);
1512         idx = imo_match_group(imo, ifp, &gsa->sa);
1513         if (idx == -1 || imo->imo_mfilters == NULL) {
1514                 error = EADDRNOTAVAIL;
1515                 goto out_locked;
1516         }
1517         imf = &imo->imo_mfilters[idx];
1518
1519 #ifdef DIAGNOSTIC
1520         if (bootverbose)
1521                 printf("%s: clearing source list\n", __func__);
1522 #endif
1523
1524         /*
1525          * Remove any existing source filters.
1526          */
1527         TAILQ_FOREACH_SAFE(ims, &imf->imf_sources, ims_next, tims) {
1528                 TAILQ_REMOVE(&imf->imf_sources, ims, ims_next);
1529                 FREE(ims, M_IPMSOURCE);
1530                 imf->imf_nsources--;
1531         }
1532         KASSERT(imf->imf_nsources == 0,
1533             ("%s: source list not cleared", __func__));
1534
1535         /*
1536          * Apply any new source filters, if present.
1537          */
1538         if (msfr.msfr_nsrcs > 0) {
1539                 struct in_msource       **pnims;
1540                 struct in_msource       *nims;
1541                 struct sockaddr_storage *kss;
1542                 struct sockaddr_storage *pkss;
1543                 sockunion_t             *psu;
1544                 int                      i, j;
1545
1546                 /*
1547                  * Drop the inp lock so we may sleep if we need to
1548                  * in order to satisfy a malloc request.
1549                  * We will re-take it before changing socket state.
1550                  */
1551                 INP_WUNLOCK(inp);
1552 #ifdef DIAGNOSTIC
1553                 if (bootverbose) {
1554                         printf("%s: loading %lu source list entries\n",
1555                             __func__, (unsigned long)msfr.msfr_nsrcs);
1556                 }
1557 #endif
1558                 /*
1559                  * Make a copy of the user-space source vector so
1560                  * that we may copy them with a single copyin. This
1561                  * allows us to deal with page faults up-front.
1562                  */
1563                 MALLOC(kss, struct sockaddr_storage *,
1564                     sizeof(struct sockaddr_storage) * msfr.msfr_nsrcs,
1565                     M_TEMP, M_WAITOK);
1566                 error = copyin(msfr.msfr_srcs, kss,
1567                     sizeof(struct sockaddr_storage) * msfr.msfr_nsrcs);
1568                 if (error) {
1569                         FREE(kss, M_TEMP);
1570                         return (error);
1571                 }
1572
1573                 /*
1574                  * Perform argument checking on every sockaddr_storage
1575                  * structure in the vector provided to us. Overwrite
1576                  * fields which should not apply to source entries.
1577                  * TODO: Check for duplicate sources on this pass.
1578                  */
1579                 psu = (sockunion_t *)kss;
1580                 for (i = 0; i < msfr.msfr_nsrcs; i++, psu++) {
1581                         switch (psu->ss.ss_family) {
1582                         case AF_INET:
1583                                 if (psu->sin.sin_len !=
1584                                     sizeof(struct sockaddr_in)) {
1585                                         error = EINVAL;
1586                                 } else {
1587                                         psu->sin.sin_port = 0;
1588                                 }
1589                                 break;
1590 #ifdef notyet
1591                         case AF_INET6;
1592                                 if (psu->sin6.sin6_len !=
1593                                     sizeof(struct sockaddr_in6)) {
1594                                         error = EINVAL;
1595                                 } else {
1596                                         psu->sin6.sin6_port = 0;
1597                                         psu->sin6.sin6_flowinfo = 0;
1598                                 }
1599                                 break;
1600 #endif
1601                         default:
1602                                 error = EAFNOSUPPORT;
1603                                 break;
1604                         }
1605                         if (error)
1606                                 break;
1607                 }
1608                 if (error) {
1609                         FREE(kss, M_TEMP);
1610                         return (error);
1611                 }
1612
1613                 /*
1614                  * Allocate a block to track all the in_msource
1615                  * entries we are about to allocate, in case we
1616                  * abruptly need to free them.
1617                  */
1618                 MALLOC(pnims, struct in_msource **,
1619                     sizeof(struct in_msource *) * msfr.msfr_nsrcs,
1620                     M_TEMP, M_WAITOK | M_ZERO);
1621
1622                 /*
1623                  * Allocate up to nsrcs individual chunks.
1624                  * If we encounter an error, backtrack out of
1625                  * all allocations cleanly; updates must be atomic.
1626                  */
1627                 pkss = kss;
1628                 nims = NULL;
1629                 for (i = 0; i < msfr.msfr_nsrcs; i++, pkss++) {
1630                         MALLOC(nims, struct in_msource *,
1631                             sizeof(struct in_msource) * msfr.msfr_nsrcs,
1632                             M_IPMSOURCE, M_WAITOK | M_ZERO);
1633                         pnims[i] = nims;
1634                 }
1635                 if (i < msfr.msfr_nsrcs) {
1636                         for (j = 0; j < i; j++) {
1637                                 if (pnims[j] != NULL)
1638                                         FREE(pnims[j], M_IPMSOURCE);
1639                         }
1640                         FREE(pnims, M_TEMP);
1641                         FREE(kss, M_TEMP);
1642                         return (ENOBUFS);
1643                 }
1644
1645                 INP_UNLOCK_ASSERT(inp);
1646
1647                 /*
1648                  * Finally, apply the filters to the socket.
1649                  * Re-take the inp lock; we are changing socket state.
1650                  */
1651                 pkss = kss;
1652                 INP_WLOCK(inp);
1653                 for (i = 0; i < msfr.msfr_nsrcs; i++, pkss++) {
1654                         memcpy(&(pnims[i]->ims_addr), pkss,
1655                             sizeof(struct sockaddr_storage));
1656                         TAILQ_INSERT_TAIL(&imf->imf_sources, pnims[i],
1657                             ims_next);
1658                         imf->imf_nsources++;
1659                 }
1660                 FREE(pnims, M_TEMP);
1661                 FREE(kss, M_TEMP);
1662         }
1663
1664         /*
1665          * Update the filter mode on the socket before releasing the inpcb.
1666          */
1667         INP_WLOCK_ASSERT(inp);
1668         imf->imf_fmode = msfr.msfr_fmode;
1669
1670 out_locked:
1671         INP_WUNLOCK(inp);
1672         return (error);
1673 }
1674
1675 /*
1676  * Set the IP multicast options in response to user setsockopt().
1677  *
1678  * Many of the socket options handled in this function duplicate the
1679  * functionality of socket options in the regular unicast API. However,
1680  * it is not possible to merge the duplicate code, because the idempotence
1681  * of the IPv4 multicast part of the BSD Sockets API must be preserved;
1682  * the effects of these options must be treated as separate and distinct.
1683  */
1684 int
1685 inp_setmoptions(struct inpcb *inp, struct sockopt *sopt)
1686 {
1687         struct ip_moptions      *imo;
1688         int                      error;
1689
1690         error = 0;
1691
1692         /*
1693          * If socket is neither of type SOCK_RAW or SOCK_DGRAM,
1694          * or is a divert socket, reject it.
1695          * XXX Unlocked read of inp_socket believed OK.
1696          */
1697         if (inp->inp_socket->so_proto->pr_protocol == IPPROTO_DIVERT ||
1698             (inp->inp_socket->so_proto->pr_type != SOCK_RAW &&
1699             inp->inp_socket->so_proto->pr_type != SOCK_DGRAM))
1700                 return (EOPNOTSUPP);
1701
1702         switch (sopt->sopt_name) {
1703         case IP_MULTICAST_VIF: {
1704                 int vifi;
1705                 /*
1706                  * Select a multicast VIF for transmission.
1707                  * Only useful if multicast forwarding is active.
1708                  */
1709                 if (legal_vif_num == NULL) {
1710                         error = EOPNOTSUPP;
1711                         break;
1712                 }
1713                 error = sooptcopyin(sopt, &vifi, sizeof(int), sizeof(int));
1714                 if (error)
1715                         break;
1716                 if (!legal_vif_num(vifi) && (vifi != -1)) {
1717                         error = EINVAL;
1718                         break;
1719                 }
1720                 imo = inp_findmoptions(inp);
1721                 imo->imo_multicast_vif = vifi;
1722                 INP_WUNLOCK(inp);
1723                 break;
1724         }
1725
1726         case IP_MULTICAST_IF:
1727                 error = inp_set_multicast_if(inp, sopt);
1728                 break;
1729
1730         case IP_MULTICAST_TTL: {
1731                 u_char ttl;
1732
1733                 /*
1734                  * Set the IP time-to-live for outgoing multicast packets.
1735                  * The original multicast API required a char argument,
1736                  * which is inconsistent with the rest of the socket API.
1737                  * We allow either a char or an int.
1738                  */
1739                 if (sopt->sopt_valsize == sizeof(u_char)) {
1740                         error = sooptcopyin(sopt, &ttl, sizeof(u_char),
1741                             sizeof(u_char));
1742                         if (error)
1743                                 break;
1744                 } else {
1745                         u_int ittl;
1746
1747                         error = sooptcopyin(sopt, &ittl, sizeof(u_int),
1748                             sizeof(u_int));
1749                         if (error)
1750                                 break;
1751                         if (ittl > 255) {
1752                                 error = EINVAL;
1753                                 break;
1754                         }
1755                         ttl = (u_char)ittl;
1756                 }
1757                 imo = inp_findmoptions(inp);
1758                 imo->imo_multicast_ttl = ttl;
1759                 INP_WUNLOCK(inp);
1760                 break;
1761         }
1762
1763         case IP_MULTICAST_LOOP: {
1764                 u_char loop;
1765
1766                 /*
1767                  * Set the loopback flag for outgoing multicast packets.
1768                  * Must be zero or one.  The original multicast API required a
1769                  * char argument, which is inconsistent with the rest
1770                  * of the socket API.  We allow either a char or an int.
1771                  */
1772                 if (sopt->sopt_valsize == sizeof(u_char)) {
1773                         error = sooptcopyin(sopt, &loop, sizeof(u_char),
1774                             sizeof(u_char));
1775                         if (error)
1776                                 break;
1777                 } else {
1778                         u_int iloop;
1779
1780                         error = sooptcopyin(sopt, &iloop, sizeof(u_int),
1781                                             sizeof(u_int));
1782                         if (error)
1783                                 break;
1784                         loop = (u_char)iloop;
1785                 }
1786                 imo = inp_findmoptions(inp);
1787                 imo->imo_multicast_loop = !!loop;
1788                 INP_WUNLOCK(inp);
1789                 break;
1790         }
1791
1792         case IP_ADD_MEMBERSHIP:
1793         case IP_ADD_SOURCE_MEMBERSHIP:
1794         case MCAST_JOIN_GROUP:
1795         case MCAST_JOIN_SOURCE_GROUP:
1796                 error = inp_join_group(inp, sopt);
1797                 break;
1798
1799         case IP_DROP_MEMBERSHIP:
1800         case IP_DROP_SOURCE_MEMBERSHIP:
1801         case MCAST_LEAVE_GROUP:
1802         case MCAST_LEAVE_SOURCE_GROUP:
1803                 error = inp_leave_group(inp, sopt);
1804                 break;
1805
1806         case IP_BLOCK_SOURCE:
1807         case IP_UNBLOCK_SOURCE:
1808         case MCAST_BLOCK_SOURCE:
1809         case MCAST_UNBLOCK_SOURCE:
1810                 error = inp_change_source_filter(inp, sopt);
1811                 break;
1812
1813         case IP_MSFILTER:
1814                 error = inp_set_source_filters(inp, sopt);
1815                 break;
1816
1817         default:
1818                 error = EOPNOTSUPP;
1819                 break;
1820         }
1821
1822         INP_UNLOCK_ASSERT(inp);
1823
1824         return (error);
1825 }
1826
1827 /*
1828  * Following RFC1724 section 3.3, 0.0.0.0/8 is interpreted as interface index.
1829  */
1830 static struct ifnet *
1831 ip_multicast_if(struct in_addr *a)
1832 {
1833         int ifindex;
1834         struct ifnet *ifp;
1835
1836         if (ntohl(a->s_addr) >> 24 == 0) {
1837                 ifindex = ntohl(a->s_addr) & 0xffffff;
1838                 if (ifindex < 0 || if_index < ifindex)
1839                         return (NULL);
1840                 ifp = ifnet_byindex(ifindex);
1841         } else
1842                 INADDR_TO_IFP(*a, ifp);
1843         return (ifp);
1844 }
1845