getifaddrs.c revision 1.4 
1/*	$NetBSD: getifaddrs.c,v 1.4 2000/04/24 10:40:25 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.4 2000/04/24 10:40:25 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#define	HAVE_IFAM_DATA
83#endif
84
85int
86getifaddrs(struct ifaddrs **pif)
87{
88	int icnt = 1;
89	int dcnt = 0;
90	int ncnt = 0;
91#ifdef	NET_RT_IFLIST
92	int mib[6];
93	size_t needed;
94	char *buf;
95	char *next;
96	struct ifaddrs *cif = 0;
97	char *p, *p0;
98	struct rt_msghdr *rtm;
99	struct if_msghdr *ifm;
100	struct ifa_msghdr *ifam;
101	struct sockaddr_dl *dl;
102	struct sockaddr *sa;
103	struct ifaddrs *ifa, *ift;
104	u_short index = 0;
105#else	/* NET_RT_IFLIST */
106	char buf[1024];
107	int m, sock;
108	struct ifconf ifc;
109	struct ifreq *ifr;
110	struct ifreq *lifr;
111#endif	/* NET_RT_IFLIST */
112	int i;
113	size_t len, alen;
114	char *data;
115	char *names;
116
117#ifdef	NET_RT_IFLIST
118	mib[0] = CTL_NET;
119	mib[1] = PF_ROUTE;
120	mib[2] = 0;             /* protocol */
121	mib[3] = 0;             /* wildcard address family */
122	mib[4] = NET_RT_IFLIST;
123	mib[5] = 0;             /* no flags */
124	if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
125		return (-1);
126	if ((buf = malloc(needed)) == NULL)
127		return (-1);
128	if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
129		free(buf);
130		return (-1);
131	}
132
133	for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
134		rtm = (struct rt_msghdr *)next;
135		if (rtm->rtm_version != RTM_VERSION)
136			continue;
137		switch (rtm->rtm_type) {
138		case RTM_IFINFO:
139			ifm = (struct if_msghdr *)rtm;
140			if (ifm->ifm_addrs & RTA_IFP) {
141				index = ifm->ifm_index;
142				++icnt;
143				dl = (struct sockaddr_dl *)(ifm + 1);
144				dcnt += SA_RLEN((struct sockaddr *)dl) +
145					ALIGNBYTES;
146#ifdef	HAVE_IFM_DATA
147				dcnt += sizeof(ifm->ifm_data);
148#endif	/* HAVE_IFM_DATA */
149				ncnt += dl->sdl_nlen + 1;
150			} else
151				index = 0;
152			break;
153
154		case RTM_NEWADDR:
155			ifam = (struct ifa_msghdr *)rtm;
156			if (index && ifam->ifam_index != index)
157				abort();	/* this cannot happen */
158
159#define	RTA_MASKS	(RTA_NETMASK | RTA_IFA | RTA_BRD)
160			if (index == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
161				break;
162			p = (char *)(ifam + 1);
163			++icnt;
164#ifdef	HAVE_IFAM_DATA
165			dcnt += sizeof(ifam->ifam_data) + ALIGNBYTES;
166#endif	/* HAVE_IFAM_DATA */
167			/* Scan to look for length of address */
168			alen = 0;
169			for (p0 = p, i = 0; i < RTAX_MAX; i++) {
170				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
171				    == 0)
172					continue;
173				sa = (struct sockaddr *)p;
174				len = SA_RLEN(sa);
175				if (i == RTAX_IFA) {
176					alen = len;
177					break;
178				}
179				p += len;
180			}
181			for (p = p0, i = 0; i < RTAX_MAX; i++) {
182				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
183				    == 0)
184					continue;
185				sa = (struct sockaddr *)p;
186				len = SA_RLEN(sa);
187				if (i == RTAX_NETMASK && SA_LEN(sa) == 0)
188					dcnt += alen;
189				else
190					dcnt += len;
191				p += len;
192			}
193			break;
194		}
195	}
196#else	/* NET_RT_IFLIST */
197	ifc.ifc_buf = buf;
198	ifc.ifc_len = sizeof(buf);
199
200	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
201		return (-1);
202	i =  ioctl(sock, SIOCGIFCONF, (char *)&ifc);
203	close(sock);
204	if (i < 0)
205		return (-1);
206
207	ifr = ifc.ifc_req;
208	lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];
209
210	while (ifr < lifr) {
211		struct sockaddr *sa;
212
213		sa = &ifr->ifr_addr;
214		++icnt;
215		dcnt += SA_RLEN(sa);
216		ncnt += sizeof(ifr->ifr_name) + 1;
217
218		ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
219	}
220#endif	/* NET_RT_IFLIST */
221
222	if (icnt + dcnt + ncnt == 1) {
223		*pif = NULL;
224		free(buf);
225		return (0);
226	}
227	data = malloc(sizeof(struct ifaddrs) * icnt + dcnt + ncnt);
228	if (data == NULL) {
229		free(buf);
230		return(-1);
231	}
232
233	ifa = (struct ifaddrs *)data;
234	data += sizeof(struct ifaddrs) * icnt;
235	names = data + dcnt;
236
237	memset(ifa, 0, sizeof(struct ifaddrs) * icnt);
238	ift = ifa;
239
240#ifdef	NET_RT_IFLIST
241	index = 0;
242	for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
243		rtm = (struct rt_msghdr *)next;
244		if (rtm->rtm_version != RTM_VERSION)
245			continue;
246		switch (rtm->rtm_type) {
247		case RTM_IFINFO:
248			ifm = (struct if_msghdr *)rtm;
249			if (ifm->ifm_addrs & RTA_IFP) {
250				index = ifm->ifm_index;
251				dl = (struct sockaddr_dl *)(ifm + 1);
252
253				cif = ift;
254				ift->ifa_name = names;
255				ift->ifa_flags = (int)ifm->ifm_flags;
256				memcpy(names, dl->sdl_data, dl->sdl_nlen);
257				names[dl->sdl_nlen] = 0;
258				names += dl->sdl_nlen + 1;
259
260				ift->ifa_addr = (struct sockaddr *)data;
261				memcpy(data, dl, SA_LEN((struct sockaddr *)dl));
262				data += SA_RLEN((struct sockaddr *)dl);
263
264#ifdef	HAVE_IFM_DATA
265				/* ifm_data needs to be aligned */
266				ift->ifa_data = data = (void *)ALIGN(data);
267				memcpy(data, &ifm->ifm_data, sizeof(ifm->ifm_data));
268 				data += sizeof(ifm->ifm_data);
269#else	/* HAVE_IFM_DATA */
270				ift->ifa_data = NULL;
271#endif	/* HAVE_IFM_DATA */
272
273				ift = (ift->ifa_next = ift + 1);
274			} else
275				index = 0;
276			break;
277
278		case RTM_NEWADDR:
279			ifam = (struct ifa_msghdr *)rtm;
280			if (index && ifam->ifam_index != index)
281				abort();	/* this cannot happen */
282
283			if (index == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
284				break;
285			ift->ifa_name = cif->ifa_name;
286			ift->ifa_flags = cif->ifa_flags;
287			ift->ifa_data = NULL;
288			p = (char *)(ifam + 1);
289			/* Scan to look for length of address */
290			alen = 0;
291			for (p0 = p, i = 0; i < RTAX_MAX; i++) {
292				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
293				    == 0)
294					continue;
295				sa = (struct sockaddr *)p;
296				len = SA_RLEN(sa);
297				if (i == RTAX_IFA) {
298					alen = len;
299					break;
300				}
301				p += len;
302			}
303			for (p = p0, i = 0; i < RTAX_MAX; i++) {
304				if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
305				    == 0)
306					continue;
307				sa = (struct sockaddr *)p;
308				len = SA_RLEN(sa);
309				switch (i) {
310				case RTAX_IFA:
311					ift->ifa_addr = (struct sockaddr *)data;
312					memcpy(data, p, len);
313					data += len;
314					break;
315
316				case RTAX_NETMASK:
317					ift->ifa_netmask =
318					    (struct sockaddr *)data;
319					if (SA_LEN(sa) == 0) {
320						memset(data, 0, alen);
321						data += alen;
322						break;
323					}
324					memcpy(data, p, len);
325					data += len;
326					break;
327
328				case RTAX_BRD:
329					ift->ifa_broadaddr =
330					    (struct sockaddr *)data;
331					memcpy(data, p, len);
332					data += len;
333					break;
334				}
335				p += len;
336			}
337
338#ifdef	HAVE_IFAM_DATA
339			/* ifam_data needs to be aligned */
340			ift->ifa_data = data = (void *)ALIGN(data);
341			memcpy(data, &ifam->ifam_data, sizeof(ifam->ifam_data));
342			data += sizeof(ifam->ifam_data);
343#endif	/* HAVE_IFAM_DATA */
344
345			ift = (ift->ifa_next = ift + 1);
346			break;
347		}
348	}
349
350	free(buf);
351#else	/* NET_RT_IFLIST */
352	ifr = ifc.ifc_req;
353	lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];
354
355	while (ifr < lifr) {
356		struct sockaddr *sa;
357
358		ift->ifa_name = names;
359		names[sizeof(ifr->ifr_name)] = 0;
360		strncpy(names, ifr->ifr_name, sizeof(ifr->ifr_name));
361		while (*names++)
362			;
363
364		ift->ifa_addr = (struct sockaddr *)data;
365		sa = &ifr->ifr_addr;
366		memcpy(data, sa, SA_LEN(sa));
367		data += SA_RLEN(sa);
368
369		ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
370		ift = (ift->ifa_next = ift + 1);
371	}
372#endif	/* NET_RT_IFLIST */
373	if (--ift >= ifa) {
374		ift->ifa_next = NULL;
375		*pif = ifa;
376	} else {
377		*pif = NULL;
378		free(ifa);
379	}
380	return (0);
381}
382
383void
384freeifaddrs(struct ifaddrs *ifp)
385{
386	free(ifp);
387}
388