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