1 /* $OpenBSD: parse.c,v 1.11 2004/05/05 23:07:47 deraadt Exp $ */
2
3 /* Common parser code for dhcpd and dhclient. */
4
5 /*-
6 * SPDX-License-Identifier: BSD-3-Clause
7 *
8 * Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 *
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of The Internet Software Consortium nor the names
21 * of its contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
25 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
26 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
29 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
32 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
33 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
34 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
35 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * This software has been written for the Internet Software Consortium
39 * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
40 * Enterprises. To learn more about the Internet Software Consortium,
41 * see ``http://www.vix.com/isc''. To learn more about Vixie
42 * Enterprises, see ``http://www.vix.com''.
43 */
44
45 #include <sys/cdefs.h>
46 #include <stdbool.h>
47
48 #include "dhcpd.h"
49 #include "dhctoken.h"
50
51 /* Skip to the semicolon ending the current statement. If we encounter
52 * braces, the matching closing brace terminates the statement. If we
53 * encounter a right brace but haven't encountered a left brace, return
54 * leaving the brace in the token buffer for the caller. If we see a
55 * semicolon and haven't seen a left brace, return. This lets us skip
56 * over:
57 *
58 * statement;
59 * statement foo bar { }
60 * statement foo bar { statement { } }
61 * statement}
62 *
63 * ...et cetera.
64 */
65 void
skip_to_semi(FILE * cfile)66 skip_to_semi(FILE *cfile)
67 {
68 int brace_count = 0, token;
69 char *val;
70
71 do {
72 token = peek_token(&val, cfile);
73 if (token == RBRACE) {
74 if (brace_count) {
75 token = next_token(&val, cfile);
76 if (!--brace_count)
77 return;
78 } else
79 return;
80 } else if (token == LBRACE) {
81 brace_count++;
82 } else if (token == SEMI && !brace_count) {
83 token = next_token(&val, cfile);
84 return;
85 } else if (token == '\n') {
86 /*
87 * EOL only happens when parsing
88 * /etc/resolv.conf, and we treat it like a
89 * semicolon because the resolv.conf file is
90 * line-oriented.
91 */
92 token = next_token(&val, cfile);
93 return;
94 }
95 token = next_token(&val, cfile);
96 } while (token != EOF);
97 }
98
99 int
parse_semi(FILE * cfile)100 parse_semi(FILE *cfile)
101 {
102 int token;
103 char *val;
104
105 token = next_token(&val, cfile);
106 if (token != SEMI) {
107 parse_warn("semicolon expected.");
108 skip_to_semi(cfile);
109 return (0);
110 }
111 return (1);
112 }
113
114 /*
115 * string-parameter :== STRING SEMI
116 */
117 char *
parse_string(FILE * cfile)118 parse_string(FILE *cfile)
119 {
120 char *val, *s;
121 size_t valsize;
122 int token;
123
124 token = next_token(&val, cfile);
125 if (token != STRING) {
126 parse_warn("filename must be a string");
127 skip_to_semi(cfile);
128 return (NULL);
129 }
130 valsize = strlen(val) + 1;
131 s = malloc(valsize);
132 if (!s)
133 error("no memory for string %s.", val);
134 memcpy(s, val, valsize);
135
136 if (!parse_semi(cfile)) {
137 free(s);
138 return (NULL);
139 }
140 return (s);
141 }
142
143 int
parse_ip_addr(FILE * cfile,struct iaddr * addr)144 parse_ip_addr(FILE *cfile, struct iaddr *addr)
145 {
146 addr->len = 4;
147 if (parse_numeric_aggregate(cfile, addr->iabuf,
148 &addr->len, DOT, 10, 8))
149 return (1);
150 return (0);
151 }
152
153 /*
154 * hardware-parameter :== HARDWARE ETHERNET csns SEMI
155 * csns :== NUMBER | csns COLON NUMBER
156 */
157 void
parse_hardware_param(FILE * cfile,struct hardware * hardware)158 parse_hardware_param(FILE *cfile, struct hardware *hardware)
159 {
160 unsigned char *t;
161 int token;
162 size_t hlen;
163 char *val;
164
165 token = next_token(&val, cfile);
166 switch (token) {
167 case ETHERNET:
168 hardware->htype = HTYPE_ETHER;
169 break;
170 case TOKEN_RING:
171 hardware->htype = HTYPE_IEEE802;
172 break;
173 case FDDI:
174 hardware->htype = HTYPE_FDDI;
175 break;
176 default:
177 parse_warn("expecting a network hardware type");
178 skip_to_semi(cfile);
179 return;
180 }
181
182 /*
183 * Parse the hardware address information. Technically, it
184 * would make a lot of sense to restrict the length of the data
185 * we'll accept here to the length of a particular hardware
186 * address type. Unfortunately, there are some broken clients
187 * out there that put bogus data in the chaddr buffer, and we
188 * accept that data in the lease file rather than simply failing
189 * on such clients. Yuck.
190 */
191 hlen = 0;
192 t = parse_numeric_aggregate(cfile, NULL, &hlen, COLON, 16, 8);
193 if (!t)
194 return;
195 if (hlen > sizeof(hardware->haddr)) {
196 free(t);
197 parse_warn("hardware address too long");
198 } else {
199 hardware->hlen = hlen;
200 memcpy((unsigned char *)&hardware->haddr[0], t,
201 hardware->hlen);
202 if (hlen < sizeof(hardware->haddr))
203 memset(&hardware->haddr[hlen], 0,
204 sizeof(hardware->haddr) - hlen);
205 free(t);
206 }
207
208 token = next_token(&val, cfile);
209 if (token != SEMI) {
210 parse_warn("expecting semicolon.");
211 skip_to_semi(cfile);
212 }
213 }
214
215 /*
216 * lease-time :== NUMBER SEMI
217 */
218 void
parse_lease_time(FILE * cfile,time_t * timep)219 parse_lease_time(FILE *cfile, time_t *timep)
220 {
221 char *val;
222 int token;
223
224 token = next_token(&val, cfile);
225 if (token != NUMBER) {
226 parse_warn("Expecting numeric lease time");
227 skip_to_semi(cfile);
228 return;
229 }
230 convert_num((unsigned char *)timep, val, 10, 32);
231 /* Unswap the number - convert_num returns stuff in NBO. */
232 *timep = ntohl(*timep); /* XXX */
233
234 parse_semi(cfile);
235 }
236
237 /*
238 * No BNF for numeric aggregates - that's defined by the caller. What
239 * this function does is to parse a sequence of numbers separated by the
240 * token specified in separator. If max is zero, any number of numbers
241 * will be parsed; otherwise, exactly max numbers are expected. Base
242 * and size tell us how to internalize the numbers once they've been
243 * tokenized.
244 */
245 unsigned char *
parse_numeric_aggregate(FILE * cfile,unsigned char * buf,size_t * max,int separator,unsigned base,int size)246 parse_numeric_aggregate(FILE *cfile, unsigned char *buf, size_t *max,
247 int separator, unsigned base, int size)
248 {
249 unsigned char *bufp = buf, *s = NULL;
250 int token;
251 char *val, *t;
252 size_t valsize, count = 0;
253 pair c = NULL;
254 unsigned char *lbufp = NULL;
255
256 if (!bufp && *max) {
257 lbufp = bufp = malloc(*max * size / 8);
258 if (!bufp)
259 error("can't allocate space for numeric aggregate");
260 } else
261 s = bufp;
262
263 do {
264 if (count) {
265 token = peek_token(&val, cfile);
266 if (token != separator) {
267 if (!*max)
268 break;
269 if (token != RBRACE && token != LBRACE)
270 token = next_token(&val, cfile);
271 parse_warn("too few numbers.");
272 if (token != SEMI)
273 skip_to_semi(cfile);
274 free(lbufp);
275 return (NULL);
276 }
277 token = next_token(&val, cfile);
278 }
279 token = next_token(&val, cfile);
280
281 if (token == EOF) {
282 parse_warn("unexpected end of file");
283 break;
284 }
285
286 /* Allow NUMBER_OR_NAME if base is 16. */
287 if (token != NUMBER &&
288 (base != 16 || token != NUMBER_OR_NAME)) {
289 parse_warn("expecting numeric value.");
290 skip_to_semi(cfile);
291 free(lbufp);
292 return (NULL);
293 }
294 /*
295 * If we can, convert the number now; otherwise, build a
296 * linked list of all the numbers.
297 */
298 if (s) {
299 convert_num(s, val, base, size);
300 s += size / 8;
301 } else {
302 valsize = strlen(val) + 1;
303 t = malloc(valsize);
304 if (!t)
305 error("no temp space for number.");
306 memcpy(t, val, valsize);
307 c = cons(t, c);
308 }
309 } while (++count != *max);
310
311 /* If we had to cons up a list, convert it now. */
312 if (c) {
313 free(lbufp);
314 bufp = malloc(count * size / 8);
315 if (!bufp)
316 error("can't allocate space for numeric aggregate.");
317 s = bufp + count - size / 8;
318 *max = count;
319 }
320 while (c) {
321 pair cdr = c->cdr;
322 convert_num(s, (char *)c->car, base, size);
323 s -= size / 8;
324 /* Free up temp space. */
325 free(c->car);
326 free(c);
327 c = cdr;
328 }
329 return (bufp);
330 }
331
332 void
convert_num(unsigned char * buf,char * str,unsigned base,int size)333 convert_num(unsigned char *buf, char *str, unsigned base, int size)
334 {
335 bool negative = false;
336 unsigned tval, max;
337 u_int32_t val = 0;
338 char *ptr = str;
339
340 if (*ptr == '-') {
341 negative = true;
342 ptr++;
343 }
344
345 /* If base wasn't specified, figure it out from the data. */
346 if (!base) {
347 if (ptr[0] == '0') {
348 if (ptr[1] == 'x') {
349 base = 16;
350 ptr += 2;
351 } else if (isascii(ptr[1]) && isdigit(ptr[1])) {
352 base = 8;
353 ptr += 1;
354 } else
355 base = 10;
356 } else
357 base = 10;
358 }
359
360 do {
361 tval = *ptr++;
362 /* XXX assumes ASCII... */
363 if (tval >= 'a')
364 tval = tval - 'a' + 10;
365 else if (tval >= 'A')
366 tval = tval - 'A' + 10;
367 else if (tval >= '0')
368 tval -= '0';
369 else {
370 warning("Bogus number: %s.", str);
371 break;
372 }
373 if (tval >= base) {
374 warning("Bogus number: %s: digit %d not in base %d",
375 str, tval, base);
376 break;
377 }
378 val = val * base + tval;
379 } while (*ptr);
380
381 if (negative)
382 max = (1 << (size - 1));
383 else
384 max = (1 << (size - 1)) + ((1 << (size - 1)) - 1);
385 if (val > max) {
386 switch (base) {
387 case 8:
388 warning("value %s%o exceeds max (%d) for precision.",
389 negative ? "-" : "", val, max);
390 break;
391 case 16:
392 warning("value %s%x exceeds max (%d) for precision.",
393 negative ? "-" : "", val, max);
394 break;
395 default:
396 warning("value %s%u exceeds max (%d) for precision.",
397 negative ? "-" : "", val, max);
398 break;
399 }
400 }
401
402 if (negative)
403 switch (size) {
404 case 8:
405 *buf = -(unsigned long)val;
406 break;
407 case 16:
408 putShort(buf, -(unsigned long)val);
409 break;
410 case 32:
411 putLong(buf, -(unsigned long)val);
412 break;
413 default:
414 warning("Unexpected integer size: %d", size);
415 break;
416 }
417 else
418 switch (size) {
419 case 8:
420 *buf = (u_int8_t)val;
421 break;
422 case 16:
423 putUShort(buf, (u_int16_t)val);
424 break;
425 case 32:
426 putULong(buf, val);
427 break;
428 default:
429 warning("Unexpected integer size: %d", size);
430 break;
431 }
432 }
433
434 /*
435 * date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER
436 * NUMBER COLON NUMBER COLON NUMBER SEMI
437 *
438 * Dates are always in GMT; first number is day of week; next is
439 * year/month/day; next is hours:minutes:seconds on a 24-hour
440 * clock.
441 */
442 time_t
parse_date(FILE * cfile)443 parse_date(FILE *cfile)
444 {
445 static int months[11] = { 31, 59, 90, 120, 151, 181,
446 212, 243, 273, 304, 334 };
447 int guess, token;
448 struct tm tm;
449 char *val;
450
451 /* Day of week... */
452 token = next_token(&val, cfile);
453 if (token != NUMBER) {
454 parse_warn("numeric day of week expected.");
455 if (token != SEMI)
456 skip_to_semi(cfile);
457 return (0);
458 }
459 tm.tm_wday = atoi(val);
460
461 /* Year... */
462 token = next_token(&val, cfile);
463 if (token != NUMBER) {
464 parse_warn("numeric year expected.");
465 if (token != SEMI)
466 skip_to_semi(cfile);
467 return (0);
468 }
469 tm.tm_year = atoi(val);
470 if (tm.tm_year > 1900)
471 tm.tm_year -= 1900;
472
473 /* Slash separating year from month... */
474 token = next_token(&val, cfile);
475 if (token != SLASH) {
476 parse_warn("expected slash separating year from month.");
477 if (token != SEMI)
478 skip_to_semi(cfile);
479 return (0);
480 }
481
482 /* Month... */
483 token = next_token(&val, cfile);
484 if (token != NUMBER) {
485 parse_warn("numeric month expected.");
486 if (token != SEMI)
487 skip_to_semi(cfile);
488 return (0);
489 }
490 tm.tm_mon = atoi(val) - 1;
491
492 /* Slash separating month from day... */
493 token = next_token(&val, cfile);
494 if (token != SLASH) {
495 parse_warn("expected slash separating month from day.");
496 if (token != SEMI)
497 skip_to_semi(cfile);
498 return (0);
499 }
500
501 /* Month... */
502 token = next_token(&val, cfile);
503 if (token != NUMBER) {
504 parse_warn("numeric day of month expected.");
505 if (token != SEMI)
506 skip_to_semi(cfile);
507 return (0);
508 }
509 tm.tm_mday = atoi(val);
510
511 /* Hour... */
512 token = next_token(&val, cfile);
513 if (token != NUMBER) {
514 parse_warn("numeric hour expected.");
515 if (token != SEMI)
516 skip_to_semi(cfile);
517 return (0);
518 }
519 tm.tm_hour = atoi(val);
520
521 /* Colon separating hour from minute... */
522 token = next_token(&val, cfile);
523 if (token != COLON) {
524 parse_warn("expected colon separating hour from minute.");
525 if (token != SEMI)
526 skip_to_semi(cfile);
527 return (0);
528 }
529
530 /* Minute... */
531 token = next_token(&val, cfile);
532 if (token != NUMBER) {
533 parse_warn("numeric minute expected.");
534 if (token != SEMI)
535 skip_to_semi(cfile);
536 return (0);
537 }
538 tm.tm_min = atoi(val);
539
540 /* Colon separating minute from second... */
541 token = next_token(&val, cfile);
542 if (token != COLON) {
543 parse_warn("expected colon separating hour from minute.");
544 if (token != SEMI)
545 skip_to_semi(cfile);
546 return (0);
547 }
548
549 /* Minute... */
550 token = next_token(&val, cfile);
551 if (token != NUMBER) {
552 parse_warn("numeric minute expected.");
553 if (token != SEMI)
554 skip_to_semi(cfile);
555 return (0);
556 }
557 tm.tm_sec = atoi(val);
558 tm.tm_isdst = 0;
559
560 /* XXX: We assume that mktime does not use tm_yday. */
561 tm.tm_yday = 0;
562
563 /* Make sure the date ends in a semicolon... */
564 token = next_token(&val, cfile);
565 if (token != SEMI) {
566 parse_warn("semicolon expected.");
567 skip_to_semi(cfile);
568 return (0);
569 }
570
571 /* Guess the time value... */
572 guess = ((((((365 * (tm.tm_year - 70) + /* Days in years since '70 */
573 (tm.tm_year - 69) / 4 + /* Leap days since '70 */
574 (tm.tm_mon /* Days in months this year */
575 ? months[tm.tm_mon - 1]
576 : 0) +
577 (tm.tm_mon > 1 && /* Leap day this year */
578 !((tm.tm_year - 72) & 3)) +
579 tm.tm_mday - 1) * 24) + /* Day of month */
580 tm.tm_hour) * 60) +
581 tm.tm_min) * 60) + tm.tm_sec;
582
583 /*
584 * This guess could be wrong because of leap seconds or other
585 * weirdness we don't know about that the system does. For
586 * now, we're just going to accept the guess, but at some point
587 * it might be nice to do a successive approximation here to get
588 * an exact value. Even if the error is small, if the server
589 * is restarted frequently (and thus the lease database is
590 * reread), the error could accumulate into something
591 * significant.
592 */
593 return (guess);
594 }
595