1/* 2 * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC") 3 * Copyright (C) 1999-2002 Internet Software Consortium. 4 * 5 * Permission to use, copy, modify, and 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: netaddr.c,v 1.18.12.9 2004/05/15 03:46:12 jinmei Exp $ */ 19 20#include <config.h> 21 22#define ISC_ONLY_IPV6 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 35isc_boolean_t 36isc_netaddr_equal(const isc_netaddr_t *a, const isc_netaddr_t *b) { 37 REQUIRE(a != NULL && b != NULL); 38 39 if (a->family != b->family) 40 return (ISC_FALSE); 41 42 if (a->zone != b->zone) 43 return (ISC_FALSE); 44 45 switch (a->family) { 46 case AF_INET: 47 if (a->type.in.s_addr != b->type.in.s_addr) 48 return (ISC_FALSE); 49 break; 50 case AF_INET6: 51 if (memcmp(&a->type.in6, &b->type.in6, 52 sizeof(a->type.in6)) != 0 || 53 a->zone != b->zone) 54 return (ISC_FALSE); 55 break; 56 default: 57 return (ISC_FALSE); 58 } 59 return (ISC_TRUE); 60} 61 62isc_boolean_t 63isc_netaddr_eqprefix(const isc_netaddr_t *a, const isc_netaddr_t *b, 64 unsigned int prefixlen) 65{ 66 const unsigned char *pa, *pb; 67 unsigned int ipabytes; /* Length of whole IP address in bytes */ 68 unsigned int nbytes; /* Number of significant whole bytes */ 69 unsigned int nbits; /* Number of significant leftover bits */ 70 71 REQUIRE(a != NULL && b != NULL); 72 73 if (a->family != b->family) 74 return (ISC_FALSE); 75 76 if (a->zone != b->zone) 77 return (ISC_FALSE); 78 79 switch (a->family) { 80 case AF_INET: 81 pa = (const unsigned char *) &a->type.in; 82 pb = (const unsigned char *) &b->type.in; 83 ipabytes = 4; 84 break; 85 case AF_INET6: 86 pa = (const unsigned char *) &a->type.in6; 87 pb = (const unsigned char *) &b->type.in6; 88 ipabytes = 16; 89 break; 90 default: 91 pa = pb = NULL; /* Avoid silly compiler warning. */ 92 ipabytes = 0; /* Ditto. */ 93 return (ISC_FALSE); 94 } 95 96 /* 97 * Don't crash if we get a pattern like 10.0.0.1/9999999. 98 */ 99 if (prefixlen > ipabytes * 8) 100 prefixlen = ipabytes * 8; 101 102 nbytes = prefixlen / 8; 103 nbits = prefixlen % 8; 104 105 if (nbytes > 0) { 106 if (memcmp(pa, pb, nbytes) != 0) 107 return (ISC_FALSE); 108 } 109 if (nbits > 0) { 110 unsigned int bytea, byteb, mask; 111 INSIST(nbytes < ipabytes); 112 INSIST(nbits < 8); 113 bytea = pa[nbytes]; 114 byteb = pb[nbytes]; 115 mask = (0xFF << (8-nbits)) & 0xFF; 116 if ((bytea & mask) != (byteb & mask)) 117 return (ISC_FALSE); 118 } 119 return (ISC_TRUE); 120} 121 122isc_result_t 123isc_netaddr_totext(const isc_netaddr_t *netaddr, isc_buffer_t *target) { 124 char abuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255")]; 125 char zbuf[sizeof("%4294967295")]; 126 unsigned int alen; 127 int zlen; 128 const char *r; 129 const void *type; 130 131 REQUIRE(netaddr != NULL); 132 133 switch (netaddr->family) { 134 case AF_INET: 135 type = &netaddr->type.in; 136 break; 137 case AF_INET6: 138 type = &netaddr->type.in6; 139 break; 140 default: 141 return (ISC_R_FAILURE); 142 } 143 r = inet_ntop(netaddr->family, type, abuf, sizeof(abuf)); 144 if (r == NULL) 145 return (ISC_R_FAILURE); 146 147 alen = strlen(abuf); 148 INSIST(alen < sizeof(abuf)); 149 150 zlen = 0; 151 if (netaddr->family == AF_INET6 && netaddr->zone != 0) { 152 zlen = snprintf(zbuf, sizeof(zbuf), "%%%u", netaddr->zone); 153 if (zlen < 0) 154 return (ISC_R_FAILURE); 155 INSIST((unsigned int)zlen < sizeof(zbuf)); 156 } 157 158 if (alen + zlen > isc_buffer_availablelength(target)) 159 return (ISC_R_NOSPACE); 160 161 isc_buffer_putmem(target, (unsigned char *)abuf, alen); 162 isc_buffer_putmem(target, (unsigned char *)zbuf, zlen); 163 164 return (ISC_R_SUCCESS); 165} 166 167void 168isc_netaddr_format(const isc_netaddr_t *na, char *array, unsigned int size) { 169 isc_result_t result; 170 isc_buffer_t buf; 171 172 isc_buffer_init(&buf, array, size); 173 result = isc_netaddr_totext(na, &buf); 174 175 /* 176 * Null terminate. 177 */ 178 if (result == ISC_R_SUCCESS) { 179 if (isc_buffer_availablelength(&buf) >= 1) 180 isc_buffer_putuint8(&buf, 0); 181 else 182 result = ISC_R_NOSPACE; 183 } 184 185 if (result != ISC_R_SUCCESS) { 186 snprintf(array, size, 187 isc_msgcat_get(isc_msgcat, ISC_MSGSET_NETADDR, 188 ISC_MSG_UNKNOWNADDR, 189 "<unknown address, family %u>"), 190 na->family); 191 array[size - 1] = '\0'; 192 } 193} 194 195isc_result_t 196isc_netaddr_masktoprefixlen(const isc_netaddr_t *s, unsigned int *lenp) { 197 unsigned int nbits, nbytes, ipbytes, i; 198 const unsigned char *p; 199 200 switch (s->family) { 201 case AF_INET: 202 p = (const unsigned char *) &s->type.in; 203 ipbytes = 4; 204 break; 205 case AF_INET6: 206 p = (const unsigned char *) &s->type.in6; 207 ipbytes = 16; 208 break; 209 default: 210 ipbytes = 0; 211 return (ISC_R_NOTIMPLEMENTED); 212 } 213 nbytes = nbits = 0; 214 for (i = 0; i < ipbytes; i++) { 215 if (p[i] != 0xFF) 216 break; 217 } 218 nbytes = i; 219 if (i < ipbytes) { 220 unsigned int c = p[nbytes]; 221 while ((c & 0x80) != 0 && nbits < 8) { 222 c <<= 1; nbits++; 223 } 224 if ((c & 0xFF) != 0) 225 return (ISC_R_MASKNONCONTIG); 226 i++; 227 } 228 for (; i < ipbytes; i++) { 229 if (p[i] != 0) 230 return (ISC_R_MASKNONCONTIG); 231 i++; 232 } 233 *lenp = nbytes * 8 + nbits; 234 return (ISC_R_SUCCESS); 235} 236 237void 238isc_netaddr_fromin(isc_netaddr_t *netaddr, const struct in_addr *ina) { 239 memset(netaddr, 0, sizeof(*netaddr)); 240 netaddr->family = AF_INET; 241 netaddr->type.in = *ina; 242} 243 244void 245isc_netaddr_fromin6(isc_netaddr_t *netaddr, const struct in6_addr *ina6) { 246 memset(netaddr, 0, sizeof(*netaddr)); 247 netaddr->family = AF_INET6; 248 netaddr->type.in6 = *ina6; 249} 250 251void 252isc_netaddr_setzone(isc_netaddr_t *netaddr, isc_uint32_t zone) { 253 /* we currently only support AF_INET6. */ 254 REQUIRE(netaddr->family == AF_INET6); 255 256 netaddr->zone = zone; 257} 258 259isc_uint32_t 260isc_netaddr_getzone(const isc_netaddr_t *netaddr) { 261 return (netaddr->zone); 262} 263 264void 265isc_netaddr_fromsockaddr(isc_netaddr_t *t, const isc_sockaddr_t *s) { 266 int family = s->type.sa.sa_family; 267 t->family = family; 268 switch (family) { 269 case AF_INET: 270 t->type.in = s->type.sin.sin_addr; 271 t->zone = 0; 272 break; 273 case AF_INET6: 274 memcpy(&t->type.in6, &s->type.sin6.sin6_addr, 16); 275#ifdef ISC_PLATFORM_HAVESCOPEID 276 t->zone = s->type.sin6.sin6_scope_id; 277#else 278 t->zone = 0; 279#endif 280 break; 281 default: 282 INSIST(0); 283 } 284} 285 286void 287isc_netaddr_any(isc_netaddr_t *netaddr) { 288 memset(netaddr, 0, sizeof(*netaddr)); 289 netaddr->family = AF_INET; 290 netaddr->type.in.s_addr = INADDR_ANY; 291} 292 293#ifdef ISC_PLATFORM_HAVEIPV6 294void 295isc_netaddr_any6(isc_netaddr_t *netaddr) { 296 memset(netaddr, 0, sizeof(*netaddr)); 297 netaddr->family = AF_INET6; 298 netaddr->type.in6 = in6addr_any; 299} 300#endif 301 302isc_boolean_t 303isc_netaddr_ismulticast(isc_netaddr_t *na) { 304 switch (na->family) { 305 case AF_INET: 306 return (ISC_TF(ISC_IPADDR_ISMULTICAST(na->type.in.s_addr))); 307 case AF_INET6: 308 return (ISC_TF(IN6_IS_ADDR_MULTICAST(&na->type.in6))); 309 default: 310 return (ISC_FALSE); /* XXXMLG ? */ 311 } 312} 313 314isc_boolean_t 315isc_netaddr_isexperimental(isc_netaddr_t *na) { 316 switch (na->family) { 317 case AF_INET: 318 return (ISC_TF(ISC_IPADDR_ISEXPERIMENTAL(na->type.in.s_addr))); 319 default: 320 return (ISC_FALSE); /* XXXMLG ? */ 321 } 322} 323 324isc_boolean_t 325isc_netaddr_islinklocal(isc_netaddr_t *na) { 326 switch (na->family) { 327 case AF_INET: 328 return (ISC_FALSE); 329 case AF_INET6: 330 return (ISC_TF(IN6_IS_ADDR_LINKLOCAL(&na->type.in6))); 331 default: 332 return (ISC_FALSE); 333 } 334} 335 336isc_boolean_t 337isc_netaddr_issitelocal(isc_netaddr_t *na) { 338 switch (na->family) { 339 case AF_INET: 340 return (ISC_FALSE); 341 case AF_INET6: 342 return (ISC_TF(IN6_IS_ADDR_SITELOCAL(&na->type.in6))); 343 default: 344 return (ISC_FALSE); 345 } 346} 347 348#ifdef ISC_PLATFORM_HAVEIPV6 349void 350isc_netaddr_fromv4mapped(isc_netaddr_t *t, const isc_netaddr_t *s) { 351 isc_netaddr_t *src; 352 353 DE_CONST(s, src); /* Must come before IN6_IS_ADDR_V4MAPPED. */ 354 355 REQUIRE(s->family == AF_INET6); 356 REQUIRE(IN6_IS_ADDR_V4MAPPED(&src->type.in6)); 357 358 memset(t, 0, sizeof(*t)); 359 t->family = AF_INET; 360 memcpy(&t->type.in, (char *)&src->type.in6 + 12, 4); 361 return; 362} 363#endif 364