Annotation of embedaddon/dhcp/common/parse.c, revision 1.1
1.1 ! misho 1: /* parse.c
! 2:
! 3: Common parser code for dhcpd and dhclient. */
! 4:
! 5: /*
! 6: * Copyright (c) 2004-2010 by Internet Systems Consortium, Inc. ("ISC")
! 7: * Copyright (c) 1995-2003 by Internet Software Consortium
! 8: *
! 9: * Permission to use, copy, modify, and distribute this software for any
! 10: * purpose with or without fee is hereby granted, provided that the above
! 11: * copyright notice and this permission notice appear in all copies.
! 12: *
! 13: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
! 14: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 15: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
! 16: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 17: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 18: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
! 19: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 20: *
! 21: * Internet Systems Consortium, Inc.
! 22: * 950 Charter Street
! 23: * Redwood City, CA 94063
! 24: * <info@isc.org>
! 25: * https://www.isc.org/
! 26: *
! 27: * This software has been written for Internet Systems Consortium
! 28: * by Ted Lemon in cooperation with Vixie Enterprises and Nominum, Inc.
! 29: * To learn more about Internet Systems Consortium, see
! 30: * ``https://www.isc.org/''. To learn more about Vixie Enterprises,
! 31: * see ``http://www.vix.com''. To learn more about Nominum, Inc., see
! 32: * ``http://www.nominum.com''.
! 33: */
! 34:
! 35: #include "dhcpd.h"
! 36: #include <syslog.h>
! 37:
! 38: /* Enumerations can be specified in option formats, and are used for
! 39: parsing, so we define the routines that manage them here. */
! 40:
! 41: struct enumeration *enumerations;
! 42:
! 43: void add_enumeration (struct enumeration *enumeration)
! 44: {
! 45: enumeration -> next = enumerations;
! 46: enumerations = enumeration;
! 47: }
! 48:
! 49: struct enumeration *find_enumeration (const char *name, int length)
! 50: {
! 51: struct enumeration *e;
! 52:
! 53: for (e = enumerations; e; e = e -> next)
! 54: if (strlen (e -> name) == length &&
! 55: !memcmp (e -> name, name, (unsigned)length))
! 56: return e;
! 57: return (struct enumeration *)0;
! 58: }
! 59:
! 60: struct enumeration_value *find_enumeration_value (const char *name,
! 61: int length,
! 62: unsigned *widthp,
! 63: const char *value)
! 64: {
! 65: struct enumeration *e;
! 66: int i;
! 67:
! 68: e = find_enumeration (name, length);
! 69: if (e) {
! 70: if (widthp != NULL)
! 71: *widthp = e->width;
! 72: for (i = 0; e -> values [i].name; i++) {
! 73: if (!strcmp (value, e -> values [i].name))
! 74: return &e -> values [i];
! 75: }
! 76: }
! 77: return (struct enumeration_value *)0;
! 78: }
! 79:
! 80: /* Skip to the semicolon ending the current statement. If we encounter
! 81: braces, the matching closing brace terminates the statement. If we
! 82: encounter a right brace but haven't encountered a left brace, return
! 83: leaving the brace in the token buffer for the caller. If we see a
! 84: semicolon and haven't seen a left brace, return. This lets us skip
! 85: over:
! 86:
! 87: statement;
! 88: statement foo bar { }
! 89: statement foo bar { statement { } }
! 90: statement}
! 91:
! 92: ...et cetera. */
! 93:
! 94: void skip_to_semi (cfile)
! 95: struct parse *cfile;
! 96: {
! 97: skip_to_rbrace (cfile, 0);
! 98: }
! 99:
! 100: void skip_to_rbrace (cfile, brace_count)
! 101: struct parse *cfile;
! 102: int brace_count;
! 103: {
! 104: enum dhcp_token token;
! 105: const char *val;
! 106:
! 107: #if defined (DEBUG_TOKEN)
! 108: log_error ("skip_to_rbrace: %d\n", brace_count);
! 109: #endif
! 110: do {
! 111: token = peek_token (&val, (unsigned *)0, cfile);
! 112: if (token == RBRACE) {
! 113: token = next_token (&val, (unsigned *)0, cfile);
! 114: if (brace_count) {
! 115: if (!--brace_count)
! 116: return;
! 117: } else
! 118: return;
! 119: } else if (token == LBRACE) {
! 120: brace_count++;
! 121: } else if (token == SEMI && !brace_count) {
! 122: token = next_token (&val, (unsigned *)0, cfile);
! 123: return;
! 124: } else if (token == EOL) {
! 125: /* EOL only happens when parsing /etc/resolv.conf,
! 126: and we treat it like a semicolon because the
! 127: resolv.conf file is line-oriented. */
! 128: token = next_token (&val, (unsigned *)0, cfile);
! 129: return;
! 130: }
! 131: token = next_token (&val, (unsigned *)0, cfile);
! 132: } while (token != END_OF_FILE);
! 133: }
! 134:
! 135: int parse_semi (cfile)
! 136: struct parse *cfile;
! 137: {
! 138: enum dhcp_token token;
! 139: const char *val;
! 140:
! 141: token = next_token (&val, (unsigned *)0, cfile);
! 142: if (token != SEMI) {
! 143: parse_warn (cfile, "semicolon expected.");
! 144: skip_to_semi (cfile);
! 145: return 0;
! 146: }
! 147: return 1;
! 148: }
! 149:
! 150: /* string-parameter :== STRING SEMI */
! 151:
! 152: int parse_string (cfile, sptr, lptr)
! 153: struct parse *cfile;
! 154: char **sptr;
! 155: unsigned *lptr;
! 156: {
! 157: const char *val;
! 158: enum dhcp_token token;
! 159: char *s;
! 160: unsigned len;
! 161:
! 162: token = next_token (&val, &len, cfile);
! 163: if (token != STRING) {
! 164: parse_warn (cfile, "expecting a string");
! 165: skip_to_semi (cfile);
! 166: return 0;
! 167: }
! 168: s = (char *)dmalloc (len + 1, MDL);
! 169: if (!s)
! 170: log_fatal ("no memory for string %s.", val);
! 171: memcpy (s, val, len + 1);
! 172:
! 173: if (!parse_semi (cfile)) {
! 174: dfree (s, MDL);
! 175: return 0;
! 176: }
! 177: if (sptr)
! 178: *sptr = s;
! 179: else
! 180: dfree (s, MDL);
! 181: if (lptr)
! 182: *lptr = len;
! 183: return 1;
! 184: }
! 185:
! 186: /*
! 187: * hostname :== IDENTIFIER
! 188: * | IDENTIFIER DOT
! 189: * | hostname DOT IDENTIFIER
! 190: */
! 191:
! 192: char *parse_host_name (cfile)
! 193: struct parse *cfile;
! 194: {
! 195: const char *val;
! 196: enum dhcp_token token;
! 197: unsigned len = 0;
! 198: char *s;
! 199: char *t;
! 200: pair c = (pair)0;
! 201: int ltid = 0;
! 202:
! 203: /* Read a dotted hostname... */
! 204: do {
! 205: /* Read a token, which should be an identifier. */
! 206: token = peek_token (&val, (unsigned *)0, cfile);
! 207: if (!is_identifier (token) && token != NUMBER)
! 208: break;
! 209: token = next_token (&val, (unsigned *)0, cfile);
! 210:
! 211: /* Store this identifier... */
! 212: if (!(s = (char *)dmalloc (strlen (val) + 1, MDL)))
! 213: log_fatal ("can't allocate temp space for hostname.");
! 214: strcpy (s, val);
! 215: c = cons ((caddr_t)s, c);
! 216: len += strlen (s) + 1;
! 217: /* Look for a dot; if it's there, keep going, otherwise
! 218: we're done. */
! 219: token = peek_token (&val, (unsigned *)0, cfile);
! 220: if (token == DOT) {
! 221: token = next_token (&val, (unsigned *)0, cfile);
! 222: ltid = 1;
! 223: } else
! 224: ltid = 0;
! 225: } while (token == DOT);
! 226:
! 227: /* Should be at least one token. */
! 228: if (!len)
! 229: return (char *)0;
! 230:
! 231: /* Assemble the hostname together into a string. */
! 232: if (!(s = (char *)dmalloc (len + ltid, MDL)))
! 233: log_fatal ("can't allocate space for hostname.");
! 234: t = s + len + ltid;
! 235: *--t = 0;
! 236: if (ltid)
! 237: *--t = '.';
! 238: while (c) {
! 239: pair cdr = c -> cdr;
! 240: unsigned l = strlen ((char *)(c -> car));
! 241: t -= l;
! 242: memcpy (t, (char *)(c -> car), l);
! 243: /* Free up temp space. */
! 244: dfree (c -> car, MDL);
! 245: dfree (c, MDL);
! 246: c = cdr;
! 247: if (t != s)
! 248: *--t = '.';
! 249: }
! 250: return s;
! 251: }
! 252:
! 253: /* ip-addr-or-hostname :== ip-address | hostname
! 254: ip-address :== NUMBER DOT NUMBER DOT NUMBER DOT NUMBER
! 255:
! 256: Parse an ip address or a hostname. If uniform is zero, put in
! 257: an expr_substring node to limit hostnames that evaluate to more
! 258: than one IP address.
! 259:
! 260: Note that RFC1123 permits hostnames to consist of all digits,
! 261: making it difficult to quickly disambiguate them from ip addresses.
! 262: */
! 263:
! 264: int parse_ip_addr_or_hostname (expr, cfile, uniform)
! 265: struct expression **expr;
! 266: struct parse *cfile;
! 267: int uniform;
! 268: {
! 269: const char *val;
! 270: enum dhcp_token token;
! 271: unsigned char addr [4];
! 272: unsigned len = sizeof addr;
! 273: char *name;
! 274: struct expression *x = (struct expression *)0;
! 275: int ipaddr = 0;
! 276:
! 277: token = peek_token (&val, (unsigned *)0, cfile);
! 278:
! 279: if (token == NUMBER) {
! 280: /*
! 281: * a hostname may be numeric, but domain names must
! 282: * start with a letter, so we can disambiguate by
! 283: * looking ahead a few tokens. we save the parse
! 284: * context first, and restore it after we know what
! 285: * we're dealing with.
! 286: */
! 287: save_parse_state(cfile);
! 288: (void) next_token(NULL, NULL, cfile);
! 289: if (next_token(NULL, NULL, cfile) == DOT &&
! 290: next_token(NULL, NULL, cfile) == NUMBER)
! 291: ipaddr = 1;
! 292: restore_parse_state(cfile);
! 293:
! 294: if (ipaddr &&
! 295: parse_numeric_aggregate (cfile, addr, &len, DOT, 10, 8))
! 296: return make_const_data (expr, addr, len, 0, 1, MDL);
! 297:
! 298: }
! 299:
! 300: if (is_identifier (token) || token == NUMBER) {
! 301: name = parse_host_name (cfile);
! 302: if (!name)
! 303: return 0;
! 304: if (!make_host_lookup (expr, name)) {
! 305: dfree(name, MDL);
! 306: return 0;
! 307: }
! 308: dfree(name, MDL);
! 309: if (!uniform) {
! 310: if (!make_limit (&x, *expr, 4))
! 311: return 0;
! 312: expression_dereference (expr, MDL);
! 313: *expr = x;
! 314: }
! 315: } else {
! 316: if (token != RBRACE && token != LBRACE)
! 317: token = next_token (&val, (unsigned *)0, cfile);
! 318: parse_warn (cfile, "%s (%d): expecting IP address or hostname",
! 319: val, token);
! 320: if (token != SEMI)
! 321: skip_to_semi (cfile);
! 322: return 0;
! 323: }
! 324:
! 325: return 1;
! 326: }
! 327:
! 328: /*
! 329: * ip-address :== NUMBER DOT NUMBER DOT NUMBER DOT NUMBER
! 330: */
! 331:
! 332: int parse_ip_addr (cfile, addr)
! 333: struct parse *cfile;
! 334: struct iaddr *addr;
! 335: {
! 336: addr -> len = 4;
! 337: if (parse_numeric_aggregate (cfile, addr -> iabuf,
! 338: &addr -> len, DOT, 10, 8))
! 339: return 1;
! 340: return 0;
! 341: }
! 342:
! 343: /*
! 344: * Return true if every character in the string is hexadecimal.
! 345: */
! 346: static int
! 347: is_hex_string(const char *s) {
! 348: while (*s != '\0') {
! 349: if (!isxdigit((int)*s)) {
! 350: return 0;
! 351: }
! 352: s++;
! 353: }
! 354: return 1;
! 355: }
! 356:
! 357: /*
! 358: * ip-address6 :== (complicated set of rules)
! 359: *
! 360: * See section 2.2 of RFC 1884 for details.
! 361: *
! 362: * We are lazy for this. We pull numbers, names, colons, and dots
! 363: * together and then throw the resulting string at the inet_pton()
! 364: * function.
! 365: */
! 366:
! 367: int
! 368: parse_ip6_addr(struct parse *cfile, struct iaddr *addr) {
! 369: enum dhcp_token token;
! 370: const char *val;
! 371: int val_len;
! 372:
! 373: char v6[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
! 374: int v6_len;
! 375:
! 376: /*
! 377: * First token is non-raw. This way we eat any whitespace before
! 378: * our IPv6 address begins, like one would expect.
! 379: */
! 380: token = peek_token(&val, NULL, cfile);
! 381:
! 382: /*
! 383: * Gather symbols.
! 384: */
! 385: v6_len = 0;
! 386: for (;;) {
! 387: if ((((token == NAME) || (token == NUMBER_OR_NAME)) &&
! 388: is_hex_string(val)) ||
! 389: (token == NUMBER) ||
! 390: (token == DOT) ||
! 391: (token == COLON)) {
! 392:
! 393: next_raw_token(&val, NULL, cfile);
! 394: val_len = strlen(val);
! 395: if ((v6_len + val_len) >= sizeof(v6)) {
! 396: parse_warn(cfile, "Invalid IPv6 address.");
! 397: skip_to_semi(cfile);
! 398: return 0;
! 399: }
! 400: memcpy(v6+v6_len, val, val_len);
! 401: v6_len += val_len;
! 402:
! 403: } else {
! 404: break;
! 405: }
! 406: token = peek_raw_token(&val, NULL, cfile);
! 407: }
! 408: v6[v6_len] = '\0';
! 409:
! 410: /*
! 411: * Use inet_pton() for actual work.
! 412: */
! 413: if (inet_pton(AF_INET6, v6, addr->iabuf) <= 0) {
! 414: parse_warn(cfile, "Invalid IPv6 address.");
! 415: skip_to_semi(cfile);
! 416: return 0;
! 417: }
! 418: addr->len = 16;
! 419: return 1;
! 420: }
! 421:
! 422: /*
! 423: * Same as parse_ip6_addr() above, but returns the value in the
! 424: * expression rather than in an address structure.
! 425: */
! 426: int
! 427: parse_ip6_addr_expr(struct expression **expr,
! 428: struct parse *cfile) {
! 429: struct iaddr addr;
! 430:
! 431: if (!parse_ip6_addr(cfile, &addr)) {
! 432: return 0;
! 433: }
! 434: return make_const_data(expr, addr.iabuf, addr.len, 0, 1, MDL);
! 435: }
! 436:
! 437: /*
! 438: * ip6-prefix :== ip6-address "/" NUMBER
! 439: */
! 440: int
! 441: parse_ip6_prefix(struct parse *cfile, struct iaddr *addr, u_int8_t *plen) {
! 442: enum dhcp_token token;
! 443: const char *val;
! 444: int n;
! 445:
! 446: if (!parse_ip6_addr(cfile, addr)) {
! 447: return 0;
! 448: }
! 449: token = next_token(&val, NULL, cfile);
! 450: if (token != SLASH) {
! 451: parse_warn(cfile, "Slash expected.");
! 452: if (token != SEMI)
! 453: skip_to_semi(cfile);
! 454: return 0;
! 455: }
! 456: token = next_token(&val, NULL, cfile);
! 457: if (token != NUMBER) {
! 458: parse_warn(cfile, "Number expected.");
! 459: if (token != SEMI)
! 460: skip_to_semi(cfile);
! 461: return 0;
! 462: }
! 463: n = atoi(val);
! 464: if ((n < 0) || (n > 128)) {
! 465: parse_warn(cfile, "Invalid IPv6 prefix length.");
! 466: skip_to_semi(cfile);
! 467: return 0;
! 468: }
! 469: if (!is_cidr_mask_valid(addr, n)) {
! 470: parse_warn(cfile, "network mask too short.");
! 471: skip_to_semi(cfile);
! 472: return 0;
! 473: }
! 474: *plen = n;
! 475: return 1;
! 476: }
! 477:
! 478: /*
! 479: * ip-address-with-subnet :== ip-address |
! 480: * ip-address "/" NUMBER
! 481: */
! 482:
! 483: int
! 484: parse_ip_addr_with_subnet(cfile, match)
! 485: struct parse *cfile;
! 486: struct iaddrmatch *match;
! 487: {
! 488: const char *val, *orig;
! 489: enum dhcp_token token;
! 490: int prefixlen;
! 491: int fflen;
! 492: unsigned char newval, warnmask=0;
! 493:
! 494: if (parse_ip_addr(cfile, &match->addr)) {
! 495: /* default to host mask */
! 496: prefixlen = match->addr.len * 8;
! 497:
! 498: token = peek_token(&val, NULL, cfile);
! 499:
! 500: if (token == SLASH) {
! 501: next_token(&val, NULL, cfile);
! 502: token = next_token(&val, NULL, cfile);
! 503:
! 504: if (token != NUMBER) {
! 505: parse_warn(cfile, "Invalid CIDR prefix length:"
! 506: " expecting a number.");
! 507: return 0;
! 508: }
! 509:
! 510: prefixlen = atoi(val);
! 511:
! 512: if (prefixlen < 0 ||
! 513: prefixlen > (match->addr.len * 8)) {
! 514: parse_warn(cfile, "subnet prefix is out of "
! 515: "range [0..%d].",
! 516: match->addr.len * 8);
! 517: return 0;
! 518: }
! 519: }
! 520:
! 521: /* construct a suitable mask field */
! 522:
! 523: /* copy length */
! 524: match->mask.len = match->addr.len;
! 525:
! 526: /* count of 0xff bytes in mask */
! 527: fflen = prefixlen / 8;
! 528:
! 529: /* set leading mask */
! 530: memset(match->mask.iabuf, 0xff, fflen);
! 531:
! 532: /* set zeroes */
! 533: if (fflen < match->mask.len) {
! 534: match->mask.iabuf[fflen] =
! 535: "\x00\x80\xc0\xe0\xf0\xf8\xfc\xfe"[prefixlen % 8];
! 536:
! 537: memset(match->mask.iabuf+fflen+1, 0x00,
! 538: match->mask.len - fflen - 1);
! 539:
! 540: /* AND-out insignificant bits from supplied netmask. */
! 541: orig = piaddr(match->addr);
! 542: do {
! 543: newval = match->addr.iabuf[fflen] &
! 544: match->mask.iabuf[fflen];
! 545:
! 546: if (newval != match->addr.iabuf[fflen]) {
! 547: warnmask = 1;
! 548: match->addr.iabuf[fflen] = newval;
! 549: }
! 550: } while (++fflen < match->mask.len);
! 551:
! 552: if (warnmask) {
! 553: log_error("Warning: Extraneous bits removed "
! 554: "in address component of %s/%d.",
! 555: orig, prefixlen);
! 556: log_error("New value: %s/%d.",
! 557: piaddr(match->addr), prefixlen);
! 558: }
! 559: }
! 560:
! 561: return 1;
! 562: }
! 563:
! 564: parse_warn(cfile,
! 565: "expecting ip-address or ip-address/prefixlen");
! 566:
! 567: return 0; /* let caller pick up pieces */
! 568: }
! 569:
! 570: /*
! 571: * hardware-parameter :== HARDWARE hardware-type colon-separated-hex-list SEMI
! 572: * hardware-type :== ETHERNET | TOKEN_RING | TOKEN_FDDI
! 573: */
! 574:
! 575: void parse_hardware_param (cfile, hardware)
! 576: struct parse *cfile;
! 577: struct hardware *hardware;
! 578: {
! 579: const char *val;
! 580: enum dhcp_token token;
! 581: unsigned hlen;
! 582: unsigned char *t;
! 583:
! 584: token = next_token (&val, (unsigned *)0, cfile);
! 585: switch (token) {
! 586: case ETHERNET:
! 587: hardware -> hbuf [0] = HTYPE_ETHER;
! 588: break;
! 589: case TOKEN_RING:
! 590: hardware -> hbuf [0] = HTYPE_IEEE802;
! 591: break;
! 592: case TOKEN_FDDI:
! 593: hardware -> hbuf [0] = HTYPE_FDDI;
! 594: break;
! 595: default:
! 596: if (!strncmp (val, "unknown-", 8)) {
! 597: hardware -> hbuf [0] = atoi (&val [8]);
! 598: } else {
! 599: parse_warn (cfile,
! 600: "expecting a network hardware type");
! 601: skip_to_semi (cfile);
! 602:
! 603: return;
! 604: }
! 605: }
! 606:
! 607: /* Parse the hardware address information. Technically,
! 608: it would make a lot of sense to restrict the length of the
! 609: data we'll accept here to the length of a particular hardware
! 610: address type. Unfortunately, there are some broken clients
! 611: out there that put bogus data in the chaddr buffer, and we accept
! 612: that data in the lease file rather than simply failing on such
! 613: clients. Yuck. */
! 614: hlen = 0;
! 615: token = peek_token (&val, (unsigned *)0, cfile);
! 616: if (token == SEMI) {
! 617: hardware -> hlen = 1;
! 618: goto out;
! 619: }
! 620: t = parse_numeric_aggregate (cfile, (unsigned char *)0, &hlen,
! 621: COLON, 16, 8);
! 622: if (!t) {
! 623: hardware -> hlen = 1;
! 624: return;
! 625: }
! 626: if (hlen + 1 > sizeof hardware -> hbuf) {
! 627: dfree (t, MDL);
! 628: parse_warn (cfile, "hardware address too long");
! 629: } else {
! 630: hardware -> hlen = hlen + 1;
! 631: memcpy ((unsigned char *)&hardware -> hbuf [1], t, hlen);
! 632: if (hlen + 1 < sizeof hardware -> hbuf)
! 633: memset (&hardware -> hbuf [hlen + 1], 0,
! 634: (sizeof hardware -> hbuf) - hlen - 1);
! 635: dfree (t, MDL);
! 636: }
! 637:
! 638: out:
! 639: token = next_token (&val, (unsigned *)0, cfile);
! 640: if (token != SEMI) {
! 641: parse_warn (cfile, "expecting semicolon.");
! 642: skip_to_semi (cfile);
! 643: }
! 644: }
! 645:
! 646: /* lease-time :== NUMBER SEMI */
! 647:
! 648: void parse_lease_time (cfile, timep)
! 649: struct parse *cfile;
! 650: TIME *timep;
! 651: {
! 652: const char *val;
! 653: enum dhcp_token token;
! 654: u_int32_t num;
! 655:
! 656: token = next_token (&val, (unsigned *)0, cfile);
! 657: if (token != NUMBER) {
! 658: parse_warn (cfile, "Expecting numeric lease time");
! 659: skip_to_semi (cfile);
! 660: return;
! 661: }
! 662: convert_num(cfile, (unsigned char *)&num, val, 10, 32);
! 663: /* Unswap the number - convert_num returns stuff in NBO. */
! 664: *timep = ntohl(num);
! 665:
! 666: parse_semi (cfile);
! 667: }
! 668:
! 669: /* No BNF for numeric aggregates - that's defined by the caller. What
! 670: this function does is to parse a sequence of numbers separated by
! 671: the token specified in separator. If max is zero, any number of
! 672: numbers will be parsed; otherwise, exactly max numbers are
! 673: expected. Base and size tell us how to internalize the numbers
! 674: once they've been tokenized. */
! 675:
! 676: unsigned char *parse_numeric_aggregate (cfile, buf,
! 677: max, separator, base, size)
! 678: struct parse *cfile;
! 679: unsigned char *buf;
! 680: unsigned *max;
! 681: int separator;
! 682: int base;
! 683: unsigned size;
! 684: {
! 685: const char *val;
! 686: enum dhcp_token token;
! 687: unsigned char *bufp = buf, *s, *t;
! 688: unsigned count = 0;
! 689: pair c = (pair)0;
! 690:
! 691: if (!bufp && *max) {
! 692: bufp = (unsigned char *)dmalloc (*max * size / 8, MDL);
! 693: if (!bufp)
! 694: log_fatal ("no space for numeric aggregate");
! 695: s = 0;
! 696: } else
! 697: s = bufp;
! 698:
! 699: do {
! 700: if (count) {
! 701: token = peek_token (&val, (unsigned *)0, cfile);
! 702: if (token != separator) {
! 703: if (!*max)
! 704: break;
! 705: if (token != RBRACE && token != LBRACE)
! 706: token = next_token (&val,
! 707: (unsigned *)0,
! 708: cfile);
! 709: parse_warn (cfile, "too few numbers.");
! 710: if (token != SEMI)
! 711: skip_to_semi (cfile);
! 712: return (unsigned char *)0;
! 713: }
! 714: token = next_token (&val, (unsigned *)0, cfile);
! 715: }
! 716: token = next_token (&val, (unsigned *)0, cfile);
! 717:
! 718: if (token == END_OF_FILE) {
! 719: parse_warn (cfile, "unexpected end of file");
! 720: break;
! 721: }
! 722:
! 723: /* Allow NUMBER_OR_NAME if base is 16. */
! 724: if (token != NUMBER &&
! 725: (base != 16 || token != NUMBER_OR_NAME)) {
! 726: parse_warn (cfile, "expecting numeric value.");
! 727: skip_to_semi (cfile);
! 728: return (unsigned char *)0;
! 729: }
! 730: /* If we can, convert the number now; otherwise, build
! 731: a linked list of all the numbers. */
! 732: if (s) {
! 733: convert_num (cfile, s, val, base, size);
! 734: s += size / 8;
! 735: } else {
! 736: t = (unsigned char *)dmalloc (strlen (val) + 1, MDL);
! 737: if (!t)
! 738: log_fatal ("no temp space for number.");
! 739: strcpy ((char *)t, val);
! 740: c = cons ((caddr_t)t, c);
! 741: }
! 742: } while (++count != *max);
! 743:
! 744: /* If we had to cons up a list, convert it now. */
! 745: if (c) {
! 746: bufp = (unsigned char *)dmalloc (count * size / 8, MDL);
! 747: if (!bufp)
! 748: log_fatal ("no space for numeric aggregate.");
! 749: s = bufp + count - size / 8;
! 750: *max = count;
! 751: }
! 752: while (c) {
! 753: pair cdr = c -> cdr;
! 754: convert_num (cfile, s, (char *)(c -> car), base, size);
! 755: s -= size / 8;
! 756: /* Free up temp space. */
! 757: dfree (c -> car, MDL);
! 758: dfree (c, MDL);
! 759: c = cdr;
! 760: }
! 761: return bufp;
! 762: }
! 763:
! 764: void convert_num (cfile, buf, str, base, size)
! 765: struct parse *cfile;
! 766: unsigned char *buf;
! 767: const char *str;
! 768: int base;
! 769: unsigned size;
! 770: {
! 771: const unsigned char *ptr = (const unsigned char *)str;
! 772: int negative = 0;
! 773: u_int32_t val = 0;
! 774: int tval;
! 775: int max;
! 776:
! 777: if (*ptr == '-') {
! 778: negative = 1;
! 779: ++ptr;
! 780: }
! 781:
! 782: /* If base wasn't specified, figure it out from the data. */
! 783: if (!base) {
! 784: if (ptr [0] == '0') {
! 785: if (ptr [1] == 'x') {
! 786: base = 16;
! 787: ptr += 2;
! 788: } else if (isascii (ptr [1]) && isdigit (ptr [1])) {
! 789: base = 8;
! 790: ptr += 1;
! 791: } else {
! 792: base = 10;
! 793: }
! 794: } else {
! 795: base = 10;
! 796: }
! 797: }
! 798:
! 799: do {
! 800: tval = *ptr++;
! 801: /* XXX assumes ASCII... */
! 802: if (tval >= 'a')
! 803: tval = tval - 'a' + 10;
! 804: else if (tval >= 'A')
! 805: tval = tval - 'A' + 10;
! 806: else if (tval >= '0')
! 807: tval -= '0';
! 808: else {
! 809: parse_warn (cfile, "Bogus number: %s.", str);
! 810: break;
! 811: }
! 812: if (tval >= base) {
! 813: parse_warn (cfile,
! 814: "Bogus number %s: digit %d not in base %d",
! 815: str, tval, base);
! 816: break;
! 817: }
! 818: val = val * base + tval;
! 819: } while (*ptr);
! 820:
! 821: if (negative)
! 822: max = (1 << (size - 1));
! 823: else
! 824: max = (1 << (size - 1)) + ((1 << (size - 1)) - 1);
! 825: if (val > max) {
! 826: switch (base) {
! 827: case 8:
! 828: parse_warn (cfile,
! 829: "%s%lo exceeds max (%d) for precision.",
! 830: negative ? "-" : "",
! 831: (unsigned long)val, max);
! 832: break;
! 833: case 16:
! 834: parse_warn (cfile,
! 835: "%s%lx exceeds max (%d) for precision.",
! 836: negative ? "-" : "",
! 837: (unsigned long)val, max);
! 838: break;
! 839: default:
! 840: parse_warn (cfile,
! 841: "%s%lu exceeds max (%d) for precision.",
! 842: negative ? "-" : "",
! 843: (unsigned long)val, max);
! 844: break;
! 845: }
! 846: }
! 847:
! 848: if (negative) {
! 849: switch (size) {
! 850: case 8:
! 851: *buf = -(unsigned long)val;
! 852: break;
! 853: case 16:
! 854: putShort (buf, -(long)val);
! 855: break;
! 856: case 32:
! 857: putLong (buf, -(long)val);
! 858: break;
! 859: default:
! 860: parse_warn (cfile,
! 861: "Unexpected integer size: %d\n", size);
! 862: break;
! 863: }
! 864: } else {
! 865: switch (size) {
! 866: case 8:
! 867: *buf = (u_int8_t)val;
! 868: break;
! 869: case 16:
! 870: putUShort (buf, (u_int16_t)val);
! 871: break;
! 872: case 32:
! 873: putULong (buf, val);
! 874: break;
! 875: default:
! 876: parse_warn (cfile,
! 877: "Unexpected integer size: %d\n", size);
! 878: break;
! 879: }
! 880: }
! 881: }
! 882:
! 883: /*
! 884: * date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER
! 885: * NUMBER COLON NUMBER COLON NUMBER |
! 886: * NUMBER NUMBER SLASH NUMBER SLASH NUMBER
! 887: * NUMBER COLON NUMBER COLON NUMBER NUMBER |
! 888: * EPOCH NUMBER |
! 889: * NEVER
! 890: *
! 891: * Dates are stored in UTC or with a timezone offset; first number is day
! 892: * of week; next is year/month/day; next is hours:minutes:seconds on a
! 893: * 24-hour clock, followed by the timezone offset in seconds, which is
! 894: * optional.
! 895: */
! 896:
! 897: /*
! 898: * just parse the date
! 899: * any trailing semi must be consumed by the caller of this routine
! 900: */
! 901: TIME
! 902: parse_date_core(cfile)
! 903: struct parse *cfile;
! 904: {
! 905: int guess;
! 906: int tzoff, wday, year, mon, mday, hour, min, sec;
! 907: const char *val;
! 908: enum dhcp_token token;
! 909: static int months[11] = { 31, 59, 90, 120, 151, 181,
! 910: 212, 243, 273, 304, 334 };
! 911:
! 912: /* "never", "epoch" or day of week */
! 913: token = peek_token(&val, NULL, cfile);
! 914: if (token == NEVER) {
! 915: token = next_token(&val, NULL, cfile); /* consume NEVER */
! 916: return(MAX_TIME);
! 917: }
! 918:
! 919: /* This indicates 'local' time format. */
! 920: if (token == EPOCH) {
! 921: token = next_token(&val, NULL, cfile); /* consume EPOCH */
! 922: token = peek_token(&val, NULL, cfile);
! 923:
! 924: if (token != NUMBER) {
! 925: if (token != SEMI)
! 926: token = next_token(&val, NULL, cfile);
! 927: parse_warn(cfile, "Seconds since epoch expected.");
! 928: return((TIME)0);
! 929: }
! 930:
! 931: token = next_token(&val, NULL, cfile); /* consume number */
! 932: guess = atoi(val);
! 933:
! 934: return((TIME)guess);
! 935: }
! 936:
! 937: if (token != NUMBER) {
! 938: if (token != SEMI)
! 939: token = next_token(&val, NULL, cfile);
! 940: parse_warn(cfile, "numeric day of week expected.");
! 941: return((TIME)0);
! 942: }
! 943: token = next_token(&val, NULL, cfile); /* consume day of week */
! 944: wday = atoi(val);
! 945:
! 946: /* Year... */
! 947: token = peek_token(&val, NULL, cfile);
! 948: if (token != NUMBER) {
! 949: if (token != SEMI)
! 950: token = next_token(&val, NULL, cfile);
! 951: parse_warn(cfile, "numeric year expected.");
! 952: return((TIME)0);
! 953: }
! 954: token = next_token(&val, NULL, cfile); /* consume year */
! 955:
! 956: /* Note: the following is not a Y2K bug - it's a Y1.9K bug. Until
! 957: somebody invents a time machine, I think we can safely disregard
! 958: it. This actually works around a stupid Y2K bug that was present
! 959: in a very early beta release of dhcpd. */
! 960: year = atoi(val);
! 961: if (year > 1900)
! 962: year -= 1900;
! 963:
! 964: /* Slash separating year from month... */
! 965: token = peek_token(&val, NULL, cfile);
! 966: if (token != SLASH) {
! 967: if (token != SEMI)
! 968: token = next_token(&val, NULL, cfile);
! 969: parse_warn(cfile,
! 970: "expected slash separating year from month.");
! 971: return((TIME)0);
! 972: }
! 973: token = next_token(&val, NULL, cfile); /* consume SLASH */
! 974:
! 975: /* Month... */
! 976: token = peek_token(&val, NULL, cfile);
! 977: if (token != NUMBER) {
! 978: if (token != SEMI)
! 979: token = next_token(&val, NULL, cfile);
! 980: parse_warn(cfile, "numeric month expected.");
! 981: return((TIME)0);
! 982: }
! 983: token = next_token(&val, NULL, cfile); /* consume month */
! 984: mon = atoi(val) - 1;
! 985:
! 986: /* Slash separating month from day... */
! 987: token = peek_token(&val, NULL, cfile);
! 988: if (token != SLASH) {
! 989: if (token != SEMI)
! 990: token = next_token(&val, NULL, cfile);
! 991: parse_warn(cfile,
! 992: "expected slash separating month from day.");
! 993: return((TIME)0);
! 994: }
! 995: token = next_token(&val, NULL, cfile); /* consume SLASH */
! 996:
! 997: /* Day of month... */
! 998: token = peek_token(&val, NULL, cfile);
! 999: if (token != NUMBER) {
! 1000: if (token != SEMI)
! 1001: token = next_token(&val, NULL, cfile);
! 1002: parse_warn(cfile, "numeric day of month expected.");
! 1003: return((TIME)0);
! 1004: }
! 1005: token = next_token(&val, NULL, cfile); /* consume day of month */
! 1006: mday = atoi(val);
! 1007:
! 1008: /* Hour... */
! 1009: token = peek_token(&val, NULL, cfile);
! 1010: if (token != NUMBER) {
! 1011: if (token != SEMI)
! 1012: token = next_token(&val, NULL, cfile);
! 1013: parse_warn(cfile, "numeric hour expected.");
! 1014: return((TIME)0);
! 1015: }
! 1016: token = next_token(&val, NULL, cfile); /* consume hour */
! 1017: hour = atoi(val);
! 1018:
! 1019: /* Colon separating hour from minute... */
! 1020: token = peek_token(&val, NULL, cfile);
! 1021: if (token != COLON) {
! 1022: if (token != SEMI)
! 1023: token = next_token(&val, NULL, cfile);
! 1024: parse_warn(cfile,
! 1025: "expected colon separating hour from minute.");
! 1026: return((TIME)0);
! 1027: }
! 1028: token = next_token(&val, NULL, cfile); /* consume colon */
! 1029:
! 1030: /* Minute... */
! 1031: token = peek_token(&val, NULL, cfile);
! 1032: if (token != NUMBER) {
! 1033: if (token != SEMI)
! 1034: token = next_token(&val, NULL, cfile);
! 1035: parse_warn(cfile, "numeric minute expected.");
! 1036: return((TIME)0);
! 1037: }
! 1038: token = next_token(&val, NULL, cfile); /* consume minute */
! 1039: min = atoi(val);
! 1040:
! 1041: /* Colon separating minute from second... */
! 1042: token = peek_token(&val, NULL, cfile);
! 1043: if (token != COLON) {
! 1044: if (token != SEMI)
! 1045: token = next_token(&val, NULL, cfile);
! 1046: parse_warn(cfile,
! 1047: "expected colon separating minute from second.");
! 1048: return((TIME)0);
! 1049: }
! 1050: token = next_token(&val, NULL, cfile); /* consume colon */
! 1051:
! 1052: /* Second... */
! 1053: token = peek_token(&val, NULL, cfile);
! 1054: if (token != NUMBER) {
! 1055: if (token != SEMI)
! 1056: token = next_token(&val, NULL, cfile);
! 1057: parse_warn(cfile, "numeric second expected.");
! 1058: return((TIME)0);
! 1059: }
! 1060: token = next_token(&val, NULL, cfile); /* consume second */
! 1061: sec = atoi(val);
! 1062:
! 1063: tzoff = 0;
! 1064: token = peek_token(&val, NULL, cfile);
! 1065: if (token == NUMBER) {
! 1066: token = next_token(&val, NULL, cfile); /* consume tzoff */
! 1067: tzoff = atoi(val);
! 1068: } else if (token != SEMI) {
! 1069: token = next_token(&val, NULL, cfile);
! 1070: parse_warn(cfile,
! 1071: "Time zone offset or semicolon expected.");
! 1072: return((TIME)0);
! 1073: }
! 1074:
! 1075: /* Guess the time value... */
! 1076: guess = ((((((365 * (year - 70) + /* Days in years since '70 */
! 1077: (year - 69) / 4 + /* Leap days since '70 */
! 1078: (mon /* Days in months this year */
! 1079: ? months [mon - 1]
! 1080: : 0) +
! 1081: (mon > 1 && /* Leap day this year */
! 1082: !((year - 72) & 3)) +
! 1083: mday - 1) * 24) + /* Day of month */
! 1084: hour) * 60) +
! 1085: min) * 60) + sec + tzoff;
! 1086:
! 1087: /* This guess could be wrong because of leap seconds or other
! 1088: weirdness we don't know about that the system does. For
! 1089: now, we're just going to accept the guess, but at some point
! 1090: it might be nice to do a successive approximation here to
! 1091: get an exact value. Even if the error is small, if the
! 1092: server is restarted frequently (and thus the lease database
! 1093: is reread), the error could accumulate into something
! 1094: significant. */
! 1095:
! 1096: return((TIME)guess);
! 1097: }
! 1098:
! 1099: /*
! 1100: * Wrapper to consume the semicolon after the date
! 1101: * :== date semi
! 1102: */
! 1103:
! 1104: TIME
! 1105: parse_date(cfile)
! 1106: struct parse *cfile;
! 1107: {
! 1108: TIME guess;
! 1109: guess = parse_date_core(cfile);
! 1110:
! 1111: /* Make sure the date ends in a semicolon... */
! 1112: if (!parse_semi(cfile))
! 1113: return((TIME)0);
! 1114: return(guess);
! 1115: }
! 1116:
! 1117:
! 1118:
! 1119: /*
! 1120: * option-name :== IDENTIFIER |
! 1121: IDENTIFIER . IDENTIFIER
! 1122: */
! 1123:
! 1124: isc_result_t
! 1125: parse_option_name (cfile, allocate, known, opt)
! 1126: struct parse *cfile;
! 1127: int allocate;
! 1128: int *known;
! 1129: struct option **opt;
! 1130: {
! 1131: const char *val;
! 1132: enum dhcp_token token;
! 1133: char *uname;
! 1134: struct universe *universe;
! 1135: struct option *option;
! 1136: unsigned code;
! 1137:
! 1138: if (opt == NULL)
! 1139: return ISC_R_INVALIDARG;
! 1140:
! 1141: token = next_token (&val, (unsigned *)0, cfile);
! 1142: if (!is_identifier (token)) {
! 1143: parse_warn (cfile,
! 1144: "expecting identifier after option keyword.");
! 1145: if (token != SEMI)
! 1146: skip_to_semi (cfile);
! 1147: return ISC_R_BADPARSE;
! 1148: }
! 1149: uname = dmalloc (strlen (val) + 1, MDL);
! 1150: if (!uname)
! 1151: log_fatal ("no memory for uname information.");
! 1152: strcpy (uname, val);
! 1153: token = peek_token (&val, (unsigned *)0, cfile);
! 1154: if (token == DOT) {
! 1155: /* Go ahead and take the DOT token... */
! 1156: token = next_token (&val, (unsigned *)0, cfile);
! 1157:
! 1158: /* The next token should be an identifier... */
! 1159: token = next_token (&val, (unsigned *)0, cfile);
! 1160: if (!is_identifier (token)) {
! 1161: parse_warn (cfile, "expecting identifier after '.'");
! 1162: if (token != SEMI)
! 1163: skip_to_semi (cfile);
! 1164: return ISC_R_BADPARSE;
! 1165: }
! 1166:
! 1167: /* Look up the option name hash table for the specified
! 1168: uname. */
! 1169: universe = (struct universe *)0;
! 1170: if (!universe_hash_lookup (&universe, universe_hash,
! 1171: uname, 0, MDL)) {
! 1172: parse_warn (cfile, "no option space named %s.", uname);
! 1173: skip_to_semi (cfile);
! 1174: return ISC_R_NOTFOUND;
! 1175: }
! 1176: } else {
! 1177: /* Use the default hash table, which contains all the
! 1178: standard dhcp option names. */
! 1179: val = uname;
! 1180: universe = &dhcp_universe;
! 1181: }
! 1182:
! 1183: /* Look up the actual option info... */
! 1184: option_name_hash_lookup(opt, universe->name_hash, val, 0, MDL);
! 1185: option = *opt;
! 1186:
! 1187: /* If we didn't get an option structure, it's an undefined option. */
! 1188: if (option) {
! 1189: if (known)
! 1190: *known = 1;
! 1191: /* If the option name is of the form unknown-[decimal], use
! 1192: * the trailing decimal value to find the option definition.
! 1193: * If there is no definition, construct one. This is to
! 1194: * support legacy use of unknown options in config files or
! 1195: * lease databases.
! 1196: */
! 1197: } else if (strncasecmp(val, "unknown-", 8) == 0) {
! 1198: code = atoi(val+8);
! 1199:
! 1200: /* Option code 0 is always illegal for us, thanks
! 1201: * to the option decoder.
! 1202: */
! 1203: if (code == 0 || code == universe->end) {
! 1204: parse_warn(cfile, "Option codes 0 and %u are illegal "
! 1205: "in the %s space.", universe->end,
! 1206: universe->name);
! 1207: skip_to_semi(cfile);
! 1208: dfree(uname, MDL);
! 1209: return ISC_R_FAILURE;
! 1210: }
! 1211:
! 1212: /* It's odd to think of unknown option codes as
! 1213: * being known, but this means we know what the
! 1214: * parsed name is talking about.
! 1215: */
! 1216: if (known)
! 1217: *known = 1;
! 1218:
! 1219: option_code_hash_lookup(opt, universe->code_hash,
! 1220: &code, 0, MDL);
! 1221: option = *opt;
! 1222:
! 1223: /* If we did not find an option of that code,
! 1224: * manufacture an unknown-xxx option definition.
! 1225: * Its single reference will ensure that it is
! 1226: * deleted once the option is recycled out of
! 1227: * existence (by the parent).
! 1228: */
! 1229: if (option == NULL) {
! 1230: option = new_option(val, MDL);
! 1231: option->universe = universe;
! 1232: option->code = code;
! 1233: option->format = default_option_format;
! 1234: option_reference(opt, option, MDL);
! 1235: } else
! 1236: log_info("option %s has been redefined as option %s. "
! 1237: "Please update your configs if neccessary.",
! 1238: val, option->name);
! 1239: /* If we've been told to allocate, that means that this
! 1240: * (might) be an option code definition, so we'll create
! 1241: * an option structure and return it for the parent to
! 1242: * decide.
! 1243: */
! 1244: } else if (allocate) {
! 1245: option = new_option(val, MDL);
! 1246: option -> universe = universe;
! 1247: option_reference(opt, option, MDL);
! 1248: } else {
! 1249: parse_warn(cfile, "no option named %s in space %s",
! 1250: val, universe->name);
! 1251: skip_to_semi (cfile);
! 1252: dfree(uname, MDL);
! 1253: return ISC_R_NOTFOUND;
! 1254: }
! 1255:
! 1256: /* Free the initial identifier token. */
! 1257: dfree (uname, MDL);
! 1258: return ISC_R_SUCCESS;
! 1259: }
! 1260:
! 1261: /* IDENTIFIER [WIDTHS] SEMI
! 1262: * WIDTHS ~= LENGTH WIDTH NUMBER
! 1263: * CODE WIDTH NUMBER
! 1264: */
! 1265:
! 1266: void parse_option_space_decl (cfile)
! 1267: struct parse *cfile;
! 1268: {
! 1269: int token;
! 1270: const char *val;
! 1271: struct universe **ua, *nu;
! 1272: char *nu_name;
! 1273: int tsize=1, lsize=1, hsize = 0;
! 1274:
! 1275: next_token (&val, (unsigned *)0, cfile); /* Discard the SPACE token,
! 1276: which was checked by the
! 1277: caller. */
! 1278: token = next_token (&val, (unsigned *)0, cfile);
! 1279: if (!is_identifier (token)) {
! 1280: parse_warn (cfile, "expecting identifier.");
! 1281: skip_to_semi (cfile);
! 1282: return;
! 1283: }
! 1284: nu = new_universe (MDL);
! 1285: if (!nu)
! 1286: log_fatal ("No memory for new option space.");
! 1287:
! 1288: /* Set up the server option universe... */
! 1289: nu_name = dmalloc (strlen (val) + 1, MDL);
! 1290: if (!nu_name)
! 1291: log_fatal ("No memory for new option space name.");
! 1292: strcpy (nu_name, val);
! 1293: nu -> name = nu_name;
! 1294:
! 1295: do {
! 1296: token = next_token(&val, NULL, cfile);
! 1297: switch(token) {
! 1298: case SEMI:
! 1299: break;
! 1300:
! 1301: case CODE:
! 1302: token = next_token(&val, NULL, cfile);
! 1303: if (token != WIDTH) {
! 1304: parse_warn(cfile, "expecting width token.");
! 1305: goto bad;
! 1306: }
! 1307:
! 1308: token = next_token(&val, NULL, cfile);
! 1309: if (token != NUMBER) {
! 1310: parse_warn(cfile, "expecting number 1, 2, 4.");
! 1311: goto bad;
! 1312: }
! 1313:
! 1314: tsize = atoi(val);
! 1315:
! 1316:
! 1317: switch (tsize) {
! 1318: case 1:
! 1319: if (!hsize)
! 1320: hsize = BYTE_NAME_HASH_SIZE;
! 1321: break;
! 1322: case 2:
! 1323: if (!hsize)
! 1324: hsize = WORD_NAME_HASH_SIZE;
! 1325: break;
! 1326: case 4:
! 1327: if (!hsize)
! 1328: hsize = QUAD_NAME_HASH_SIZE;
! 1329: break;
! 1330: default:
! 1331: parse_warn(cfile, "invalid code width (%d), "
! 1332: "expecting a 1, 2 or 4.",
! 1333: tsize);
! 1334: goto bad;
! 1335: }
! 1336: break;
! 1337:
! 1338: case LENGTH:
! 1339: token = next_token(&val, NULL, cfile);
! 1340: if (token != WIDTH) {
! 1341: parse_warn(cfile, "expecting width token.");
! 1342: goto bad;
! 1343: }
! 1344:
! 1345: token = next_token(&val, NULL, cfile);
! 1346: if (token != NUMBER) {
! 1347: parse_warn(cfile, "expecting number 1 or 2.");
! 1348: goto bad;
! 1349: }
! 1350:
! 1351: lsize = atoi(val);
! 1352: if (lsize != 1 && lsize != 2) {
! 1353: parse_warn(cfile, "invalid length width (%d) "
! 1354: "expecting 1 or 2.", lsize);
! 1355: goto bad;
! 1356: }
! 1357:
! 1358: break;
! 1359:
! 1360: case HASH:
! 1361: token = next_token(&val, NULL, cfile);
! 1362: if (token != SIZE) {
! 1363: parse_warn(cfile, "expecting size token.");
! 1364: goto bad;
! 1365: }
! 1366:
! 1367: token = next_token(&val, NULL, cfile);
! 1368: if (token != NUMBER) {
! 1369: parse_warn(cfile, "expecting a 10base number");
! 1370: goto bad;
! 1371: }
! 1372:
! 1373: /* (2^31)-1 is the highest Mersenne prime we should
! 1374: * probably allow...
! 1375: */
! 1376: hsize = atoi(val);
! 1377: if (hsize < 0 || hsize > 0x7FFFFFFF) {
! 1378: parse_warn(cfile, "invalid hash length: %d",
! 1379: hsize);
! 1380: goto bad;
! 1381: }
! 1382:
! 1383: break;
! 1384:
! 1385: default:
! 1386: parse_warn(cfile, "Unexpected token.");
! 1387: }
! 1388: } while (token != SEMI);
! 1389:
! 1390: if (!hsize)
! 1391: hsize = DEFAULT_SPACE_HASH_SIZE;
! 1392:
! 1393: nu -> lookup_func = lookup_hashed_option;
! 1394: nu -> option_state_dereference = hashed_option_state_dereference;
! 1395: nu -> foreach = hashed_option_space_foreach;
! 1396: nu -> save_func = save_hashed_option;
! 1397: nu -> delete_func = delete_hashed_option;
! 1398: nu -> encapsulate = hashed_option_space_encapsulate;
! 1399: nu -> decode = parse_option_buffer;
! 1400: nu -> length_size = lsize;
! 1401: nu -> tag_size = tsize;
! 1402: switch(tsize) {
! 1403: case 1:
! 1404: nu->get_tag = getUChar;
! 1405: nu->store_tag = putUChar;
! 1406: break;
! 1407: case 2:
! 1408: nu->get_tag = getUShort;
! 1409: nu->store_tag = putUShort;
! 1410: break;
! 1411: case 4:
! 1412: nu->get_tag = getULong;
! 1413: nu->store_tag = putULong;
! 1414: break;
! 1415: default:
! 1416: log_fatal("Impossible condition at %s:%d.", MDL);
! 1417: }
! 1418: switch(lsize) {
! 1419: case 0:
! 1420: nu->get_length = NULL;
! 1421: nu->store_length = NULL;
! 1422: break;
! 1423: case 1:
! 1424: nu->get_length = getUChar;
! 1425: nu->store_length = putUChar;
! 1426: break;
! 1427: case 2:
! 1428: nu->get_length = getUShort;
! 1429: nu->store_length = putUShort;
! 1430: break;
! 1431: default:
! 1432: log_fatal("Impossible condition at %s:%d.", MDL);
! 1433: }
! 1434: nu -> index = universe_count++;
! 1435: if (nu -> index >= universe_max) {
! 1436: ua = dmalloc (universe_max * 2 * sizeof *ua, MDL);
! 1437: if (!ua)
! 1438: log_fatal ("No memory to expand option space array.");
! 1439: memcpy (ua, universes, universe_max * sizeof *ua);
! 1440: universe_max *= 2;
! 1441: dfree (universes, MDL);
! 1442: universes = ua;
! 1443: }
! 1444: universes [nu -> index] = nu;
! 1445: if (!option_name_new_hash(&nu->name_hash, hsize, MDL) ||
! 1446: !option_code_new_hash(&nu->code_hash, hsize, MDL))
! 1447: log_fatal("Can't allocate %s option hash table.", nu->name);
! 1448: universe_hash_add (universe_hash, nu -> name, 0, nu, MDL);
! 1449: return;
! 1450:
! 1451: bad:
! 1452: dfree(nu_name, MDL);
! 1453: dfree(nu, MDL);
! 1454: }
! 1455:
! 1456: /* This is faked up to look good right now. Ideally, this should do a
! 1457: recursive parse and allow arbitrary data structure definitions, but for
! 1458: now it just allows you to specify a single type, an array of single types,
! 1459: a sequence of types, or an array of sequences of types.
! 1460:
! 1461: ocd :== NUMBER EQUALS ocsd SEMI
! 1462:
! 1463: ocsd :== ocsd_type |
! 1464: ocsd_type_sequence |
! 1465: ARRAY OF ocsd_simple_type_sequence
! 1466:
! 1467: ocsd_type_sequence :== LBRACE ocsd_types RBRACE
! 1468:
! 1469: ocsd_simple_type_sequence :== LBRACE ocsd_simple_types RBRACE
! 1470:
! 1471: ocsd_types :== ocsd_type |
! 1472: ocsd_types ocsd_type
! 1473:
! 1474: ocsd_type :== ocsd_simple_type |
! 1475: ARRAY OF ocsd_simple_type
! 1476:
! 1477: ocsd_simple_types :== ocsd_simple_type |
! 1478: ocsd_simple_types ocsd_simple_type
! 1479:
! 1480: ocsd_simple_type :== BOOLEAN |
! 1481: INTEGER NUMBER |
! 1482: SIGNED INTEGER NUMBER |
! 1483: UNSIGNED INTEGER NUMBER |
! 1484: IP-ADDRESS |
! 1485: TEXT |
! 1486: STRING |
! 1487: ENCAPSULATE identifier */
! 1488:
! 1489: int parse_option_code_definition (cfile, option)
! 1490: struct parse *cfile;
! 1491: struct option *option;
! 1492: {
! 1493: const char *val;
! 1494: enum dhcp_token token;
! 1495: struct option *oldopt;
! 1496: unsigned arrayp = 0;
! 1497: int recordp = 0;
! 1498: int no_more_in_record = 0;
! 1499: char tokbuf [128];
! 1500: unsigned tokix = 0;
! 1501: char type;
! 1502: int is_signed;
! 1503: char *s;
! 1504: int has_encapsulation = 0;
! 1505: struct universe *encapsulated;
! 1506:
! 1507: /* Parse the option code. */
! 1508: token = next_token (&val, (unsigned *)0, cfile);
! 1509: if (token != NUMBER) {
! 1510: parse_warn (cfile, "expecting option code number.");
! 1511: skip_to_semi (cfile);
! 1512: return 0;
! 1513: }
! 1514: option -> code = atoi (val);
! 1515:
! 1516: token = next_token (&val, (unsigned *)0, cfile);
! 1517: if (token != EQUAL) {
! 1518: parse_warn (cfile, "expecting \"=\"");
! 1519: skip_to_semi (cfile);
! 1520: return 0;
! 1521: }
! 1522:
! 1523: /* See if this is an array. */
! 1524: token = next_token (&val, (unsigned *)0, cfile);
! 1525: if (token == ARRAY) {
! 1526: token = next_token (&val, (unsigned *)0, cfile);
! 1527: if (token != OF) {
! 1528: parse_warn (cfile, "expecting \"of\".");
! 1529: skip_to_semi (cfile);
! 1530: return 0;
! 1531: }
! 1532: arrayp = 1;
! 1533: token = next_token (&val, (unsigned *)0, cfile);
! 1534: }
! 1535:
! 1536: if (token == LBRACE) {
! 1537: recordp = 1;
! 1538: token = next_token (&val, (unsigned *)0, cfile);
! 1539: }
! 1540:
! 1541: /* At this point we're expecting a data type. */
! 1542: next_type:
! 1543: if (has_encapsulation) {
! 1544: parse_warn (cfile,
! 1545: "encapsulate must always be the last item.");
! 1546: skip_to_semi (cfile);
! 1547: return 0;
! 1548: }
! 1549:
! 1550: switch (token) {
! 1551: case ARRAY:
! 1552: if (arrayp) {
! 1553: parse_warn (cfile, "no nested arrays.");
! 1554: skip_to_rbrace (cfile, recordp);
! 1555: if (recordp)
! 1556: skip_to_semi (cfile);
! 1557: return 0;
! 1558: }
! 1559: token = next_token (&val, (unsigned *)0, cfile);
! 1560: if (token != OF) {
! 1561: parse_warn (cfile, "expecting \"of\".");
! 1562: skip_to_semi (cfile);
! 1563: return 0;
! 1564: }
! 1565: arrayp = recordp + 1;
! 1566: token = next_token (&val, (unsigned *)0, cfile);
! 1567: if ((recordp) && (token == LBRACE)) {
! 1568: parse_warn (cfile,
! 1569: "only uniform array inside record.");
! 1570: skip_to_rbrace (cfile, recordp + 1);
! 1571: skip_to_semi (cfile);
! 1572: return 0;
! 1573: }
! 1574: goto next_type;
! 1575: case BOOLEAN:
! 1576: type = 'f';
! 1577: break;
! 1578: case INTEGER:
! 1579: is_signed = 1;
! 1580: parse_integer:
! 1581: token = next_token (&val, (unsigned *)0, cfile);
! 1582: if (token != NUMBER) {
! 1583: parse_warn (cfile, "expecting number.");
! 1584: skip_to_rbrace (cfile, recordp);
! 1585: if (recordp)
! 1586: skip_to_semi (cfile);
! 1587: return 0;
! 1588: }
! 1589: switch (atoi (val)) {
! 1590: case 8:
! 1591: type = is_signed ? 'b' : 'B';
! 1592: break;
! 1593: case 16:
! 1594: type = is_signed ? 's' : 'S';
! 1595: break;
! 1596: case 32:
! 1597: type = is_signed ? 'l' : 'L';
! 1598: break;
! 1599: default:
! 1600: parse_warn (cfile,
! 1601: "%s bit precision is not supported.", val);
! 1602: skip_to_rbrace (cfile, recordp);
! 1603: if (recordp)
! 1604: skip_to_semi (cfile);
! 1605: return 0;
! 1606: }
! 1607: break;
! 1608: case SIGNED:
! 1609: is_signed = 1;
! 1610: parse_signed:
! 1611: token = next_token (&val, (unsigned *)0, cfile);
! 1612: if (token != INTEGER) {
! 1613: parse_warn (cfile, "expecting \"integer\" keyword.");
! 1614: skip_to_rbrace (cfile, recordp);
! 1615: if (recordp)
! 1616: skip_to_semi (cfile);
! 1617: return 0;
! 1618: }
! 1619: goto parse_integer;
! 1620: case UNSIGNED:
! 1621: is_signed = 0;
! 1622: goto parse_signed;
! 1623:
! 1624: case IP_ADDRESS:
! 1625: type = 'I';
! 1626: break;
! 1627: case IP6_ADDRESS:
! 1628: type = '6';
! 1629: break;
! 1630: case DOMAIN_NAME:
! 1631: type = 'd';
! 1632: goto no_arrays;
! 1633: case DOMAIN_LIST:
! 1634: /* Consume optional compression indicator. */
! 1635: token = peek_token(&val, NULL, cfile);
! 1636: if (token == COMPRESSED) {
! 1637: token = next_token(&val, NULL, cfile);
! 1638: tokbuf[tokix++] = 'D';
! 1639: type = 'c';
! 1640: } else
! 1641: type = 'D';
! 1642: goto no_arrays;
! 1643: case TEXT:
! 1644: type = 't';
! 1645: no_arrays:
! 1646: if (arrayp) {
! 1647: parse_warn (cfile, "arrays of text strings not %s",
! 1648: "yet supported.");
! 1649: skip_to_rbrace (cfile, recordp);
! 1650: if (recordp)
! 1651: skip_to_semi (cfile);
! 1652: return 0;
! 1653: }
! 1654: no_more_in_record = 1;
! 1655: break;
! 1656: case STRING_TOKEN:
! 1657: type = 'X';
! 1658: goto no_arrays;
! 1659:
! 1660: case ENCAPSULATE:
! 1661: token = next_token (&val, (unsigned *)0, cfile);
! 1662: if (!is_identifier (token)) {
! 1663: parse_warn (cfile,
! 1664: "expecting option space identifier");
! 1665: skip_to_semi (cfile);
! 1666: return 0;
! 1667: }
! 1668: encapsulated = NULL;
! 1669: if (!universe_hash_lookup(&encapsulated, universe_hash,
! 1670: val, strlen(val), MDL)) {
! 1671: parse_warn(cfile, "unknown option space %s", val);
! 1672: skip_to_semi (cfile);
! 1673: return 0;
! 1674: }
! 1675: if (strlen (val) + tokix + 2 > sizeof (tokbuf))
! 1676: goto toobig;
! 1677: tokbuf [tokix++] = 'E';
! 1678: strcpy (&tokbuf [tokix], val);
! 1679: tokix += strlen (val);
! 1680: type = '.';
! 1681: has_encapsulation = 1;
! 1682: break;
! 1683:
! 1684: case ZEROLEN:
! 1685: type = 'Z';
! 1686: if (arrayp) {
! 1687: parse_warn (cfile, "array incompatible with zerolen.");
! 1688: skip_to_rbrace (cfile, recordp);
! 1689: if (recordp)
! 1690: skip_to_semi (cfile);
! 1691: return 0;
! 1692: }
! 1693: no_more_in_record = 1;
! 1694: break;
! 1695:
! 1696: default:
! 1697: parse_warn (cfile, "unknown data type %s", val);
! 1698: skip_to_rbrace (cfile, recordp);
! 1699: if (recordp)
! 1700: skip_to_semi (cfile);
! 1701: return 0;
! 1702: }
! 1703:
! 1704: if (tokix == sizeof tokbuf) {
! 1705: toobig:
! 1706: parse_warn (cfile, "too many types in record.");
! 1707: skip_to_rbrace (cfile, recordp);
! 1708: if (recordp)
! 1709: skip_to_semi (cfile);
! 1710: return 0;
! 1711: }
! 1712: tokbuf [tokix++] = type;
! 1713:
! 1714: if (recordp) {
! 1715: token = next_token (&val, (unsigned *)0, cfile);
! 1716: if (arrayp > recordp) {
! 1717: if (tokix == sizeof tokbuf) {
! 1718: parse_warn (cfile,
! 1719: "too many types in record.");
! 1720: skip_to_rbrace (cfile, 1);
! 1721: skip_to_semi (cfile);
! 1722: return 0;
! 1723: }
! 1724: arrayp = 0;
! 1725: tokbuf[tokix++] = 'a';
! 1726: }
! 1727: if (token == COMMA) {
! 1728: if (no_more_in_record) {
! 1729: parse_warn (cfile,
! 1730: "%s must be at end of record.",
! 1731: type == 't' ? "text" : "string");
! 1732: skip_to_rbrace (cfile, 1);
! 1733: if (recordp)
! 1734: skip_to_semi (cfile);
! 1735: return 0;
! 1736: }
! 1737: token = next_token (&val, (unsigned *)0, cfile);
! 1738: goto next_type;
! 1739: }
! 1740: if (token != RBRACE) {
! 1741: parse_warn (cfile, "expecting right brace.");
! 1742: skip_to_rbrace (cfile, 1);
! 1743: if (recordp)
! 1744: skip_to_semi (cfile);
! 1745: return 0;
! 1746: }
! 1747: }
! 1748: if (!parse_semi (cfile)) {
! 1749: parse_warn (cfile, "semicolon expected.");
! 1750: skip_to_semi (cfile);
! 1751: if (recordp)
! 1752: skip_to_semi (cfile);
! 1753: return 0;
! 1754: }
! 1755: if (has_encapsulation && arrayp) {
! 1756: parse_warn (cfile,
! 1757: "Arrays of encapsulations don't make sense.");
! 1758: return 0;
! 1759: }
! 1760: s = dmalloc(tokix + (arrayp ? 1 : 0) + 1, MDL);
! 1761: if (s == NULL) {
! 1762: log_fatal("no memory for option format.");
! 1763: }
! 1764: memcpy(s, tokbuf, tokix);
! 1765: if (arrayp) {
! 1766: s[tokix++] = (arrayp > recordp) ? 'a' : 'A';
! 1767: }
! 1768: s[tokix] = '\0';
! 1769:
! 1770: option -> format = s;
! 1771:
! 1772: oldopt = NULL;
! 1773: option_code_hash_lookup(&oldopt, option->universe->code_hash,
! 1774: &option->code, 0, MDL);
! 1775: if (oldopt != NULL) {
! 1776: /*
! 1777: * XXX: This illegalizes a configuration syntax that was
! 1778: * valid in 3.0.x, where multiple name->code mappings are
! 1779: * given, but only one code->name mapping survives. It is
! 1780: * unclear what can or should be done at this point, but it
! 1781: * seems best to retain 3.0.x behaviour for upgrades to go
! 1782: * smoothly.
! 1783: *
! 1784: option_name_hash_delete(option->universe->name_hash,
! 1785: oldopt->name, 0, MDL);
! 1786: */
! 1787: option_code_hash_delete(option->universe->code_hash,
! 1788: &oldopt->code, 0, MDL);
! 1789:
! 1790: option_dereference(&oldopt, MDL);
! 1791: }
! 1792: option_code_hash_add(option->universe->code_hash, &option->code, 0,
! 1793: option, MDL);
! 1794: option_name_hash_add(option->universe->name_hash, option->name, 0,
! 1795: option, MDL);
! 1796: if (has_encapsulation) {
! 1797: /* INSIST(tokbuf[0] == 'E'); */
! 1798: /* INSIST(encapsulated != NULL); */
! 1799: if (!option_code_hash_lookup(&encapsulated->enc_opt,
! 1800: option->universe->code_hash,
! 1801: &option->code, 0, MDL)) {
! 1802: log_fatal("error finding encapsulated option (%s:%d)",
! 1803: MDL);
! 1804: }
! 1805: }
! 1806: return 1;
! 1807: }
! 1808:
! 1809: /*
! 1810: * base64 :== NUMBER_OR_STRING
! 1811: */
! 1812:
! 1813: int parse_base64 (data, cfile)
! 1814: struct data_string *data;
! 1815: struct parse *cfile;
! 1816: {
! 1817: enum dhcp_token token;
! 1818: const char *val;
! 1819: int i, j, k;
! 1820: unsigned acc = 0;
! 1821: static unsigned char
! 1822: from64 [] = {64, 64, 64, 64, 64, 64, 64, 64, /* \"#$%&' */
! 1823: 64, 64, 64, 62, 64, 64, 64, 63, /* ()*+,-./ */
! 1824: 52, 53, 54, 55, 56, 57, 58, 59, /* 01234567 */
! 1825: 60, 61, 64, 64, 64, 64, 64, 64, /* 89:;<=>? */
! 1826: 64, 0, 1, 2, 3, 4, 5, 6, /* @ABCDEFG */
! 1827: 7, 8, 9, 10, 11, 12, 13, 14, /* HIJKLMNO */
! 1828: 15, 16, 17, 18, 19, 20, 21, 22, /* PQRSTUVW */
! 1829: 23, 24, 25, 64, 64, 64, 64, 64, /* XYZ[\]^_ */
! 1830: 64, 26, 27, 28, 29, 30, 31, 32, /* 'abcdefg */
! 1831: 33, 34, 35, 36, 37, 38, 39, 40, /* hijklmno */
! 1832: 41, 42, 43, 44, 45, 46, 47, 48, /* pqrstuvw */
! 1833: 49, 50, 51, 64, 64, 64, 64, 64}; /* xyz{|}~ */
! 1834: struct string_list *bufs = (struct string_list *)0,
! 1835: *last = (struct string_list *)0,
! 1836: *t;
! 1837: int cc = 0;
! 1838: int terminated = 0;
! 1839:
! 1840: /* It's possible for a + or a / to cause a base64 quantity to be
! 1841: tokenized into more than one token, so we have to parse them all
! 1842: in before decoding. */
! 1843: do {
! 1844: unsigned l;
! 1845:
! 1846: token = next_token (&val, &l, cfile);
! 1847: t = dmalloc (l + sizeof *t, MDL);
! 1848: if (!t)
! 1849: log_fatal ("no memory for base64 buffer.");
! 1850: memset (t, 0, (sizeof *t) - 1);
! 1851: memcpy (t -> string, val, l + 1);
! 1852: cc += l;
! 1853: if (last)
! 1854: last -> next = t;
! 1855: else
! 1856: bufs = t;
! 1857: last = t;
! 1858: token = peek_token (&val, (unsigned *)0, cfile);
! 1859: } while (token == NUMBER_OR_NAME || token == NAME || token == EQUAL ||
! 1860: token == NUMBER || token == PLUS || token == SLASH ||
! 1861: token == STRING);
! 1862:
! 1863: data -> len = cc;
! 1864: data -> len = (data -> len * 3) / 4;
! 1865: if (!buffer_allocate (&data -> buffer, data -> len, MDL)) {
! 1866: parse_warn (cfile, "can't allocate buffer for base64 data.");
! 1867: data -> len = 0;
! 1868: data -> data = (unsigned char *)0;
! 1869: return 0;
! 1870: }
! 1871:
! 1872: j = k = 0;
! 1873: for (t = bufs; t; t = t -> next) {
! 1874: for (i = 0; t -> string [i]; i++) {
! 1875: unsigned foo = t -> string [i];
! 1876: if (terminated && foo != '=') {
! 1877: parse_warn (cfile,
! 1878: "stuff after base64 '=' terminator: %s.",
! 1879: &t -> string [i]);
! 1880: goto bad;
! 1881: }
! 1882: if (foo < ' ' || foo > 'z') {
! 1883: bad64:
! 1884: parse_warn (cfile,
! 1885: "invalid base64 character %d.",
! 1886: t -> string [i]);
! 1887: bad:
! 1888: data_string_forget (data, MDL);
! 1889: goto out;
! 1890: }
! 1891: if (foo == '=')
! 1892: terminated = 1;
! 1893: else {
! 1894: foo = from64 [foo - ' '];
! 1895: if (foo == 64)
! 1896: goto bad64;
! 1897: acc = (acc << 6) + foo;
! 1898: switch (k % 4) {
! 1899: case 0:
! 1900: break;
! 1901: case 1:
! 1902: data -> buffer -> data [j++] = (acc >> 4);
! 1903: acc = acc & 0x0f;
! 1904: break;
! 1905:
! 1906: case 2:
! 1907: data -> buffer -> data [j++] = (acc >> 2);
! 1908: acc = acc & 0x03;
! 1909: break;
! 1910: case 3:
! 1911: data -> buffer -> data [j++] = acc;
! 1912: acc = 0;
! 1913: break;
! 1914: }
! 1915: }
! 1916: k++;
! 1917: }
! 1918: }
! 1919: if (k % 4) {
! 1920: if (acc) {
! 1921: parse_warn (cfile,
! 1922: "partial base64 value left over: %d.",
! 1923: acc);
! 1924: }
! 1925: }
! 1926: data -> len = j;
! 1927: data -> data = data -> buffer -> data;
! 1928: out:
! 1929: for (t = bufs; t; t = last) {
! 1930: last = t -> next;
! 1931: dfree (t, MDL);
! 1932: }
! 1933: if (data -> len)
! 1934: return 1;
! 1935: else
! 1936: return 0;
! 1937: }
! 1938:
! 1939:
! 1940: /*
! 1941: * colon-separated-hex-list :== NUMBER |
! 1942: * NUMBER COLON colon-separated-hex-list
! 1943: */
! 1944:
! 1945: int parse_cshl (data, cfile)
! 1946: struct data_string *data;
! 1947: struct parse *cfile;
! 1948: {
! 1949: u_int8_t ibuf [128];
! 1950: unsigned ilen = 0;
! 1951: unsigned tlen = 0;
! 1952: struct option_tag *sl = (struct option_tag *)0;
! 1953: struct option_tag *next, **last = &sl;
! 1954: enum dhcp_token token;
! 1955: const char *val;
! 1956: unsigned char *rvp;
! 1957:
! 1958: do {
! 1959: token = next_token (&val, (unsigned *)0, cfile);
! 1960: if (token != NUMBER && token != NUMBER_OR_NAME) {
! 1961: parse_warn (cfile, "expecting hexadecimal number.");
! 1962: skip_to_semi (cfile);
! 1963: for (; sl; sl = next) {
! 1964: next = sl -> next;
! 1965: dfree (sl, MDL);
! 1966: }
! 1967: return 0;
! 1968: }
! 1969: if (ilen == sizeof ibuf) {
! 1970: next = (struct option_tag *)
! 1971: dmalloc (ilen - 1 +
! 1972: sizeof (struct option_tag), MDL);
! 1973: if (!next)
! 1974: log_fatal ("no memory for string list.");
! 1975: memcpy (next -> data, ibuf, ilen);
! 1976: *last = next;
! 1977: last = &next -> next;
! 1978: tlen += ilen;
! 1979: ilen = 0;
! 1980: }
! 1981: convert_num (cfile, &ibuf [ilen++], val, 16, 8);
! 1982:
! 1983: token = peek_token (&val, (unsigned *)0, cfile);
! 1984: if (token != COLON)
! 1985: break;
! 1986: token = next_token (&val, (unsigned *)0, cfile);
! 1987: } while (1);
! 1988:
! 1989: if (!buffer_allocate (&data -> buffer, tlen + ilen, MDL))
! 1990: log_fatal ("no memory to store octet data.");
! 1991: data -> data = &data -> buffer -> data [0];
! 1992: data -> len = tlen + ilen;
! 1993: data -> terminated = 0;
! 1994:
! 1995: rvp = &data -> buffer -> data [0];
! 1996: while (sl) {
! 1997: next = sl -> next;
! 1998: memcpy (rvp, sl -> data, sizeof ibuf);
! 1999: rvp += sizeof ibuf;
! 2000: dfree (sl, MDL);
! 2001: sl = next;
! 2002: }
! 2003:
! 2004: memcpy (rvp, ibuf, ilen);
! 2005: return 1;
! 2006: }
! 2007:
! 2008: /*
! 2009: * executable-statements :== executable-statement executable-statements |
! 2010: * executable-statement
! 2011: *
! 2012: * executable-statement :==
! 2013: * IF if-statement |
! 2014: * ADD class-name SEMI |
! 2015: * BREAK SEMI |
! 2016: * OPTION option-parameter SEMI |
! 2017: * SUPERSEDE option-parameter SEMI |
! 2018: * PREPEND option-parameter SEMI |
! 2019: * APPEND option-parameter SEMI
! 2020: */
! 2021:
! 2022: int parse_executable_statements (statements, cfile, lose, case_context)
! 2023: struct executable_statement **statements;
! 2024: struct parse *cfile;
! 2025: int *lose;
! 2026: enum expression_context case_context;
! 2027: {
! 2028: struct executable_statement **next;
! 2029:
! 2030: next = statements;
! 2031: while (parse_executable_statement (next, cfile, lose, case_context))
! 2032: next = &((*next) -> next);
! 2033: if (!*lose)
! 2034: return 1;
! 2035: return 0;
! 2036: }
! 2037:
! 2038: int parse_executable_statement (result, cfile, lose, case_context)
! 2039: struct executable_statement **result;
! 2040: struct parse *cfile;
! 2041: int *lose;
! 2042: enum expression_context case_context;
! 2043: {
! 2044: #if defined(ENABLE_EXECUTE)
! 2045: unsigned len;
! 2046: struct expression **ep;
! 2047: #endif
! 2048: enum dhcp_token token;
! 2049: const char *val;
! 2050: struct class *cta;
! 2051: struct option *option=NULL;
! 2052: struct option_cache *cache;
! 2053: int known;
! 2054: int flag;
! 2055: int i;
! 2056: struct dns_zone *zone;
! 2057: isc_result_t status;
! 2058: char *s;
! 2059:
! 2060: token = peek_token (&val, (unsigned *)0, cfile);
! 2061: switch (token) {
! 2062: case DB_TIME_FORMAT:
! 2063: next_token(&val, NULL, cfile);
! 2064:
! 2065: token = next_token(&val, NULL, cfile);
! 2066: if (token == DEFAULT) {
! 2067: db_time_format = DEFAULT_TIME_FORMAT;
! 2068: } else if (token == LOCAL) {
! 2069: db_time_format = LOCAL_TIME_FORMAT;
! 2070: } else {
! 2071: parse_warn(cfile, "Expecting 'local' or 'default'.");
! 2072: if (token != SEMI)
! 2073: skip_to_semi(cfile);
! 2074: *lose = 1;
! 2075: return 0;
! 2076: }
! 2077:
! 2078: token = next_token(&val, NULL, cfile);
! 2079: if (token != SEMI) {
! 2080: parse_warn(cfile, "Expecting a semicolon.");
! 2081: *lose = 1;
! 2082: return 0;
! 2083: }
! 2084:
! 2085: /* We're done here. */
! 2086: return 1;
! 2087:
! 2088: case IF:
! 2089: next_token (&val, (unsigned *)0, cfile);
! 2090: return parse_if_statement (result, cfile, lose);
! 2091:
! 2092: case TOKEN_ADD:
! 2093: token = next_token (&val, (unsigned *)0, cfile);
! 2094: token = next_token (&val, (unsigned *)0, cfile);
! 2095: if (token != STRING) {
! 2096: parse_warn (cfile, "expecting class name.");
! 2097: skip_to_semi (cfile);
! 2098: *lose = 1;
! 2099: return 0;
! 2100: }
! 2101: cta = (struct class *)0;
! 2102: status = find_class (&cta, val, MDL);
! 2103: if (status != ISC_R_SUCCESS) {
! 2104: parse_warn (cfile, "class %s: %s",
! 2105: val, isc_result_totext (status));
! 2106: skip_to_semi (cfile);
! 2107: *lose = 1;
! 2108: return 0;
! 2109: }
! 2110: if (!parse_semi (cfile)) {
! 2111: *lose = 1;
! 2112: return 0;
! 2113: }
! 2114: if (!executable_statement_allocate (result, MDL))
! 2115: log_fatal ("no memory for new statement.");
! 2116: (*result) -> op = add_statement;
! 2117: (*result) -> data.add = cta;
! 2118: break;
! 2119:
! 2120: case BREAK:
! 2121: token = next_token (&val, (unsigned *)0, cfile);
! 2122: if (!parse_semi (cfile)) {
! 2123: *lose = 1;
! 2124: return 0;
! 2125: }
! 2126: if (!executable_statement_allocate (result, MDL))
! 2127: log_fatal ("no memory for new statement.");
! 2128: (*result) -> op = break_statement;
! 2129: break;
! 2130:
! 2131: case SEND:
! 2132: token = next_token (&val, (unsigned *)0, cfile);
! 2133: known = 0;
! 2134: status = parse_option_name (cfile, 0, &known, &option);
! 2135: if (status != ISC_R_SUCCESS || option == NULL) {
! 2136: *lose = 1;
! 2137: return 0;
! 2138: }
! 2139: status = parse_option_statement(result, cfile, 1, option,
! 2140: send_option_statement);
! 2141: option_dereference(&option, MDL);
! 2142: return status;
! 2143:
! 2144: case SUPERSEDE:
! 2145: case OPTION:
! 2146: token = next_token (&val, (unsigned *)0, cfile);
! 2147: known = 0;
! 2148: status = parse_option_name (cfile, 0, &known, &option);
! 2149: if (status != ISC_R_SUCCESS || option == NULL) {
! 2150: *lose = 1;
! 2151: return 0;
! 2152: }
! 2153: status = parse_option_statement(result, cfile, 1, option,
! 2154: supersede_option_statement);
! 2155: option_dereference(&option, MDL);
! 2156: return status;
! 2157:
! 2158: case ALLOW:
! 2159: flag = 1;
! 2160: goto pad;
! 2161: case DENY:
! 2162: flag = 0;
! 2163: goto pad;
! 2164: case IGNORE:
! 2165: flag = 2;
! 2166: pad:
! 2167: token = next_token (&val, (unsigned *)0, cfile);
! 2168: cache = (struct option_cache *)0;
! 2169: if (!parse_allow_deny (&cache, cfile, flag))
! 2170: return 0;
! 2171: if (!executable_statement_allocate (result, MDL))
! 2172: log_fatal ("no memory for new statement.");
! 2173: (*result) -> op = supersede_option_statement;
! 2174: (*result) -> data.option = cache;
! 2175: break;
! 2176:
! 2177: case DEFAULT:
! 2178: token = next_token (&val, (unsigned *)0, cfile);
! 2179: token = peek_token (&val, (unsigned *)0, cfile);
! 2180: if (token == COLON)
! 2181: goto switch_default;
! 2182: known = 0;
! 2183: status = parse_option_name (cfile, 0, &known, &option);
! 2184: if (status != ISC_R_SUCCESS || option == NULL) {
! 2185: *lose = 1;
! 2186: return 0;
! 2187: }
! 2188: status = parse_option_statement(result, cfile, 1, option,
! 2189: default_option_statement);
! 2190: option_dereference(&option, MDL);
! 2191: return status;
! 2192:
! 2193: case PREPEND:
! 2194: token = next_token (&val, (unsigned *)0, cfile);
! 2195: known = 0;
! 2196: status = parse_option_name (cfile, 0, &known, &option);
! 2197: if (status != ISC_R_SUCCESS || option == NULL) {
! 2198: *lose = 1;
! 2199: return 0;
! 2200: }
! 2201: status = parse_option_statement(result, cfile, 1, option,
! 2202: prepend_option_statement);
! 2203: option_dereference(&option, MDL);
! 2204: return status;
! 2205:
! 2206: case APPEND:
! 2207: token = next_token (&val, (unsigned *)0, cfile);
! 2208: known = 0;
! 2209: status = parse_option_name (cfile, 0, &known, &option);
! 2210: if (status != ISC_R_SUCCESS || option == NULL) {
! 2211: *lose = 1;
! 2212: return 0;
! 2213: }
! 2214: status = parse_option_statement(result, cfile, 1, option,
! 2215: append_option_statement);
! 2216: option_dereference(&option, MDL);
! 2217: return status;
! 2218:
! 2219: case ON:
! 2220: token = next_token (&val, (unsigned *)0, cfile);
! 2221: return parse_on_statement (result, cfile, lose);
! 2222:
! 2223: case SWITCH:
! 2224: token = next_token (&val, (unsigned *)0, cfile);
! 2225: return parse_switch_statement (result, cfile, lose);
! 2226:
! 2227: case CASE:
! 2228: token = next_token (&val, (unsigned *)0, cfile);
! 2229: if (case_context == context_any) {
! 2230: parse_warn (cfile,
! 2231: "case statement in inappropriate scope.");
! 2232: *lose = 1;
! 2233: skip_to_semi (cfile);
! 2234: return 0;
! 2235: }
! 2236: return parse_case_statement (result,
! 2237: cfile, lose, case_context);
! 2238:
! 2239: switch_default:
! 2240: token = next_token (&val, (unsigned *)0, cfile);
! 2241: if (case_context == context_any) {
! 2242: parse_warn (cfile, "switch default statement in %s",
! 2243: "inappropriate scope.");
! 2244:
! 2245: *lose = 1;
! 2246: return 0;
! 2247: } else {
! 2248: if (!executable_statement_allocate (result, MDL))
! 2249: log_fatal ("no memory for default statement.");
! 2250: (*result) -> op = default_statement;
! 2251: return 1;
! 2252: }
! 2253:
! 2254: case DEFINE:
! 2255: case TOKEN_SET:
! 2256: token = next_token (&val, (unsigned *)0, cfile);
! 2257: if (token == DEFINE)
! 2258: flag = 1;
! 2259: else
! 2260: flag = 0;
! 2261:
! 2262: token = next_token (&val, (unsigned *)0, cfile);
! 2263: if (token != NAME && token != NUMBER_OR_NAME) {
! 2264: parse_warn (cfile,
! 2265: "%s can't be a variable name", val);
! 2266: badset:
! 2267: skip_to_semi (cfile);
! 2268: *lose = 1;
! 2269: return 0;
! 2270: }
! 2271:
! 2272: if (!executable_statement_allocate (result, MDL))
! 2273: log_fatal ("no memory for set statement.");
! 2274: (*result) -> op = flag ? define_statement : set_statement;
! 2275: (*result) -> data.set.name = dmalloc (strlen (val) + 1, MDL);
! 2276: if (!(*result)->data.set.name)
! 2277: log_fatal ("can't allocate variable name");
! 2278: strcpy ((*result) -> data.set.name, val);
! 2279: token = next_token (&val, (unsigned *)0, cfile);
! 2280:
! 2281: if (token == LPAREN) {
! 2282: struct string_list *head, *cur, *new;
! 2283: struct expression *expr;
! 2284: head = cur = (struct string_list *)0;
! 2285: do {
! 2286: token = next_token (&val,
! 2287: (unsigned *)0, cfile);
! 2288: if (token == RPAREN)
! 2289: break;
! 2290: if (token != NAME && token != NUMBER_OR_NAME) {
! 2291: parse_warn (cfile,
! 2292: "expecting argument name");
! 2293: skip_to_rbrace (cfile, 0);
! 2294: *lose = 1;
! 2295: executable_statement_dereference
! 2296: (result, MDL);
! 2297: return 0;
! 2298: }
! 2299: new = ((struct string_list *)
! 2300: dmalloc (sizeof (struct string_list) +
! 2301: strlen (val), MDL));
! 2302: if (!new)
! 2303: log_fatal ("can't allocate string.");
! 2304: memset (new, 0, sizeof *new);
! 2305: strcpy (new -> string, val);
! 2306: if (cur) {
! 2307: cur -> next = new;
! 2308: cur = new;
! 2309: } else {
! 2310: head = cur = new;
! 2311: }
! 2312: token = next_token (&val,
! 2313: (unsigned *)0, cfile);
! 2314: } while (token == COMMA);
! 2315:
! 2316: if (token != RPAREN) {
! 2317: parse_warn (cfile, "expecting right paren.");
! 2318: badx:
! 2319: skip_to_semi (cfile);
! 2320: *lose = 1;
! 2321: executable_statement_dereference (result, MDL);
! 2322: return 0;
! 2323: }
! 2324:
! 2325: token = next_token (&val, (unsigned *)0, cfile);
! 2326: if (token != LBRACE) {
! 2327: parse_warn (cfile, "expecting left brace.");
! 2328: goto badx;
! 2329: }
! 2330:
! 2331: expr = (struct expression *)0;
! 2332: if (!(expression_allocate (&expr, MDL)))
! 2333: log_fatal ("can't allocate expression.");
! 2334: expr -> op = expr_function;
! 2335: if (!fundef_allocate (&expr -> data.func, MDL))
! 2336: log_fatal ("can't allocate fundef.");
! 2337: expr -> data.func -> args = head;
! 2338: (*result) -> data.set.expr = expr;
! 2339:
! 2340: if (!(parse_executable_statements
! 2341: (&expr -> data.func -> statements, cfile, lose,
! 2342: case_context))) {
! 2343: if (*lose)
! 2344: goto badx;
! 2345: }
! 2346:
! 2347: token = next_token (&val, (unsigned *)0, cfile);
! 2348: if (token != RBRACE) {
! 2349: parse_warn (cfile, "expecting rigt brace.");
! 2350: goto badx;
! 2351: }
! 2352: } else {
! 2353: if (token != EQUAL) {
! 2354: parse_warn (cfile,
! 2355: "expecting '=' in %s statement.",
! 2356: flag ? "define" : "set");
! 2357: goto badset;
! 2358: }
! 2359:
! 2360: if (!parse_expression (&(*result) -> data.set.expr,
! 2361: cfile, lose, context_any,
! 2362: (struct expression **)0,
! 2363: expr_none)) {
! 2364: if (!*lose)
! 2365: parse_warn (cfile,
! 2366: "expecting expression.");
! 2367: else
! 2368: *lose = 1;
! 2369: skip_to_semi (cfile);
! 2370: executable_statement_dereference (result, MDL);
! 2371: return 0;
! 2372: }
! 2373: if (!parse_semi (cfile)) {
! 2374: *lose = 1;
! 2375: executable_statement_dereference (result, MDL);
! 2376: return 0;
! 2377: }
! 2378: }
! 2379: break;
! 2380:
! 2381: case UNSET:
! 2382: token = next_token (&val, (unsigned *)0, cfile);
! 2383:
! 2384: token = next_token (&val, (unsigned *)0, cfile);
! 2385: if (token != NAME && token != NUMBER_OR_NAME) {
! 2386: parse_warn (cfile,
! 2387: "%s can't be a variable name", val);
! 2388: skip_to_semi (cfile);
! 2389: *lose = 1;
! 2390: return 0;
! 2391: }
! 2392:
! 2393: if (!executable_statement_allocate (result, MDL))
! 2394: log_fatal ("no memory for set statement.");
! 2395: (*result) -> op = unset_statement;
! 2396: (*result) -> data.unset = dmalloc (strlen (val) + 1, MDL);
! 2397: if (!(*result)->data.unset)
! 2398: log_fatal ("can't allocate variable name");
! 2399: strcpy ((*result) -> data.unset, val);
! 2400: if (!parse_semi (cfile)) {
! 2401: *lose = 1;
! 2402: executable_statement_dereference (result, MDL);
! 2403: return 0;
! 2404: }
! 2405: break;
! 2406:
! 2407: case EVAL:
! 2408: token = next_token (&val, (unsigned *)0, cfile);
! 2409:
! 2410: if (!executable_statement_allocate (result, MDL))
! 2411: log_fatal ("no memory for eval statement.");
! 2412: (*result) -> op = eval_statement;
! 2413:
! 2414: if (!parse_expression (&(*result) -> data.eval,
! 2415: cfile, lose, context_data, /* XXX */
! 2416: (struct expression **)0, expr_none)) {
! 2417: if (!*lose)
! 2418: parse_warn (cfile,
! 2419: "expecting data expression.");
! 2420: else
! 2421: *lose = 1;
! 2422: skip_to_semi (cfile);
! 2423: executable_statement_dereference (result, MDL);
! 2424: return 0;
! 2425: }
! 2426: if (!parse_semi (cfile)) {
! 2427: *lose = 1;
! 2428: executable_statement_dereference (result, MDL);
! 2429: }
! 2430: break;
! 2431:
! 2432: case EXECUTE:
! 2433: #ifdef ENABLE_EXECUTE
! 2434: token = next_token(&val, NULL, cfile);
! 2435:
! 2436: if (!executable_statement_allocate (result, MDL))
! 2437: log_fatal ("no memory for execute statement.");
! 2438: (*result)->op = execute_statement;
! 2439:
! 2440: token = next_token(&val, NULL, cfile);
! 2441: if (token != LPAREN) {
! 2442: parse_warn(cfile, "left parenthesis expected.");
! 2443: skip_to_semi(cfile);
! 2444: *lose = 1;
! 2445: return 0;
! 2446: }
! 2447:
! 2448: token = next_token(&val, &len, cfile);
! 2449: if (token != STRING) {
! 2450: parse_warn(cfile, "Expecting a quoted string.");
! 2451: skip_to_semi(cfile);
! 2452: *lose = 1;
! 2453: return 0;
! 2454: }
! 2455:
! 2456: (*result)->data.execute.command = dmalloc(len + 1, MDL);
! 2457: if ((*result)->data.execute.command == NULL)
! 2458: log_fatal("can't allocate command name");
! 2459: strcpy((*result)->data.execute.command, val);
! 2460:
! 2461: ep = &(*result)->data.execute.arglist;
! 2462: (*result)->data.execute.argc = 0;
! 2463:
! 2464: while((token = next_token(&val, NULL, cfile)) == COMMA) {
! 2465: if (!expression_allocate(ep, MDL))
! 2466: log_fatal ("can't allocate expression");
! 2467:
! 2468: if (!parse_data_expression (&(*ep) -> data.arg.val,
! 2469: cfile, lose)) {
! 2470: if (!*lose) {
! 2471: parse_warn (cfile,
! 2472: "expecting expression.");
! 2473: *lose = 1;
! 2474: }
! 2475: skip_to_semi(cfile);
! 2476: *lose = 1;
! 2477: return 0;
! 2478: }
! 2479: ep = &(*ep)->data.arg.next;
! 2480: (*result)->data.execute.argc++;
! 2481: }
! 2482:
! 2483: if (token != RPAREN) {
! 2484: parse_warn(cfile, "right parenthesis expected.");
! 2485: skip_to_semi(cfile);
! 2486: *lose = 1;
! 2487: return 0;
! 2488: }
! 2489:
! 2490: if (!parse_semi (cfile)) {
! 2491: *lose = 1;
! 2492: executable_statement_dereference (result, MDL);
! 2493: }
! 2494: #else /* ! ENABLE_EXECUTE */
! 2495: parse_warn(cfile, "define ENABLE_EXECUTE in site.h to "
! 2496: "enable execute(); expressions.");
! 2497: skip_to_semi(cfile);
! 2498: *lose = 1;
! 2499: return 0;
! 2500: #endif /* ENABLE_EXECUTE */
! 2501: break;
! 2502:
! 2503: case RETURN:
! 2504: token = next_token (&val, (unsigned *)0, cfile);
! 2505:
! 2506: if (!executable_statement_allocate (result, MDL))
! 2507: log_fatal ("no memory for return statement.");
! 2508: (*result) -> op = return_statement;
! 2509:
! 2510: if (!parse_expression (&(*result) -> data.retval,
! 2511: cfile, lose, context_data,
! 2512: (struct expression **)0, expr_none)) {
! 2513: if (!*lose)
! 2514: parse_warn (cfile,
! 2515: "expecting data expression.");
! 2516: else
! 2517: *lose = 1;
! 2518: skip_to_semi (cfile);
! 2519: executable_statement_dereference (result, MDL);
! 2520: return 0;
! 2521: }
! 2522: if (!parse_semi (cfile)) {
! 2523: *lose = 1;
! 2524: executable_statement_dereference (result, MDL);
! 2525: return 0;
! 2526: }
! 2527: break;
! 2528:
! 2529: case LOG:
! 2530: token = next_token (&val, (unsigned *)0, cfile);
! 2531:
! 2532: if (!executable_statement_allocate (result, MDL))
! 2533: log_fatal ("no memory for log statement.");
! 2534: (*result) -> op = log_statement;
! 2535:
! 2536: token = next_token (&val, (unsigned *)0, cfile);
! 2537: if (token != LPAREN) {
! 2538: parse_warn (cfile, "left parenthesis expected.");
! 2539: skip_to_semi (cfile);
! 2540: *lose = 1;
! 2541: return 0;
! 2542: }
! 2543:
! 2544: token = peek_token (&val, (unsigned *)0, cfile);
! 2545: i = 1;
! 2546: if (token == FATAL) {
! 2547: (*result) -> data.log.priority = log_priority_fatal;
! 2548: } else if (token == ERROR) {
! 2549: (*result) -> data.log.priority = log_priority_error;
! 2550: } else if (token == TOKEN_DEBUG) {
! 2551: (*result) -> data.log.priority = log_priority_debug;
! 2552: } else if (token == INFO) {
! 2553: (*result) -> data.log.priority = log_priority_info;
! 2554: } else {
! 2555: (*result) -> data.log.priority = log_priority_debug;
! 2556: i = 0;
! 2557: }
! 2558: if (i) {
! 2559: token = next_token (&val, (unsigned *)0, cfile);
! 2560: token = next_token (&val, (unsigned *)0, cfile);
! 2561: if (token != COMMA) {
! 2562: parse_warn (cfile, "comma expected.");
! 2563: skip_to_semi (cfile);
! 2564: *lose = 1;
! 2565: return 0;
! 2566: }
! 2567: }
! 2568:
! 2569: if (!(parse_data_expression
! 2570: (&(*result) -> data.log.expr, cfile, lose))) {
! 2571: skip_to_semi (cfile);
! 2572: *lose = 1;
! 2573: return 0;
! 2574: }
! 2575:
! 2576: token = next_token (&val, (unsigned *)0, cfile);
! 2577: if (token != RPAREN) {
! 2578: parse_warn (cfile, "right parenthesis expected.");
! 2579: skip_to_semi (cfile);
! 2580: *lose = 1;
! 2581: return 0;
! 2582: }
! 2583:
! 2584: token = next_token (&val, (unsigned *)0, cfile);
! 2585: if (token != SEMI) {
! 2586: parse_warn (cfile, "semicolon expected.");
! 2587: skip_to_semi (cfile);
! 2588: *lose = 1;
! 2589: return 0;
! 2590: }
! 2591: break;
! 2592:
! 2593: /* Not really a statement, but we parse it here anyway
! 2594: because it's appropriate for all DHCP agents with
! 2595: parsers. */
! 2596: case ZONE:
! 2597: token = next_token (&val, (unsigned *)0, cfile);
! 2598: zone = (struct dns_zone *)0;
! 2599: if (!dns_zone_allocate (&zone, MDL))
! 2600: log_fatal ("no memory for new zone.");
! 2601: zone -> name = parse_host_name (cfile);
! 2602: if (!zone -> name) {
! 2603: parse_warn (cfile, "expecting hostname.");
! 2604: badzone:
! 2605: *lose = 1;
! 2606: skip_to_semi (cfile);
! 2607: dns_zone_dereference (&zone, MDL);
! 2608: return 0;
! 2609: }
! 2610: i = strlen (zone -> name);
! 2611: if (zone -> name [i - 1] != '.') {
! 2612: s = dmalloc ((unsigned)i + 2, MDL);
! 2613: if (!s) {
! 2614: parse_warn (cfile, "no trailing '.' on zone");
! 2615: goto badzone;
! 2616: }
! 2617: strcpy (s, zone -> name);
! 2618: s [i] = '.';
! 2619: s [i + 1] = 0;
! 2620: dfree (zone -> name, MDL);
! 2621: zone -> name = s;
! 2622: }
! 2623: if (!parse_zone (zone, cfile))
! 2624: goto badzone;
! 2625: status = enter_dns_zone (zone);
! 2626: if (status != ISC_R_SUCCESS) {
! 2627: parse_warn (cfile, "dns zone key %s: %s",
! 2628: zone -> name, isc_result_totext (status));
! 2629: dns_zone_dereference (&zone, MDL);
! 2630: return 0;
! 2631: }
! 2632: dns_zone_dereference (&zone, MDL);
! 2633: return 1;
! 2634:
! 2635: /* Also not really a statement, but same idea as above. */
! 2636: case KEY:
! 2637: token = next_token (&val, (unsigned *)0, cfile);
! 2638: if (!parse_key (cfile)) {
! 2639: *lose = 1;
! 2640: return 0;
! 2641: }
! 2642: return 1;
! 2643:
! 2644: default:
! 2645: if (config_universe && is_identifier (token)) {
! 2646: option = (struct option *)0;
! 2647: option_name_hash_lookup(&option,
! 2648: config_universe->name_hash,
! 2649: val, 0, MDL);
! 2650: if (option) {
! 2651: token = next_token (&val,
! 2652: (unsigned *)0, cfile);
! 2653: status = parse_option_statement
! 2654: (result, cfile, 1, option,
! 2655: supersede_option_statement);
! 2656: option_dereference(&option, MDL);
! 2657: return status;
! 2658: }
! 2659: }
! 2660:
! 2661: if (token == NUMBER_OR_NAME || token == NAME) {
! 2662: /* This is rather ugly. Since function calls are
! 2663: data expressions, fake up an eval statement. */
! 2664: if (!executable_statement_allocate (result, MDL))
! 2665: log_fatal ("no memory for eval statement.");
! 2666: (*result) -> op = eval_statement;
! 2667:
! 2668: if (!parse_expression (&(*result) -> data.eval,
! 2669: cfile, lose, context_data,
! 2670: (struct expression **)0,
! 2671: expr_none)) {
! 2672: if (!*lose)
! 2673: parse_warn (cfile, "expecting "
! 2674: "function call.");
! 2675: else
! 2676: *lose = 1;
! 2677: skip_to_semi (cfile);
! 2678: executable_statement_dereference (result, MDL);
! 2679: return 0;
! 2680: }
! 2681: if (!parse_semi (cfile)) {
! 2682: *lose = 1;
! 2683: executable_statement_dereference (result, MDL);
! 2684: return 0;
! 2685: }
! 2686: break;
! 2687: }
! 2688:
! 2689: *lose = 0;
! 2690: return 0;
! 2691: }
! 2692:
! 2693: return 1;
! 2694: }
! 2695:
! 2696: /* zone-statements :== zone-statement |
! 2697: zone-statement zone-statements
! 2698: zone-statement :==
! 2699: PRIMARY ip-addresses SEMI |
! 2700: SECONDARY ip-addresses SEMI |
! 2701: key-reference SEMI
! 2702: ip-addresses :== ip-addr-or-hostname |
! 2703: ip-addr-or-hostname COMMA ip-addresses
! 2704: key-reference :== KEY STRING |
! 2705: KEY identifier */
! 2706:
! 2707: int parse_zone (struct dns_zone *zone, struct parse *cfile)
! 2708: {
! 2709: int token;
! 2710: const char *val;
! 2711: char *key_name;
! 2712: struct option_cache *oc;
! 2713: int done = 0;
! 2714:
! 2715: token = next_token (&val, (unsigned *)0, cfile);
! 2716: if (token != LBRACE) {
! 2717: parse_warn (cfile, "expecting left brace");
! 2718: return 0;
! 2719: }
! 2720:
! 2721: do {
! 2722: token = peek_token (&val, (unsigned *)0, cfile);
! 2723: switch (token) {
! 2724: case PRIMARY:
! 2725: if (zone -> primary) {
! 2726: parse_warn (cfile,
! 2727: "more than one primary.");
! 2728: skip_to_semi (cfile);
! 2729: return 0;
! 2730: }
! 2731: if (!option_cache_allocate (&zone -> primary, MDL))
! 2732: log_fatal ("can't allocate primary option cache.");
! 2733: oc = zone -> primary;
! 2734: goto consemup;
! 2735:
! 2736: case SECONDARY:
! 2737: if (zone -> secondary) {
! 2738: parse_warn (cfile, "more than one secondary.");
! 2739: skip_to_semi (cfile);
! 2740: return 0;
! 2741: }
! 2742: if (!option_cache_allocate (&zone -> secondary, MDL))
! 2743: log_fatal ("can't allocate secondary.");
! 2744: oc = zone -> secondary;
! 2745: consemup:
! 2746: token = next_token (&val, (unsigned *)0, cfile);
! 2747: do {
! 2748: struct expression *expr = (struct expression *)0;
! 2749: if (!parse_ip_addr_or_hostname (&expr, cfile, 0)) {
! 2750: parse_warn (cfile,
! 2751: "expecting IP addr or hostname.");
! 2752: skip_to_semi (cfile);
! 2753: return 0;
! 2754: }
! 2755: if (oc -> expression) {
! 2756: struct expression *old =
! 2757: (struct expression *)0;
! 2758: expression_reference (&old,
! 2759: oc -> expression,
! 2760: MDL);
! 2761: expression_dereference (&oc -> expression,
! 2762: MDL);
! 2763: if (!make_concat (&oc -> expression,
! 2764: old, expr))
! 2765: log_fatal ("no memory for concat.");
! 2766: expression_dereference (&expr, MDL);
! 2767: expression_dereference (&old, MDL);
! 2768: } else {
! 2769: expression_reference (&oc -> expression,
! 2770: expr, MDL);
! 2771: expression_dereference (&expr, MDL);
! 2772: }
! 2773: token = next_token (&val, (unsigned *)0, cfile);
! 2774: } while (token == COMMA);
! 2775: if (token != SEMI) {
! 2776: parse_warn (cfile, "expecting semicolon.");
! 2777: skip_to_semi (cfile);
! 2778: return 0;
! 2779: }
! 2780: break;
! 2781:
! 2782: case KEY:
! 2783: token = next_token (&val, (unsigned *)0, cfile);
! 2784: token = peek_token (&val, (unsigned *)0, cfile);
! 2785: if (token == STRING) {
! 2786: token = next_token (&val, (unsigned *)0, cfile);
! 2787: key_name = (char *)0;
! 2788: } else {
! 2789: key_name = parse_host_name (cfile);
! 2790: if (!key_name) {
! 2791: parse_warn (cfile, "expecting key name.");
! 2792: skip_to_semi (cfile);
! 2793: return 0;
! 2794: }
! 2795: val = key_name;
! 2796: }
! 2797: if (omapi_auth_key_lookup_name (&zone -> key, val) !=
! 2798: ISC_R_SUCCESS)
! 2799: parse_warn (cfile, "unknown key %s", val);
! 2800: if (key_name)
! 2801: dfree (key_name, MDL);
! 2802: if (!parse_semi (cfile))
! 2803: return 0;
! 2804: break;
! 2805:
! 2806: default:
! 2807: done = 1;
! 2808: break;
! 2809: }
! 2810: } while (!done);
! 2811:
! 2812: token = next_token (&val, (unsigned *)0, cfile);
! 2813: if (token != RBRACE) {
! 2814: parse_warn (cfile, "expecting right brace.");
! 2815: return 0;
! 2816: }
! 2817: return 1;
! 2818: }
! 2819:
! 2820: /* key-statements :== key-statement |
! 2821: key-statement key-statements
! 2822: key-statement :==
! 2823: ALGORITHM host-name SEMI |
! 2824: secret-definition SEMI
! 2825: secret-definition :== SECRET base64val |
! 2826: SECRET STRING */
! 2827:
! 2828: int parse_key (struct parse *cfile)
! 2829: {
! 2830: int token;
! 2831: const char *val;
! 2832: int done = 0;
! 2833: struct auth_key *key;
! 2834: struct data_string ds;
! 2835: isc_result_t status;
! 2836: char *s;
! 2837:
! 2838: key = (struct auth_key *)0;
! 2839: if (omapi_auth_key_new (&key, MDL) != ISC_R_SUCCESS)
! 2840: log_fatal ("no memory for key");
! 2841:
! 2842: token = peek_token (&val, (unsigned *)0, cfile);
! 2843: if (token == STRING) {
! 2844: token = next_token (&val, (unsigned *)0, cfile);
! 2845: key -> name = dmalloc (strlen (val) + 1, MDL);
! 2846: if (!key -> name)
! 2847: log_fatal ("no memory for key name.");
! 2848: strcpy (key -> name, val);
! 2849:
! 2850: } else {
! 2851: key -> name = parse_host_name (cfile);
! 2852: if (!key -> name) {
! 2853: parse_warn (cfile, "expecting key name.");
! 2854: skip_to_semi (cfile);
! 2855: goto bad;
! 2856: }
! 2857: }
! 2858:
! 2859: token = next_token (&val, (unsigned *)0, cfile);
! 2860: if (token != LBRACE) {
! 2861: parse_warn (cfile, "expecting left brace");
! 2862: goto bad;
! 2863: }
! 2864:
! 2865: do {
! 2866: token = next_token (&val, (unsigned *)0, cfile);
! 2867: switch (token) {
! 2868: case ALGORITHM:
! 2869: if (key -> algorithm) {
! 2870: parse_warn (cfile,
! 2871: "key %s: too many algorithms",
! 2872: key -> name);
! 2873: goto rbad;
! 2874: }
! 2875: key -> algorithm = parse_host_name (cfile);
! 2876: if (!key -> algorithm) {
! 2877: parse_warn (cfile,
! 2878: "expecting key algorithm name.");
! 2879: goto rbad;
! 2880: }
! 2881: if (!parse_semi (cfile))
! 2882: goto rbad;
! 2883: /* If the algorithm name isn't an FQDN, tack on
! 2884: the .SIG-ALG.REG.NET. domain. */
! 2885: s = strrchr (key -> algorithm, '.');
! 2886: if (!s) {
! 2887: static char add [] = ".SIG-ALG.REG.INT.";
! 2888: s = dmalloc (strlen (key -> algorithm) +
! 2889: sizeof (add), MDL);
! 2890: if (!s) {
! 2891: log_error ("no memory for key %s.",
! 2892: "algorithm");
! 2893: goto rbad;
! 2894: }
! 2895: strcpy (s, key -> algorithm);
! 2896: strcat (s, add);
! 2897: dfree (key -> algorithm, MDL);
! 2898: key -> algorithm = s;
! 2899: } else if (s [1]) {
! 2900: /* If there is no trailing '.', hack one in. */
! 2901: s = dmalloc (strlen (key -> algorithm) + 2, MDL);
! 2902: if (!s) {
! 2903: log_error ("no memory for key %s.",
! 2904: key -> algorithm);
! 2905: goto rbad;
! 2906: }
! 2907: strcpy (s, key -> algorithm);
! 2908: strcat (s, ".");
! 2909: dfree (key -> algorithm, MDL);
! 2910: key -> algorithm = s;
! 2911: }
! 2912: break;
! 2913:
! 2914: case SECRET:
! 2915: if (key -> key) {
! 2916: parse_warn (cfile, "key %s: too many secrets",
! 2917: key -> name);
! 2918: goto rbad;
! 2919: }
! 2920:
! 2921: memset (&ds, 0, sizeof(ds));
! 2922: if (!parse_base64 (&ds, cfile))
! 2923: goto rbad;
! 2924: status = omapi_data_string_new (&key -> key, ds.len,
! 2925: MDL);
! 2926: if (status != ISC_R_SUCCESS)
! 2927: goto rbad;
! 2928: memcpy (key -> key -> value,
! 2929: ds.buffer -> data, ds.len);
! 2930: data_string_forget (&ds, MDL);
! 2931:
! 2932: if (!parse_semi (cfile))
! 2933: goto rbad;
! 2934: break;
! 2935:
! 2936: default:
! 2937: done = 1;
! 2938: break;
! 2939: }
! 2940: } while (!done);
! 2941: if (token != RBRACE) {
! 2942: parse_warn (cfile, "expecting right brace.");
! 2943: goto rbad;
! 2944: }
! 2945: /* Allow the BIND 8 syntax, which has a semicolon after each
! 2946: closing brace. */
! 2947: token = peek_token (&val, (unsigned *)0, cfile);
! 2948: if (token == SEMI)
! 2949: token = next_token (&val, (unsigned *)0, cfile);
! 2950:
! 2951: /* Remember the key. */
! 2952: status = omapi_auth_key_enter (key);
! 2953: if (status != ISC_R_SUCCESS) {
! 2954: parse_warn (cfile, "tsig key %s: %s",
! 2955: key -> name, isc_result_totext (status));
! 2956: goto bad;
! 2957: }
! 2958: omapi_auth_key_dereference (&key, MDL);
! 2959: return 1;
! 2960:
! 2961: rbad:
! 2962: skip_to_rbrace (cfile, 1);
! 2963: bad:
! 2964: omapi_auth_key_dereference (&key, MDL);
! 2965: return 0;
! 2966: }
! 2967:
! 2968: /*
! 2969: * on-statement :== event-types LBRACE executable-statements RBRACE
! 2970: * event-types :== event-type OR event-types |
! 2971: * event-type
! 2972: * event-type :== EXPIRY | COMMIT | RELEASE
! 2973: */
! 2974:
! 2975: int parse_on_statement (result, cfile, lose)
! 2976: struct executable_statement **result;
! 2977: struct parse *cfile;
! 2978: int *lose;
! 2979: {
! 2980: enum dhcp_token token;
! 2981: const char *val;
! 2982:
! 2983: if (!executable_statement_allocate (result, MDL))
! 2984: log_fatal ("no memory for new statement.");
! 2985: (*result) -> op = on_statement;
! 2986:
! 2987: do {
! 2988: token = next_token (&val, (unsigned *)0, cfile);
! 2989: switch (token) {
! 2990: case EXPIRY:
! 2991: (*result) -> data.on.evtypes |= ON_EXPIRY;
! 2992: break;
! 2993:
! 2994: case COMMIT:
! 2995: (*result) -> data.on.evtypes |= ON_COMMIT;
! 2996: break;
! 2997:
! 2998: case RELEASE:
! 2999: (*result) -> data.on.evtypes |= ON_RELEASE;
! 3000: break;
! 3001:
! 3002: case TRANSMISSION:
! 3003: (*result) -> data.on.evtypes |= ON_TRANSMISSION;
! 3004: break;
! 3005:
! 3006: default:
! 3007: parse_warn (cfile, "expecting a lease event type");
! 3008: skip_to_semi (cfile);
! 3009: *lose = 1;
! 3010: executable_statement_dereference (result, MDL);
! 3011: return 0;
! 3012: }
! 3013: token = next_token (&val, (unsigned *)0, cfile);
! 3014: } while (token == OR);
! 3015:
! 3016: /* Semicolon means no statements. */
! 3017: if (token == SEMI)
! 3018: return 1;
! 3019:
! 3020: if (token != LBRACE) {
! 3021: parse_warn (cfile, "left brace expected.");
! 3022: skip_to_semi (cfile);
! 3023: *lose = 1;
! 3024: executable_statement_dereference (result, MDL);
! 3025: return 0;
! 3026: }
! 3027: if (!parse_executable_statements (&(*result) -> data.on.statements,
! 3028: cfile, lose, context_any)) {
! 3029: if (*lose) {
! 3030: /* Try to even things up. */
! 3031: do {
! 3032: token = next_token (&val,
! 3033: (unsigned *)0, cfile);
! 3034: } while (token != END_OF_FILE && token != RBRACE);
! 3035: executable_statement_dereference (result, MDL);
! 3036: return 0;
! 3037: }
! 3038: }
! 3039: token = next_token (&val, (unsigned *)0, cfile);
! 3040: if (token != RBRACE) {
! 3041: parse_warn (cfile, "right brace expected.");
! 3042: skip_to_semi (cfile);
! 3043: *lose = 1;
! 3044: executable_statement_dereference (result, MDL);
! 3045: return 0;
! 3046: }
! 3047: return 1;
! 3048: }
! 3049:
! 3050: /*
! 3051: * switch-statement :== LPAREN expr RPAREN LBRACE executable-statements RBRACE
! 3052: *
! 3053: */
! 3054:
! 3055: int parse_switch_statement (result, cfile, lose)
! 3056: struct executable_statement **result;
! 3057: struct parse *cfile;
! 3058: int *lose;
! 3059: {
! 3060: enum dhcp_token token;
! 3061: const char *val;
! 3062:
! 3063: if (!executable_statement_allocate (result, MDL))
! 3064: log_fatal ("no memory for new statement.");
! 3065: (*result) -> op = switch_statement;
! 3066:
! 3067: token = next_token (&val, (unsigned *)0, cfile);
! 3068: if (token != LPAREN) {
! 3069: parse_warn (cfile, "expecting left brace.");
! 3070: pfui:
! 3071: *lose = 1;
! 3072: skip_to_semi (cfile);
! 3073: gnorf:
! 3074: executable_statement_dereference (result, MDL);
! 3075: return 0;
! 3076: }
! 3077:
! 3078: if (!parse_expression (&(*result) -> data.s_switch.expr,
! 3079: cfile, lose, context_data_or_numeric,
! 3080: (struct expression **)0, expr_none)) {
! 3081: if (!*lose) {
! 3082: parse_warn (cfile,
! 3083: "expecting data or numeric expression.");
! 3084: goto pfui;
! 3085: }
! 3086: goto gnorf;
! 3087: }
! 3088:
! 3089: token = next_token (&val, (unsigned *)0, cfile);
! 3090: if (token != RPAREN) {
! 3091: parse_warn (cfile, "right paren expected.");
! 3092: goto pfui;
! 3093: }
! 3094:
! 3095: token = next_token (&val, (unsigned *)0, cfile);
! 3096: if (token != LBRACE) {
! 3097: parse_warn (cfile, "left brace expected.");
! 3098: goto pfui;
! 3099: }
! 3100: if (!(parse_executable_statements
! 3101: (&(*result) -> data.s_switch.statements, cfile, lose,
! 3102: (is_data_expression ((*result) -> data.s_switch.expr)
! 3103: ? context_data : context_numeric)))) {
! 3104: if (*lose) {
! 3105: skip_to_rbrace (cfile, 1);
! 3106: executable_statement_dereference (result, MDL);
! 3107: return 0;
! 3108: }
! 3109: }
! 3110: token = next_token (&val, (unsigned *)0, cfile);
! 3111: if (token != RBRACE) {
! 3112: parse_warn (cfile, "right brace expected.");
! 3113: goto pfui;
! 3114: }
! 3115: return 1;
! 3116: }
! 3117:
! 3118: /*
! 3119: * case-statement :== CASE expr COLON
! 3120: *
! 3121: */
! 3122:
! 3123: int parse_case_statement (result, cfile, lose, case_context)
! 3124: struct executable_statement **result;
! 3125: struct parse *cfile;
! 3126: int *lose;
! 3127: enum expression_context case_context;
! 3128: {
! 3129: enum dhcp_token token;
! 3130: const char *val;
! 3131:
! 3132: if (!executable_statement_allocate (result, MDL))
! 3133: log_fatal ("no memory for new statement.");
! 3134: (*result) -> op = case_statement;
! 3135:
! 3136: if (!parse_expression (&(*result) -> data.c_case,
! 3137: cfile, lose, case_context,
! 3138: (struct expression **)0, expr_none))
! 3139: {
! 3140: if (!*lose) {
! 3141: parse_warn (cfile, "expecting %s expression.",
! 3142: (case_context == context_data
! 3143: ? "data" : "numeric"));
! 3144: }
! 3145: pfui:
! 3146: *lose = 1;
! 3147: skip_to_semi (cfile);
! 3148: executable_statement_dereference (result, MDL);
! 3149: return 0;
! 3150: }
! 3151:
! 3152: token = next_token (&val, (unsigned *)0, cfile);
! 3153: if (token != COLON) {
! 3154: parse_warn (cfile, "colon expected.");
! 3155: goto pfui;
! 3156: }
! 3157: return 1;
! 3158: }
! 3159:
! 3160: /*
! 3161: * if-statement :== boolean-expression LBRACE executable-statements RBRACE
! 3162: * else-statement
! 3163: *
! 3164: * else-statement :== <null> |
! 3165: * ELSE LBRACE executable-statements RBRACE |
! 3166: * ELSE IF if-statement |
! 3167: * ELSIF if-statement
! 3168: */
! 3169:
! 3170: int parse_if_statement (result, cfile, lose)
! 3171: struct executable_statement **result;
! 3172: struct parse *cfile;
! 3173: int *lose;
! 3174: {
! 3175: enum dhcp_token token;
! 3176: const char *val;
! 3177: int parenp;
! 3178:
! 3179: if (!executable_statement_allocate (result, MDL))
! 3180: log_fatal ("no memory for if statement.");
! 3181:
! 3182: (*result) -> op = if_statement;
! 3183:
! 3184: token = peek_token (&val, (unsigned *)0, cfile);
! 3185: if (token == LPAREN) {
! 3186: parenp = 1;
! 3187: next_token (&val, (unsigned *)0, cfile);
! 3188: } else
! 3189: parenp = 0;
! 3190:
! 3191:
! 3192: if (!parse_boolean_expression (&(*result) -> data.ie.expr,
! 3193: cfile, lose)) {
! 3194: if (!*lose)
! 3195: parse_warn (cfile, "boolean expression expected.");
! 3196: executable_statement_dereference (result, MDL);
! 3197: *lose = 1;
! 3198: return 0;
! 3199: }
! 3200: #if defined (DEBUG_EXPRESSION_PARSE)
! 3201: print_expression ("if condition", (*result) -> data.ie.expr);
! 3202: #endif
! 3203: if (parenp) {
! 3204: token = next_token (&val, (unsigned *)0, cfile);
! 3205: if (token != RPAREN) {
! 3206: parse_warn (cfile, "expecting right paren.");
! 3207: *lose = 1;
! 3208: executable_statement_dereference (result, MDL);
! 3209: return 0;
! 3210: }
! 3211: }
! 3212: token = next_token (&val, (unsigned *)0, cfile);
! 3213: if (token != LBRACE) {
! 3214: parse_warn (cfile, "left brace expected.");
! 3215: skip_to_semi (cfile);
! 3216: *lose = 1;
! 3217: executable_statement_dereference (result, MDL);
! 3218: return 0;
! 3219: }
! 3220: if (!parse_executable_statements (&(*result) -> data.ie.tc,
! 3221: cfile, lose, context_any)) {
! 3222: if (*lose) {
! 3223: /* Try to even things up. */
! 3224: do {
! 3225: token = next_token (&val,
! 3226: (unsigned *)0, cfile);
! 3227: } while (token != END_OF_FILE && token != RBRACE);
! 3228: executable_statement_dereference (result, MDL);
! 3229: return 0;
! 3230: }
! 3231: }
! 3232: token = next_token (&val, (unsigned *)0, cfile);
! 3233: if (token != RBRACE) {
! 3234: parse_warn (cfile, "right brace expected.");
! 3235: skip_to_semi (cfile);
! 3236: *lose = 1;
! 3237: executable_statement_dereference (result, MDL);
! 3238: return 0;
! 3239: }
! 3240: token = peek_token (&val, (unsigned *)0, cfile);
! 3241: if (token == ELSE) {
! 3242: token = next_token (&val, (unsigned *)0, cfile);
! 3243: token = peek_token (&val, (unsigned *)0, cfile);
! 3244: if (token == IF) {
! 3245: token = next_token (&val, (unsigned *)0, cfile);
! 3246: if (!parse_if_statement (&(*result) -> data.ie.fc,
! 3247: cfile, lose)) {
! 3248: if (!*lose)
! 3249: parse_warn (cfile,
! 3250: "expecting if statement");
! 3251: executable_statement_dereference (result, MDL);
! 3252: *lose = 1;
! 3253: return 0;
! 3254: }
! 3255: } else if (token != LBRACE) {
! 3256: parse_warn (cfile, "left brace or if expected.");
! 3257: skip_to_semi (cfile);
! 3258: *lose = 1;
! 3259: executable_statement_dereference (result, MDL);
! 3260: return 0;
! 3261: } else {
! 3262: token = next_token (&val, (unsigned *)0, cfile);
! 3263: if (!(parse_executable_statements
! 3264: (&(*result) -> data.ie.fc,
! 3265: cfile, lose, context_any))) {
! 3266: executable_statement_dereference (result, MDL);
! 3267: return 0;
! 3268: }
! 3269: token = next_token (&val, (unsigned *)0, cfile);
! 3270: if (token != RBRACE) {
! 3271: parse_warn (cfile, "right brace expected.");
! 3272: skip_to_semi (cfile);
! 3273: *lose = 1;
! 3274: executable_statement_dereference (result, MDL);
! 3275: return 0;
! 3276: }
! 3277: }
! 3278: } else if (token == ELSIF) {
! 3279: token = next_token (&val, (unsigned *)0, cfile);
! 3280: if (!parse_if_statement (&(*result) -> data.ie.fc,
! 3281: cfile, lose)) {
! 3282: if (!*lose)
! 3283: parse_warn (cfile,
! 3284: "expecting conditional.");
! 3285: executable_statement_dereference (result, MDL);
! 3286: *lose = 1;
! 3287: return 0;
! 3288: }
! 3289: } else
! 3290: (*result) -> data.ie.fc = (struct executable_statement *)0;
! 3291:
! 3292: return 1;
! 3293: }
! 3294:
! 3295: /*
! 3296: * boolean_expression :== CHECK STRING |
! 3297: * NOT boolean-expression |
! 3298: * data-expression EQUAL data-expression |
! 3299: * data-expression BANG EQUAL data-expression |
! 3300: * data-expression REGEX_MATCH data-expression |
! 3301: * boolean-expression AND boolean-expression |
! 3302: * boolean-expression OR boolean-expression
! 3303: * EXISTS OPTION-NAME
! 3304: */
! 3305:
! 3306: int parse_boolean_expression (expr, cfile, lose)
! 3307: struct expression **expr;
! 3308: struct parse *cfile;
! 3309: int *lose;
! 3310: {
! 3311: /* Parse an expression... */
! 3312: if (!parse_expression (expr, cfile, lose, context_boolean,
! 3313: (struct expression **)0, expr_none))
! 3314: return 0;
! 3315:
! 3316: if (!is_boolean_expression (*expr) &&
! 3317: (*expr) -> op != expr_variable_reference &&
! 3318: (*expr) -> op != expr_funcall) {
! 3319: parse_warn (cfile, "Expecting a boolean expression.");
! 3320: *lose = 1;
! 3321: expression_dereference (expr, MDL);
! 3322: return 0;
! 3323: }
! 3324: return 1;
! 3325: }
! 3326:
! 3327: /* boolean :== ON SEMI | OFF SEMI | TRUE SEMI | FALSE SEMI */
! 3328:
! 3329: int parse_boolean (cfile)
! 3330: struct parse *cfile;
! 3331: {
! 3332: enum dhcp_token token;
! 3333: const char *val;
! 3334: int rv;
! 3335:
! 3336: token = next_token (&val, (unsigned *)0, cfile);
! 3337: if (!strcasecmp (val, "true")
! 3338: || !strcasecmp (val, "on"))
! 3339: rv = 1;
! 3340: else if (!strcasecmp (val, "false")
! 3341: || !strcasecmp (val, "off"))
! 3342: rv = 0;
! 3343: else {
! 3344: parse_warn (cfile,
! 3345: "boolean value (true/false/on/off) expected");
! 3346: skip_to_semi (cfile);
! 3347: return 0;
! 3348: }
! 3349: parse_semi (cfile);
! 3350: return rv;
! 3351: }
! 3352:
! 3353:
! 3354: /*
! 3355: * data_expression :== SUBSTRING LPAREN data-expression COMMA
! 3356: * numeric-expression COMMA
! 3357: * numeric-expression RPAREN |
! 3358: * CONCAT LPAREN data-expression COMMA
! 3359: * data-expression RPAREN
! 3360: * SUFFIX LPAREN data_expression COMMA
! 3361: * numeric-expression RPAREN |
! 3362: * LCASE LPAREN data_expression RPAREN |
! 3363: * UCASE LPAREN data_expression RPAREN |
! 3364: * OPTION option_name |
! 3365: * HARDWARE |
! 3366: * PACKET LPAREN numeric-expression COMMA
! 3367: * numeric-expression RPAREN |
! 3368: * STRING |
! 3369: * colon_separated_hex_list
! 3370: */
! 3371:
! 3372: int parse_data_expression (expr, cfile, lose)
! 3373: struct expression **expr;
! 3374: struct parse *cfile;
! 3375: int *lose;
! 3376: {
! 3377: /* Parse an expression... */
! 3378: if (!parse_expression (expr, cfile, lose, context_data,
! 3379: (struct expression **)0, expr_none))
! 3380: return 0;
! 3381:
! 3382: if (!is_data_expression (*expr) &&
! 3383: (*expr) -> op != expr_variable_reference &&
! 3384: (*expr) -> op != expr_funcall) {
! 3385: expression_dereference (expr, MDL);
! 3386: parse_warn (cfile, "Expecting a data expression.");
! 3387: *lose = 1;
! 3388: return 0;
! 3389: }
! 3390: return 1;
! 3391: }
! 3392:
! 3393: /*
! 3394: * numeric-expression :== EXTRACT_INT LPAREN data-expression
! 3395: * COMMA number RPAREN |
! 3396: * NUMBER
! 3397: */
! 3398:
! 3399: int parse_numeric_expression (expr, cfile, lose)
! 3400: struct expression **expr;
! 3401: struct parse *cfile;
! 3402: int *lose;
! 3403: {
! 3404: /* Parse an expression... */
! 3405: if (!parse_expression (expr, cfile, lose, context_numeric,
! 3406: (struct expression **)0, expr_none))
! 3407: return 0;
! 3408:
! 3409: if (!is_numeric_expression (*expr) &&
! 3410: (*expr) -> op != expr_variable_reference &&
! 3411: (*expr) -> op != expr_funcall) {
! 3412: expression_dereference (expr, MDL);
! 3413: parse_warn (cfile, "Expecting a numeric expression.");
! 3414: *lose = 1;
! 3415: return 0;
! 3416: }
! 3417: return 1;
! 3418: }
! 3419:
! 3420: /*
! 3421: * dns-expression :==
! 3422: * UPDATE LPAREN ns-class COMMA ns-type COMMA data-expression COMMA
! 3423: * data-expression COMMA numeric-expression RPAREN
! 3424: * DELETE LPAREN ns-class COMMA ns-type COMMA data-expression COMMA
! 3425: * data-expression RPAREN
! 3426: * EXISTS LPAREN ns-class COMMA ns-type COMMA data-expression COMMA
! 3427: * data-expression RPAREN
! 3428: * NOT EXISTS LPAREN ns-class COMMA ns-type COMMA data-expression COMMA
! 3429: * data-expression RPAREN
! 3430: * ns-class :== IN | CHAOS | HS | NUMBER
! 3431: * ns-type :== A | PTR | MX | TXT | NUMBER
! 3432: */
! 3433:
! 3434: int parse_dns_expression (expr, cfile, lose)
! 3435: struct expression **expr;
! 3436: struct parse *cfile;
! 3437: int *lose;
! 3438: {
! 3439: /* Parse an expression... */
! 3440: if (!parse_expression (expr, cfile, lose, context_dns,
! 3441: (struct expression **)0, expr_none))
! 3442: return 0;
! 3443:
! 3444: if (!is_dns_expression (*expr) &&
! 3445: (*expr) -> op != expr_variable_reference &&
! 3446: (*expr) -> op != expr_funcall) {
! 3447: expression_dereference (expr, MDL);
! 3448: parse_warn (cfile, "Expecting a dns update subexpression.");
! 3449: *lose = 1;
! 3450: return 0;
! 3451: }
! 3452: return 1;
! 3453: }
! 3454:
! 3455: /* Parse a subexpression that does not contain a binary operator. */
! 3456:
! 3457: int parse_non_binary (expr, cfile, lose, context)
! 3458: struct expression **expr;
! 3459: struct parse *cfile;
! 3460: int *lose;
! 3461: enum expression_context context;
! 3462: {
! 3463: enum dhcp_token token;
! 3464: const char *val;
! 3465: struct collection *col;
! 3466: struct expression *nexp, **ep;
! 3467: int known;
! 3468: enum expr_op opcode;
! 3469: const char *s;
! 3470: char *cptr;
! 3471: unsigned long u;
! 3472: isc_result_t status;
! 3473: unsigned len;
! 3474:
! 3475: token = peek_token (&val, (unsigned *)0, cfile);
! 3476:
! 3477: /* Check for unary operators... */
! 3478: switch (token) {
! 3479: case CHECK:
! 3480: token = next_token (&val, (unsigned *)0, cfile);
! 3481: token = next_token (&val, (unsigned *)0, cfile);
! 3482: if (token != STRING) {
! 3483: parse_warn (cfile, "string expected.");
! 3484: skip_to_semi (cfile);
! 3485: *lose = 1;
! 3486: return 0;
! 3487: }
! 3488: for (col = collections; col; col = col -> next)
! 3489: if (!strcmp (col -> name, val))
! 3490: break;
! 3491: if (!col) {
! 3492: parse_warn (cfile, "unknown collection.");
! 3493: *lose = 1;
! 3494: return 0;
! 3495: }
! 3496: if (!expression_allocate (expr, MDL))
! 3497: log_fatal ("can't allocate expression");
! 3498: (*expr) -> op = expr_check;
! 3499: (*expr) -> data.check = col;
! 3500: break;
! 3501:
! 3502: case TOKEN_NOT:
! 3503: token = next_token (&val, (unsigned *)0, cfile);
! 3504: if (context == context_dns) {
! 3505: token = peek_token (&val, (unsigned *)0, cfile);
! 3506: goto not_exists;
! 3507: }
! 3508: if (!expression_allocate (expr, MDL))
! 3509: log_fatal ("can't allocate expression");
! 3510: (*expr) -> op = expr_not;
! 3511: if (!parse_non_binary (&(*expr) -> data.not,
! 3512: cfile, lose, context_boolean)) {
! 3513: if (!*lose) {
! 3514: parse_warn (cfile, "expression expected");
! 3515: skip_to_semi (cfile);
! 3516: }
! 3517: *lose = 1;
! 3518: expression_dereference (expr, MDL);
! 3519: return 0;
! 3520: }
! 3521: if (!is_boolean_expression ((*expr) -> data.not)) {
! 3522: *lose = 1;
! 3523: parse_warn (cfile, "boolean expression expected");
! 3524: skip_to_semi (cfile);
! 3525: expression_dereference (expr, MDL);
! 3526: return 0;
! 3527: }
! 3528: break;
! 3529:
! 3530: case LPAREN:
! 3531: token = next_token (&val, (unsigned *)0, cfile);
! 3532: if (!parse_expression (expr, cfile, lose, context,
! 3533: (struct expression **)0, expr_none)) {
! 3534: if (!*lose) {
! 3535: parse_warn (cfile, "expression expected");
! 3536: skip_to_semi (cfile);
! 3537: }
! 3538: *lose = 1;
! 3539: return 0;
! 3540: }
! 3541: token = next_token (&val, (unsigned *)0, cfile);
! 3542: if (token != RPAREN) {
! 3543: *lose = 1;
! 3544: parse_warn (cfile, "right paren expected");
! 3545: skip_to_semi (cfile);
! 3546: return 0;
! 3547: }
! 3548: break;
! 3549:
! 3550: case EXISTS:
! 3551: if (context == context_dns)
! 3552: goto ns_exists;
! 3553: token = next_token (&val, (unsigned *)0, cfile);
! 3554: if (!expression_allocate (expr, MDL))
! 3555: log_fatal ("can't allocate expression");
! 3556: (*expr) -> op = expr_exists;
! 3557: known = 0;
! 3558: /* Pass reference directly to expression structure. */
! 3559: status = parse_option_name(cfile, 0, &known,
! 3560: &(*expr)->data.option);
! 3561: if (status != ISC_R_SUCCESS ||
! 3562: (*expr)->data.option == NULL) {
! 3563: *lose = 1;
! 3564: expression_dereference (expr, MDL);
! 3565: return 0;
! 3566: }
! 3567: break;
! 3568:
! 3569: case STATIC:
! 3570: token = next_token (&val, (unsigned *)0, cfile);
! 3571: if (!expression_allocate (expr, MDL))
! 3572: log_fatal ("can't allocate expression");
! 3573: (*expr) -> op = expr_static;
! 3574: break;
! 3575:
! 3576: case KNOWN:
! 3577: token = next_token (&val, (unsigned *)0, cfile);
! 3578: if (!expression_allocate (expr, MDL))
! 3579: log_fatal ("can't allocate expression");
! 3580: (*expr) -> op = expr_known;
! 3581: break;
! 3582:
! 3583: case SUBSTRING:
! 3584: token = next_token (&val, (unsigned *)0, cfile);
! 3585: if (!expression_allocate (expr, MDL))
! 3586: log_fatal ("can't allocate expression");
! 3587: (*expr) -> op = expr_substring;
! 3588:
! 3589: token = next_token (&val, (unsigned *)0, cfile);
! 3590: if (token != LPAREN) {
! 3591: nolparen:
! 3592: expression_dereference (expr, MDL);
! 3593: parse_warn (cfile, "left parenthesis expected.");
! 3594: *lose = 1;
! 3595: return 0;
! 3596: }
! 3597:
! 3598: if (!parse_data_expression (&(*expr) -> data.substring.expr,
! 3599: cfile, lose)) {
! 3600: nodata:
! 3601: expression_dereference (expr, MDL);
! 3602: if (!*lose) {
! 3603: parse_warn (cfile,
! 3604: "expecting data expression.");
! 3605: skip_to_semi (cfile);
! 3606: *lose = 1;
! 3607: }
! 3608: return 0;
! 3609: }
! 3610:
! 3611: token = next_token (&val, (unsigned *)0, cfile);
! 3612: if (token != COMMA) {
! 3613: nocomma:
! 3614: expression_dereference (expr, MDL);
! 3615: parse_warn (cfile, "comma expected.");
! 3616: *lose = 1;
! 3617:
! 3618: return 0;
! 3619: }
! 3620:
! 3621: if (!parse_numeric_expression
! 3622: (&(*expr) -> data.substring.offset,cfile, lose)) {
! 3623: nonum:
! 3624: if (!*lose) {
! 3625: parse_warn (cfile,
! 3626: "expecting numeric expression.");
! 3627: skip_to_semi (cfile);
! 3628: *lose = 1;
! 3629: }
! 3630: expression_dereference (expr, MDL);
! 3631: return 0;
! 3632: }
! 3633:
! 3634: token = next_token (&val, (unsigned *)0, cfile);
! 3635: if (token != COMMA)
! 3636: goto nocomma;
! 3637:
! 3638: if (!parse_numeric_expression
! 3639: (&(*expr) -> data.substring.len, cfile, lose))
! 3640: goto nonum;
! 3641:
! 3642: token = next_token (&val, (unsigned *)0, cfile);
! 3643: if (token != RPAREN) {
! 3644: norparen:
! 3645: parse_warn (cfile, "right parenthesis expected.");
! 3646: *lose = 1;
! 3647: expression_dereference (expr, MDL);
! 3648: return 0;
! 3649: }
! 3650: break;
! 3651:
! 3652: case SUFFIX:
! 3653: token = next_token (&val, (unsigned *)0, cfile);
! 3654: if (!expression_allocate (expr, MDL))
! 3655: log_fatal ("can't allocate expression");
! 3656: (*expr) -> op = expr_suffix;
! 3657:
! 3658: token = next_token (&val, (unsigned *)0, cfile);
! 3659: if (token != LPAREN)
! 3660: goto nolparen;
! 3661:
! 3662: if (!parse_data_expression (&(*expr) -> data.suffix.expr,
! 3663: cfile, lose))
! 3664: goto nodata;
! 3665:
! 3666: token = next_token (&val, (unsigned *)0, cfile);
! 3667: if (token != COMMA)
! 3668: goto nocomma;
! 3669:
! 3670: if (!parse_numeric_expression (&(*expr) -> data.suffix.len,
! 3671: cfile, lose))
! 3672: goto nonum;
! 3673:
! 3674: token = next_token (&val, (unsigned *)0, cfile);
! 3675: if (token != RPAREN)
! 3676: goto norparen;
! 3677: break;
! 3678:
! 3679: case LCASE:
! 3680: token = next_token(&val, (unsigned *)0, cfile);
! 3681: if (!expression_allocate(expr, MDL))
! 3682: log_fatal ("can't allocate expression");
! 3683: (*expr)->op = expr_lcase;
! 3684:
! 3685: token = next_token(&val, (unsigned *)0, cfile);
! 3686: if (token != LPAREN)
! 3687: goto nolparen;
! 3688:
! 3689: if (!parse_data_expression(&(*expr)->data.lcase, cfile, lose))
! 3690: goto nodata;
! 3691:
! 3692: token = next_token(&val, (unsigned *)0, cfile);
! 3693: if (token != RPAREN)
! 3694: goto norparen;
! 3695: break;
! 3696:
! 3697: case UCASE:
! 3698: token = next_token(&val, (unsigned *)0, cfile);
! 3699: if (!expression_allocate(expr, MDL))
! 3700: log_fatal ("can't allocate expression");
! 3701: (*expr)->op = expr_ucase;
! 3702:
! 3703: token = next_token (&val, (unsigned *)0, cfile);
! 3704: if (token != LPAREN)
! 3705: goto nolparen;
! 3706:
! 3707: if (!parse_data_expression(&(*expr)->data.ucase,
! 3708: cfile, lose))
! 3709: goto nodata;
! 3710:
! 3711: token = next_token(&val, (unsigned *)0, cfile);
! 3712: if (token != RPAREN)
! 3713: goto norparen;
! 3714: break;
! 3715:
! 3716: case CONCAT:
! 3717: token = next_token (&val, (unsigned *)0, cfile);
! 3718: if (!expression_allocate (expr, MDL))
! 3719: log_fatal ("can't allocate expression");
! 3720: (*expr) -> op = expr_concat;
! 3721:
! 3722: token = next_token (&val, (unsigned *)0, cfile);
! 3723: if (token != LPAREN)
! 3724: goto nolparen;
! 3725:
! 3726: if (!parse_data_expression (&(*expr) -> data.concat [0],
! 3727: cfile, lose))
! 3728: goto nodata;
! 3729:
! 3730: token = next_token (&val, (unsigned *)0, cfile);
! 3731: if (token != COMMA)
! 3732: goto nocomma;
! 3733:
! 3734: concat_another:
! 3735: if (!parse_data_expression (&(*expr) -> data.concat [1],
! 3736: cfile, lose))
! 3737: goto nodata;
! 3738:
! 3739: token = next_token (&val, (unsigned *)0, cfile);
! 3740:
! 3741: if (token == COMMA) {
! 3742: nexp = (struct expression *)0;
! 3743: if (!expression_allocate (&nexp, MDL))
! 3744: log_fatal ("can't allocate at CONCAT2");
! 3745: nexp -> op = expr_concat;
! 3746: expression_reference (&nexp -> data.concat [0],
! 3747: *expr, MDL);
! 3748: expression_dereference (expr, MDL);
! 3749: expression_reference (expr, nexp, MDL);
! 3750: expression_dereference (&nexp, MDL);
! 3751: goto concat_another;
! 3752: }
! 3753:
! 3754: if (token != RPAREN)
! 3755: goto norparen;
! 3756: break;
! 3757:
! 3758: case BINARY_TO_ASCII:
! 3759: token = next_token (&val, (unsigned *)0, cfile);
! 3760: if (!expression_allocate (expr, MDL))
! 3761: log_fatal ("can't allocate expression");
! 3762: (*expr) -> op = expr_binary_to_ascii;
! 3763:
! 3764: token = next_token (&val, (unsigned *)0, cfile);
! 3765: if (token != LPAREN)
! 3766: goto nolparen;
! 3767:
! 3768: if (!parse_numeric_expression (&(*expr) -> data.b2a.base,
! 3769: cfile, lose))
! 3770: goto nodata;
! 3771:
! 3772: token = next_token (&val, (unsigned *)0, cfile);
! 3773: if (token != COMMA)
! 3774: goto nocomma;
! 3775:
! 3776: if (!parse_numeric_expression (&(*expr) -> data.b2a.width,
! 3777: cfile, lose))
! 3778: goto nodata;
! 3779:
! 3780: token = next_token (&val, (unsigned *)0, cfile);
! 3781: if (token != COMMA)
! 3782: goto nocomma;
! 3783:
! 3784: if (!parse_data_expression (&(*expr) -> data.b2a.separator,
! 3785: cfile, lose))
! 3786: goto nodata;
! 3787:
! 3788: token = next_token (&val, (unsigned *)0, cfile);
! 3789: if (token != COMMA)
! 3790: goto nocomma;
! 3791:
! 3792: if (!parse_data_expression (&(*expr) -> data.b2a.buffer,
! 3793: cfile, lose))
! 3794: goto nodata;
! 3795:
! 3796: token = next_token (&val, (unsigned *)0, cfile);
! 3797: if (token != RPAREN)
! 3798: goto norparen;
! 3799: break;
! 3800:
! 3801: case REVERSE:
! 3802: token = next_token (&val, (unsigned *)0, cfile);
! 3803: if (!expression_allocate (expr, MDL))
! 3804: log_fatal ("can't allocate expression");
! 3805: (*expr) -> op = expr_reverse;
! 3806:
! 3807: token = next_token (&val, (unsigned *)0, cfile);
! 3808: if (token != LPAREN)
! 3809: goto nolparen;
! 3810:
! 3811: if (!(parse_numeric_expression
! 3812: (&(*expr) -> data.reverse.width, cfile, lose)))
! 3813: goto nodata;
! 3814:
! 3815: token = next_token (&val, (unsigned *)0, cfile);
! 3816: if (token != COMMA)
! 3817: goto nocomma;
! 3818:
! 3819: if (!(parse_data_expression
! 3820: (&(*expr) -> data.reverse.buffer, cfile, lose)))
! 3821: goto nodata;
! 3822:
! 3823: token = next_token (&val, (unsigned *)0, cfile);
! 3824: if (token != RPAREN)
! 3825: goto norparen;
! 3826: break;
! 3827:
! 3828: case PICK:
! 3829: /* pick (a, b, c) actually produces an internal representation
! 3830: that looks like pick (a, pick (b, pick (c, nil))). */
! 3831: token = next_token (&val, (unsigned *)0, cfile);
! 3832: if (!(expression_allocate (expr, MDL)))
! 3833: log_fatal ("can't allocate expression");
! 3834:
! 3835: token = next_token (&val, (unsigned *)0, cfile);
! 3836: if (token != LPAREN)
! 3837: goto nolparen;
! 3838:
! 3839: nexp = (struct expression *)0;
! 3840: expression_reference (&nexp, *expr, MDL);
! 3841: do {
! 3842: nexp -> op = expr_pick_first_value;
! 3843: if (!(parse_data_expression
! 3844: (&nexp -> data.pick_first_value.car,
! 3845: cfile, lose)))
! 3846: goto nodata;
! 3847:
! 3848: token = next_token (&val, (unsigned *)0, cfile);
! 3849: if (token == COMMA) {
! 3850: struct expression *foo = (struct expression *)0;
! 3851: if (!expression_allocate (&foo, MDL))
! 3852: log_fatal ("can't allocate expr");
! 3853: expression_reference
! 3854: (&nexp -> data.pick_first_value.cdr, foo, MDL);
! 3855: expression_dereference (&nexp, MDL);
! 3856: expression_reference (&nexp, foo, MDL);
! 3857: expression_dereference (&foo, MDL);
! 3858: }
! 3859: } while (token == COMMA);
! 3860: expression_dereference (&nexp, MDL);
! 3861:
! 3862: if (token != RPAREN)
! 3863: goto norparen;
! 3864: break;
! 3865:
! 3866: /* dns-update and dns-delete are present for historical
! 3867: purposes, but are deprecated in favor of ns-update
! 3868: in combination with update, delete, exists and not
! 3869: exists. */
! 3870: case DNS_UPDATE:
! 3871: case DNS_DELETE:
! 3872: #if !defined (NSUPDATE)
! 3873: parse_warn (cfile,
! 3874: "Please rebuild dhcpd with --with-nsupdate.");
! 3875: #endif
! 3876: token = next_token (&val, (unsigned *)0, cfile);
! 3877: if (token == DNS_UPDATE)
! 3878: opcode = expr_ns_add;
! 3879: else
! 3880: opcode = expr_ns_delete;
! 3881:
! 3882: token = next_token (&val, (unsigned *)0, cfile);
! 3883: if (token != LPAREN)
! 3884: goto nolparen;
! 3885:
! 3886: token = next_token (&val, (unsigned *)0, cfile);
! 3887: if (token != STRING) {
! 3888: parse_warn (cfile,
! 3889: "parse_expression: expecting string.");
! 3890: badnsupdate:
! 3891: skip_to_semi (cfile);
! 3892: *lose = 1;
! 3893: return 0;
! 3894: }
! 3895:
! 3896: if (!strcasecmp (val, "a"))
! 3897: u = T_A;
! 3898: else if (!strcasecmp (val, "aaaa"))
! 3899: u = T_AAAA;
! 3900: else if (!strcasecmp (val, "ptr"))
! 3901: u = T_PTR;
! 3902: else if (!strcasecmp (val, "mx"))
! 3903: u = T_MX;
! 3904: else if (!strcasecmp (val, "cname"))
! 3905: u = T_CNAME;
! 3906: else if (!strcasecmp (val, "TXT"))
! 3907: u = T_TXT;
! 3908: else {
! 3909: parse_warn (cfile, "unexpected rrtype: %s", val);
! 3910: goto badnsupdate;
! 3911: }
! 3912:
! 3913: s = (opcode == expr_ns_add
! 3914: ? "old-dns-update"
! 3915: : "old-dns-delete");
! 3916: cptr = dmalloc (strlen (s) + 1, MDL);
! 3917: if (!cptr)
! 3918: log_fatal ("can't allocate name for %s", s);
! 3919: strcpy (cptr, s);
! 3920: if (!expression_allocate (expr, MDL))
! 3921: log_fatal ("can't allocate expression");
! 3922: (*expr) -> op = expr_funcall;
! 3923: (*expr) -> data.funcall.name = cptr;
! 3924:
! 3925: /* Fake up a function call. */
! 3926: ep = &(*expr) -> data.funcall.arglist;
! 3927: if (!expression_allocate (ep, MDL))
! 3928: log_fatal ("can't allocate expression");
! 3929: (*ep) -> op = expr_arg;
! 3930: if (!make_const_int (&(*ep) -> data.arg.val, u))
! 3931: log_fatal ("can't allocate rrtype value.");
! 3932:
! 3933: token = next_token (&val, (unsigned *)0, cfile);
! 3934: if (token != COMMA)
! 3935: goto nocomma;
! 3936: ep = &((*ep) -> data.arg.next);
! 3937: if (!expression_allocate (ep, MDL))
! 3938: log_fatal ("can't allocate expression");
! 3939: (*ep) -> op = expr_arg;
! 3940: if (!(parse_data_expression (&(*ep) -> data.arg.val,
! 3941: cfile, lose)))
! 3942: goto nodata;
! 3943:
! 3944: token = next_token (&val, (unsigned *)0, cfile);
! 3945: if (token != COMMA)
! 3946: goto nocomma;
! 3947:
! 3948: ep = &((*ep) -> data.arg.next);
! 3949: if (!expression_allocate (ep, MDL))
! 3950: log_fatal ("can't allocate expression");
! 3951: (*ep) -> op = expr_arg;
! 3952: if (!(parse_data_expression (&(*ep) -> data.arg.val,
! 3953: cfile, lose)))
! 3954: goto nodata;
! 3955:
! 3956: if (opcode == expr_ns_add) {
! 3957: token = next_token (&val, (unsigned *)0, cfile);
! 3958: if (token != COMMA)
! 3959: goto nocomma;
! 3960:
! 3961: ep = &((*ep) -> data.arg.next);
! 3962: if (!expression_allocate (ep, MDL))
! 3963: log_fatal ("can't allocate expression");
! 3964: (*ep) -> op = expr_arg;
! 3965: if (!(parse_numeric_expression (&(*ep) -> data.arg.val,
! 3966: cfile, lose))) {
! 3967: parse_warn (cfile,
! 3968: "expecting numeric expression.");
! 3969: goto badnsupdate;
! 3970: }
! 3971: }
! 3972:
! 3973: token = next_token (&val, (unsigned *)0, cfile);
! 3974: if (token != RPAREN)
! 3975: goto norparen;
! 3976: break;
! 3977:
! 3978: case NS_UPDATE:
! 3979: #if !defined (NSUPDATE)
! 3980: parse_warn (cfile,
! 3981: "Please rebuild dhcpd with --with-nsupdate.");
! 3982: #endif
! 3983: token = next_token (&val, (unsigned *)0, cfile);
! 3984: if (!expression_allocate (expr, MDL))
! 3985: log_fatal ("can't allocate expression");
! 3986:
! 3987: token = next_token (&val, (unsigned *)0, cfile);
! 3988: if (token != LPAREN)
! 3989: goto nolparen;
! 3990:
! 3991: nexp = *expr;
! 3992: do {
! 3993: nexp -> op = expr_dns_transaction;
! 3994: if (!(parse_dns_expression
! 3995: (&nexp -> data.dns_transaction.car,
! 3996: cfile, lose)))
! 3997: {
! 3998: if (!*lose)
! 3999: parse_warn
! 4000: (cfile,
! 4001: "expecting dns expression.");
! 4002: expression_dereference (expr, MDL);
! 4003: *lose = 1;
! 4004: return 0;
! 4005: }
! 4006:
! 4007: token = next_token (&val, (unsigned *)0, cfile);
! 4008:
! 4009: if (token == COMMA) {
! 4010: if (!(expression_allocate
! 4011: (&nexp -> data.dns_transaction.cdr,
! 4012: MDL)))
! 4013: log_fatal
! 4014: ("can't allocate expression");
! 4015: nexp = nexp -> data.dns_transaction.cdr;
! 4016: }
! 4017: } while (token == COMMA);
! 4018:
! 4019: if (token != RPAREN)
! 4020: goto norparen;
! 4021: break;
! 4022:
! 4023: /* NOT EXISTS is special cased above... */
! 4024: not_exists:
! 4025: token = peek_token (&val, (unsigned *)0, cfile);
! 4026: if (token != EXISTS) {
! 4027: parse_warn (cfile, "expecting DNS prerequisite.");
! 4028: *lose = 1;
! 4029: return 0;
! 4030: }
! 4031: opcode = expr_ns_not_exists;
! 4032: goto nsupdatecode;
! 4033: case TOKEN_ADD:
! 4034: opcode = expr_ns_add;
! 4035: goto nsupdatecode;
! 4036: case TOKEN_DELETE:
! 4037: opcode = expr_ns_delete;
! 4038: goto nsupdatecode;
! 4039: ns_exists:
! 4040: opcode = expr_ns_exists;
! 4041: nsupdatecode:
! 4042: token = next_token (&val, (unsigned *)0, cfile);
! 4043:
! 4044: #if !defined (NSUPDATE)
! 4045: parse_warn (cfile,
! 4046: "Please rebuild dhcpd with --with-nsupdate.");
! 4047: #endif
! 4048: if (!expression_allocate (expr, MDL))
! 4049: log_fatal ("can't allocate expression");
! 4050: (*expr) -> op = opcode;
! 4051:
! 4052: token = next_token (&val, (unsigned *)0, cfile);
! 4053: if (token != LPAREN)
! 4054: goto nolparen;
! 4055:
! 4056: token = next_token (&val, (unsigned *)0, cfile);
! 4057: if (!is_identifier (token) && token != NUMBER) {
! 4058: parse_warn (cfile, "expecting identifier or number.");
! 4059: badnsop:
! 4060: expression_dereference (expr, MDL);
! 4061: skip_to_semi (cfile);
! 4062: *lose = 1;
! 4063: return 0;
! 4064: }
! 4065:
! 4066: if (token == NUMBER)
! 4067: (*expr) -> data.ns_add.rrclass = atoi (val);
! 4068: else if (!strcasecmp (val, "in"))
! 4069: (*expr) -> data.ns_add.rrclass = C_IN;
! 4070: else if (!strcasecmp (val, "chaos"))
! 4071: (*expr) -> data.ns_add.rrclass = C_CHAOS;
! 4072: else if (!strcasecmp (val, "hs"))
! 4073: (*expr) -> data.ns_add.rrclass = C_HS;
! 4074: else {
! 4075: parse_warn (cfile, "unexpected rrclass: %s", val);
! 4076: goto badnsop;
! 4077: }
! 4078:
! 4079: token = next_token (&val, (unsigned *)0, cfile);
! 4080: if (token != COMMA)
! 4081: goto nocomma;
! 4082:
! 4083: token = next_token (&val, (unsigned *)0, cfile);
! 4084: if (!is_identifier (token) && token != NUMBER) {
! 4085: parse_warn (cfile, "expecting identifier or number.");
! 4086: goto badnsop;
! 4087: }
! 4088:
! 4089: if (token == NUMBER)
! 4090: (*expr) -> data.ns_add.rrtype = atoi (val);
! 4091: else if (!strcasecmp (val, "a"))
! 4092: (*expr) -> data.ns_add.rrtype = T_A;
! 4093: else if (!strcasecmp (val, "aaaa"))
! 4094: (*expr) -> data.ns_add.rrtype = T_AAAA;
! 4095: else if (!strcasecmp (val, "ptr"))
! 4096: (*expr) -> data.ns_add.rrtype = T_PTR;
! 4097: else if (!strcasecmp (val, "mx"))
! 4098: (*expr) -> data.ns_add.rrtype = T_MX;
! 4099: else if (!strcasecmp (val, "cname"))
! 4100: (*expr) -> data.ns_add.rrtype = T_CNAME;
! 4101: else if (!strcasecmp (val, "TXT"))
! 4102: (*expr) -> data.ns_add.rrtype = T_TXT;
! 4103: else {
! 4104: parse_warn (cfile, "unexpected rrtype: %s", val);
! 4105: goto badnsop;
! 4106: }
! 4107:
! 4108: token = next_token (&val, (unsigned *)0, cfile);
! 4109: if (token != COMMA)
! 4110: goto nocomma;
! 4111:
! 4112: if (!(parse_data_expression
! 4113: (&(*expr) -> data.ns_add.rrname, cfile, lose)))
! 4114: goto nodata;
! 4115:
! 4116: token = next_token (&val, (unsigned *)0, cfile);
! 4117: if (token != COMMA)
! 4118: goto nocomma;
! 4119:
! 4120: if (!(parse_data_expression
! 4121: (&(*expr) -> data.ns_add.rrdata, cfile, lose)))
! 4122: goto nodata;
! 4123:
! 4124: if (opcode == expr_ns_add) {
! 4125: token = next_token (&val, (unsigned *)0, cfile);
! 4126: if (token != COMMA)
! 4127: goto nocomma;
! 4128:
! 4129: if (!(parse_numeric_expression
! 4130: (&(*expr) -> data.ns_add.ttl, cfile,
! 4131: lose))) {
! 4132: if (!*lose)
! 4133: parse_warn (cfile,
! 4134: "expecting numeric expression.");
! 4135: goto badnsupdate;
! 4136: }
! 4137: }
! 4138:
! 4139: token = next_token (&val, (unsigned *)0, cfile);
! 4140: if (token != RPAREN)
! 4141: goto norparen;
! 4142: break;
! 4143:
! 4144: case OPTION:
! 4145: case CONFIG_OPTION:
! 4146: if (!expression_allocate (expr, MDL))
! 4147: log_fatal ("can't allocate expression");
! 4148: (*expr) -> op = (token == OPTION
! 4149: ? expr_option
! 4150: : expr_config_option);
! 4151: token = next_token (&val, (unsigned *)0, cfile);
! 4152: known = 0;
! 4153: /* Pass reference directly to expression structure. */
! 4154: status = parse_option_name(cfile, 0, &known,
! 4155: &(*expr)->data.option);
! 4156: if (status != ISC_R_SUCCESS ||
! 4157: (*expr)->data.option == NULL) {
! 4158: *lose = 1;
! 4159: expression_dereference (expr, MDL);
! 4160: return 0;
! 4161: }
! 4162: break;
! 4163:
! 4164: case HARDWARE:
! 4165: token = next_token (&val, (unsigned *)0, cfile);
! 4166: if (!expression_allocate (expr, MDL))
! 4167: log_fatal ("can't allocate expression");
! 4168: (*expr) -> op = expr_hardware;
! 4169: break;
! 4170:
! 4171: case LEASED_ADDRESS:
! 4172: token = next_token (&val, (unsigned *)0, cfile);
! 4173: if (!expression_allocate (expr, MDL))
! 4174: log_fatal ("can't allocate expression");
! 4175: (*expr) -> op = expr_leased_address;
! 4176: break;
! 4177:
! 4178: case CLIENT_STATE:
! 4179: token = next_token (&val, (unsigned *)0, cfile);
! 4180: if (!expression_allocate (expr, MDL))
! 4181: log_fatal ("can't allocate expression");
! 4182: (*expr) -> op = expr_client_state;
! 4183: break;
! 4184:
! 4185: case FILENAME:
! 4186: token = next_token (&val, (unsigned *)0, cfile);
! 4187: if (!expression_allocate (expr, MDL))
! 4188: log_fatal ("can't allocate expression");
! 4189: (*expr) -> op = expr_filename;
! 4190: break;
! 4191:
! 4192: case SERVER_NAME:
! 4193: token = next_token (&val, (unsigned *)0, cfile);
! 4194: if (!expression_allocate (expr, MDL))
! 4195: log_fatal ("can't allocate expression");
! 4196: (*expr) -> op = expr_sname;
! 4197: break;
! 4198:
! 4199: case LEASE_TIME:
! 4200: token = next_token (&val, (unsigned *)0, cfile);
! 4201: if (!expression_allocate (expr, MDL))
! 4202: log_fatal ("can't allocate expression");
! 4203: (*expr) -> op = expr_lease_time;
! 4204: break;
! 4205:
! 4206: case TOKEN_NULL:
! 4207: token = next_token (&val, (unsigned *)0, cfile);
! 4208: if (!expression_allocate (expr, MDL))
! 4209: log_fatal ("can't allocate expression");
! 4210: (*expr) -> op = expr_null;
! 4211: break;
! 4212:
! 4213: case HOST_DECL_NAME:
! 4214: token = next_token (&val, (unsigned *)0, cfile);
! 4215: if (!expression_allocate (expr, MDL))
! 4216: log_fatal ("can't allocate expression");
! 4217: (*expr) -> op = expr_host_decl_name;
! 4218: break;
! 4219:
! 4220: case UPDATED_DNS_RR:
! 4221: token = next_token (&val, (unsigned *)0, cfile);
! 4222:
! 4223: token = next_token (&val, (unsigned *)0, cfile);
! 4224: if (token != LPAREN)
! 4225: goto nolparen;
! 4226:
! 4227: token = next_token (&val, (unsigned *)0, cfile);
! 4228: if (token != STRING) {
! 4229: parse_warn (cfile, "expecting string.");
! 4230: bad_rrtype:
! 4231: *lose = 1;
! 4232: return 0;
! 4233: }
! 4234: if (!strcasecmp (val, "a"))
! 4235: s = "ddns-fwd-name";
! 4236: else if (!strcasecmp (val, "ptr"))
! 4237: s = "ddns-rev-name";
! 4238: else {
! 4239: parse_warn (cfile, "invalid DNS rrtype: %s", val);
! 4240: goto bad_rrtype;
! 4241: }
! 4242:
! 4243: token = next_token (&val, (unsigned *)0, cfile);
! 4244: if (token != RPAREN)
! 4245: goto norparen;
! 4246:
! 4247: if (!expression_allocate (expr, MDL))
! 4248: log_fatal ("can't allocate expression");
! 4249: (*expr) -> op = expr_variable_reference;
! 4250: (*expr) -> data.variable =
! 4251: dmalloc (strlen (s) + 1, MDL);
! 4252: if (!(*expr) -> data.variable)
! 4253: log_fatal ("can't allocate variable name.");
! 4254: strcpy ((*expr) -> data.variable, s);
! 4255: break;
! 4256:
! 4257: case PACKET:
! 4258: token = next_token (&val, (unsigned *)0, cfile);
! 4259: if (!expression_allocate (expr, MDL))
! 4260: log_fatal ("can't allocate expression");
! 4261: (*expr) -> op = expr_packet;
! 4262:
! 4263: token = next_token (&val, (unsigned *)0, cfile);
! 4264: if (token != LPAREN)
! 4265: goto nolparen;
! 4266:
! 4267: if (!parse_numeric_expression (&(*expr) -> data.packet.offset,
! 4268: cfile, lose))
! 4269: goto nonum;
! 4270:
! 4271: token = next_token (&val, (unsigned *)0, cfile);
! 4272: if (token != COMMA)
! 4273: goto nocomma;
! 4274:
! 4275: if (!parse_numeric_expression (&(*expr) -> data.packet.len,
! 4276: cfile, lose))
! 4277: goto nonum;
! 4278:
! 4279: token = next_token (&val, (unsigned *)0, cfile);
! 4280: if (token != RPAREN)
! 4281: goto norparen;
! 4282: break;
! 4283:
! 4284: case STRING:
! 4285: token = next_token (&val, &len, cfile);
! 4286: if (!make_const_data (expr, (const unsigned char *)val,
! 4287: len, 1, 1, MDL))
! 4288: log_fatal ("can't make constant string expression.");
! 4289: break;
! 4290:
! 4291: case EXTRACT_INT:
! 4292: token = next_token (&val, (unsigned *)0, cfile);
! 4293: token = next_token (&val, (unsigned *)0, cfile);
! 4294: if (token != LPAREN) {
! 4295: parse_warn (cfile, "left parenthesis expected.");
! 4296: *lose = 1;
! 4297: return 0;
! 4298: }
! 4299:
! 4300: if (!expression_allocate (expr, MDL))
! 4301: log_fatal ("can't allocate expression");
! 4302:
! 4303: if (!parse_data_expression (&(*expr) -> data.extract_int,
! 4304: cfile, lose)) {
! 4305: if (!*lose) {
! 4306: parse_warn (cfile,
! 4307: "expecting data expression.");
! 4308: skip_to_semi (cfile);
! 4309: *lose = 1;
! 4310: }
! 4311: expression_dereference (expr, MDL);
! 4312: return 0;
! 4313: }
! 4314:
! 4315: token = next_token (&val, (unsigned *)0, cfile);
! 4316: if (token != COMMA) {
! 4317: parse_warn (cfile, "comma expected.");
! 4318: *lose = 1;
! 4319: expression_dereference (expr, MDL);
! 4320: return 0;
! 4321: }
! 4322:
! 4323: token = next_token (&val, (unsigned *)0, cfile);
! 4324: if (token != NUMBER) {
! 4325: parse_warn (cfile, "number expected.");
! 4326: *lose = 1;
! 4327: expression_dereference (expr, MDL);
! 4328: return 0;
! 4329: }
! 4330: switch (atoi (val)) {
! 4331: case 8:
! 4332: (*expr) -> op = expr_extract_int8;
! 4333: break;
! 4334:
! 4335: case 16:
! 4336: (*expr) -> op = expr_extract_int16;
! 4337: break;
! 4338:
! 4339: case 32:
! 4340: (*expr) -> op = expr_extract_int32;
! 4341: break;
! 4342:
! 4343: default:
! 4344: parse_warn (cfile,
! 4345: "unsupported integer size %d", atoi (val));
! 4346: *lose = 1;
! 4347: skip_to_semi (cfile);
! 4348: expression_dereference (expr, MDL);
! 4349: return 0;
! 4350: }
! 4351:
! 4352: token = next_token (&val, (unsigned *)0, cfile);
! 4353: if (token != RPAREN) {
! 4354: parse_warn (cfile, "right parenthesis expected.");
! 4355: *lose = 1;
! 4356: expression_dereference (expr, MDL);
! 4357: return 0;
! 4358: }
! 4359: break;
! 4360:
! 4361: case ENCODE_INT:
! 4362: token = next_token (&val, (unsigned *)0, cfile);
! 4363: token = next_token (&val, (unsigned *)0, cfile);
! 4364: if (token != LPAREN) {
! 4365: parse_warn (cfile, "left parenthesis expected.");
! 4366: *lose = 1;
! 4367: return 0;
! 4368: }
! 4369:
! 4370: if (!expression_allocate (expr, MDL))
! 4371: log_fatal ("can't allocate expression");
! 4372:
! 4373: if (!parse_numeric_expression (&(*expr) -> data.encode_int,
! 4374: cfile, lose)) {
! 4375: parse_warn (cfile, "expecting numeric expression.");
! 4376: skip_to_semi (cfile);
! 4377: *lose = 1;
! 4378: expression_dereference (expr, MDL);
! 4379: return 0;
! 4380: }
! 4381:
! 4382: token = next_token (&val, (unsigned *)0, cfile);
! 4383: if (token != COMMA) {
! 4384: parse_warn (cfile, "comma expected.");
! 4385: *lose = 1;
! 4386: expression_dereference (expr, MDL);
! 4387: return 0;
! 4388: }
! 4389:
! 4390: token = next_token (&val, (unsigned *)0, cfile);
! 4391: if (token != NUMBER) {
! 4392: parse_warn (cfile, "number expected.");
! 4393: *lose = 1;
! 4394: expression_dereference (expr, MDL);
! 4395: return 0;
! 4396: }
! 4397: switch (atoi (val)) {
! 4398: case 8:
! 4399: (*expr) -> op = expr_encode_int8;
! 4400: break;
! 4401:
! 4402: case 16:
! 4403: (*expr) -> op = expr_encode_int16;
! 4404: break;
! 4405:
! 4406: case 32:
! 4407: (*expr) -> op = expr_encode_int32;
! 4408: break;
! 4409:
! 4410: default:
! 4411: parse_warn (cfile,
! 4412: "unsupported integer size %d", atoi (val));
! 4413: *lose = 1;
! 4414: skip_to_semi (cfile);
! 4415: expression_dereference (expr, MDL);
! 4416: return 0;
! 4417: }
! 4418:
! 4419: token = next_token (&val, (unsigned *)0, cfile);
! 4420: if (token != RPAREN) {
! 4421: parse_warn (cfile, "right parenthesis expected.");
! 4422: *lose = 1;
! 4423: expression_dereference (expr, MDL);
! 4424: return 0;
! 4425: }
! 4426: break;
! 4427:
! 4428: case NUMBER:
! 4429: /* If we're in a numeric context, this should just be a
! 4430: number, by itself. */
! 4431: if (context == context_numeric ||
! 4432: context == context_data_or_numeric) {
! 4433: next_token (&val, (unsigned *)0, cfile);
! 4434: if (!expression_allocate (expr, MDL))
! 4435: log_fatal ("can't allocate expression");
! 4436: (*expr) -> op = expr_const_int;
! 4437: (*expr) -> data.const_int = atoi (val);
! 4438: break;
! 4439: }
! 4440:
! 4441: case NUMBER_OR_NAME:
! 4442: if (!expression_allocate (expr, MDL))
! 4443: log_fatal ("can't allocate expression");
! 4444:
! 4445: (*expr) -> op = expr_const_data;
! 4446: if (!parse_cshl (&(*expr) -> data.const_data, cfile)) {
! 4447: expression_dereference (expr, MDL);
! 4448: return 0;
! 4449: }
! 4450: break;
! 4451:
! 4452: case NS_FORMERR:
! 4453: known = FORMERR;
! 4454: goto ns_const;
! 4455: ns_const:
! 4456: token = next_token (&val, (unsigned *)0, cfile);
! 4457: if (!expression_allocate (expr, MDL))
! 4458: log_fatal ("can't allocate expression");
! 4459: (*expr) -> op = expr_const_int;
! 4460: (*expr) -> data.const_int = known;
! 4461: break;
! 4462:
! 4463: case NS_NOERROR:
! 4464: known = ISC_R_SUCCESS;
! 4465: goto ns_const;
! 4466:
! 4467: case NS_NOTAUTH:
! 4468: known = ISC_R_NOTAUTH;
! 4469: goto ns_const;
! 4470:
! 4471: case NS_NOTIMP:
! 4472: known = ISC_R_NOTIMPLEMENTED;
! 4473: goto ns_const;
! 4474:
! 4475: case NS_NOTZONE:
! 4476: known = ISC_R_NOTZONE;
! 4477: goto ns_const;
! 4478:
! 4479: case NS_NXDOMAIN:
! 4480: known = ISC_R_NXDOMAIN;
! 4481: goto ns_const;
! 4482:
! 4483: case NS_NXRRSET:
! 4484: known = ISC_R_NXRRSET;
! 4485: goto ns_const;
! 4486:
! 4487: case NS_REFUSED:
! 4488: known = ISC_R_REFUSED;
! 4489: goto ns_const;
! 4490:
! 4491: case NS_SERVFAIL:
! 4492: known = ISC_R_SERVFAIL;
! 4493: goto ns_const;
! 4494:
! 4495: case NS_YXDOMAIN:
! 4496: known = ISC_R_YXDOMAIN;
! 4497: goto ns_const;
! 4498:
! 4499: case NS_YXRRSET:
! 4500: known = ISC_R_YXRRSET;
! 4501: goto ns_const;
! 4502:
! 4503: case BOOTING:
! 4504: known = S_INIT;
! 4505: goto ns_const;
! 4506:
! 4507: case REBOOT:
! 4508: known = S_REBOOTING;
! 4509: goto ns_const;
! 4510:
! 4511: case SELECT:
! 4512: known = S_SELECTING;
! 4513: goto ns_const;
! 4514:
! 4515: case REQUEST:
! 4516: known = S_REQUESTING;
! 4517: goto ns_const;
! 4518:
! 4519: case BOUND:
! 4520: known = S_BOUND;
! 4521: goto ns_const;
! 4522:
! 4523: case RENEW:
! 4524: known = S_RENEWING;
! 4525: goto ns_const;
! 4526:
! 4527: case REBIND:
! 4528: known = S_REBINDING;
! 4529: goto ns_const;
! 4530:
! 4531: case DEFINED:
! 4532: token = next_token (&val, (unsigned *)0, cfile);
! 4533: token = next_token (&val, (unsigned *)0, cfile);
! 4534: if (token != LPAREN)
! 4535: goto nolparen;
! 4536:
! 4537: token = next_token (&val, (unsigned *)0, cfile);
! 4538: if (token != NAME && token != NUMBER_OR_NAME) {
! 4539: parse_warn (cfile, "%s can't be a variable name", val);
! 4540: skip_to_semi (cfile);
! 4541: *lose = 1;
! 4542: return 0;
! 4543: }
! 4544:
! 4545: if (!expression_allocate (expr, MDL))
! 4546: log_fatal ("can't allocate expression");
! 4547: (*expr) -> op = expr_variable_exists;
! 4548: (*expr) -> data.variable = dmalloc (strlen (val) + 1, MDL);
! 4549: if (!(*expr)->data.variable)
! 4550: log_fatal ("can't allocate variable name");
! 4551: strcpy ((*expr) -> data.variable, val);
! 4552: token = next_token (&val, (unsigned *)0, cfile);
! 4553: if (token != RPAREN)
! 4554: goto norparen;
! 4555: break;
! 4556:
! 4557: case GETHOSTBYNAME:
! 4558: token = next_token(&val, NULL, cfile);
! 4559:
! 4560: token = next_token(NULL, NULL, cfile);
! 4561: if (token != LPAREN)
! 4562: goto nolparen;
! 4563:
! 4564: /* The argument is a quoted string. */
! 4565: token = next_token(&val, NULL, cfile);
! 4566: if (token != STRING) {
! 4567: parse_warn(cfile, "Expecting quoted literal: "
! 4568: "\"foo.example.com\"");
! 4569: skip_to_semi(cfile);
! 4570: *lose = 1;
! 4571: return 0;
! 4572: }
! 4573: if (!make_host_lookup(expr, val))
! 4574: log_fatal("Error creating gethostbyname() internal "
! 4575: "record. (%s:%d)", MDL);
! 4576:
! 4577: token = next_token(NULL, NULL, cfile);
! 4578: if (token != RPAREN)
! 4579: goto norparen;
! 4580: break;
! 4581:
! 4582: /* Not a valid start to an expression... */
! 4583: default:
! 4584: if (token != NAME && token != NUMBER_OR_NAME)
! 4585: return 0;
! 4586:
! 4587: token = next_token (&val, (unsigned *)0, cfile);
! 4588:
! 4589: /* Save the name of the variable being referenced. */
! 4590: cptr = dmalloc (strlen (val) + 1, MDL);
! 4591: if (!cptr)
! 4592: log_fatal ("can't allocate variable name");
! 4593: strcpy (cptr, val);
! 4594:
! 4595: /* Simple variable reference, as far as we can tell. */
! 4596: token = peek_token (&val, (unsigned *)0, cfile);
! 4597: if (token != LPAREN) {
! 4598: if (!expression_allocate (expr, MDL))
! 4599: log_fatal ("can't allocate expression");
! 4600: (*expr) -> op = expr_variable_reference;
! 4601: (*expr) -> data.variable = cptr;
! 4602: break;
! 4603: }
! 4604:
! 4605: token = next_token (&val, (unsigned *)0, cfile);
! 4606: if (!expression_allocate (expr, MDL))
! 4607: log_fatal ("can't allocate expression");
! 4608: (*expr) -> op = expr_funcall;
! 4609: (*expr) -> data.funcall.name = cptr;
! 4610:
! 4611: /* Now parse the argument list. */
! 4612: ep = &(*expr) -> data.funcall.arglist;
! 4613: do {
! 4614: if (!expression_allocate (ep, MDL))
! 4615: log_fatal ("can't allocate expression");
! 4616: (*ep) -> op = expr_arg;
! 4617: if (!parse_expression (&(*ep) -> data.arg.val,
! 4618: cfile, lose, context_any,
! 4619: (struct expression **)0,
! 4620: expr_none)) {
! 4621: if (!*lose) {
! 4622: parse_warn (cfile,
! 4623: "expecting expression.");
! 4624: *lose = 1;
! 4625: }
! 4626: skip_to_semi (cfile);
! 4627: expression_dereference (expr, MDL);
! 4628: return 0;
! 4629: }
! 4630: ep = &((*ep) -> data.arg.next);
! 4631: token = next_token (&val, (unsigned *)0, cfile);
! 4632: } while (token == COMMA);
! 4633: if (token != RPAREN) {
! 4634: parse_warn (cfile, "Right parenthesis expected.");
! 4635: skip_to_semi (cfile);
! 4636: *lose = 1;
! 4637: expression_dereference (expr, MDL);
! 4638: return 0;
! 4639: }
! 4640: break;
! 4641: }
! 4642: return 1;
! 4643: }
! 4644:
! 4645: /* Parse an expression. */
! 4646:
! 4647: int parse_expression (expr, cfile, lose, context, plhs, binop)
! 4648: struct expression **expr;
! 4649: struct parse *cfile;
! 4650: int *lose;
! 4651: enum expression_context context;
! 4652: struct expression **plhs;
! 4653: enum expr_op binop;
! 4654: {
! 4655: enum dhcp_token token;
! 4656: const char *val;
! 4657: struct expression *rhs = (struct expression *)0, *tmp;
! 4658: struct expression *lhs = (struct expression *)0;
! 4659: enum expr_op next_op;
! 4660: enum expression_context
! 4661: lhs_context = context_any,
! 4662: rhs_context = context_any;
! 4663:
! 4664: /* Consume the left hand side we were passed. */
! 4665: if (plhs) {
! 4666: expression_reference (&lhs, *plhs, MDL);
! 4667: expression_dereference (plhs, MDL);
! 4668: }
! 4669:
! 4670: new_rhs:
! 4671: if (!parse_non_binary (&rhs, cfile, lose, context)) {
! 4672: /* If we already have a left-hand side, then it's not
! 4673: okay for there not to be a right-hand side here, so
! 4674: we need to flag it as an error. */
! 4675: if (lhs) {
! 4676: if (!*lose) {
! 4677: parse_warn (cfile,
! 4678: "expecting right-hand side.");
! 4679: *lose = 1;
! 4680: skip_to_semi (cfile);
! 4681: }
! 4682: expression_dereference (&lhs, MDL);
! 4683: }
! 4684: return 0;
! 4685: }
! 4686:
! 4687: /* At this point, rhs contains either an entire subexpression,
! 4688: or at least a left-hand-side. If we do not see a binary token
! 4689: as the next token, we're done with the expression. */
! 4690:
! 4691: token = peek_token (&val, (unsigned *)0, cfile);
! 4692: switch (token) {
! 4693: case BANG:
! 4694: token = next_token (&val, (unsigned *)0, cfile);
! 4695: token = peek_token (&val, (unsigned *)0, cfile);
! 4696: if (token != EQUAL) {
! 4697: parse_warn (cfile, "! in boolean context without =");
! 4698: *lose = 1;
! 4699: skip_to_semi (cfile);
! 4700: if (lhs)
! 4701: expression_dereference (&lhs, MDL);
! 4702: return 0;
! 4703: }
! 4704: next_op = expr_not_equal;
! 4705: context = expression_context (rhs);
! 4706: break;
! 4707:
! 4708: case EQUAL:
! 4709: next_op = expr_equal;
! 4710: context = expression_context (rhs);
! 4711: break;
! 4712:
! 4713: case TILDE:
! 4714: #ifdef HAVE_REGEX_H
! 4715: token = next_token(&val, NULL, cfile);
! 4716: token = peek_token(&val, NULL, cfile);
! 4717:
! 4718: if (token == TILDE)
! 4719: next_op = expr_iregex_match;
! 4720: else if (token == EQUAL)
! 4721: next_op = expr_regex_match;
! 4722: else {
! 4723: parse_warn(cfile, "expecting ~= or ~~ operator");
! 4724: *lose = 1;
! 4725: skip_to_semi(cfile);
! 4726: if (lhs)
! 4727: expression_dereference(&lhs, MDL);
! 4728: return 0;
! 4729: }
! 4730:
! 4731: context = expression_context(rhs);
! 4732: #else
! 4733: parse_warn(cfile, "No support for regex operator.");
! 4734: *lose = 1;
! 4735: skip_to_semi(cfile);
! 4736: if (lhs != NULL)
! 4737: expression_dereference(&lhs, MDL);
! 4738: return 0;
! 4739: #endif
! 4740: break;
! 4741:
! 4742: case AND:
! 4743: next_op = expr_and;
! 4744: context = expression_context (rhs);
! 4745: break;
! 4746:
! 4747: case OR:
! 4748: next_op = expr_or;
! 4749: context = expression_context (rhs);
! 4750: break;
! 4751:
! 4752: case PLUS:
! 4753: next_op = expr_add;
! 4754: context = expression_context (rhs);
! 4755: break;
! 4756:
! 4757: case MINUS:
! 4758: next_op = expr_subtract;
! 4759: context = expression_context (rhs);
! 4760: break;
! 4761:
! 4762: case SLASH:
! 4763: next_op = expr_divide;
! 4764: context = expression_context (rhs);
! 4765: break;
! 4766:
! 4767: case ASTERISK:
! 4768: next_op = expr_multiply;
! 4769: context = expression_context (rhs);
! 4770: break;
! 4771:
! 4772: case PERCENT:
! 4773: next_op = expr_remainder;
! 4774: context = expression_context (rhs);
! 4775: break;
! 4776:
! 4777: case AMPERSAND:
! 4778: next_op = expr_binary_and;
! 4779: context = expression_context (rhs);
! 4780: break;
! 4781:
! 4782: case PIPE:
! 4783: next_op = expr_binary_or;
! 4784: context = expression_context (rhs);
! 4785: break;
! 4786:
! 4787: case CARET:
! 4788: next_op = expr_binary_xor;
! 4789: context = expression_context (rhs);
! 4790: break;
! 4791:
! 4792: default:
! 4793: next_op = expr_none;
! 4794: }
! 4795:
! 4796: /* If we have no lhs yet, we just parsed it. */
! 4797: if (!lhs) {
! 4798: /* If there was no operator following what we just parsed,
! 4799: then we're done - return it. */
! 4800: if (next_op == expr_none) {
! 4801: *expr = rhs;
! 4802: return 1;
! 4803: }
! 4804: lhs = rhs;
! 4805: rhs = (struct expression *)0;
! 4806: binop = next_op;
! 4807: next_token (&val, (unsigned *)0, cfile);
! 4808: goto new_rhs;
! 4809: }
! 4810:
! 4811: /* If the next binary operator is of greater precedence than the
! 4812: * current operator, then rhs we have parsed so far is actually
! 4813: * the lhs of the next operator. To get this value, we have to
! 4814: * recurse.
! 4815: */
! 4816: if (binop != expr_none && next_op != expr_none &&
! 4817: op_precedence (binop, next_op) < 0) {
! 4818:
! 4819: /* Eat the subexpression operator token, which we pass to
! 4820: * parse_expression...we only peek()'d earlier.
! 4821: */
! 4822: token = next_token (&val, (unsigned *)0, cfile);
! 4823:
! 4824: /* Continue parsing of the right hand side with that token. */
! 4825: tmp = rhs;
! 4826: rhs = (struct expression *)0;
! 4827: if (!parse_expression (&rhs, cfile, lose, op_context (next_op),
! 4828: &tmp, next_op)) {
! 4829: if (!*lose) {
! 4830: parse_warn (cfile,
! 4831: "expecting a subexpression");
! 4832: *lose = 1;
! 4833: }
! 4834: return 0;
! 4835: }
! 4836: next_op = expr_none;
! 4837: }
! 4838:
! 4839: if (binop != expr_none) {
! 4840: rhs_context = expression_context(rhs);
! 4841: lhs_context = expression_context(lhs);
! 4842:
! 4843: if ((rhs_context != context_any) && (lhs_context != context_any) &&
! 4844: (rhs_context != lhs_context)) {
! 4845: parse_warn (cfile, "illegal expression relating different types");
! 4846: skip_to_semi (cfile);
! 4847: expression_dereference (&rhs, MDL);
! 4848: expression_dereference (&lhs, MDL);
! 4849: *lose = 1;
! 4850: return 0;
! 4851: }
! 4852:
! 4853: switch(binop) {
! 4854: case expr_not_equal:
! 4855: case expr_equal:
! 4856: if ((rhs_context != context_data_or_numeric) &&
! 4857: (rhs_context != context_data) &&
! 4858: (rhs_context != context_numeric) &&
! 4859: (rhs_context != context_any)) {
! 4860: parse_warn (cfile, "expecting data/numeric expression");
! 4861: skip_to_semi (cfile);
! 4862: expression_dereference (&rhs, MDL);
! 4863: *lose = 1;
! 4864: return 0;
! 4865: }
! 4866: break;
! 4867:
! 4868: case expr_regex_match:
! 4869: #ifdef HAVE_REGEX_H
! 4870: if (expression_context(rhs) != context_data) {
! 4871: parse_warn(cfile, "expecting data expression");
! 4872: skip_to_semi(cfile);
! 4873: expression_dereference(&rhs, MDL);
! 4874: *lose = 1;
! 4875: return 0;
! 4876: }
! 4877: #else
! 4878: /* It should not be possible to attempt to parse the right
! 4879: * hand side of an operator there is no support for.
! 4880: */
! 4881: log_fatal("Impossible condition at %s:%d.", MDL);
! 4882: #endif
! 4883: break;
! 4884:
! 4885: case expr_and:
! 4886: case expr_or:
! 4887: if ((rhs_context != context_boolean) &&
! 4888: (rhs_context != context_any)) {
! 4889: parse_warn (cfile, "expecting boolean expressions");
! 4890: skip_to_semi (cfile);
! 4891: expression_dereference (&rhs, MDL);
! 4892: *lose = 1;
! 4893: return 0;
! 4894: }
! 4895: break;
! 4896:
! 4897: case expr_add:
! 4898: case expr_subtract:
! 4899: case expr_divide:
! 4900: case expr_multiply:
! 4901: case expr_remainder:
! 4902: case expr_binary_and:
! 4903: case expr_binary_or:
! 4904: case expr_binary_xor:
! 4905: if ((rhs_context != context_numeric) &&
! 4906: (rhs_context != context_any)) {
! 4907: parse_warn (cfile, "expecting numeric expressions");
! 4908: skip_to_semi (cfile);
! 4909: expression_dereference (&rhs, MDL);
! 4910: *lose = 1;
! 4911: return 0;
! 4912: }
! 4913: break;
! 4914:
! 4915: default:
! 4916: break;
! 4917: }
! 4918: }
! 4919:
! 4920: /* Now, if we didn't find a binary operator, we're done parsing
! 4921: this subexpression, so combine it with the preceding binary
! 4922: operator and return the result. */
! 4923: if (next_op == expr_none) {
! 4924: if (!expression_allocate (expr, MDL))
! 4925: log_fatal ("Can't allocate expression!");
! 4926:
! 4927: (*expr) -> op = binop;
! 4928: /* All the binary operators' data union members
! 4929: are the same, so we'll cheat and use the member
! 4930: for the equals operator. */
! 4931: (*expr) -> data.equal [0] = lhs;
! 4932: (*expr) -> data.equal [1] = rhs;
! 4933: return 1;
! 4934: }
! 4935:
! 4936: /* Eat the operator token - we now know it was a binary operator... */
! 4937: token = next_token (&val, (unsigned *)0, cfile);
! 4938:
! 4939: /* Now combine the LHS and the RHS using binop. */
! 4940: tmp = (struct expression *)0;
! 4941: if (!expression_allocate (&tmp, MDL))
! 4942: log_fatal ("No memory for equal precedence combination.");
! 4943:
! 4944: /* Store the LHS and RHS. */
! 4945: tmp -> data.equal [0] = lhs;
! 4946: tmp -> data.equal [1] = rhs;
! 4947: tmp -> op = binop;
! 4948:
! 4949: lhs = tmp;
! 4950: tmp = (struct expression *)0;
! 4951: rhs = (struct expression *)0;
! 4952:
! 4953: /* Recursions don't return until we have parsed the end of the
! 4954: expression, so if we recursed earlier, we can now return what
! 4955: we got. */
! 4956: if (next_op == expr_none) {
! 4957: *expr = lhs;
! 4958: return 1;
! 4959: }
! 4960:
! 4961: binop = next_op;
! 4962: goto new_rhs;
! 4963: }
! 4964:
! 4965:
! 4966: int parse_option_data (expr, cfile, lookups, option)
! 4967: struct expression **expr;
! 4968: struct parse *cfile;
! 4969: int lookups;
! 4970: struct option *option;
! 4971: {
! 4972: const char *val;
! 4973: const char *fmt = NULL;
! 4974: struct expression *tmp;
! 4975: enum dhcp_token token;
! 4976:
! 4977: do {
! 4978: /*
! 4979: * Set a flag if this is an array of a simple type (i.e.,
! 4980: * not an array of pairs of IP addresses, or something like
! 4981: * that.
! 4982: */
! 4983: int uniform = 0;
! 4984:
! 4985: and_again:
! 4986: /* Set fmt to start of format for 'A' and one char back
! 4987: * for 'a'.
! 4988: */
! 4989: if ((fmt != NULL) && (fmt != option->format) && (*fmt == 'a'))
! 4990: fmt -= 1;
! 4991: else if ((fmt == NULL) || (*fmt == 'A'))
! 4992: fmt = option->format;
! 4993:
! 4994: /* 'a' means always uniform */
! 4995: if ((fmt[0] != 'Z') && (tolower((unsigned char)fmt[1]) == 'a'))
! 4996: uniform = 1;
! 4997:
! 4998: do {
! 4999: if ((*fmt == 'A') || (*fmt == 'a'))
! 5000: break;
! 5001: if (*fmt == 'o') {
! 5002: /* consume the optional flag */
! 5003: fmt++;
! 5004: continue;
! 5005: }
! 5006:
! 5007: if (fmt[1] == 'o') {
! 5008: /*
! 5009: * A value for the current format is
! 5010: * optional - check to see if the next
! 5011: * token is a semi-colon if so we don't
! 5012: * need to parse it and doing so would
! 5013: * consume the semi-colon which our
! 5014: * caller is expecting to parse
! 5015: */
! 5016: token = peek_token(&val, (unsigned *)0,
! 5017: cfile);
! 5018: if (token == SEMI) {
! 5019: fmt++;
! 5020: continue;
! 5021: }
! 5022: }
! 5023:
! 5024: tmp = *expr;
! 5025: *expr = NULL;
! 5026:
! 5027: if (!parse_option_token(expr, cfile, &fmt, tmp,
! 5028: uniform, lookups)) {
! 5029: if (fmt [1] != 'o') {
! 5030: if (tmp)
! 5031: expression_dereference (&tmp,
! 5032: MDL);
! 5033: return 0;
! 5034: }
! 5035: *expr = tmp;
! 5036: tmp = NULL;
! 5037: }
! 5038: if (tmp)
! 5039: expression_dereference (&tmp, MDL);
! 5040:
! 5041: fmt++;
! 5042: } while (*fmt != '\0');
! 5043:
! 5044: if ((*fmt == 'A') || (*fmt == 'a')) {
! 5045: token = peek_token (&val, (unsigned *)0, cfile);
! 5046: /* Comma means: continue with next element in array */
! 5047: if (token == COMMA) {
! 5048: token = next_token (&val,
! 5049: (unsigned *)0, cfile);
! 5050: continue;
! 5051: }
! 5052: /* no comma: end of array.
! 5053: 'A' or end of string means: leave the loop */
! 5054: if ((*fmt == 'A') || (fmt[1] == '\0'))
! 5055: break;
! 5056: /* 'a' means: go on with next char */
! 5057: if (*fmt == 'a') {
! 5058: fmt++;
! 5059: goto and_again;
! 5060: }
! 5061: }
! 5062: } while ((*fmt == 'A') || (*fmt == 'a'));
! 5063:
! 5064: return 1;
! 5065: }
! 5066:
! 5067: /* option-statement :== identifier DOT identifier <syntax> SEMI
! 5068: | identifier <syntax> SEMI
! 5069:
! 5070: Option syntax is handled specially through format strings, so it
! 5071: would be painful to come up with BNF for it. However, it always
! 5072: starts as above and ends in a SEMI. */
! 5073:
! 5074: int parse_option_statement (result, cfile, lookups, option, op)
! 5075: struct executable_statement **result;
! 5076: struct parse *cfile;
! 5077: int lookups;
! 5078: struct option *option;
! 5079: enum statement_op op;
! 5080: {
! 5081: const char *val;
! 5082: enum dhcp_token token;
! 5083: struct expression *expr = (struct expression *)0;
! 5084: int lose;
! 5085:
! 5086: token = peek_token (&val, (unsigned *)0, cfile);
! 5087: if ((token == SEMI) && (option->format[0] != 'Z')) {
! 5088: /* Eat the semicolon... */
! 5089: /*
! 5090: * XXXSK: I'm not sure why we should ever get here, but we
! 5091: * do during our startup. This confuses things if
! 5092: * we are parsing a zero-length option, so don't
! 5093: * eat the semicolon token in that case.
! 5094: */
! 5095: token = next_token (&val, (unsigned *)0, cfile);
! 5096: } else if (token == EQUAL) {
! 5097: /* Eat the equals sign. */
! 5098: token = next_token (&val, (unsigned *)0, cfile);
! 5099:
! 5100: /* Parse a data expression and use its value for the data. */
! 5101: if (!parse_data_expression (&expr, cfile, &lose)) {
! 5102: /* In this context, we must have an executable
! 5103: statement, so if we found something else, it's
! 5104: still an error. */
! 5105: if (!lose) {
! 5106: parse_warn (cfile,
! 5107: "expecting a data expression.");
! 5108: skip_to_semi (cfile);
! 5109: }
! 5110: return 0;
! 5111: }
! 5112: } else {
! 5113: if (! parse_option_data(&expr, cfile, lookups, option))
! 5114: return 0;
! 5115: }
! 5116:
! 5117: if (!parse_semi (cfile))
! 5118: return 0;
! 5119: if (!executable_statement_allocate (result, MDL))
! 5120: log_fatal ("no memory for option statement.");
! 5121:
! 5122: (*result)->op = op;
! 5123: if (expr && !option_cache (&(*result)->data.option,
! 5124: NULL, expr, option, MDL))
! 5125: log_fatal ("no memory for option cache");
! 5126:
! 5127: if (expr)
! 5128: expression_dereference (&expr, MDL);
! 5129:
! 5130: return 1;
! 5131: }
! 5132:
! 5133: int parse_option_token (rv, cfile, fmt, expr, uniform, lookups)
! 5134: struct expression **rv;
! 5135: struct parse *cfile;
! 5136: const char **fmt;
! 5137: struct expression *expr;
! 5138: int uniform;
! 5139: int lookups;
! 5140: {
! 5141: const char *val;
! 5142: enum dhcp_token token;
! 5143: struct expression *t = (struct expression *)0;
! 5144: unsigned char buf [4];
! 5145: unsigned len;
! 5146: struct iaddr addr;
! 5147: int compress;
! 5148: isc_boolean_t freeval = ISC_FALSE;
! 5149: const char *f, *g;
! 5150: struct enumeration_value *e;
! 5151:
! 5152: switch (**fmt) {
! 5153: case 'U':
! 5154: token = next_token (&val, &len, cfile);
! 5155: if (!is_identifier (token)) {
! 5156: if ((*fmt) [1] != 'o') {
! 5157: parse_warn (cfile, "expecting identifier.");
! 5158: if (token != SEMI)
! 5159: skip_to_semi (cfile);
! 5160: }
! 5161: return 0;
! 5162: }
! 5163: if (!make_const_data (&t, (const unsigned char *)val,
! 5164: len, 1, 1, MDL))
! 5165: log_fatal ("No memory for %s", val);
! 5166: break;
! 5167:
! 5168: case 'E':
! 5169: g = strchr (*fmt, '.');
! 5170: if (!g) {
! 5171: parse_warn (cfile,
! 5172: "malformed encapsulation format (bug!)");
! 5173: skip_to_semi (cfile);
! 5174: return 0;
! 5175: }
! 5176: *fmt = g;
! 5177: case 'X':
! 5178: token = peek_token (&val, (unsigned *)0, cfile);
! 5179: if (token == NUMBER_OR_NAME || token == NUMBER) {
! 5180: if (!expression_allocate (&t, MDL))
! 5181: return 0;
! 5182: if (!parse_cshl (&t -> data.const_data, cfile)) {
! 5183: expression_dereference (&t, MDL);
! 5184: return 0;
! 5185: }
! 5186: t -> op = expr_const_data;
! 5187: } else {
! 5188: token = next_token (&val, &len, cfile);
! 5189:
! 5190: if(token == STRING) {
! 5191: if (!make_const_data (&t,
! 5192: (const unsigned char *)val,
! 5193: len, 1, 1, MDL))
! 5194: log_fatal ("No memory for \"%s\"", val);
! 5195: } else {
! 5196: if ((*fmt) [1] != 'o') {
! 5197: parse_warn (cfile, "expecting string "
! 5198: "or hexadecimal data.");
! 5199: skip_to_semi (cfile);
! 5200: }
! 5201: return 0;
! 5202: }
! 5203: }
! 5204: break;
! 5205:
! 5206: case 'D': /* Domain list... */
! 5207: if ((*fmt)[1] == 'c') {
! 5208: compress = 1;
! 5209: /* Skip the compress-flag atom. */
! 5210: (*fmt)++;
! 5211: } else
! 5212: compress = 0;
! 5213:
! 5214: t = parse_domain_list(cfile, compress);
! 5215:
! 5216: if (!t) {
! 5217: if ((*fmt)[1] != 'o')
! 5218: skip_to_semi(cfile);
! 5219: return 0;
! 5220: }
! 5221:
! 5222: break;
! 5223:
! 5224: case 'd': /* Domain name... */
! 5225: val = parse_host_name (cfile);
! 5226: if (!val) {
! 5227: parse_warn (cfile, "not a valid domain name.");
! 5228: skip_to_semi (cfile);
! 5229: return 0;
! 5230: }
! 5231: len = strlen (val);
! 5232: freeval = ISC_TRUE;
! 5233: goto make_string;
! 5234:
! 5235: case 't': /* Text string... */
! 5236: token = next_token (&val, &len, cfile);
! 5237: if (token != STRING && !is_identifier (token)) {
! 5238: if ((*fmt) [1] != 'o') {
! 5239: parse_warn (cfile, "expecting string.");
! 5240: if (token != SEMI)
! 5241: skip_to_semi (cfile);
! 5242: }
! 5243: return 0;
! 5244: }
! 5245: make_string:
! 5246: if (!make_const_data (&t, (const unsigned char *)val,
! 5247: len, 1, 1, MDL))
! 5248: log_fatal ("No memory for concatenation");
! 5249: if (freeval == ISC_TRUE) {
! 5250: dfree((char *)val, MDL);
! 5251: freeval = ISC_FALSE;
! 5252: }
! 5253: break;
! 5254:
! 5255: case 'N':
! 5256: f = (*fmt) + 1;
! 5257: g = strchr (*fmt, '.');
! 5258: if (!g) {
! 5259: parse_warn (cfile, "malformed %s (bug!)",
! 5260: "enumeration format");
! 5261: foo:
! 5262: skip_to_semi (cfile);
! 5263: return 0;
! 5264: }
! 5265: *fmt = g;
! 5266: token = next_token (&val, (unsigned *)0, cfile);
! 5267: if (!is_identifier (token)) {
! 5268: parse_warn (cfile,
! 5269: "identifier expected");
! 5270: goto foo;
! 5271: }
! 5272: e = find_enumeration_value (f, (*fmt) - f, &len, val);
! 5273: if (!e) {
! 5274: parse_warn (cfile, "unknown value");
! 5275: goto foo;
! 5276: }
! 5277: if (!make_const_data (&t, &e -> value, len, 0, 1, MDL))
! 5278: return 0;
! 5279: break;
! 5280:
! 5281: case 'I': /* IP address or hostname. */
! 5282: if (lookups) {
! 5283: if (!parse_ip_addr_or_hostname (&t, cfile, uniform))
! 5284: return 0;
! 5285: } else {
! 5286: if (!parse_ip_addr (cfile, &addr))
! 5287: return 0;
! 5288: if (!make_const_data (&t, addr.iabuf, addr.len,
! 5289: 0, 1, MDL))
! 5290: return 0;
! 5291: }
! 5292: break;
! 5293:
! 5294: case '6': /* IPv6 address. */
! 5295: if (!parse_ip6_addr(cfile, &addr)) {
! 5296: return 0;
! 5297: }
! 5298: if (!make_const_data(&t, addr.iabuf, addr.len, 0, 1, MDL)) {
! 5299: return 0;
! 5300: }
! 5301: break;
! 5302:
! 5303: case 'T': /* Lease interval. */
! 5304: token = next_token (&val, (unsigned *)0, cfile);
! 5305: if (token != INFINITE)
! 5306: goto check_number;
! 5307: putLong (buf, -1);
! 5308: if (!make_const_data (&t, buf, 4, 0, 1, MDL))
! 5309: return 0;
! 5310: break;
! 5311:
! 5312: case 'L': /* Unsigned 32-bit integer... */
! 5313: case 'l': /* Signed 32-bit integer... */
! 5314: token = next_token (&val, (unsigned *)0, cfile);
! 5315: check_number:
! 5316: if ((token != NUMBER) && (token != NUMBER_OR_NAME)) {
! 5317: need_number:
! 5318: if ((*fmt) [1] != 'o') {
! 5319: parse_warn (cfile, "expecting number.");
! 5320: if (token != SEMI)
! 5321: skip_to_semi (cfile);
! 5322: }
! 5323: return 0;
! 5324: }
! 5325: convert_num (cfile, buf, val, 0, 32);
! 5326: if (!make_const_data (&t, buf, 4, 0, 1, MDL))
! 5327: return 0;
! 5328: break;
! 5329:
! 5330: case 's': /* Signed 16-bit integer. */
! 5331: case 'S': /* Unsigned 16-bit integer. */
! 5332: token = next_token (&val, (unsigned *)0, cfile);
! 5333: if ((token != NUMBER) && (token != NUMBER_OR_NAME))
! 5334: goto need_number;
! 5335: convert_num (cfile, buf, val, 0, 16);
! 5336: if (!make_const_data (&t, buf, 2, 0, 1, MDL))
! 5337: return 0;
! 5338: break;
! 5339:
! 5340: case 'b': /* Signed 8-bit integer. */
! 5341: case 'B': /* Unsigned 8-bit integer. */
! 5342: token = next_token (&val, (unsigned *)0, cfile);
! 5343: if ((token != NUMBER) && (token != NUMBER_OR_NAME))
! 5344: goto need_number;
! 5345: convert_num (cfile, buf, val, 0, 8);
! 5346: if (!make_const_data (&t, buf, 1, 0, 1, MDL))
! 5347: return 0;
! 5348: break;
! 5349:
! 5350: case 'f': /* Boolean flag. */
! 5351: token = next_token (&val, (unsigned *)0, cfile);
! 5352: if (!is_identifier (token)) {
! 5353: if ((*fmt) [1] != 'o')
! 5354: parse_warn (cfile, "expecting identifier.");
! 5355: bad_flag:
! 5356: if ((*fmt) [1] != 'o') {
! 5357: if (token != SEMI)
! 5358: skip_to_semi (cfile);
! 5359: }
! 5360: return 0;
! 5361: }
! 5362: if (!strcasecmp (val, "true")
! 5363: || !strcasecmp (val, "on"))
! 5364: buf [0] = 1;
! 5365: else if (!strcasecmp (val, "false")
! 5366: || !strcasecmp (val, "off"))
! 5367: buf [0] = 0;
! 5368: else if (!strcasecmp (val, "ignore"))
! 5369: buf [0] = 2;
! 5370: else {
! 5371: if ((*fmt) [1] != 'o')
! 5372: parse_warn (cfile, "expecting boolean.");
! 5373: goto bad_flag;
! 5374: }
! 5375: if (!make_const_data (&t, buf, 1, 0, 1, MDL))
! 5376: return 0;
! 5377: break;
! 5378:
! 5379: case 'Z': /* Zero-length option. */
! 5380: token = peek_token (&val, (unsigned *)0, cfile);
! 5381: if (token != SEMI) {
! 5382: parse_warn(cfile, "semicolon expected.");
! 5383: skip_to_semi(cfile);
! 5384: }
! 5385: buf[0] = '\0';
! 5386: if (!make_const_data(&t, /* expression */
! 5387: buf, /* buffer */
! 5388: 0, /* length */
! 5389: 0, /* terminated */
! 5390: 1, /* allocate */
! 5391: MDL))
! 5392: return 0;
! 5393: break;
! 5394:
! 5395: default:
! 5396: parse_warn (cfile, "Bad format '%c' in parse_option_token.",
! 5397: **fmt);
! 5398: skip_to_semi (cfile);
! 5399: return 0;
! 5400: }
! 5401: if (expr) {
! 5402: if (!make_concat (rv, expr, t))
! 5403: return 0;
! 5404: } else
! 5405: expression_reference (rv, t, MDL);
! 5406: expression_dereference (&t, MDL);
! 5407: return 1;
! 5408: }
! 5409:
! 5410: int parse_option_decl (oc, cfile)
! 5411: struct option_cache **oc;
! 5412: struct parse *cfile;
! 5413: {
! 5414: const char *val;
! 5415: int token;
! 5416: u_int8_t buf [4];
! 5417: u_int8_t hunkbuf [1024];
! 5418: unsigned hunkix = 0;
! 5419: const char *fmt, *f;
! 5420: struct option *option=NULL;
! 5421: struct iaddr ip_addr;
! 5422: u_int8_t *dp;
! 5423: const u_int8_t *cdp;
! 5424: unsigned len;
! 5425: int nul_term = 0;
! 5426: struct buffer *bp;
! 5427: int known = 0;
! 5428: int compress;
! 5429: struct expression *express = NULL;
! 5430: struct enumeration_value *e;
! 5431: isc_result_t status;
! 5432:
! 5433: status = parse_option_name (cfile, 0, &known, &option);
! 5434: if (status != ISC_R_SUCCESS || option == NULL)
! 5435: return 0;
! 5436:
! 5437: /* Parse the option data... */
! 5438: do {
! 5439: for (fmt = option -> format; *fmt; fmt++) {
! 5440: if (*fmt == 'A')
! 5441: break;
! 5442: if (*fmt == 'o' && fmt != option -> format)
! 5443: continue;
! 5444: switch (*fmt) {
! 5445: case 'E':
! 5446: fmt = strchr (fmt, '.');
! 5447: if (!fmt) {
! 5448: parse_warn (cfile,
! 5449: "malformed %s (bug!)",
! 5450: "encapsulation format");
! 5451: goto parse_exit;
! 5452: }
! 5453: case 'X':
! 5454: len = parse_X (cfile, &hunkbuf [hunkix],
! 5455: sizeof hunkbuf - hunkix);
! 5456: hunkix += len;
! 5457: break;
! 5458:
! 5459: case 't': /* Text string... */
! 5460: token = peek_token (&val,
! 5461: &len, cfile);
! 5462: if (token == SEMI && fmt[1] == 'o') {
! 5463: fmt++;
! 5464: break;
! 5465: }
! 5466: token = next_token (&val,
! 5467: &len, cfile);
! 5468: if (token != STRING) {
! 5469: parse_warn (cfile,
! 5470: "expecting string.");
! 5471: goto parse_exit;
! 5472: }
! 5473: if (hunkix + len + 1 > sizeof hunkbuf) {
! 5474: parse_warn (cfile,
! 5475: "option data buffer %s",
! 5476: "overflow");
! 5477: goto parse_exit;
! 5478: }
! 5479: memcpy (&hunkbuf [hunkix], val, len + 1);
! 5480: nul_term = 1;
! 5481: hunkix += len;
! 5482: break;
! 5483:
! 5484: case 'D':
! 5485: if (fmt[1] == 'c') {
! 5486: compress = 1;
! 5487: fmt++;
! 5488: } else
! 5489: compress = 0;
! 5490:
! 5491: express = parse_domain_list(cfile, compress);
! 5492:
! 5493: if (express == NULL)
! 5494: goto exit;
! 5495:
! 5496: if (express->op != expr_const_data) {
! 5497: parse_warn(cfile, "unexpected "
! 5498: "expression");
! 5499: goto parse_exit;
! 5500: }
! 5501:
! 5502: len = express->data.const_data.len;
! 5503: cdp = express->data.const_data.data;
! 5504:
! 5505: if ((hunkix + len) > sizeof(hunkbuf)) {
! 5506: parse_warn(cfile, "option data buffer "
! 5507: "overflow");
! 5508: goto parse_exit;
! 5509: }
! 5510: memcpy(&hunkbuf[hunkix], cdp, len);
! 5511: hunkix += len;
! 5512:
! 5513: expression_dereference(&express, MDL);
! 5514: break;
! 5515:
! 5516: case 'N':
! 5517: f = fmt + 1;
! 5518: fmt = strchr (fmt, '.');
! 5519: if (!fmt) {
! 5520: parse_warn (cfile,
! 5521: "malformed %s (bug!)",
! 5522: "enumeration format");
! 5523: goto parse_exit;
! 5524: }
! 5525: token = next_token (&val,
! 5526: (unsigned *)0, cfile);
! 5527: if (!is_identifier (token)) {
! 5528: parse_warn (cfile,
! 5529: "identifier expected");
! 5530: goto parse_exit;
! 5531: }
! 5532: e = find_enumeration_value (f, fmt - f,
! 5533: &len, val);
! 5534: if (!e) {
! 5535: parse_warn (cfile,
! 5536: "unknown value");
! 5537: goto parse_exit;
! 5538: }
! 5539: dp = &e -> value;
! 5540: goto alloc;
! 5541:
! 5542: case '6':
! 5543: if (!parse_ip6_addr(cfile, &ip_addr))
! 5544: goto exit;
! 5545: len = ip_addr.len;
! 5546: dp = ip_addr.iabuf;
! 5547: goto alloc;
! 5548:
! 5549: case 'I': /* IP address. */
! 5550: if (!parse_ip_addr (cfile, &ip_addr))
! 5551: goto exit;
! 5552: len = ip_addr.len;
! 5553: dp = ip_addr.iabuf;
! 5554:
! 5555: alloc:
! 5556: if (hunkix + len > sizeof hunkbuf) {
! 5557: parse_warn (cfile,
! 5558: "option data buffer %s",
! 5559: "overflow");
! 5560: goto parse_exit;
! 5561: }
! 5562: memcpy (&hunkbuf [hunkix], dp, len);
! 5563: hunkix += len;
! 5564: break;
! 5565:
! 5566: case 'L': /* Unsigned 32-bit integer... */
! 5567: case 'l': /* Signed 32-bit integer... */
! 5568: token = next_token (&val,
! 5569: (unsigned *)0, cfile);
! 5570: if ((token != NUMBER) &&
! 5571: (token != NUMBER_OR_NAME)) {
! 5572: need_number:
! 5573: parse_warn (cfile,
! 5574: "expecting number.");
! 5575: if (token != SEMI)
! 5576: goto parse_exit;
! 5577: else
! 5578: goto exit;
! 5579: }
! 5580: convert_num (cfile, buf, val, 0, 32);
! 5581: len = 4;
! 5582: dp = buf;
! 5583: goto alloc;
! 5584:
! 5585: case 's': /* Signed 16-bit integer. */
! 5586: case 'S': /* Unsigned 16-bit integer. */
! 5587: token = next_token (&val,
! 5588: (unsigned *)0, cfile);
! 5589: if ((token != NUMBER) &&
! 5590: (token != NUMBER_OR_NAME))
! 5591: goto need_number;
! 5592: convert_num (cfile, buf, val, 0, 16);
! 5593: len = 2;
! 5594: dp = buf;
! 5595: goto alloc;
! 5596:
! 5597: case 'b': /* Signed 8-bit integer. */
! 5598: case 'B': /* Unsigned 8-bit integer. */
! 5599: token = next_token (&val,
! 5600: (unsigned *)0, cfile);
! 5601: if ((token != NUMBER) &&
! 5602: (token != NUMBER_OR_NAME))
! 5603: goto need_number;
! 5604: convert_num (cfile, buf, val, 0, 8);
! 5605: len = 1;
! 5606: dp = buf;
! 5607: goto alloc;
! 5608:
! 5609: case 'f': /* Boolean flag. */
! 5610: token = next_token (&val,
! 5611: (unsigned *)0, cfile);
! 5612: if (!is_identifier (token)) {
! 5613: parse_warn (cfile,
! 5614: "expecting identifier.");
! 5615: bad_flag:
! 5616: if (token != SEMI)
! 5617: goto parse_exit;
! 5618: else
! 5619: goto exit;
! 5620: }
! 5621: if (!strcasecmp (val, "true")
! 5622: || !strcasecmp (val, "on"))
! 5623: buf [0] = 1;
! 5624: else if (!strcasecmp (val, "false")
! 5625: || !strcasecmp (val, "off"))
! 5626: buf [0] = 0;
! 5627: else {
! 5628: parse_warn (cfile,
! 5629: "expecting boolean.");
! 5630: goto bad_flag;
! 5631: }
! 5632: len = 1;
! 5633: dp = buf;
! 5634: goto alloc;
! 5635:
! 5636: case 'Z': /* Zero-length option */
! 5637: token = next_token(&val, (unsigned *)0, cfile);
! 5638: if (token != SEMI) {
! 5639: parse_warn(cfile,
! 5640: "semicolon expected.");
! 5641: goto parse_exit;
! 5642: }
! 5643: len = 0;
! 5644: buf[0] = '\0';
! 5645: break;
! 5646:
! 5647: default:
! 5648: log_error ("parse_option_param: Bad format %c",
! 5649: *fmt);
! 5650: goto parse_exit;
! 5651: }
! 5652: }
! 5653: token = next_token (&val, (unsigned *)0, cfile);
! 5654: } while (*fmt == 'A' && token == COMMA);
! 5655:
! 5656: if (token != SEMI) {
! 5657: parse_warn (cfile, "semicolon expected.");
! 5658: goto parse_exit;
! 5659: }
! 5660:
! 5661: bp = (struct buffer *)0;
! 5662: if (!buffer_allocate (&bp, hunkix + nul_term, MDL))
! 5663: log_fatal ("no memory to store option declaration.");
! 5664: if (!bp -> data)
! 5665: log_fatal ("out of memory allocating option data.");
! 5666: memcpy (bp -> data, hunkbuf, hunkix + nul_term);
! 5667:
! 5668: if (!option_cache_allocate (oc, MDL))
! 5669: log_fatal ("out of memory allocating option cache.");
! 5670:
! 5671: (*oc) -> data.buffer = bp;
! 5672: (*oc) -> data.data = &bp -> data [0];
! 5673: (*oc) -> data.terminated = nul_term;
! 5674: (*oc) -> data.len = hunkix;
! 5675: option_reference(&(*oc)->option, option, MDL);
! 5676: option_dereference(&option, MDL);
! 5677: return 1;
! 5678:
! 5679: parse_exit:
! 5680: if (express != NULL)
! 5681: expression_dereference(&express, MDL);
! 5682: skip_to_semi (cfile);
! 5683: exit:
! 5684: option_dereference(&option, MDL);
! 5685:
! 5686: return 0;
! 5687: }
! 5688:
! 5689: /* Consider merging parse_cshl into this. */
! 5690:
! 5691: int parse_X (cfile, buf, max)
! 5692: struct parse *cfile;
! 5693: u_int8_t *buf;
! 5694: unsigned max;
! 5695: {
! 5696: int token;
! 5697: const char *val;
! 5698: unsigned len;
! 5699:
! 5700: token = peek_token (&val, (unsigned *)0, cfile);
! 5701: if (token == NUMBER_OR_NAME || token == NUMBER) {
! 5702: len = 0;
! 5703: do {
! 5704: token = next_token (&val, (unsigned *)0, cfile);
! 5705: if (token != NUMBER && token != NUMBER_OR_NAME) {
! 5706: parse_warn (cfile,
! 5707: "expecting hexadecimal constant.");
! 5708: skip_to_semi (cfile);
! 5709: return 0;
! 5710: }
! 5711: convert_num (cfile, &buf [len], val, 16, 8);
! 5712: if (len++ > max) {
! 5713: parse_warn (cfile,
! 5714: "hexadecimal constant too long.");
! 5715: skip_to_semi (cfile);
! 5716: return 0;
! 5717: }
! 5718: token = peek_token (&val, (unsigned *)0, cfile);
! 5719: if (token == COLON)
! 5720: token = next_token (&val,
! 5721: (unsigned *)0, cfile);
! 5722: } while (token == COLON);
! 5723: val = (char *)buf;
! 5724: } else if (token == STRING) {
! 5725: token = next_token (&val, &len, cfile);
! 5726: if (len + 1 > max) {
! 5727: parse_warn (cfile, "string constant too long.");
! 5728: skip_to_semi (cfile);
! 5729: return 0;
! 5730: }
! 5731: memcpy (buf, val, len + 1);
! 5732: } else {
! 5733: parse_warn (cfile, "expecting string or hexadecimal data");
! 5734: skip_to_semi (cfile);
! 5735: return 0;
! 5736: }
! 5737: return len;
! 5738: }
! 5739:
! 5740: int parse_warn (struct parse *cfile, const char *fmt, ...)
! 5741: {
! 5742: va_list list;
! 5743: char lexbuf [256];
! 5744: char mbuf [1024];
! 5745: char fbuf [1024];
! 5746: unsigned i, lix;
! 5747:
! 5748: do_percentm (mbuf, fmt);
! 5749: /* %Audit% This is log output. %2004.06.17,Safe%
! 5750: * If we truncate we hope the user can get a hint from the log.
! 5751: */
! 5752: snprintf (fbuf, sizeof fbuf, "%s line %d: %s",
! 5753: cfile -> tlname, cfile -> lexline, mbuf);
! 5754:
! 5755: va_start (list, fmt);
! 5756: vsnprintf (mbuf, sizeof mbuf, fbuf, list);
! 5757: va_end (list);
! 5758:
! 5759: lix = 0;
! 5760: for (i = 0;
! 5761: cfile -> token_line [i] && i < (cfile -> lexchar - 1); i++) {
! 5762: if (lix < (sizeof lexbuf) - 1)
! 5763: lexbuf [lix++] = ' ';
! 5764: if (cfile -> token_line [i] == '\t') {
! 5765: for (; lix < (sizeof lexbuf) - 1 && (lix & 7); lix++)
! 5766: lexbuf [lix] = ' ';
! 5767: }
! 5768: }
! 5769: lexbuf [lix] = 0;
! 5770:
! 5771: #ifndef DEBUG
! 5772: syslog (log_priority | LOG_ERR, "%s", mbuf);
! 5773: syslog (log_priority | LOG_ERR, "%s", cfile -> token_line);
! 5774: if (cfile -> lexchar < 81)
! 5775: syslog (log_priority | LOG_ERR, "%s^", lexbuf);
! 5776: #endif
! 5777:
! 5778: if (log_perror) {
! 5779: IGNORE_RET (write (STDERR_FILENO, mbuf, strlen (mbuf)));
! 5780: IGNORE_RET (write (STDERR_FILENO, "\n", 1));
! 5781: IGNORE_RET (write (STDERR_FILENO, cfile -> token_line,
! 5782: strlen (cfile -> token_line)));
! 5783: IGNORE_RET (write (STDERR_FILENO, "\n", 1));
! 5784: if (cfile -> lexchar < 81)
! 5785: IGNORE_RET (write (STDERR_FILENO, lexbuf, lix));
! 5786: IGNORE_RET (write (STDERR_FILENO, "^\n", 2));
! 5787: }
! 5788:
! 5789: cfile -> warnings_occurred = 1;
! 5790:
! 5791: return 0;
! 5792: }
! 5793:
! 5794: struct expression *
! 5795: parse_domain_list(struct parse *cfile, int compress)
! 5796: {
! 5797: const char *val;
! 5798: enum dhcp_token token = SEMI;
! 5799: struct expression *t = NULL;
! 5800: unsigned len, clen = 0;
! 5801: int result;
! 5802: unsigned char compbuf[256 * NS_MAXCDNAME];
! 5803: const unsigned char *dnptrs[256], **lastdnptr;
! 5804:
! 5805: memset(compbuf, 0, sizeof(compbuf));
! 5806: memset(dnptrs, 0, sizeof(dnptrs));
! 5807: dnptrs[0] = compbuf;
! 5808: lastdnptr = &dnptrs[255];
! 5809:
! 5810: do {
! 5811: /* Consume the COMMA token if peeked. */
! 5812: if (token == COMMA)
! 5813: next_token(&val, NULL, cfile);
! 5814:
! 5815: /* Get next (or first) value. */
! 5816: token = next_token(&val, &len, cfile);
! 5817:
! 5818: if (token != STRING) {
! 5819: parse_warn(cfile, "Expecting a domain string.");
! 5820: return NULL;
! 5821: }
! 5822:
! 5823: /* If compression pointers are enabled, compress. If not,
! 5824: * just pack the names in series into the buffer.
! 5825: */
! 5826: if (compress) {
! 5827: result = MRns_name_compress(val, compbuf + clen,
! 5828: sizeof(compbuf) - clen,
! 5829: dnptrs, lastdnptr);
! 5830:
! 5831: if (result < 0) {
! 5832: parse_warn(cfile, "Error compressing domain "
! 5833: "list: %m");
! 5834: return NULL;
! 5835: }
! 5836:
! 5837: clen += result;
! 5838: } else {
! 5839: result = MRns_name_pton(val, compbuf + clen,
! 5840: sizeof(compbuf) - clen);
! 5841:
! 5842: /* result == 1 means the input was fully qualified.
! 5843: * result == 0 means the input wasn't.
! 5844: * result == -1 means bad things.
! 5845: */
! 5846: if (result < 0) {
! 5847: parse_warn(cfile, "Error assembling domain "
! 5848: "list: %m");
! 5849: return NULL;
! 5850: }
! 5851:
! 5852: /*
! 5853: * We need to figure out how many bytes to increment
! 5854: * our buffer pointer since pton doesn't tell us.
! 5855: */
! 5856: while (compbuf[clen] != 0)
! 5857: clen += compbuf[clen] + 1;
! 5858:
! 5859: /* Count the last label (0). */
! 5860: clen++;
! 5861: }
! 5862:
! 5863: if (clen > sizeof(compbuf))
! 5864: log_fatal("Impossible error at %s:%d", MDL);
! 5865:
! 5866: token = peek_token(&val, NULL, cfile);
! 5867: } while (token == COMMA);
! 5868:
! 5869: if (!make_const_data(&t, compbuf, clen, 1, 1, MDL))
! 5870: log_fatal("No memory for domain list object.");
! 5871:
! 5872: return t;
! 5873: }
! 5874:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse.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