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
getifaddrs(struct ifaddrs ** ifap)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
freeifaddrs(struct ifaddrs * ifa)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
getallifaddrs(sa_family_t af,struct ifaddrs ** ifap,int64_t flags)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
getallifs(int s,sa_family_t af,struct lifreq ** lifr,int * numifs,int64_t lifc_flags)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