Annotation of embedaddon/dhcp/common/inet.c, revision 1.1
1.1 ! misho 1: /* inet.c
! 2:
! 3: Subroutines to manipulate internet addresses and ports in a safely portable
! 4: way... */
! 5:
! 6: /*
! 7: * Copyright (c) 2011 by Internet Systems Consortium, Inc. ("ISC")
! 8: * Copyright (c) 2007-2009 by Internet Systems Consortium, Inc. ("ISC")
! 9: * Copyright (c) 2004,2005 by Internet Systems Consortium, Inc. ("ISC")
! 10: * Copyright (c) 1995-2003 by Internet Software Consortium
! 11: *
! 12: * Permission to use, copy, modify, and distribute this software for any
! 13: * purpose with or without fee is hereby granted, provided that the above
! 14: * copyright notice and this permission notice appear in all copies.
! 15: *
! 16: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 17: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 18: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 19: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 20: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 21: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 22: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 23: *
! 24: * Internet Systems Consortium, Inc.
! 25: * 950 Charter Street
! 26: * Redwood City, CA 94063
! 27: * <info@isc.org>
! 28: * https://www.isc.org/
! 29: *
! 30: * This software has been written for Internet Systems Consortium
! 31: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
! 32: * To learn more about Internet Systems Consortium, see
! 33: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
! 34: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
! 35: * ``http://www.nominum.com''.
! 36: */
! 37:
! 38: #include "dhcpd.h"
! 39:
! 40: /* Return just the network number of an internet address... */
! 41:
! 42: struct iaddr subnet_number (addr, mask)
! 43: struct iaddr addr;
! 44: struct iaddr mask;
! 45: {
! 46: int i;
! 47: struct iaddr rv;
! 48:
! 49: if (addr.len > sizeof(addr.iabuf))
! 50: log_fatal("subnet_number():%s:%d: Invalid addr length.", MDL);
! 51: if (addr.len != mask.len)
! 52: log_fatal("subnet_number():%s:%d: Addr/mask length mismatch.",
! 53: MDL);
! 54:
! 55: rv.len = 0;
! 56:
! 57: /* Both addresses must have the same length... */
! 58: if (addr.len != mask.len)
! 59: return rv;
! 60:
! 61: rv.len = addr.len;
! 62: for (i = 0; i < rv.len; i++)
! 63: rv.iabuf [i] = addr.iabuf [i] & mask.iabuf [i];
! 64: return rv;
! 65: }
! 66:
! 67: /* Combine a network number and a integer to produce an internet address.
! 68: This won't work for subnets with more than 32 bits of host address, but
! 69: maybe this isn't a problem. */
! 70:
! 71: struct iaddr ip_addr (subnet, mask, host_address)
! 72: struct iaddr subnet;
! 73: struct iaddr mask;
! 74: u_int32_t host_address;
! 75: {
! 76: int i, j, k;
! 77: u_int32_t swaddr;
! 78: struct iaddr rv;
! 79: unsigned char habuf [sizeof swaddr];
! 80:
! 81: if (subnet.len > sizeof(subnet.iabuf))
! 82: log_fatal("ip_addr():%s:%d: Invalid addr length.", MDL);
! 83: if (subnet.len != mask.len)
! 84: log_fatal("ip_addr():%s:%d: Addr/mask length mismatch.",
! 85: MDL);
! 86:
! 87: swaddr = htonl (host_address);
! 88: memcpy (habuf, &swaddr, sizeof swaddr);
! 89:
! 90: /* Combine the subnet address and the host address. If
! 91: the host address is bigger than can fit in the subnet,
! 92: return a zero-length iaddr structure. */
! 93: rv = subnet;
! 94: j = rv.len - sizeof habuf;
! 95: for (i = sizeof habuf - 1; i >= 0; i--) {
! 96: if (mask.iabuf [i + j]) {
! 97: if (habuf [i] > (mask.iabuf [i + j] ^ 0xFF)) {
! 98: rv.len = 0;
! 99: return rv;
! 100: }
! 101: for (k = i - 1; k >= 0; k--) {
! 102: if (habuf [k]) {
! 103: rv.len = 0;
! 104: return rv;
! 105: }
! 106: }
! 107: rv.iabuf [i + j] |= habuf [i];
! 108: break;
! 109: } else
! 110: rv.iabuf [i + j] = habuf [i];
! 111: }
! 112:
! 113: return rv;
! 114: }
! 115:
! 116: /* Given a subnet number and netmask, return the address on that subnet
! 117: for which the host portion of the address is all ones (the standard
! 118: broadcast address). */
! 119:
! 120: struct iaddr broadcast_addr (subnet, mask)
! 121: struct iaddr subnet;
! 122: struct iaddr mask;
! 123: {
! 124: int i;
! 125: struct iaddr rv;
! 126:
! 127: if (subnet.len > sizeof(subnet.iabuf))
! 128: log_fatal("broadcast_addr():%s:%d: Invalid addr length.", MDL);
! 129: if (subnet.len != mask.len)
! 130: log_fatal("broadcast_addr():%s:%d: Addr/mask length mismatch.",
! 131: MDL);
! 132:
! 133: if (subnet.len != mask.len) {
! 134: rv.len = 0;
! 135: return rv;
! 136: }
! 137:
! 138: for (i = 0; i < subnet.len; i++) {
! 139: rv.iabuf [i] = subnet.iabuf [i] | (~mask.iabuf [i] & 255);
! 140: }
! 141: rv.len = subnet.len;
! 142:
! 143: return rv;
! 144: }
! 145:
! 146: u_int32_t host_addr (addr, mask)
! 147: struct iaddr addr;
! 148: struct iaddr mask;
! 149: {
! 150: int i;
! 151: u_int32_t swaddr;
! 152: struct iaddr rv;
! 153:
! 154: if (addr.len > sizeof(addr.iabuf))
! 155: log_fatal("host_addr():%s:%d: Invalid addr length.", MDL);
! 156: if (addr.len != mask.len)
! 157: log_fatal("host_addr():%s:%d: Addr/mask length mismatch.",
! 158: MDL);
! 159:
! 160: rv.len = 0;
! 161:
! 162: /* Mask out the network bits... */
! 163: rv.len = addr.len;
! 164: for (i = 0; i < rv.len; i++)
! 165: rv.iabuf [i] = addr.iabuf [i] & ~mask.iabuf [i];
! 166:
! 167: /* Copy out up to 32 bits... */
! 168: memcpy (&swaddr, &rv.iabuf [rv.len - sizeof swaddr], sizeof swaddr);
! 169:
! 170: /* Swap it and return it. */
! 171: return ntohl (swaddr);
! 172: }
! 173:
! 174: int addr_eq (addr1, addr2)
! 175: struct iaddr addr1, addr2;
! 176: {
! 177: if (addr1.len > sizeof(addr1.iabuf))
! 178: log_fatal("addr_eq():%s:%d: Invalid addr length.", MDL);
! 179:
! 180: if (addr1.len != addr2.len)
! 181: return 0;
! 182: return memcmp (addr1.iabuf, addr2.iabuf, addr1.len) == 0;
! 183: }
! 184:
! 185: /* addr_match
! 186: *
! 187: * compares an IP address against a network/mask combination
! 188: * by ANDing the IP with the mask and seeing whether the result
! 189: * matches the masked network value.
! 190: */
! 191: int
! 192: addr_match(addr, match)
! 193: struct iaddr *addr;
! 194: struct iaddrmatch *match;
! 195: {
! 196: int i;
! 197:
! 198: if (addr->len != match->addr.len)
! 199: return 0;
! 200:
! 201: i = 0;
! 202: for (i = 0 ; i < addr->len ; i++) {
! 203: if ((addr->iabuf[i] & match->mask.iabuf[i]) !=
! 204: match->addr.iabuf[i])
! 205: return 0;
! 206: }
! 207: return 1;
! 208: }
! 209:
! 210: /*
! 211: * Compares the addresses a1 and a2.
! 212: *
! 213: * If a1 < a2, returns -1.
! 214: * If a1 == a2, returns 0.
! 215: * If a1 > a2, returns 1.
! 216: *
! 217: * WARNING: if a1 and a2 differ in length, returns 0.
! 218: */
! 219: int
! 220: addr_cmp(const struct iaddr *a1, const struct iaddr *a2) {
! 221: int i;
! 222:
! 223: if (a1->len != a2->len) {
! 224: return 0;
! 225: }
! 226:
! 227: for (i=0; i<a1->len; i++) {
! 228: if (a1->iabuf[i] < a2->iabuf[i]) {
! 229: return -1;
! 230: }
! 231: if (a1->iabuf[i] > a2->iabuf[i]) {
! 232: return 1;
! 233: }
! 234: }
! 235:
! 236: return 0;
! 237: }
! 238:
! 239: /*
! 240: * Performs a bitwise-OR of two addresses.
! 241: *
! 242: * Returns 1 if the result is non-zero, or 0 otherwise.
! 243: *
! 244: * WARNING: if a1 and a2 differ in length, returns 0.
! 245: */
! 246: int
! 247: addr_or(struct iaddr *result, const struct iaddr *a1, const struct iaddr *a2) {
! 248: int i;
! 249: int all_zero;
! 250:
! 251: if (a1->len != a2->len) {
! 252: return 0;
! 253: }
! 254:
! 255: all_zero = 1;
! 256:
! 257: result->len = a1->len;
! 258: for (i=0; i<a1->len; i++) {
! 259: result->iabuf[i] = a1->iabuf[i] | a2->iabuf[i];
! 260: if (result->iabuf[i] != 0) {
! 261: all_zero = 0;
! 262: }
! 263: }
! 264:
! 265: return !all_zero;
! 266: }
! 267:
! 268: /*
! 269: * Performs a bitwise-AND of two addresses.
! 270: *
! 271: * Returns 1 if the result is non-zero, or 0 otherwise.
! 272: *
! 273: * WARNING: if a1 and a2 differ in length, returns 0.
! 274: */
! 275: int
! 276: addr_and(struct iaddr *result, const struct iaddr *a1, const struct iaddr *a2) {
! 277: int i;
! 278: int all_zero;
! 279:
! 280: if (a1->len != a2->len) {
! 281: return 0;
! 282: }
! 283:
! 284: all_zero = 1;
! 285:
! 286: result->len = a1->len;
! 287: for (i=0; i<a1->len; i++) {
! 288: result->iabuf[i] = a1->iabuf[i] & a2->iabuf[i];
! 289: if (result->iabuf[i] != 0) {
! 290: all_zero = 0;
! 291: }
! 292: }
! 293:
! 294: return !all_zero;
! 295: }
! 296:
! 297: /*
! 298: * Check if a bitmask of the given length is valid for the address.
! 299: * This is not the case if any bits longer than the bitmask are 1.
! 300: *
! 301: * So, this is valid:
! 302: *
! 303: * 127.0.0.0/8
! 304: *
! 305: * But this is not:
! 306: *
! 307: * 127.0.0.1/8
! 308: *
! 309: * Because the final ".1" would get masked out by the /8.
! 310: */
! 311: isc_boolean_t
! 312: is_cidr_mask_valid(const struct iaddr *addr, int bits) {
! 313: int zero_bits;
! 314: int zero_bytes;
! 315: int i;
! 316: char byte;
! 317: int shift_bits;
! 318:
! 319: /*
! 320: * Check our bit boundaries.
! 321: */
! 322: if (bits < 0) {
! 323: return ISC_FALSE;
! 324: }
! 325: if (bits > (addr->len * 8)) {
! 326: return ISC_FALSE;
! 327: }
! 328:
! 329: /*
! 330: * Figure out how many low-order bits need to be zero.
! 331: */
! 332: zero_bits = (addr->len * 8) - bits;
! 333: zero_bytes = zero_bits / 8;
! 334:
! 335: /*
! 336: * Check to make sure the low-order bytes are zero.
! 337: */
! 338: for (i=1; i<=zero_bytes; i++) {
! 339: if (addr->iabuf[addr->len-i] != 0) {
! 340: return ISC_FALSE;
! 341: }
! 342: }
! 343:
! 344: /*
! 345: * Look to see if any bits not in right-hand bytes are
! 346: * non-zero, by making a byte that has these bits set to zero
! 347: * comparing to the original byte. If these two values are
! 348: * equal, then the right-hand bits are zero, and we are
! 349: * happy.
! 350: */
! 351: shift_bits = zero_bits % 8;
! 352: if (shift_bits == 0) return ISC_TRUE;
! 353: byte = addr->iabuf[addr->len-zero_bytes-1];
! 354: return (((byte >> shift_bits) << shift_bits) == byte);
! 355: }
! 356:
! 357: /*
! 358: * range2cidr
! 359: *
! 360: * Converts a range of IP addresses to a set of CIDR networks.
! 361: *
! 362: * Examples:
! 363: * 192.168.0.0 - 192.168.0.255 = 192.168.0.0/24
! 364: * 10.0.0.0 - 10.0.1.127 = 10.0.0.0/24, 10.0.1.0/25
! 365: * 255.255.255.32 - 255.255.255.255 = 255.255.255.32/27, 255.255.255.64/26,
! 366: * 255.255.255.128/25
! 367: */
! 368: isc_result_t
! 369: range2cidr(struct iaddrcidrnetlist **result,
! 370: const struct iaddr *lo, const struct iaddr *hi) {
! 371: struct iaddr addr;
! 372: struct iaddr mask;
! 373: int bit;
! 374: struct iaddr end_addr;
! 375: struct iaddr dummy;
! 376: int ofs, val;
! 377: struct iaddrcidrnetlist *net;
! 378: int tmp;
! 379:
! 380: if (result == NULL) {
! 381: return ISC_R_INVALIDARG;
! 382: }
! 383: if (*result != NULL) {
! 384: return ISC_R_INVALIDARG;
! 385: }
! 386: if ((lo == NULL) || (hi == NULL) || (lo->len != hi->len)) {
! 387: return ISC_R_INVALIDARG;
! 388: }
! 389:
! 390: /*
! 391: * Put our start and end in the right order, if reversed.
! 392: */
! 393: if (addr_cmp(lo, hi) > 0) {
! 394: const struct iaddr *tmp;
! 395: tmp = lo;
! 396: lo = hi;
! 397: hi = tmp;
! 398: }
! 399:
! 400: /*
! 401: * Theory of operation:
! 402: *
! 403: * -------------------
! 404: * Start at the low end, and keep trying larger networks
! 405: * until we get one that is too big (explained below).
! 406: *
! 407: * We keep a "mask", which is the ones-complement of a
! 408: * normal netmask. So, a /23 has a netmask of 255.255.254.0,
! 409: * and a mask of 0.0.1.255.
! 410: *
! 411: * We know when a network is too big when we bitwise-AND the
! 412: * mask with the starting address and we get a non-zero
! 413: * result, like this:
! 414: *
! 415: * addr: 192.168.1.0, mask: 0.0.1.255
! 416: * bitwise-AND: 0.0.1.0
! 417: *
! 418: * A network is also too big if the bitwise-OR of the mask
! 419: * with the starting address is larger than the end address,
! 420: * like this:
! 421: *
! 422: * start: 192.168.1.0, mask: 0.0.1.255, end: 192.168.0.255
! 423: * bitwise-OR: 192.168.1.255
! 424: *
! 425: * -------------------
! 426: * Once we have found a network that is too big, we add the
! 427: * appropriate CIDR network to our list of found networks.
! 428: *
! 429: * We then use the next IP address as our low address, and
! 430: * begin the process of searching for a network that is
! 431: * too big again, starting with an empty mask.
! 432: */
! 433: addr = *lo;
! 434: bit = 0;
! 435: memset(&mask, 0, sizeof(mask));
! 436: mask.len = addr.len;
! 437: while (addr_cmp(&addr, hi) <= 0) {
! 438: /*
! 439: * Bitwise-OR mask with (1 << bit)
! 440: */
! 441: ofs = addr.len - (bit / 8) - 1;
! 442: val = 1 << (bit % 8);
! 443: if (ofs >= 0) {
! 444: mask.iabuf[ofs] |= val;
! 445: }
! 446:
! 447: /*
! 448: * See if we're too big, and save this network if so.
! 449: */
! 450: addr_or(&end_addr, &addr, &mask);
! 451: if ((ofs < 0) ||
! 452: (addr_cmp(&end_addr, hi) > 0) ||
! 453: addr_and(&dummy, &addr, &mask)) {
! 454: /*
! 455: * Add a new prefix to our list.
! 456: */
! 457: net = dmalloc(sizeof(*net), MDL);
! 458: if (net == NULL) {
! 459: while (*result != NULL) {
! 460: net = (*result)->next;
! 461: dfree(*result, MDL);
! 462: *result = net;
! 463: }
! 464: return ISC_R_NOMEMORY;
! 465: }
! 466: net->cidrnet.lo_addr = addr;
! 467: net->cidrnet.bits = (addr.len * 8) - bit;
! 468: net->next = *result;
! 469: *result = net;
! 470:
! 471: /*
! 472: * Figure out our new starting address,
! 473: * by adding (1 << bit) to our previous
! 474: * starting address.
! 475: */
! 476: tmp = addr.iabuf[ofs] + val;
! 477: while ((ofs >= 0) && (tmp > 255)) {
! 478: addr.iabuf[ofs] = tmp - 256;
! 479: ofs--;
! 480: tmp = addr.iabuf[ofs] + 1;
! 481: }
! 482: if (ofs < 0) {
! 483: /* Gone past last address, we're done. */
! 484: break;
! 485: }
! 486: addr.iabuf[ofs] = tmp;
! 487:
! 488: /*
! 489: * Reset our bit and mask.
! 490: */
! 491: bit = 0;
! 492: memset(mask.iabuf, 0, sizeof(mask.iabuf));
! 493: memset(end_addr.iabuf, 0, sizeof(end_addr.iabuf));
! 494: } else {
! 495: /*
! 496: * If we're not too big, increase our network size.
! 497: */
! 498: bit++;
! 499: }
! 500: }
! 501:
! 502: /*
! 503: * We're done.
! 504: */
! 505: return ISC_R_SUCCESS;
! 506: }
! 507:
! 508: /*
! 509: * Free a list of CIDR networks, such as returned from range2cidr().
! 510: */
! 511: isc_result_t
! 512: free_iaddrcidrnetlist(struct iaddrcidrnetlist **result) {
! 513: struct iaddrcidrnetlist *p;
! 514:
! 515: if (result == NULL) {
! 516: return ISC_R_INVALIDARG;
! 517: }
! 518: if (*result == NULL) {
! 519: return ISC_R_INVALIDARG;
! 520: }
! 521:
! 522: while (*result != NULL) {
! 523: p = *result;
! 524: *result = p->next;
! 525: dfree(p, MDL);
! 526: }
! 527:
! 528: return ISC_R_SUCCESS;
! 529: }
! 530:
! 531: /* piaddr() turns an iaddr structure into a printable address. */
! 532: /* XXX: should use a const pointer rather than passing the structure */
! 533: const char *
! 534: piaddr(const struct iaddr addr) {
! 535: static char
! 536: pbuf[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
! 537: /* "255.255.255.255" */
! 538:
! 539: /* INSIST((addr.len == 0) || (addr.len == 4) || (addr.len == 16)); */
! 540:
! 541: if (addr.len == 0) {
! 542: return "<null address>";
! 543: }
! 544: if (addr.len == 4) {
! 545: return inet_ntop(AF_INET, addr.iabuf, pbuf, sizeof(pbuf));
! 546: }
! 547: if (addr.len == 16) {
! 548: return inet_ntop(AF_INET6, addr.iabuf, pbuf, sizeof(pbuf));
! 549: }
! 550:
! 551: log_fatal("piaddr():%s:%d: Invalid address length %d.", MDL,
! 552: addr.len);
! 553: /* quell compiler warnings */
! 554: return NULL;
! 555: }
! 556:
! 557: /* piaddrmask takes an iaddr structure mask, determines the bitlength of
! 558: * the mask, and then returns the printable CIDR notation of the two.
! 559: */
! 560: char *
! 561: piaddrmask(struct iaddr *addr, struct iaddr *mask) {
! 562: int mw;
! 563: unsigned int oct, bit;
! 564:
! 565: if ((addr->len != 4) && (addr->len != 16))
! 566: log_fatal("piaddrmask():%s:%d: Address length %d invalid",
! 567: MDL, addr->len);
! 568: if (addr->len != mask->len)
! 569: log_fatal("piaddrmask():%s:%d: Address and mask size mismatch",
! 570: MDL);
! 571:
! 572: /* Determine netmask width in bits. */
! 573: for (mw = (mask->len * 8) ; mw > 0 ; ) {
! 574: oct = (mw - 1) / 8;
! 575: bit = 0x80 >> ((mw - 1) % 8);
! 576: if (!mask->iabuf[oct])
! 577: mw -= 8;
! 578: else if (mask->iabuf[oct] & bit)
! 579: break;
! 580: else
! 581: mw--;
! 582: }
! 583:
! 584: if (mw < 0)
! 585: log_fatal("Impossible condition at %s:%d.", MDL);
! 586:
! 587: return piaddrcidr(addr, mw);
! 588: }
! 589:
! 590: /* Format an address and mask-length into printable CIDR notation. */
! 591: char *
! 592: piaddrcidr(const struct iaddr *addr, unsigned int bits) {
! 593: static char
! 594: ret[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255/128")];
! 595: /* "255.255.255.255/32" */
! 596:
! 597: /* INSIST(addr != NULL); */
! 598: /* INSIST((addr->len == 4) || (addr->len == 16)); */
! 599: /* INSIST(bits <= (addr->len * 8)); */
! 600:
! 601: if (bits > (addr->len * 8))
! 602: return NULL;
! 603:
! 604: sprintf(ret, "%s/%d", piaddr(*addr), bits);
! 605:
! 606: return ret;
! 607: }
! 608:
! 609: /* Validate that the string represents a valid port number and
! 610: * return it in network byte order
! 611: */
! 612:
! 613: u_int16_t
! 614: validate_port(char *port) {
! 615: long local_port = 0;
! 616: long lower = 1;
! 617: long upper = 65535;
! 618: char *endptr;
! 619:
! 620: errno = 0;
! 621: local_port = strtol(port, &endptr, 10);
! 622:
! 623: if ((*endptr != '\0') || (errno == ERANGE) || (errno == EINVAL))
! 624: log_fatal ("Invalid port number specification: %s", port);
! 625:
! 626: if (local_port < lower || local_port > upper)
! 627: log_fatal("Port number specified is out of range (%ld-%ld).",
! 628: lower, upper);
! 629:
! 630: return htons((u_int16_t)local_port);
! 631: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to inet.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dhcp / common