1 /* $OpenBSD: parse.c,v 1.16 2013/12/05 22:31:35 krw Exp $ */ 2 3 /* Common parser code for dhcpd and dhclient. */ 4 5 /* 6 * Copyright (c) 1995, 1996, 1997, 1998 The Internet Software Consortium. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 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. 21 * 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 34 * SUCH DAMAGE. 35 * 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''. 41 */ 42 43 #include "dhcpd.h" 44 #include "dhctoken.h" 45 46 /* 47 * Skip to the semicolon ending the current statement. If we encounter 48 * braces, the matching closing brace terminates the statement. If we 49 * encounter a right brace but haven't encountered a left brace, return 50 * leaving the brace in the token buffer for the caller. If we see a 51 * semicolon and haven't seen a left brace, return. This lets us skip 52 * over: 53 * 54 * statement; 55 * statement foo bar { } 56 * statement foo bar { statement { } } 57 * statement} 58 * 59 * ...et cetera. 60 */ 61 void 62 skip_to_semi(FILE *cfile) 63 { 64 int token; 65 char *val; 66 int brace_count = 0; 67 68 do { 69 token = peek_token(&val, cfile); 70 if (token == '}') { 71 if (brace_count) { 72 token = next_token(&val, cfile); 73 if (!--brace_count) 74 return; 75 } else 76 return; 77 } else if (token == '{') { 78 brace_count++; 79 } else if (token == ';' && !brace_count) { 80 token = next_token(&val, cfile); 81 return; 82 } else if (token == '\n') { 83 /* 84 * EOL only happens when parsing 85 * /etc/resolv.conf, and we treat it like a 86 * semicolon because the resolv.conf file is 87 * line-oriented. 88 */ 89 token = next_token(&val, cfile); 90 return; 91 } 92 token = next_token(&val, cfile); 93 } while (token != EOF); 94 } 95 96 int 97 parse_semi(FILE *cfile) 98 { 99 int token; 100 char *val; 101 102 token = next_token(&val, cfile); 103 if (token != ';') { 104 parse_warn("semicolon expected."); 105 skip_to_semi(cfile); 106 return (0); 107 } 108 return (1); 109 } 110 111 /* 112 * string-parameter :== STRING SEMI 113 */ 114 char * 115 parse_string(FILE *cfile) 116 { 117 char *val, *s; 118 int token; 119 120 token = next_token(&val, cfile); 121 if (token != TOK_STRING) { 122 parse_warn("filename must be a string"); 123 skip_to_semi(cfile); 124 return (NULL); 125 } 126 s = strdup(val); 127 if (s == NULL) 128 error("no memory for string %s.", val); 129 130 if (!parse_semi(cfile)) { 131 free(s); 132 return (NULL); 133 } 134 return (s); 135 } 136 137 /* 138 * hostname :== identifier | hostname DOT identifier 139 */ 140 char * 141 parse_host_name(FILE *cfile) 142 { 143 char *val, *s, *t; 144 int token, len = 0; 145 pair c = NULL; 146 147 /* Read a dotted hostname... */ 148 do { 149 /* Read a token, which should be an identifier. */ 150 token = next_token(&val, cfile); 151 if (!is_identifier(token) && token != TOK_NUMBER) { 152 parse_warn("expecting an identifier in hostname"); 153 skip_to_semi(cfile); 154 return (NULL); 155 } 156 /* Store this identifier... */ 157 s = strdup(val); 158 if (s == NULL) 159 error("can't allocate temp space for hostname."); 160 c = cons((caddr_t) s, c); 161 len += strlen(s) + 1; 162 /* 163 * Look for a dot; if it's there, keep going, otherwise 164 * we're done. 165 */ 166 token = peek_token(&val, cfile); 167 if (token == '.') 168 token = next_token(&val, cfile); 169 } while (token == '.'); 170 171 /* Assemble the hostname together into a string. */ 172 if (!(s = malloc(len))) 173 error("can't allocate space for hostname."); 174 t = s + len; 175 *--t = '\0'; 176 while (c) { 177 pair cdr = c->cdr; 178 int l = strlen((char *)c->car); 179 180 t -= l; 181 memcpy(t, (char *)c->car, l); 182 /* Free up temp space. */ 183 free(c->car); 184 free(c); 185 c = cdr; 186 if (t != s) 187 *--t = '.'; 188 } 189 return (s); 190 } 191 192 /* 193 * hardware-parameter :== HARDWARE ETHERNET csns SEMI 194 * csns :== NUMBER | csns COLON NUMBER 195 */ 196 void 197 parse_hardware_param(FILE *cfile, struct hardware *hardware) 198 { 199 char *val; 200 int token, hlen; 201 unsigned char *t; 202 203 token = next_token(&val, cfile); 204 switch (token) { 205 case TOK_ETHERNET: 206 hardware->htype = HTYPE_ETHER; 207 break; 208 break; 209 case TOK_IPSEC_TUNNEL: 210 hardware->htype = HTYPE_IPSEC_TUNNEL; 211 break; 212 default: 213 parse_warn("expecting a network hardware type"); 214 skip_to_semi(cfile); 215 return; 216 } 217 218 /* 219 * Parse the hardware address information. Technically, it 220 * would make a lot of sense to restrict the length of the data 221 * we'll accept here to the length of a particular hardware 222 * address type. Unfortunately, there are some broken clients 223 * out there that put bogus data in the chaddr buffer, and we 224 * accept that data in the lease file rather than simply failing 225 * on such clients. Yuck. 226 */ 227 hlen = 0; 228 t = parse_numeric_aggregate(cfile, NULL, &hlen, ':', 16, 8); 229 if (!t) 230 return; 231 if (hlen > sizeof(hardware->haddr)) { 232 free(t); 233 parse_warn("hardware address too long"); 234 } else { 235 hardware->hlen = hlen; 236 memcpy((unsigned char *)&hardware->haddr[0], t, hardware->hlen); 237 if (hlen < sizeof(hardware->haddr)) 238 memset(&hardware->haddr[hlen], 0, 239 sizeof(hardware->haddr) - hlen); 240 free(t); 241 } 242 243 token = next_token(&val, cfile); 244 if (token != ';') { 245 parse_warn("expecting semicolon."); 246 skip_to_semi(cfile); 247 } 248 } 249 250 /* 251 * lease-time :== NUMBER SEMI 252 */ 253 void 254 parse_lease_time(FILE *cfile, time_t *timep) 255 { 256 char *val; 257 uint32_t value; 258 int token; 259 260 token = next_token(&val, cfile); 261 if (token != TOK_NUMBER) { 262 parse_warn("Expecting numeric lease time"); 263 skip_to_semi(cfile); 264 return; 265 } 266 convert_num((unsigned char *)&value, val, 10, 32); 267 /* Unswap the number - convert_num returns stuff in NBO. */ 268 *timep = ntohl(value); /* XXX */ 269 270 parse_semi(cfile); 271 } 272 273 /* 274 * No BNF for numeric aggregates - that's defined by the caller. What 275 * this function does is to parse a sequence of numbers separated by the 276 * token specified in separator. If max is zero, any number of numbers 277 * will be parsed; otherwise, exactly max numbers are expected. Base 278 * and size tell us how to internalize the numbers once they've been 279 * tokenized. 280 */ 281 unsigned char * 282 parse_numeric_aggregate(FILE *cfile, unsigned char *buf, int *max, 283 int separator, int base, int size) 284 { 285 char *val, *t; 286 int token, count = 0; 287 unsigned char *bufp = buf, *s = NULL; 288 pair c = NULL; 289 290 if (!bufp && *max) { 291 bufp = malloc(*max * size / 8); 292 if (!bufp) 293 error("can't allocate space for numeric aggregate"); 294 } else 295 s = bufp; 296 297 do { 298 if (count) { 299 token = peek_token(&val, cfile); 300 if (token != separator) { 301 if (!*max) 302 break; 303 if (token != '{' && token != '}') 304 token = next_token(&val, cfile); 305 parse_warn("too few numbers."); 306 if (token != ';') 307 skip_to_semi(cfile); 308 return (NULL); 309 } 310 token = next_token(&val, cfile); 311 } 312 token = next_token(&val, cfile); 313 314 if (token == EOF) { 315 parse_warn("unexpected end of file"); 316 break; 317 } 318 /* Allow NUMBER_OR_NAME if base is 16. */ 319 if (token != TOK_NUMBER && 320 (base != 16 || token != TOK_NUMBER_OR_NAME)) { 321 parse_warn("expecting numeric value."); 322 skip_to_semi(cfile); 323 return (NULL); 324 } 325 /* 326 * If we can, convert the number now; otherwise, build a 327 * linked list of all the numbers. 328 */ 329 if (s) { 330 convert_num(s, val, base, size); 331 s += size / 8; 332 } else { 333 t = strdup(val); 334 if (t == NULL) 335 error("no temp space for number."); 336 c = cons(t, c); 337 } 338 } while (++count != *max); 339 340 /* If we had to cons up a list, convert it now. */ 341 if (c) { 342 bufp = malloc(count * size / 8); 343 if (!bufp) 344 error("can't allocate space for numeric aggregate."); 345 s = bufp + count - size / 8; 346 *max = count; 347 } 348 while (c) { 349 pair cdr = c->cdr; 350 convert_num(s, (char *)c->car, base, size); 351 s -= size / 8; 352 /* Free up temp space. */ 353 free(c->car); 354 free(c); 355 c = cdr; 356 } 357 return (bufp); 358 } 359 360 void 361 convert_num(unsigned char *buf, char *str, int base, int size) 362 { 363 int negative = 0, tval, max; 364 u_int32_t val = 0; 365 char *ptr = str; 366 367 if (*ptr == '-') { 368 negative = 1; 369 ptr++; 370 } 371 372 /* If base wasn't specified, figure it out from the data. */ 373 if (!base) { 374 if (ptr[0] == '0') { 375 if (ptr[1] == 'x') { 376 base = 16; 377 ptr += 2; 378 } else if (isascii((unsigned char)ptr[1]) && 379 isdigit((unsigned char)ptr[1])) { 380 base = 8; 381 ptr += 1; 382 } else 383 base = 10; 384 } else 385 base = 10; 386 } 387 388 do { 389 tval = *ptr++; 390 /* XXX assumes ASCII... */ 391 if (tval >= 'a') 392 tval = tval - 'a' + 10; 393 else if (tval >= 'A') 394 tval = tval - 'A' + 10; 395 else if (tval >= '0') 396 tval -= '0'; 397 else { 398 warning("Bogus number: %s.", str); 399 break; 400 } 401 if (tval >= base) { 402 warning("Bogus number: %s: digit %d not in base %d", 403 str, tval, base); 404 break; 405 } 406 val = val * base + tval; 407 } while (*ptr); 408 409 if (negative) 410 max = (1 << (size - 1)); 411 else 412 max = (1 << (size - 1)) + ((1 << (size - 1)) - 1); 413 if (val > max) { 414 switch (base) { 415 case 8: 416 warning("value %s%o exceeds max (%d) for precision.", 417 negative ? "-" : "", val, max); 418 break; 419 case 16: 420 warning("value %s%x exceeds max (%d) for precision.", 421 negative ? "-" : "", val, max); 422 break; 423 default: 424 warning("value %s%u exceeds max (%d) for precision.", 425 negative ? "-" : "", val, max); 426 break; 427 } 428 } 429 430 if (negative) { 431 switch (size) { 432 case 8: 433 *buf = -(unsigned long)val; 434 break; 435 case 16: 436 putShort(buf, -(unsigned long)val); 437 break; 438 case 32: 439 putLong(buf, -(unsigned long)val); 440 break; 441 default: 442 warning("Unexpected integer size: %d", size); 443 break; 444 } 445 } else { 446 switch (size) { 447 case 8: 448 *buf = (u_int8_t)val; 449 break; 450 case 16: 451 putUShort(buf, (u_int16_t)val); 452 break; 453 case 32: 454 putULong(buf, val); 455 break; 456 default: 457 warning("Unexpected integer size: %d", size); 458 break; 459 } 460 } 461 } 462 463 /* 464 * date :== NUMBER NUMBER SLASH NUMBER SLASH NUMBER 465 * NUMBER COLON NUMBER COLON NUMBER UTC SEMI 466 * 467 * Dates are always in UTC; first number is day of week; next is 468 * year/month/day; next is hours:minutes:seconds on a 24-hour 469 * clock. 470 */ 471 time_t 472 parse_date(FILE *cfile) 473 { 474 struct tm tm; 475 char timestr[26]; /* "w yyyy/mm/dd hh:mm:ss UTC" */ 476 char *val, *p; 477 size_t n; 478 time_t guess; 479 int token; 480 481 memset(timestr, 0, sizeof(timestr)); 482 483 do { 484 token = peek_token(NULL, cfile); 485 switch (token) { 486 case TOK_NAME: 487 case TOK_NUMBER: 488 case '/': 489 case ':': 490 token = next_token(&val, cfile); 491 n = strlcat(timestr, val, sizeof(timestr)); 492 if (n >= sizeof(timestr)) { 493 /* XXX Will break after year 9999! */ 494 parse_warn("time string too long"); 495 skip_to_semi(cfile); 496 return (0); 497 } 498 break; 499 case';': 500 break; 501 default: 502 parse_warn("invalid time string"); 503 skip_to_semi(cfile); 504 return (0); 505 } 506 } while (token != ';'); 507 508 parse_semi(cfile); 509 510 memset(&tm, 0, sizeof(tm)); /* 'cuz strptime ignores tm_isdt. */ 511 p = strptime(timestr, DB_TIMEFMT, &tm); 512 if (p == NULL || *p != '\0') { 513 p = strptime(timestr, OLD_DB_TIMEFMT, &tm); 514 if (p == NULL || *p != '\0') { 515 parse_warn("unparseable time string"); 516 return (0); 517 } 518 } 519 520 guess = timegm(&tm); 521 if (guess == -1) { 522 parse_warn("time could not be represented"); 523 return (0); 524 } 525 526 return (guess); 527 } 528