lib/libc/net/sourcefilter.c

   1 /*-
   2  * Copyright (c) 2007-2009 Bruce Simpson.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "namespace.h"
  31
  32 #include <sys/param.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/socket.h>
  35
  36 #include <net/if_dl.h>
  37 #include <net/if.h>
  38 #include <netinet/in.h>
  39 #include <netinet/in_systm.h>
  40 #include <netinet/ip.h>
  41 #include <netinet/ip_var.h>
  42
  43 #include <assert.h>
  44 #include <errno.h>
  45 #include <ifaddrs.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48
  49 #include "un-namespace.h"
  50
  51 /*
  52  * Advanced (Full-state) multicast group membership APIs [RFC3678]
  53  * Currently this module assumes IPv4 support (INET) in the base system.
  54  */
  55 #ifndef INET
  56 #define INET
  57 #endif
  58
  59 union sockunion {
  60         struct sockaddr_storage ss;
  61         struct sockaddr         sa;
  62         struct sockaddr_dl      sdl;
  63 #ifdef INET
  64         struct sockaddr_in      sin;
  65 #endif
  66 #ifdef INET6
  67         struct sockaddr_in6     sin6;
  68 #endif
  69 };
  70 typedef union sockunion sockunion_t;
  71
  72 #ifndef MIN
  73 #define MIN(a, b)       ((a) < (b) ? (a) : (b))
  74 #endif
  75
  76 /*
  77  * Internal: Map an IPv4 unicast address to an interface index.
  78  * This is quite inefficient so it is recommended applications use
  79  * the newer, more portable, protocol independent API.
  80  */
  81 static uint32_t
  82 __inaddr_to_index(in_addr_t ifaddr)
  83 {
  84         struct ifaddrs  *ifa;
  85         struct ifaddrs  *ifaddrs;
  86         char            *ifname;
  87         int              ifindex;
  88         sockunion_t     *psu;
  89
  90         if (getifaddrs(&ifaddrs) < 0)
  91                 return (0);
  92
  93         ifindex = 0;
  94         ifname = NULL;
  95
  96         /*
  97          * Pass #1: Find the ifaddr entry corresponding to the
  98          * supplied IPv4 address. We should really use the ifindex
  99          * consistently for matches, however it is not available to
 100          * us on this pass.
 101          */
 102         for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
 103                 psu = (sockunion_t *)ifa->ifa_addr;
 104                 if (psu && psu->ss.ss_family == AF_INET &&
 105                     psu->sin.sin_addr.s_addr == ifaddr) {
 106                         ifname = ifa->ifa_name;
 107                         break;
 108                 }
 109         }
 110         if (ifname == NULL)
 111                 goto out;
 112
 113         /*
 114          * Pass #2: Find the index of the interface matching the name
 115          * we obtained from looking up the IPv4 ifaddr in pass #1.
 116          * There must be a better way of doing this.
 117          */
 118         for (ifa = ifaddrs; ifa != NULL; ifa = ifa->ifa_next) {
 119                 psu = (sockunion_t *)ifa->ifa_addr;
 120                 if (psu && psu->ss.ss_family == AF_LINK &&
 121                     strcmp(ifa->ifa_name, ifname) == 0) {
 122                         ifindex = LLINDEX(&psu->sdl);
 123                         break;
 124                 }
 125         }
 126         assert(ifindex != 0);
 127
 128 out:
 129         freeifaddrs(ifaddrs);
 130         return (ifindex);
 131 }
 132
 133 /*
 134  * Set IPv4 source filter list in use on socket.
 135  *
 136  * Stubbed to setsourcefilter(). Performs conversion of structures which
 137  * may be inefficient; applications are encouraged to use the
 138  * protocol-independent API.
 139  */
 140 int
 141 setipv4sourcefilter(int s, struct in_addr interface, struct in_addr group,
 142     uint32_t fmode, uint32_t numsrc, struct in_addr *slist)
 143 {
 144 #ifdef INET
 145         sockunion_t      tmpgroup;
 146         struct in_addr  *pina;
 147         sockunion_t     *psu, *tmpslist;
 148         int              err;
 149         size_t           i;
 150         uint32_t         ifindex;
 151
 152         assert(s != -1);
 153
 154         tmpslist = NULL;
 155
 156         if (!IN_MULTICAST(ntohl(group.s_addr)) ||
 157             (fmode != MCAST_INCLUDE && fmode != MCAST_EXCLUDE)) {
 158                 errno = EINVAL;
 159                 return (-1);
 160         }
 161
 162         ifindex = __inaddr_to_index(interface.s_addr);
 163         if (ifindex == 0) {
 164                 errno = EADDRNOTAVAIL;
 165                 return (-1);
 166         }
 167
 168         memset(&tmpgroup, 0, sizeof(sockunion_t));
 169         tmpgroup.sin.sin_family = AF_INET;
 170         tmpgroup.sin.sin_len = sizeof(struct sockaddr_in);
 171         tmpgroup.sin.sin_addr = group;
 172
 173         if (numsrc != 0 || slist != NULL) {
 174                 tmpslist = calloc(numsrc, sizeof(sockunion_t));
 175                 if (tmpslist == NULL) {
 176                         errno = ENOMEM;
 177                         return (-1);
 178                 }
 179
 180                 pina = slist;
 181                 psu = tmpslist;
 182                 for (i = 0; i < numsrc; i++, pina++, psu++) {
 183                         psu->sin.sin_family = AF_INET;
 184                         psu->sin.sin_len = sizeof(struct sockaddr_in);
 185                         psu->sin.sin_addr = *pina;
 186                 }
 187         }
 188
 189         err = setsourcefilter(s, ifindex, (struct sockaddr *)&tmpgroup,
 190             sizeof(struct sockaddr_in), fmode, numsrc,
 191             (struct sockaddr_storage *)tmpslist);
 192
 193         if (tmpslist != NULL)
 194                 free(tmpslist);
 195
 196         return (err);
 197 #else /* !INET */
 198         return (EAFNOSUPPORT);
 199 #endif /* INET */
 200 }
 201
 202 /*
 203  * Get IPv4 source filter list in use on socket.
 204  *
 205  * Stubbed to getsourcefilter(). Performs conversion of structures which
 206  * may be inefficient; applications are encouraged to use the
 207  * protocol-independent API.
 208  * An slist of NULL may be used for guessing the required buffer size.
 209  */
 210 int
 211 getipv4sourcefilter(int s, struct in_addr interface, struct in_addr group,
 212     uint32_t *fmode, uint32_t *numsrc, struct in_addr *slist)
 213 {
 214         sockunion_t     *psu, *tmpslist;
 215         sockunion_t      tmpgroup;
 216         struct in_addr  *pina;
 217         int              err;
 218         size_t           i;
 219         uint32_t         ifindex, onumsrc;
 220
 221         assert(s != -1);
 222         assert(fmode != NULL);
 223         assert(numsrc != NULL);
 224
 225         onumsrc = *numsrc;
 226         *numsrc = 0;
 227         tmpslist = NULL;
 228
 229         if (!IN_MULTICAST(ntohl(group.s_addr)) ||
 230             (onumsrc != 0 && slist == NULL)) {
 231                 errno = EINVAL;
 232                 return (-1);
 233         }
 234
 235         ifindex = __inaddr_to_index(interface.s_addr);
 236         if (ifindex == 0) {
 237                 errno = EADDRNOTAVAIL;
 238                 return (-1);
 239         }
 240
 241         memset(&tmpgroup, 0, sizeof(sockunion_t));
 242         tmpgroup.sin.sin_family = AF_INET;
 243         tmpgroup.sin.sin_len = sizeof(struct sockaddr_in);
 244         tmpgroup.sin.sin_addr = group;
 245
 246         if (onumsrc != 0 || slist != NULL) {
 247                 tmpslist = calloc(onumsrc, sizeof(sockunion_t));
 248                 if (tmpslist == NULL) {
 249                         errno = ENOMEM;
 250                         return (-1);
 251                 }
 252         }
 253
 254         err = getsourcefilter(s, ifindex, (struct sockaddr *)&tmpgroup,
 255             sizeof(struct sockaddr_in), fmode, numsrc,
 256             (struct sockaddr_storage *)tmpslist);
 257
 258         if (tmpslist != NULL && *numsrc != 0) {
 259                 pina = slist;
 260                 psu = tmpslist;
 261                 for (i = 0; i < MIN(onumsrc, *numsrc); i++, psu++) {
 262                         if (psu->ss.ss_family != AF_INET)
 263                                 continue;
 264                         *pina++ = psu->sin.sin_addr;
 265                 }
 266                 free(tmpslist);
 267         }
 268
 269         return (err);
 270 }
 271
 272 /*
 273  * Set protocol-independent source filter list in use on socket.
 274  */
 275 int
 276 setsourcefilter(int s, uint32_t interface, struct sockaddr *group,
 277     socklen_t grouplen, uint32_t fmode, uint32_t numsrc,
 278     struct sockaddr_storage *slist)
 279 {
 280         struct __msfilterreq     msfr;
 281         sockunion_t             *psu;
 282         int                      level, optname;
 283
 284         if (fmode != MCAST_INCLUDE && fmode != MCAST_EXCLUDE) {
 285                 errno = EINVAL;
 286                 return (-1);
 287         }
 288
 289         psu = (sockunion_t *)group;
 290         switch (psu->ss.ss_family) {
 291 #ifdef INET
 292         case AF_INET:
 293                 if ((grouplen != sizeof(struct sockaddr_in) ||
 294                     !IN_MULTICAST(ntohl(psu->sin.sin_addr.s_addr)))) {
 295                         errno = EINVAL;
 296                         return (-1);
 297                 }
 298                 level = IPPROTO_IP;
 299                 optname = IP_MSFILTER;
 300                 break;
 301 #endif
 302 #ifdef INET6
 303         case AF_INET6:
 304                 if (grouplen != sizeof(struct sockaddr_in6) ||
 305                     !IN6_IS_ADDR_MULTICAST(&psu->sin6.sin6_addr)) {
 306                         errno = EINVAL;
 307                         return (-1);
 308                 }
 309                 level = IPPROTO_IPV6;
 310                 optname = IPV6_MSFILTER;
 311                 break;
 312 #endif
 313         default:
 314                 errno = EAFNOSUPPORT;
 315                 return (-1);
 316         }
 317
 318         memset(&msfr, 0, sizeof(msfr));
 319         msfr.msfr_ifindex = interface;
 320         msfr.msfr_fmode = fmode;
 321         msfr.msfr_nsrcs = numsrc;
 322         memcpy(&msfr.msfr_group, &psu->ss, psu->ss.ss_len);
 323         msfr.msfr_srcs = slist;         /* pointer */
 324
 325         return (_setsockopt(s, level, optname, &msfr, sizeof(msfr)));
 326 }
 327
 328 /*
 329  * Get protocol-independent source filter list in use on socket.
 330  * An slist of NULL may be used for guessing the required buffer size.
 331  */
 332 int
 333 getsourcefilter(int s, uint32_t interface, struct sockaddr *group,
 334     socklen_t grouplen, uint32_t *fmode, uint32_t *numsrc,
 335     struct sockaddr_storage *slist)
 336 {
 337         struct __msfilterreq     msfr;
 338         sockunion_t             *psu;
 339         socklen_t                optlen;
 340         int                      err, level, nsrcs, optname;
 341
 342         if (interface == 0 || group == NULL || numsrc == NULL ||
 343             fmode == NULL) {
 344                 errno = EINVAL;
 345                 return (-1);
 346         }
 347
 348         nsrcs = *numsrc;
 349         *numsrc = 0;
 350         *fmode = 0;
 351
 352         psu = (sockunion_t *)group;
 353         switch (psu->ss.ss_family) {
 354 #ifdef INET
 355         case AF_INET:
 356                 if ((grouplen != sizeof(struct sockaddr_in) ||
 357                     !IN_MULTICAST(ntohl(psu->sin.sin_addr.s_addr)))) {
 358                         errno = EINVAL;
 359                         return (-1);
 360                 }
 361                 level = IPPROTO_IP;
 362                 optname = IP_MSFILTER;
 363                 break;
 364 #endif
 365 #ifdef INET6
 366         case AF_INET6:
 367                 if (grouplen != sizeof(struct sockaddr_in6) ||
 368                     !IN6_IS_ADDR_MULTICAST(&psu->sin6.sin6_addr)) {
 369                         errno = EINVAL;
 370                         return (-1);
 371                 }
 372                 level = IPPROTO_IPV6;
 373                 optname = IPV6_MSFILTER;
 374                 break;
 375 #endif
 376         default:
 377                 errno = EAFNOSUPPORT;
 378                 return (-1);
 379                 break;
 380         }
 381
 382         optlen = sizeof(struct __msfilterreq);
 383         memset(&msfr, 0, optlen);
 384         msfr.msfr_ifindex = interface;
 385         msfr.msfr_fmode = 0;
 386         msfr.msfr_nsrcs = nsrcs;
 387         memcpy(&msfr.msfr_group, &psu->ss, psu->ss.ss_len);
 388
 389         /*
 390          * msfr_srcs is a pointer to a vector of sockaddr_storage. It
 391          * may be NULL. The kernel will always return the total number
 392          * of filter entries for the group in msfr.msfr_nsrcs.
 393          */
 394         msfr.msfr_srcs = slist;
 395         err = _getsockopt(s, level, optname, &msfr, &optlen);
 396         if (err == 0) {
 397                 *numsrc = msfr.msfr_nsrcs;
 398                 *fmode = msfr.msfr_fmode;
 399         }
 400
 401         return (err);
 402 }