usr/src/lib/libc/port/inet/getifaddrs.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2017 RackTop Systems.
  25  */
  26
  27 #include <netdb.h>
  28 #include <nss_dbdefs.h>
  29 #include <netinet/in.h>
  30 #include <sys/socket.h>
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <sys/sockio.h>
  34 #include <sys/types.h>
  35 #include <stdlib.h>
  36 #include <net/if.h>
  37 #include <ifaddrs.h>
  38 #include <libsocket_priv.h>
  39
  40 /*
  41  * Create a linked list of `struct ifaddrs' structures, one for each
  42  * address that is UP. If successful, store the list in *ifap and
  43  * return 0.  On errors, return -1 and set `errno'.
  44  *
  45  * The storage returned in *ifap is allocated dynamically and can
  46  * only be properly freed by passing it to `freeifaddrs'.
  47  */
  48 int
  49 getifaddrs(struct ifaddrs **ifap)
  50 {
  51         int             err;
  52         char            *cp;
  53         struct ifaddrs  *curr;
  54
  55         if (ifap == NULL) {
  56                 errno = EINVAL;
  57                 return (-1);
  58         }
  59         *ifap = NULL;
  60         err = getallifaddrs(AF_UNSPEC, ifap, LIFC_ENABLED);
  61         if (err == 0) {
  62                 for (curr = *ifap; curr != NULL; curr = curr->ifa_next) {
  63                         if ((cp = strchr(curr->ifa_name, ':')) != NULL)
  64                                 *cp = '\0';
  65                 }
  66         }
  67         return (err);
  68 }
  69
  70 void
  71 freeifaddrs(struct ifaddrs *ifa)
  72 {
  73         struct ifaddrs *curr;
  74
  75         while (ifa != NULL) {
  76                 curr = ifa;
  77                 ifa = ifa->ifa_next;
  78                 free(curr->ifa_name);
  79                 free(curr->ifa_addr);
  80                 free(curr->ifa_netmask);
  81                 free(curr->ifa_dstaddr);
  82                 free(curr);
  83         }
  84 }
  85
  86 /*
  87  * Returns all addresses configured on the system. If flags contain
  88  * LIFC_ENABLED, only the addresses that are UP are returned.
  89  * Address list that is returned by this function must be freed
  90  * using freeifaddrs().
  91  */
  92 int
  93 getallifaddrs(sa_family_t af, struct ifaddrs **ifap, int64_t flags)
  94 {
  95         struct lifreq *buf = NULL;
  96         struct lifreq *lifrp;
  97         struct lifreq lifrl;
  98         int ret;
  99         int s, n, numifs;
 100         struct ifaddrs *curr, *prev;
 101         sa_family_t lifr_af;
 102         int sock4;
 103         int sock6;
 104         int err;
 105
 106         /*
 107          * Initialize ifap to NULL so we can safely call freeifaddrs
 108          * on it in case of error.
 109          */
 110         if (ifap == NULL)
 111                 return (EINVAL);
 112         *ifap = NULL;
 113
 114         if ((sock4 = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 115                 return (-1);
 116         if ((sock6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
 117                 err = errno;
 118                 close(sock4);
 119                 errno = err;
 120                 return (-1);
 121         }
 122
 123 retry:
 124         /* Get all interfaces from SIOCGLIFCONF */
 125         ret = getallifs(sock4, af, &buf, &numifs, (flags & ~LIFC_ENABLED));
 126         if (ret != 0)
 127                 goto fail;
 128
 129         /*
 130          * Loop through the interfaces obtained from SIOCGLIFCOMF
 131          * and retrieve the addresses, netmask and flags.
 132          */
 133         prev = NULL;
 134         lifrp = buf;
 135         for (n = 0; n < numifs; n++, lifrp++) {
 136
 137                 /* Prepare for the ioctl call */
 138                 (void) strncpy(lifrl.lifr_name, lifrp->lifr_name,
 139                     sizeof (lifrl.lifr_name));
 140                 lifr_af = lifrp->lifr_addr.ss_family;
 141                 if (af != AF_UNSPEC && lifr_af != af)
 142                         continue;
 143
 144                 s = (lifr_af == AF_INET ? sock4 : sock6);
 145
 146                 if (ioctl(s, SIOCGLIFFLAGS, (caddr_t)&lifrl) < 0)
 147                         goto fail;
 148                 if ((flags & LIFC_ENABLED) && !(lifrl.lifr_flags & IFF_UP))
 149                         continue;
 150
 151                 /*
 152                  * Allocate the current list node. Each node contains data
 153                  * for one ifaddrs structure.
 154                  */
 155                 curr = calloc(1, sizeof (struct ifaddrs));
 156                 if (curr == NULL)
 157                         goto fail;
 158
 159                 if (prev != NULL) {
 160                         prev->ifa_next = curr;
 161                 } else {
 162                         /* First node in the linked list */
 163                         *ifap = curr;
 164                 }
 165                 prev = curr;
 166
 167                 curr->ifa_flags = lifrl.lifr_flags;
 168                 if ((curr->ifa_name = strdup(lifrp->lifr_name)) == NULL)
 169                         goto fail;
 170
 171                 curr->ifa_addr = malloc(sizeof (struct sockaddr_storage));
 172                 if (curr->ifa_addr == NULL)
 173                         goto fail;
 174                 (void) memcpy(curr->ifa_addr, &lifrp->lifr_addr,
 175                     sizeof (struct sockaddr_storage));
 176
 177                 /* Get the netmask */
 178                 if (ioctl(s, SIOCGLIFNETMASK, (caddr_t)&lifrl) < 0)
 179                         goto fail;
 180                 curr->ifa_netmask = malloc(sizeof (struct sockaddr_storage));
 181                 if (curr->ifa_netmask == NULL)
 182                         goto fail;
 183                 (void) memcpy(curr->ifa_netmask, &lifrl.lifr_addr,
 184                     sizeof (struct sockaddr_storage));
 185
 186                 /* Get the destination for a pt-pt interface */
 187                 if (curr->ifa_flags & IFF_POINTOPOINT) {
 188                         if (ioctl(s, SIOCGLIFDSTADDR, (caddr_t)&lifrl) < 0)
 189                                 goto fail;
 190                         curr->ifa_dstaddr = malloc(
 191                             sizeof (struct sockaddr_storage));
 192                         if (curr->ifa_dstaddr == NULL)
 193                                 goto fail;
 194                         (void) memcpy(curr->ifa_dstaddr, &lifrl.lifr_addr,
 195                             sizeof (struct sockaddr_storage));
 196                 } else if (curr->ifa_flags & IFF_BROADCAST) {
 197                         if (ioctl(s, SIOCGLIFBRDADDR, (caddr_t)&lifrl) < 0)
 198                                 goto fail;
 199                         curr->ifa_broadaddr = malloc(
 200                             sizeof (struct sockaddr_storage));
 201                         if (curr->ifa_broadaddr == NULL)
 202                                 goto fail;
 203                         (void) memcpy(curr->ifa_broadaddr, &lifrl.lifr_addr,
 204                             sizeof (struct sockaddr_storage));
 205                 }
 206
 207         }
 208         free(buf);
 209         close(sock4);
 210         close(sock6);
 211         return (0);
 212 fail:
 213         err = errno;
 214         free(buf);
 215         freeifaddrs(*ifap);
 216         *ifap = NULL;
 217         if (err == ENXIO)
 218                 goto retry;
 219         close(sock4);
 220         close(sock6);
 221         errno = err;
 222         return (-1);
 223 }
 224
 225 /*
 226  * Do a SIOCGLIFCONF and store all the interfaces in `buf'.
 227  */
 228 int
 229 getallifs(int s, sa_family_t af, struct lifreq **lifr, int *numifs,
 230     int64_t lifc_flags)
 231 {
 232         struct lifnum lifn;
 233         struct lifconf lifc;
 234         size_t bufsize;
 235         char *tmp;
 236         caddr_t *buf = (caddr_t *)lifr;
 237
 238         lifn.lifn_family = af;
 239         lifn.lifn_flags = lifc_flags;
 240
 241         *buf = NULL;
 242 retry:
 243         if (ioctl(s, SIOCGLIFNUM, &lifn) < 0)
 244                 goto fail;
 245
 246         /*
 247          * When calculating the buffer size needed, add a small number
 248          * of interfaces to those we counted.  We do this to capture
 249          * the interface status of potential interfaces which may have
 250          * been plumbed between the SIOCGLIFNUM and the SIOCGLIFCONF.
 251          */
 252         bufsize = (lifn.lifn_count + 4) * sizeof (struct lifreq);
 253
 254         if ((tmp = realloc(*buf, bufsize)) == NULL)
 255                 goto fail;
 256
 257         *buf = tmp;
 258         lifc.lifc_family = af;
 259         lifc.lifc_flags = lifc_flags;
 260         lifc.lifc_len = bufsize;
 261         lifc.lifc_buf = *buf;
 262         if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) < 0)
 263                 goto fail;
 264
 265         *numifs = lifc.lifc_len / sizeof (struct lifreq);
 266         if (*numifs >= (lifn.lifn_count + 4)) {
 267                 /*
 268                  * If every entry was filled, there are probably
 269                  * more interfaces than (lifn.lifn_count + 4).
 270                  * Redo the ioctls SIOCGLIFNUM and SIOCGLIFCONF to
 271                  * get all the interfaces.
 272                  */
 273                 goto retry;
 274         }
 275         return (0);
 276 fail:
 277         free(*buf);
 278         *buf = NULL;
 279         return (-1);
 280 }