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