1 /* $OpenBSD: parse.c,v 1.11 2004/05/05 23:07:47 deraadt Exp $ */
3 /* Common parser code for dhcpd and dhclient. */
6 * Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of The Internet Software Consortium nor the names
19 * of its contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
23 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
24 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
27 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
30 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
31 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
33 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * This software has been written for the Internet Software Consortium
37 * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
38 * Enterprises. To learn more about the Internet Software Consortium,
39 * see ``http://www.vix.com/isc''. To learn more about Vixie
40 * Enterprises, see ``http://www.vix.com''.
43 #include <sys/cdefs.h>
44 __FBSDID("$FreeBSD$");
49 /* Skip to the semicolon ending the current statement. If we encounter
50 * braces, the matching closing brace terminates the statement. If we
51 * encounter a right brace but haven't encountered a left brace, return
52 * leaving the brace in the token buffer for the caller. If we see a
53 * semicolon and haven't seen a left brace, return. This lets us skip
57 * statement foo bar { }
58 * statement foo bar { statement { } }
64 skip_to_semi(FILE *cfile)
66 int brace_count = 0, token;
70 token = peek_token(&val, cfile);
71 if (token == RBRACE) {
73 token = next_token(&val, cfile);
78 } else if (token == LBRACE) {
80 } else if (token == SEMI && !brace_count) {
81 token = next_token(&val, cfile);
83 } else if (token == '\n') {
85 * EOL only happens when parsing
86 * /etc/resolv.conf, and we treat it like a
87 * semicolon because the resolv.conf file is
90 token = next_token(&val, cfile);
93 token = next_token(&val, cfile);
94 } while (token != EOF);
98 parse_semi(FILE *cfile)
103 token = next_token(&val, cfile);
105 parse_warn("semicolon expected.");
113 * string-parameter :== STRING SEMI
116 parse_string(FILE *cfile)
122 token = next_token(&val, cfile);
123 if (token != STRING) {
124 parse_warn("filename must be a string");
128 valsize = strlen(val) + 1;
131 error("no memory for string %s.", val);
132 memcpy(s, val, valsize);
134 if (!parse_semi(cfile)) {
142 parse_ip_addr(FILE *cfile, struct iaddr *addr)
145 if (parse_numeric_aggregate(cfile, addr->iabuf,
146 &addr->len, DOT, 10, 8))
152 * hardware-parameter :== HARDWARE ETHERNET csns SEMI
153 * csns :== NUMBER | csns COLON NUMBER
156 parse_hardware_param(FILE *cfile, struct hardware *hardware)
162 token = next_token(&val, cfile);
165 hardware->htype = HTYPE_ETHER;
168 hardware->htype = HTYPE_IEEE802;
171 hardware->htype = HTYPE_FDDI;
174 parse_warn("expecting a network hardware type");
180 * Parse the hardware address information. Technically, it
181 * would make a lot of sense to restrict the length of the data
182 * we'll accept here to the length of a particular hardware
183 * address type. Unfortunately, there are some broken clients
184 * out there that put bogus data in the chaddr buffer, and we
185 * accept that data in the lease file rather than simply failing
186 * on such clients. Yuck.
189 t = parse_numeric_aggregate(cfile, NULL, &hlen, COLON, 16, 8);
192 if (hlen > sizeof(hardware->haddr)) {
194 parse_warn("hardware address too long");
196 hardware->hlen = hlen;
197 memcpy((unsigned char *)&hardware->haddr[0], t,
199 if (hlen < sizeof(hardware->haddr))
200 memset(&hardware->haddr[hlen], 0,
201 sizeof(hardware->haddr) - hlen);
205 token = next_token(&val, cfile);
207 parse_warn("expecting semicolon.");
213 * lease-time :== NUMBER SEMI
216 parse_lease_time(FILE *cfile, time_t *timep)
221 token = next_token(&val, cfile);
222 if (token != NUMBER) {
223 parse_warn("Expecting numeric lease time");
227 convert_num((unsigned char *)timep, val, 10, 32);
228 /* Unswap the number - convert_num returns stuff in NBO. */
229 *timep = ntohl(*timep); /* XXX */
235 * No BNF for numeric aggregates - that's defined by the caller. What
236 * this function does is to parse a sequence of numbers separated by the
237 * token specified in separator. If max is zero, any number of numbers
238 * will be parsed; otherwise, exactly max numbers are expected. Base
239 * and size tell us how to internalize the numbers once they've been
243 parse_numeric_aggregate(FILE *cfile, unsigned char *buf, int *max,
244 int separator, int base, int size)
246 unsigned char *bufp = buf, *s = NULL;
247 int token, count = 0;
251 unsigned char *lbufp = NULL;
254 lbufp = bufp = malloc(*max * size / 8);
256 error("can't allocate space for numeric aggregate");
262 token = peek_token(&val, cfile);
263 if (token != separator) {
266 if (token != RBRACE && token != LBRACE)
267 token = next_token(&val, cfile);
268 parse_warn("too few numbers.");
274 token = next_token(&val, cfile);
276 token = next_token(&val, cfile);
279 parse_warn("unexpected end of file");
283 /* Allow NUMBER_OR_NAME if base is 16. */
284 if (token != NUMBER &&
285 (base != 16 || token != NUMBER_OR_NAME)) {
286 parse_warn("expecting numeric value.");
292 * If we can, convert the number now; otherwise, build a
293 * linked list of all the numbers.
296 convert_num(s, val, base, size);
299 valsize = strlen(val) + 1;
302 error("no temp space for number.");
303 memcpy(t, val, valsize);
306 } while (++count != *max);
308 /* If we had to cons up a list, convert it now. */
311 bufp = malloc(count * size / 8);
313 error("can't allocate space for numeric aggregate.");
314 s = bufp + count - size / 8;
319 convert_num(s, (char *)c->car, base, size);
321 /* Free up temp space. */
330 convert_num(unsigned char *buf, char *str, int base, int size)
332 int negative = 0, tval, max;
341 /* If base wasn't specified, figure it out from the data. */
347 } else if (isascii(ptr[1]) && isdigit(ptr[1])) {
358 /* XXX assumes ASCII... */
360 tval = tval - 'a' + 10;
361 else if (tval >= 'A')
362 tval = tval - 'A' + 10;
363 else if (tval >= '0')
366 warning("Bogus number: %s.", str);
370 warning("Bogus number: %s: digit %d not in base %d",
374 val = val * base + tval;
378 max = (1 << (size - 1));
380 max = (1 << (size - 1)) + ((1 << (size - 1)) - 1);
384 warning("value %s%o exceeds max (%d) for precision.",
385 negative ? "-" : "", val, max);
388 warning("value %s%x exceeds max (%d) for precision.",
389 negative ? "-" : "", val, max);
392 warning("value %s%u exceeds max (%d) for precision.",
393 negative ? "-" : "", val, max);
401 *buf = -(unsigned long)val;
404 putShort(buf, -(unsigned long)val);
407 putLong(buf, -(unsigned long)val);
410 warning("Unexpected integer size: %d", size);
416 *buf = (u_int8_t)val;
419 putUShort(buf, (u_int16_t)val);
425 warning("Unexpected integer size: %d", size);
431 * date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER
432 * NUMBER COLON NUMBER COLON NUMBER SEMI
434 * Dates are always in GMT; first number is day of week; next is
435 * year/month/day; next is hours:minutes:seconds on a 24-hour
439 parse_date(FILE *cfile)
441 static int months[11] = { 31, 59, 90, 120, 151, 181,
442 212, 243, 273, 304, 334 };
448 token = next_token(&val, cfile);
449 if (token != NUMBER) {
450 parse_warn("numeric day of week expected.");
455 tm.tm_wday = atoi(val);
458 token = next_token(&val, cfile);
459 if (token != NUMBER) {
460 parse_warn("numeric year expected.");
465 tm.tm_year = atoi(val);
466 if (tm.tm_year > 1900)
469 /* Slash separating year from month... */
470 token = next_token(&val, cfile);
471 if (token != SLASH) {
472 parse_warn("expected slash separating year from month.");
479 token = next_token(&val, cfile);
480 if (token != NUMBER) {
481 parse_warn("numeric month expected.");
486 tm.tm_mon = atoi(val) - 1;
488 /* Slash separating month from day... */
489 token = next_token(&val, cfile);
490 if (token != SLASH) {
491 parse_warn("expected slash separating month from day.");
498 token = next_token(&val, cfile);
499 if (token != NUMBER) {
500 parse_warn("numeric day of month expected.");
505 tm.tm_mday = atoi(val);
508 token = next_token(&val, cfile);
509 if (token != NUMBER) {
510 parse_warn("numeric hour expected.");
515 tm.tm_hour = atoi(val);
517 /* Colon separating hour from minute... */
518 token = next_token(&val, cfile);
519 if (token != COLON) {
520 parse_warn("expected colon separating hour from minute.");
527 token = next_token(&val, cfile);
528 if (token != NUMBER) {
529 parse_warn("numeric minute expected.");
534 tm.tm_min = atoi(val);
536 /* Colon separating minute from second... */
537 token = next_token(&val, cfile);
538 if (token != COLON) {
539 parse_warn("expected colon separating hour from minute.");
546 token = next_token(&val, cfile);
547 if (token != NUMBER) {
548 parse_warn("numeric minute expected.");
553 tm.tm_sec = atoi(val);
556 /* XXX: We assume that mktime does not use tm_yday. */
559 /* Make sure the date ends in a semicolon... */
560 token = next_token(&val, cfile);
562 parse_warn("semicolon expected.");
567 /* Guess the time value... */
568 guess = ((((((365 * (tm.tm_year - 70) + /* Days in years since '70 */
569 (tm.tm_year - 69) / 4 + /* Leap days since '70 */
570 (tm.tm_mon /* Days in months this year */
571 ? months[tm.tm_mon - 1]
573 (tm.tm_mon > 1 && /* Leap day this year */
574 !((tm.tm_year - 72) & 3)) +
575 tm.tm_mday - 1) * 24) + /* Day of month */
577 tm.tm_min) * 60) + tm.tm_sec;
580 * This guess could be wrong because of leap seconds or other
581 * weirdness we don't know about that the system does. For
582 * now, we're just going to accept the guess, but at some point
583 * it might be nice to do a successive approximation here to get
584 * an exact value. Even if the error is small, if the server
585 * is restarted frequently (and thus the lease database is
586 * reread), the error could accumulate into something