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 } 281