contrib/ntp/libisc/netaddr.c

   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
  35 isc_boolean_t
  36 isc_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
  62 isc_boolean_t
  63 isc_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
 122 isc_result_t
 123 isc_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
 167 void
 168 isc_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
 195 isc_result_t
 196 isc_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
 237 void
 238 isc_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
 244 void
 245 isc_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
 251 void
 252 isc_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
 259 isc_uint32_t
 260 isc_netaddr_getzone(const isc_netaddr_t *netaddr) {
 261         return (netaddr->zone);
 262 }
 263
 264 void
 265 isc_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
 286 void
 287 isc_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
 294 void
 295 isc_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
 302 isc_boolean_t
 303 isc_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
 314 isc_boolean_t
 315 isc_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
 324 isc_boolean_t
 325 isc_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
 336 isc_boolean_t
 337 isc_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
 349 void
 350 isc_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