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 __FBSDID("$FreeBSD$"); 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 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 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 * 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 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 158 parse_hardware_param(FILE *cfile, struct hardware *hardware) 159 { 160 unsigned char *t; 161 int token, hlen; 162 char *val; 163 164 token = next_token(&val, cfile); 165 switch (token) { 166 case ETHERNET: 167 hardware->htype = HTYPE_ETHER; 168 break; 169 case TOKEN_RING: 170 hardware->htype = HTYPE_IEEE802; 171 break; 172 case FDDI: 173 hardware->htype = HTYPE_FDDI; 174 break; 175 default: 176 parse_warn("expecting a network hardware type"); 177 skip_to_semi(cfile); 178 return; 179 } 180 181 /* 182 * Parse the hardware address information. Technically, it 183 * would make a lot of sense to restrict the length of the data 184 * we'll accept here to the length of a particular hardware 185 * address type. Unfortunately, there are some broken clients 186 * out there that put bogus data in the chaddr buffer, and we 187 * accept that data in the lease file rather than simply failing 188 * on such clients. Yuck. 189 */ 190 hlen = 0; 191 t = parse_numeric_aggregate(cfile, NULL, &hlen, COLON, 16, 8); 192 if (!t) 193 return; 194 if (hlen > sizeof(hardware->haddr)) { 195 free(t); 196 parse_warn("hardware address too long"); 197 } else { 198 hardware->hlen = hlen; 199 memcpy((unsigned char *)&hardware->haddr[0], t, 200 hardware->hlen); 201 if (hlen < sizeof(hardware->haddr)) 202 memset(&hardware->haddr[hlen], 0, 203 sizeof(hardware->haddr) - hlen); 204 free(t); 205 } 206 207 token = next_token(&val, cfile); 208 if (token != SEMI) { 209 parse_warn("expecting semicolon."); 210 skip_to_semi(cfile); 211 } 212 } 213 214 /* 215 * lease-time :== NUMBER SEMI 216 */ 217 void 218 parse_lease_time(FILE *cfile, time_t *timep) 219 { 220 char *val; 221 int token; 222 223 token = next_token(&val, cfile); 224 if (token != NUMBER) { 225 parse_warn("Expecting numeric lease time"); 226 skip_to_semi(cfile); 227 return; 228 } 229 convert_num((unsigned char *)timep, val, 10, 32); 230 /* Unswap the number - convert_num returns stuff in NBO. */ 231 *timep = ntohl(*timep); /* XXX */ 232 233 parse_semi(cfile); 234 } 235 236 /* 237 * No BNF for numeric aggregates - that's defined by the caller. What 238 * this function does is to parse a sequence of numbers separated by the 239 * token specified in separator. If max is zero, any number of numbers 240 * will be parsed; otherwise, exactly max numbers are expected. Base 241 * and size tell us how to internalize the numbers once they've been 242 * tokenized. 243 */ 244 unsigned char * 245 parse_numeric_aggregate(FILE *cfile, unsigned char *buf, int *max, 246 int separator, int base, int size) 247 { 248 unsigned char *bufp = buf, *s = NULL; 249 int token, count = 0; 250 char *val, *t; 251 size_t valsize; 252 pair c = NULL; 253 unsigned char *lbufp = NULL; 254 255 if (!bufp && *max) { 256 lbufp = bufp = malloc(*max * size / 8); 257 if (!bufp) 258 error("can't allocate space for numeric aggregate"); 259 } else 260 s = bufp; 261 262 do { 263 if (count) { 264 token = peek_token(&val, cfile); 265 if (token != separator) { 266 if (!*max) 267 break; 268 if (token != RBRACE && token != LBRACE) 269 token = next_token(&val, cfile); 270 parse_warn("too few numbers."); 271 if (token != SEMI) 272 skip_to_semi(cfile); 273 free(lbufp); 274 return (NULL); 275 } 276 token = next_token(&val, cfile); 277 } 278 token = next_token(&val, cfile); 279 280 if (token == EOF) { 281 parse_warn("unexpected end of file"); 282 break; 283 } 284 285 /* Allow NUMBER_OR_NAME if base is 16. */ 286 if (token != NUMBER && 287 (base != 16 || token != NUMBER_OR_NAME)) { 288 parse_warn("expecting numeric value."); 289 skip_to_semi(cfile); 290 free(lbufp); 291 return (NULL); 292 } 293 /* 294 * If we can, convert the number now; otherwise, build a 295 * linked list of all the numbers. 296 */ 297 if (s) { 298 convert_num(s, val, base, size); 299 s += size / 8; 300 } else { 301 valsize = strlen(val) + 1; 302 t = malloc(valsize); 303 if (!t) 304 error("no temp space for number."); 305 memcpy(t, val, valsize); 306 c = cons(t, c); 307 } 308 } while (++count != *max); 309 310 /* If we had to cons up a list, convert it now. */ 311 if (c) { 312 free(lbufp); 313 bufp = malloc(count * size / 8); 314 if (!bufp) 315 error("can't allocate space for numeric aggregate."); 316 s = bufp + count - size / 8; 317 *max = count; 318 } 319 while (c) { 320 pair cdr = c->cdr; 321 convert_num(s, (char *)c->car, base, size); 322 s -= size / 8; 323 /* Free up temp space. */ 324 free(c->car); 325 free(c); 326 c = cdr; 327 } 328 return (bufp); 329 } 330 331 void 332 convert_num(unsigned char *buf, char *str, int base, int size) 333 { 334 int negative = 0, tval, max; 335 u_int32_t val = 0; 336 char *ptr = str; 337 338 if (*ptr == '-') { 339 negative = 1; 340 ptr++; 341 } 342 343 /* If base wasn't specified, figure it out from the data. */ 344 if (!base) { 345 if (ptr[0] == '0') { 346 if (ptr[1] == 'x') { 347 base = 16; 348 ptr += 2; 349 } else if (isascii(ptr[1]) && isdigit(ptr[1])) { 350 base = 8; 351 ptr += 1; 352 } else 353 base = 10; 354 } else 355 base = 10; 356 } 357 358 do { 359 tval = *ptr++; 360 /* XXX assumes ASCII... */ 361 if (tval >= 'a') 362 tval = tval - 'a' + 10; 363 else if (tval >= 'A') 364 tval = tval - 'A' + 10; 365 else if (tval >= '0') 366 tval -= '0'; 367 else { 368 warning("Bogus number: %s.", str); 369 break; 370 } 371 if (tval >= base) { 372 warning("Bogus number: %s: digit %d not in base %d", 373 str, tval, base); 374 break; 375 } 376 val = val * base + tval; 377 } while (*ptr); 378 379 if (negative) 380 max = (1 << (size - 1)); 381 else 382 max = (1 << (size - 1)) + ((1 << (size - 1)) - 1); 383 if (val > max) { 384 switch (base) { 385 case 8: 386 warning("value %s%o exceeds max (%d) for precision.", 387 negative ? "-" : "", val, max); 388 break; 389 case 16: 390 warning("value %s%x exceeds max (%d) for precision.", 391 negative ? "-" : "", val, max); 392 break; 393 default: 394 warning("value %s%u exceeds max (%d) for precision.", 395 negative ? "-" : "", val, max); 396 break; 397 } 398 } 399 400 if (negative) 401 switch (size) { 402 case 8: 403 *buf = -(unsigned long)val; 404 break; 405 case 16: 406 putShort(buf, -(unsigned long)val); 407 break; 408 case 32: 409 putLong(buf, -(unsigned long)val); 410 break; 411 default: 412 warning("Unexpected integer size: %d", size); 413 break; 414 } 415 else 416 switch (size) { 417 case 8: 418 *buf = (u_int8_t)val; 419 break; 420 case 16: 421 putUShort(buf, (u_int16_t)val); 422 break; 423 case 32: 424 putULong(buf, val); 425 break; 426 default: 427 warning("Unexpected integer size: %d", size); 428 break; 429 } 430 } 431 432 /* 433 * date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER 434 * NUMBER COLON NUMBER COLON NUMBER SEMI 435 * 436 * Dates are always in GMT; first number is day of week; next is 437 * year/month/day; next is hours:minutes:seconds on a 24-hour 438 * clock. 439 */ 440 time_t 441 parse_date(FILE *cfile) 442 { 443 static int months[11] = { 31, 59, 90, 120, 151, 181, 444 212, 243, 273, 304, 334 }; 445 int guess, token; 446 struct tm tm; 447 char *val; 448 449 /* Day of week... */ 450 token = next_token(&val, cfile); 451 if (token != NUMBER) { 452 parse_warn("numeric day of week expected."); 453 if (token != SEMI) 454 skip_to_semi(cfile); 455 return (0); 456 } 457 tm.tm_wday = atoi(val); 458 459 /* Year... */ 460 token = next_token(&val, cfile); 461 if (token != NUMBER) { 462 parse_warn("numeric year expected."); 463 if (token != SEMI) 464 skip_to_semi(cfile); 465 return (0); 466 } 467 tm.tm_year = atoi(val); 468 if (tm.tm_year > 1900) 469 tm.tm_year -= 1900; 470 471 /* Slash separating year from month... */ 472 token = next_token(&val, cfile); 473 if (token != SLASH) { 474 parse_warn("expected slash separating year from month."); 475 if (token != SEMI) 476 skip_to_semi(cfile); 477 return (0); 478 } 479 480 /* Month... */ 481 token = next_token(&val, cfile); 482 if (token != NUMBER) { 483 parse_warn("numeric month expected."); 484 if (token != SEMI) 485 skip_to_semi(cfile); 486 return (0); 487 } 488 tm.tm_mon = atoi(val) - 1; 489 490 /* Slash separating month from day... */ 491 token = next_token(&val, cfile); 492 if (token != SLASH) { 493 parse_warn("expected slash separating month from day."); 494 if (token != SEMI) 495 skip_to_semi(cfile); 496 return (0); 497 } 498 499 /* Month... */ 500 token = next_token(&val, cfile); 501 if (token != NUMBER) { 502 parse_warn("numeric day of month expected."); 503 if (token != SEMI) 504 skip_to_semi(cfile); 505 return (0); 506 } 507 tm.tm_mday = atoi(val); 508 509 /* Hour... */ 510 token = next_token(&val, cfile); 511 if (token != NUMBER) { 512 parse_warn("numeric hour expected."); 513 if (token != SEMI) 514 skip_to_semi(cfile); 515 return (0); 516 } 517 tm.tm_hour = atoi(val); 518 519 /* Colon separating hour from minute... */ 520 token = next_token(&val, cfile); 521 if (token != COLON) { 522 parse_warn("expected colon separating hour from minute."); 523 if (token != SEMI) 524 skip_to_semi(cfile); 525 return (0); 526 } 527 528 /* Minute... */ 529 token = next_token(&val, cfile); 530 if (token != NUMBER) { 531 parse_warn("numeric minute expected."); 532 if (token != SEMI) 533 skip_to_semi(cfile); 534 return (0); 535 } 536 tm.tm_min = atoi(val); 537 538 /* Colon separating minute from second... */ 539 token = next_token(&val, cfile); 540 if (token != COLON) { 541 parse_warn("expected colon separating hour from minute."); 542 if (token != SEMI) 543 skip_to_semi(cfile); 544 return (0); 545 } 546 547 /* Minute... */ 548 token = next_token(&val, cfile); 549 if (token != NUMBER) { 550 parse_warn("numeric minute expected."); 551 if (token != SEMI) 552 skip_to_semi(cfile); 553 return (0); 554 } 555 tm.tm_sec = atoi(val); 556 tm.tm_isdst = 0; 557 558 /* XXX: We assume that mktime does not use tm_yday. */ 559 tm.tm_yday = 0; 560 561 /* Make sure the date ends in a semicolon... */ 562 token = next_token(&val, cfile); 563 if (token != SEMI) { 564 parse_warn("semicolon expected."); 565 skip_to_semi(cfile); 566 return (0); 567 } 568 569 /* Guess the time value... */ 570 guess = ((((((365 * (tm.tm_year - 70) + /* Days in years since '70 */ 571 (tm.tm_year - 69) / 4 + /* Leap days since '70 */ 572 (tm.tm_mon /* Days in months this year */ 573 ? months[tm.tm_mon - 1] 574 : 0) + 575 (tm.tm_mon > 1 && /* Leap day this year */ 576 !((tm.tm_year - 72) & 3)) + 577 tm.tm_mday - 1) * 24) + /* Day of month */ 578 tm.tm_hour) * 60) + 579 tm.tm_min) * 60) + tm.tm_sec; 580 581 /* 582 * This guess could be wrong because of leap seconds or other 583 * weirdness we don't know about that the system does. For 584 * now, we're just going to accept the guess, but at some point 585 * it might be nice to do a successive approximation here to get 586 * an exact value. Even if the error is small, if the server 587 * is restarted frequently (and thus the lease database is 588 * reread), the error could accumulate into something 589 * significant. 590 */ 591 return (guess); 592 } 593