netaddr.c revision 293896 
1/*
2 * Copyright (C) 2004, 2005, 2007, 2010-2012  Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2002  Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18/* $Id$ */
19
20/*! \file */
21
22#include <config.h>
23
24#include <stdio.h>
25
26#include <isc/buffer.h>
27#include <isc/msgs.h>
28#include <isc/net.h>
29#include <isc/netaddr.h>
30#include <isc/print.h>
31#include <isc/sockaddr.h>
32#include <isc/string.h>
33#include <isc/util.h>
34#include "ntp_stdlib.h"		/* NTP change for strlcpy, strlcat */
35
36isc_boolean_t
37isc_netaddr_equal(const isc_netaddr_t *a, const isc_netaddr_t *b) {
38	REQUIRE(a != NULL && b != NULL);
39
40	if (a->family != b->family)
41		return (ISC_FALSE);
42
43	if (a->zone != b->zone)
44		return (ISC_FALSE);
45
46	switch (a->family) {
47	case AF_INET:
48		if (a->type.in.s_addr != b->type.in.s_addr)
49			return (ISC_FALSE);
50		break;
51	case AF_INET6:
52		if (memcmp(&a->type.in6, &b->type.in6,
53			   sizeof(a->type.in6)) != 0 ||
54		    a->zone != b->zone)
55			return (ISC_FALSE);
56		break;
57#ifdef ISC_PLATFORM_HAVESYSUNH
58	case AF_UNIX:
59		if (strcmp(a->type.un, b->type.un) != 0)
60			return (ISC_FALSE);
61		break;
62#endif
63	default:
64		return (ISC_FALSE);
65	}
66	return (ISC_TRUE);
67}
68
69isc_boolean_t
70isc_netaddr_eqprefix(const isc_netaddr_t *a, const isc_netaddr_t *b,
71		     unsigned int prefixlen)
72{
73	const unsigned char *pa = NULL, *pb = NULL;
74	unsigned int ipabytes = 0; /* Length of whole IP address in bytes */
75	unsigned int nbytes;       /* Number of significant whole bytes */
76	unsigned int nbits;        /* Number of significant leftover bits */
77
78	REQUIRE(a != NULL && b != NULL);
79
80	if (a->family != b->family)
81		return (ISC_FALSE);
82
83	if (a->zone != b->zone && b->zone != 0)
84		return (ISC_FALSE);
85
86	switch (a->family) {
87	case AF_INET:
88		pa = (const unsigned char *) &a->type.in;
89		pb = (const unsigned char *) &b->type.in;
90		ipabytes = 4;
91		break;
92	case AF_INET6:
93		pa = (const unsigned char *) &a->type.in6;
94		pb = (const unsigned char *) &b->type.in6;
95		ipabytes = 16;
96		break;
97	default:
98		return (ISC_FALSE);
99	}
100
101	/*
102	 * Don't crash if we get a pattern like 10.0.0.1/9999999.
103	 */
104	if (prefixlen > ipabytes * 8)
105		prefixlen = ipabytes * 8;
106
107	nbytes = prefixlen / 8;
108	nbits = prefixlen % 8;
109
110	if (nbytes > 0) {
111		if (memcmp(pa, pb, nbytes) != 0)
112			return (ISC_FALSE);
113	}
114	if (nbits > 0) {
115		unsigned int bytea, byteb, mask;
116		INSIST(nbytes < ipabytes);
117		INSIST(nbits < 8);
118		bytea = pa[nbytes];
119		byteb = pb[nbytes];
120		mask = (0xFF << (8-nbits)) & 0xFF;
121		if ((bytea & mask) != (byteb & mask))
122			return (ISC_FALSE);
123	}
124	return (ISC_TRUE);
125}
126
127isc_result_t
128isc_netaddr_totext(const isc_netaddr_t *netaddr, isc_buffer_t *target) {
129	char abuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")];
130	char zbuf[sizeof("%4294967295")];
131	unsigned int alen;
132	int zlen;
133	const char *r;
134	const void *type;
135
136	REQUIRE(netaddr != NULL);
137
138	switch (netaddr->family) {
139	case AF_INET:
140		type = &netaddr->type.in;
141		break;
142	case AF_INET6:
143		type = &netaddr->type.in6;
144		break;
145#ifdef ISC_PLATFORM_HAVESYSUNH
146	case AF_UNIX:
147		alen = strlen(netaddr->type.un);
148		if (alen > isc_buffer_availablelength(target))
149			return (ISC_R_NOSPACE);
150		isc_buffer_putmem(target,
151				  (const unsigned char *)(netaddr->type.un),
152				  alen);
153		return (ISC_R_SUCCESS);
154#endif
155	default:
156		return (ISC_R_FAILURE);
157	}
158	r = inet_ntop(netaddr->family, type, abuf, sizeof(abuf));
159	if (r == NULL)
160		return (ISC_R_FAILURE);
161
162	alen = (unsigned int)strlen(abuf); /* no overflow possible */
163	INSIST(alen < sizeof(abuf));
164
165	zlen = 0;
166	if (netaddr->family == AF_INET6 && netaddr->zone != 0) {
167		zlen = snprintf(zbuf, sizeof(zbuf), "%%%u", netaddr->zone);
168		if (zlen < 0)
169			return (ISC_R_FAILURE);
170		INSIST((unsigned int)zlen < sizeof(zbuf));
171	}
172
173	if (alen + zlen > isc_buffer_availablelength(target))
174		return (ISC_R_NOSPACE);
175
176	isc_buffer_putmem(target, (unsigned char *)abuf, alen);
177	isc_buffer_putmem(target, (unsigned char *)zbuf, zlen);
178
179	return (ISC_R_SUCCESS);
180}
181
182void
183isc_netaddr_format(const isc_netaddr_t *na, char *array, unsigned int size) {
184	isc_result_t result;
185	isc_buffer_t buf;
186
187	isc_buffer_init(&buf, array, size);
188	result = isc_netaddr_totext(na, &buf);
189
190	if (size == 0)
191		return;
192
193	/*
194	 * Null terminate.
195	 */
196	if (result == ISC_R_SUCCESS) {
197		if (isc_buffer_availablelength(&buf) >= 1)
198			isc_buffer_putuint8(&buf, 0);
199		else
200			result = ISC_R_NOSPACE;
201	}
202
203	if (result != ISC_R_SUCCESS) {
204		snprintf(array, size,
205			 "<%s %u>",
206			 isc_msgcat_get(isc_msgcat, ISC_MSGSET_NETADDR,
207					ISC_MSG_UNKNOWNADDR,
208					"unknown address, family"),
209			 na->family);
210		array[size - 1] = '\0';
211	}
212}
213
214
215isc_result_t
216isc_netaddr_prefixok(const isc_netaddr_t *na, unsigned int prefixlen) {
217	static const unsigned char zeros[16] = { 0 };
218	unsigned int nbits, nbytes, ipbytes = 0;
219	const unsigned char *p;
220
221	switch (na->family) {
222	case AF_INET:
223		p = (const unsigned char *) &na->type.in;
224		ipbytes = 4;
225		if (prefixlen > 32)
226			return (ISC_R_RANGE);
227		break;
228	case AF_INET6:
229		p = (const unsigned char *) &na->type.in6;
230		ipbytes = 16;
231		if (prefixlen > 128)
232			return (ISC_R_RANGE);
233		break;
234	default:
235		return (ISC_R_NOTIMPLEMENTED);
236	}
237	nbytes = prefixlen / 8;
238	nbits = prefixlen % 8;
239	if (nbits != 0) {
240		if ((p[nbytes] & (0xff>>nbits)) != 0U)
241			return (ISC_R_FAILURE);
242		nbytes++;
243	}
244	if (memcmp(p + nbytes, zeros, ipbytes - nbytes) != 0)
245		return (ISC_R_FAILURE);
246	return (ISC_R_SUCCESS);
247}
248
249isc_result_t
250isc_netaddr_masktoprefixlen(const isc_netaddr_t *s, unsigned int *lenp) {
251	unsigned int nbits = 0, nbytes = 0, ipbytes = 0, i;
252	const unsigned char *p;
253
254	switch (s->family) {
255	case AF_INET:
256		p = (const unsigned char *) &s->type.in;
257		ipbytes = 4;
258		break;
259	case AF_INET6:
260		p = (const unsigned char *) &s->type.in6;
261		ipbytes = 16;
262		break;
263	default:
264		return (ISC_R_NOTIMPLEMENTED);
265	}
266	for (i = 0; i < ipbytes; i++) {
267		if (p[i] != 0xFF)
268			break;
269	}
270	nbytes = i;
271	if (i < ipbytes) {
272		unsigned int c = p[nbytes];
273		while ((c & 0x80) != 0 && nbits < 8) {
274			c <<= 1; nbits++;
275		}
276		if ((c & 0xFF) != 0)
277			return (ISC_R_MASKNONCONTIG);
278		i++;
279	}
280	for (; i < ipbytes; i++) {
281		if (p[i] != 0)
282			return (ISC_R_MASKNONCONTIG);
283		i++;
284	}
285	*lenp = nbytes * 8 + nbits;
286	return (ISC_R_SUCCESS);
287}
288
289void
290isc_netaddr_fromin(isc_netaddr_t *netaddr, const struct in_addr *ina) {
291	memset(netaddr, 0, sizeof(*netaddr));
292	netaddr->family = AF_INET;
293	netaddr->type.in = *ina;
294}
295
296void
297isc_netaddr_fromin6(isc_netaddr_t *netaddr, const struct in6_addr *ina6) {
298	memset(netaddr, 0, sizeof(*netaddr));
299	netaddr->family = AF_INET6;
300	netaddr->type.in6 = *ina6;
301}
302
303isc_result_t
304isc_netaddr_frompath(isc_netaddr_t *netaddr, const char *path) {
305#ifdef ISC_PLATFORM_HAVESYSUNH
306	if (strlen(path) > sizeof(netaddr->type.un) - 1)
307		return (ISC_R_NOSPACE);
308
309        memset(netaddr, 0, sizeof(*netaddr));
310        netaddr->family = AF_UNIX;
311	strlcpy(netaddr->type.un, path, sizeof(netaddr->type.un));
312        netaddr->zone = 0;
313        return (ISC_R_SUCCESS);
314#else
315	UNUSED(netaddr);
316	UNUSED(path);
317	return (ISC_R_NOTIMPLEMENTED);
318#endif
319}
320
321
322void
323isc_netaddr_setzone(isc_netaddr_t *netaddr, isc_uint32_t zone) {
324	/* we currently only support AF_INET6. */
325	REQUIRE(netaddr->family == AF_INET6);
326
327	netaddr->zone = zone;
328}
329
330isc_uint32_t
331isc_netaddr_getzone(const isc_netaddr_t *netaddr) {
332	return (netaddr->zone);
333}
334
335void
336isc_netaddr_fromsockaddr(isc_netaddr_t *t, const isc_sockaddr_t *s) {
337	int family = s->type.sa.sa_family;
338	t->family = family;
339	switch (family) {
340	case AF_INET:
341		t->type.in = s->type.sin.sin_addr;
342		t->zone = 0;
343		break;
344	case AF_INET6:
345		memcpy(&t->type.in6, &s->type.sin6.sin6_addr, 16);
346#ifdef ISC_PLATFORM_HAVESCOPEID
347		t->zone = s->type.sin6.sin6_scope_id;
348#else
349		t->zone = 0;
350#endif
351		break;
352#ifdef ISC_PLATFORM_HAVESYSUNH
353	case AF_UNIX:
354		memcpy(t->type.un, s->type.sunix.sun_path, sizeof(t->type.un));
355		t->zone = 0;
356		break;
357#endif
358	default:
359		INSIST(0);
360	}
361}
362
363void
364isc_netaddr_any(isc_netaddr_t *netaddr) {
365	memset(netaddr, 0, sizeof(*netaddr));
366	netaddr->family = AF_INET;
367	netaddr->type.in.s_addr = INADDR_ANY;
368}
369
370void
371isc_netaddr_any6(isc_netaddr_t *netaddr) {
372	memset(netaddr, 0, sizeof(*netaddr));
373	netaddr->family = AF_INET6;
374	netaddr->type.in6 = in6addr_any;
375}
376
377isc_boolean_t
378isc_netaddr_ismulticast(isc_netaddr_t *na) {
379	switch (na->family) {
380	case AF_INET:
381		return (ISC_TF(ISC_IPADDR_ISMULTICAST(na->type.in.s_addr)));
382	case AF_INET6:
383		return (ISC_TF(IN6_IS_ADDR_MULTICAST(&na->type.in6)));
384	default:
385		return (ISC_FALSE);  /* XXXMLG ? */
386	}
387}
388
389isc_boolean_t
390isc_netaddr_isexperimental(isc_netaddr_t *na) {
391	switch (na->family) {
392	case AF_INET:
393		return (ISC_TF(ISC_IPADDR_ISEXPERIMENTAL(na->type.in.s_addr)));
394	default:
395		return (ISC_FALSE);  /* XXXMLG ? */
396	}
397}
398
399isc_boolean_t
400isc_netaddr_islinklocal(isc_netaddr_t *na) {
401	switch (na->family) {
402	case AF_INET:
403		return (ISC_FALSE);
404	case AF_INET6:
405		return (ISC_TF(IN6_IS_ADDR_LINKLOCAL(&na->type.in6)));
406	default:
407		return (ISC_FALSE);
408	}
409}
410
411isc_boolean_t
412isc_netaddr_issitelocal(isc_netaddr_t *na) {
413	switch (na->family) {
414	case AF_INET:
415		return (ISC_FALSE);
416	case AF_INET6:
417		return (ISC_TF(IN6_IS_ADDR_SITELOCAL(&na->type.in6)));
418	default:
419		return (ISC_FALSE);
420	}
421}
422
423void
424isc_netaddr_fromv4mapped(isc_netaddr_t *t, const isc_netaddr_t *s) {
425	isc_netaddr_t *src;
426
427	DE_CONST(s, src);	/* Must come before IN6_IS_ADDR_V4MAPPED. */
428
429	REQUIRE(s->family == AF_INET6);
430	REQUIRE(IN6_IS_ADDR_V4MAPPED(&src->type.in6));
431
432	memset(t, 0, sizeof(*t));
433	t->family = AF_INET;
434	memcpy(&t->type.in, (char *)&src->type.in6 + 12, 4);
435	return;
436}
437