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