getifaddrs.c revision 1.6 
1/*	$NetBSD: getifaddrs.c,v 1.6 2000/10/27 15:48:49 itojun Exp $	*/
2
3/*
4 * Copyright (c) 1995, 1999
5 *	Berkeley Software Design, Inc.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 *
13 * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 *
25 *	BSDI getifaddrs.c,v 2.12 2000/02/23 14:51:59 dab Exp
26 */
27
28#include <sys/cdefs.h>
29#if defined(LIBC_SCCS) && !defined(lint)
30__RCSID("$NetBSD: getifaddrs.c,v 1.6 2000/10/27 15:48:49 itojun Exp $");
31#endif /* LIBC_SCCS and not lint */
32
33#include "namespace.h"
34#include <sys/types.h>
35#include <sys/ioctl.h>
36#include <sys/socket.h>
37#include <net/if.h>
38#ifdef	NET_RT_IFLIST
39#include <sys/param.h>
40#include <net/route.h>
41#include <sys/sysctl.h>
42#include <net/if_dl.h>
43#endif
44
45#include <errno.h>
46#include <ifaddrs.h>
47#include <stdlib.h>
48#include <string.h>
49
50#ifdef __weak_alias
51__weak_alias(getifaddrs,_getifaddrs)
52__weak_alias(freeifaddrs,_freeifaddrs)
53#endif
54
55#if !defined(AF_LINK)
56#define	SA_LEN(sa)	sizeof(struct sockaddr)
57#endif
58
59#if !defined(SA_LEN)
60#define	SA_LEN(sa)	(sa)->sa_len
61#endif
62
63#define	SALIGN	(sizeof(long) - 1)
64#define	SA_RLEN(sa)	((sa)->sa_len ? (((sa)->sa_len + SALIGN) & ~SALIGN) : (SALIGN + 1))
65
66#ifndef	ALIGNBYTES
67/*
68 * On systems with a routing socket, ALIGNBYTES should match the value
69 * that the kernel uses when building the messages.
70 */
71#define	ALIGNBYTES	XXX
72#endif
73#ifndef	ALIGN
74#define	ALIGN(p)	(((u_long)(p) + ALIGNBYTES) &~ ALIGNBYTES)
75#endif
76
77#if	_BSDI_VERSION >= 199701
78#define	HAVE_IFM_DATA
79#endif
80
81#if	_BSDI_VERSION >= 199802
82/* ifam_data is very specific to recent versions of bsdi */
83#define	HAVE_IFAM_DATA
84#endif
85
86#if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
87#define	HAVE_IFM_DATA
88#endif
89
90int
91getifaddrs(struct ifaddrs **pif)
92{
93	int icnt = 1;
94	int dcnt = 0;
95	int ncnt = 0;
96#ifdef	NET_RT_IFLIST
97	int mib[6];
98	size_t needed;
99	char *buf;
100	char *next;
101	struct ifaddrs *cif = 0;
102	char *p, *p0;
103	struct rt_msghdr *rtm;
104	struct if_msghdr *ifm;
105	struct ifa_msghdr *ifam;
106	struct sockaddr_dl *dl;
107	struct sockaddr *sa;
108	struct ifaddrs *ifa, *ift;
109	u_short idx = 0;
110#else	/* NET_RT_IFLIST */
111	char buf[1024];
112	int m, sock;
113	struct ifconf ifc;
114	struct ifreq *ifr;
115	struct ifreq *lifr;
116#endif	/* NET_RT_IFLIST */
117	int i;
118	size_t len, alen;
119	char *data;
120	char *names;
121
122#ifdef	NET_RT_IFLIST
123	mib[0] = CTL_NET;
124	mib[1] = PF_ROUTE;
125	mib[2] = 0;             /* protocol */
126	mib[3] = 0;             /* wildcard address family */
127	mib[4] = NET_RT_IFLIST;
128	mib[5] = 0;             /* no flags */
129	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
130		return (-1);
131	if ((buf = malloc(needed)) == NULL)
132		return (-1);
133	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
134		free(buf);
135		return (-1);
136	}
137
138	for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
139		rtm = (struct rt_msghdr *)(void *)next;
140		if (rtm->rtm_version != RTM_VERSION)
141			continue;
142		switch (rtm->rtm_type) {
143		case RTM_IFINFO:
144			ifm = (struct if_msghdr *)(void *)rtm;
145			if (ifm->ifm_addrs & RTA_IFP) {
146				idx = ifm->ifm_index;
147				++icnt;
148				dl = (struct sockaddr_dl *)(void *)(ifm + 1);
149				dcnt += SA_RLEN((struct sockaddr *)(void*)dl) +
150				    ALIGNBYTES;
151#ifdef	HAVE_IFM_DATA
152				dcnt += sizeof(ifm->ifm_data);
153#endif	/* HAVE_IFM_DATA */
154				ncnt += dl->sdl_nlen + 1;
155			} else
156				idx = 0;
157			break;
158
159		case RTM_NEWADDR:
160			ifam = (struct ifa_msghdr *)(void *)rtm;
161			if (idx && ifam->ifam_index != idx)
162				abort();	/* this cannot happen */
163
164#define	RTA_MASKS	(RTA_NETMASK | RTA_IFA | RTA_BRD)
165			if (idx == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
166				break;
167			p = (char *)(void *)(ifam + 1);
168			++icnt;
169#ifdef	HAVE_IFAM_DATA
170			dcnt += sizeof(ifam->ifam_data) + ALIGNBYTES;
171#endif	/* HAVE_IFAM_DATA */
172			/* Scan to look for length of address */
173			alen = 0;
174			for (p0 = p, i = 0; i < RTAX_MAX; i++) {
175				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
176				    == 0)
177					continue;
178				sa = (struct sockaddr *)(void *)p;
179				len = SA_RLEN(sa);
180				if (i == RTAX_IFA) {
181					alen = len;
182					break;
183				}
184				p += len;
185			}
186			for (p = p0, i = 0; i < RTAX_MAX; i++) {
187				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
188				    == 0)
189					continue;
190				sa = (struct sockaddr *)(void *)p;
191				len = SA_RLEN(sa);
192				if (i == RTAX_NETMASK && SA_LEN(sa) == 0)
193					dcnt += alen;
194				else
195					dcnt += len;
196				p += len;
197			}
198			break;
199		}
200	}
201#else	/* NET_RT_IFLIST */
202	ifc.ifc_buf = buf;
203	ifc.ifc_len = sizeof(buf);
204
205	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
206		return (-1);
207	i =  ioctl(sock, SIOCGIFCONF, (char *)&ifc);
208	close(sock);
209	if (i < 0)
210		return (-1);
211
212	ifr = ifc.ifc_req;
213	lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];
214
215	while (ifr < lifr) {
216		struct sockaddr *sa;
217
218		sa = &ifr->ifr_addr;
219		++icnt;
220		dcnt += SA_RLEN(sa);
221		ncnt += sizeof(ifr->ifr_name) + 1;
222
223		ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
224	}
225#endif	/* NET_RT_IFLIST */
226
227	if (icnt + dcnt + ncnt == 1) {
228		*pif = NULL;
229		free(buf);
230		return (0);
231	}
232	data = malloc(sizeof(struct ifaddrs) * icnt + dcnt + ncnt);
233	if (data == NULL) {
234		free(buf);
235		return(-1);
236	}
237
238	ifa = (struct ifaddrs *)(void *)data;
239	data += sizeof(struct ifaddrs) * icnt;
240	names = data + dcnt;
241
242	memset(ifa, 0, sizeof(struct ifaddrs) * icnt);
243	ift = ifa;
244
245#ifdef	NET_RT_IFLIST
246	idx = 0;
247	for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
248		rtm = (struct rt_msghdr *)(void *)next;
249		if (rtm->rtm_version != RTM_VERSION)
250			continue;
251		switch (rtm->rtm_type) {
252		case RTM_IFINFO:
253			ifm = (struct if_msghdr *)(void *)rtm;
254			if (ifm->ifm_addrs & RTA_IFP) {
255				idx = ifm->ifm_index;
256				dl = (struct sockaddr_dl *)(void *)(ifm + 1);
257
258				cif = ift;
259				ift->ifa_name = names;
260				ift->ifa_flags = (int)ifm->ifm_flags;
261				memcpy(names, dl->sdl_data,
262				    (size_t)dl->sdl_nlen);
263				names[dl->sdl_nlen] = 0;
264				names += dl->sdl_nlen + 1;
265
266				ift->ifa_addr = (struct sockaddr *)(void *)data;
267				memcpy(data, dl,
268				    (size_t)SA_LEN((struct sockaddr *)
269				    (void *)dl));
270				data += SA_RLEN((struct sockaddr *)(void *)dl);
271
272#ifdef	HAVE_IFM_DATA
273				/* ifm_data needs to be aligned */
274				ift->ifa_data = data = (void *)ALIGN(data);
275				memcpy(data, &ifm->ifm_data, sizeof(ifm->ifm_data));
276 				data += sizeof(ifm->ifm_data);
277#else	/* HAVE_IFM_DATA */
278				ift->ifa_data = NULL;
279#endif	/* HAVE_IFM_DATA */
280
281				ift = (ift->ifa_next = ift + 1);
282			} else
283				idx = 0;
284			break;
285
286		case RTM_NEWADDR:
287			ifam = (struct ifa_msghdr *)(void *)rtm;
288			if (idx && ifam->ifam_index != idx)
289				abort();	/* this cannot happen */
290
291			if (idx == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
292				break;
293			ift->ifa_name = cif->ifa_name;
294			ift->ifa_flags = cif->ifa_flags;
295			ift->ifa_data = NULL;
296			p = (char *)(void *)(ifam + 1);
297			/* Scan to look for length of address */
298			alen = 0;
299			for (p0 = p, i = 0; i < RTAX_MAX; i++) {
300				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
301				    == 0)
302					continue;
303				sa = (struct sockaddr *)(void *)p;
304				len = SA_RLEN(sa);
305				if (i == RTAX_IFA) {
306					alen = len;
307					break;
308				}
309				p += len;
310			}
311			for (p = p0, i = 0; i < RTAX_MAX; i++) {
312				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
313				    == 0)
314					continue;
315				sa = (struct sockaddr *)(void *)p;
316				len = SA_RLEN(sa);
317				switch (i) {
318				case RTAX_IFA:
319					ift->ifa_addr =
320					    (struct sockaddr *)(void *)data;
321					memcpy(data, p, len);
322					data += len;
323					break;
324
325				case RTAX_NETMASK:
326					ift->ifa_netmask =
327					    (struct sockaddr *)(void *)data;
328					if (SA_LEN(sa) == 0) {
329						memset(data, 0, alen);
330						data += alen;
331						break;
332					}
333					memcpy(data, p, len);
334					data += len;
335					break;
336
337				case RTAX_BRD:
338					ift->ifa_broadaddr =
339					    (struct sockaddr *)(void *)data;
340					memcpy(data, p, len);
341					data += len;
342					break;
343				}
344				p += len;
345			}
346
347#ifdef	HAVE_IFAM_DATA
348			/* ifam_data needs to be aligned */
349			ift->ifa_data = data = (void *)ALIGN(data);
350			memcpy(data, &ifam->ifam_data, sizeof(ifam->ifam_data));
351			data += sizeof(ifam->ifam_data);
352#endif	/* HAVE_IFAM_DATA */
353
354			ift = (ift->ifa_next = ift + 1);
355			break;
356		}
357	}
358
359	free(buf);
360#else	/* NET_RT_IFLIST */
361	ifr = ifc.ifc_req;
362	lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];
363
364	while (ifr < lifr) {
365		struct sockaddr *sa;
366
367		ift->ifa_name = names;
368		names[sizeof(ifr->ifr_name)] = 0;
369		strncpy(names, ifr->ifr_name, sizeof(ifr->ifr_name));
370		while (*names++)
371			;
372
373		ift->ifa_addr = (struct sockaddr *)data;
374		sa = &ifr->ifr_addr;
375		memcpy(data, sa, SA_LEN(sa));
376		data += SA_RLEN(sa);
377
378		ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
379		ift = (ift->ifa_next = ift + 1);
380	}
381#endif	/* NET_RT_IFLIST */
382	if (--ift >= ifa) {
383		ift->ifa_next = NULL;
384		*pif = ifa;
385	} else {
386		*pif = NULL;
387		free(ifa);
388	}
389	return (0);
390}
391
392void
393freeifaddrs(struct ifaddrs *ifp)
394{
395	free(ifp);
396}
397