xref: /freebsd/sbin/dhclient/clparse.c (revision e5551216d8e563043248bc7f3cb1c75b2dbd9791)
1 /*	$OpenBSD: clparse.c,v 1.18 2004/09/15 18:15:18 henning Exp $	*/
2 
3 /* Parser for dhclient config and lease files... */
4 
5 /*-
6  * SPDX-License-Identifier: BSD-3-Clause
7  *
8  * Copyright (c) 1997 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 struct client_config top_level_config;
52 static struct interface_info *dummy_interfaces;
53 
54 static char client_script_name[] = "/sbin/dhclient-script";
55 
56 /*
57  * client-conf-file :== client-declarations EOF
58  * client-declarations :== <nil>
59  *			 | client-declaration
60  *			 | client-declarations client-declaration
61  */
62 int
63 read_client_conf(void)
64 {
65 	FILE			*cfile;
66 	char			*val;
67 	int			 token;
68 	struct client_config	*config;
69 
70 	new_parse(path_dhclient_conf);
71 
72 	/* Set up the initial dhcp option universe. */
73 	initialize_universes();
74 
75 	/* Initialize the top level client configuration. */
76 	memset(&top_level_config, 0, sizeof(top_level_config));
77 
78 	/* Set some defaults... */
79 	top_level_config.vlan_pcp = 0;
80 	top_level_config.timeout = 60;
81 	top_level_config.select_interval = 0;
82 	top_level_config.reboot_timeout = 10;
83 	top_level_config.retry_interval = 300;
84 	top_level_config.backoff_cutoff = 15;
85 	top_level_config.initial_interval = 3;
86 	top_level_config.bootp_policy = ACCEPT;
87 	top_level_config.script_name = client_script_name;
88 	top_level_config.requested_options
89 	    [top_level_config.requested_option_count++] = DHO_SUBNET_MASK;
90 	top_level_config.requested_options
91 	    [top_level_config.requested_option_count++] = DHO_BROADCAST_ADDRESS;
92 	top_level_config.requested_options
93 	    [top_level_config.requested_option_count++] = DHO_TIME_OFFSET;
94 	top_level_config.requested_options
95 	    [top_level_config.requested_option_count++] = DHO_CLASSLESS_ROUTES;
96 	top_level_config.requested_options
97 	    [top_level_config.requested_option_count++] = DHO_ROUTERS;
98 	top_level_config.requested_options
99 	    [top_level_config.requested_option_count++] = DHO_DOMAIN_NAME;
100 	top_level_config.requested_options
101 	    [top_level_config.requested_option_count++] =
102 	    DHO_DOMAIN_NAME_SERVERS;
103 	top_level_config.requested_options
104 	    [top_level_config.requested_option_count++] = DHO_HOST_NAME;
105 	top_level_config.requested_options
106 	    [top_level_config.requested_option_count++] = DHO_DOMAIN_SEARCH;
107 	top_level_config.requested_options
108 	    [top_level_config.requested_option_count++] = DHO_INTERFACE_MTU;
109 
110 	if ((cfile = fopen(path_dhclient_conf, "r")) != NULL) {
111 		do {
112 			token = peek_token(&val, cfile);
113 			if (token == EOF)
114 				break;
115 			parse_client_statement(cfile, NULL, &top_level_config);
116 		} while (1);
117 		token = next_token(&val, cfile); /* Clear the peek buffer */
118 		fclose(cfile);
119 	}
120 
121 	/*
122 	 * Set up state and config structures for clients that don't
123 	 * have per-interface configuration declarations.
124 	 */
125 	config = NULL;
126 	if (!ifi->client) {
127 		ifi->client = malloc(sizeof(struct client_state));
128 		if (!ifi->client)
129 			error("no memory for client state.");
130 		memset(ifi->client, 0, sizeof(*(ifi->client)));
131 	}
132 	if (!ifi->client->config) {
133 		if (!config) {
134 			config = malloc(sizeof(struct client_config));
135 			if (!config)
136 				error("no memory for client config.");
137 			memcpy(config, &top_level_config,
138 				sizeof(top_level_config));
139 		}
140 		ifi->client->config = config;
141 	}
142 
143 	return (!warnings_occurred);
144 }
145 
146 /*
147  * lease-file :== client-lease-statements EOF
148  * client-lease-statements :== <nil>
149  *		     | client-lease-statements LEASE client-lease-statement
150  */
151 void
152 read_client_leases(void)
153 {
154 	FILE	*cfile;
155 	char	*val;
156 	int	 token;
157 
158 	new_parse(path_dhclient_db);
159 
160 	/* Open the lease file.   If we can't open it, just return -
161 	   we can safely trust the server to remember our state. */
162 	if ((cfile = fopen(path_dhclient_db, "r")) == NULL)
163 		return;
164 	do {
165 		token = next_token(&val, cfile);
166 		if (token == EOF)
167 			break;
168 		if (token != LEASE) {
169 			warning("Corrupt lease file - possible data loss!");
170 			skip_to_semi(cfile);
171 			break;
172 		} else
173 			parse_client_lease_statement(cfile, 0);
174 
175 	} while (1);
176 	fclose(cfile);
177 }
178 
179 /*
180  * client-declaration :==
181  *	SEND option-decl |
182  *	DEFAULT option-decl |
183  *	SUPERSEDE option-decl |
184  *	PREPEND option-decl |
185  *	APPEND option-decl |
186  *	hardware-declaration |
187  *	REQUEST option-list |
188  *	REQUIRE option-list |
189  *	IGNORE option-list |
190  *	TIMEOUT number |
191  *	RETRY number |
192  *	REBOOT number |
193  *	SELECT_TIMEOUT number |
194  *	SCRIPT string |
195  *	interface-declaration |
196  *	LEASE client-lease-statement |
197  *	ALIAS client-lease-statement
198  */
199 void
200 parse_client_statement(FILE *cfile, struct interface_info *ip,
201     struct client_config *config)
202 {
203 	char		*val;
204 	struct option	*option;
205 	time_t		 tmp;
206 
207 	switch (next_token(&val, cfile)) {
208 	case SEND:
209 		parse_option_decl(cfile, &config->send_options[0]);
210 		return;
211 	case DEFAULT:
212 		option = parse_option_decl(cfile, &config->defaults[0]);
213 		if (option)
214 			config->default_actions[option->code] = ACTION_DEFAULT;
215 		return;
216 	case SUPERSEDE:
217 		option = parse_option_decl(cfile, &config->defaults[0]);
218 		if (option)
219 			config->default_actions[option->code] =
220 			    ACTION_SUPERSEDE;
221 		return;
222 	case APPEND:
223 		option = parse_option_decl(cfile, &config->defaults[0]);
224 		if (option)
225 			config->default_actions[option->code] = ACTION_APPEND;
226 		return;
227 	case PREPEND:
228 		option = parse_option_decl(cfile, &config->defaults[0]);
229 		if (option)
230 			config->default_actions[option->code] = ACTION_PREPEND;
231 		return;
232 	case MEDIA:
233 		parse_string_list(cfile, &config->media, 1);
234 		return;
235 	case HARDWARE:
236 		if (ip)
237 			parse_hardware_param(cfile, &ip->hw_address);
238 		else {
239 			parse_warn("hardware address parameter %s",
240 				    "not allowed here.");
241 			skip_to_semi(cfile);
242 		}
243 		return;
244 	case REQUEST:
245 		config->requested_option_count =
246 			parse_option_list(cfile, config->requested_options);
247 		return;
248 	case REQUIRE:
249 		memset(config->required_options, 0,
250 		    sizeof(config->required_options));
251 		parse_option_list(cfile, config->required_options);
252 		return;
253 	case IGNORE:
254 		parse_option_list(cfile, config->ignored_options);
255 		return;
256 	case TIMEOUT:
257 		parse_lease_time(cfile, &config->timeout);
258 		return;
259 	case RETRY:
260 		parse_lease_time(cfile, &config->retry_interval);
261 		return;
262 	case SELECT_TIMEOUT:
263 		parse_lease_time(cfile, &config->select_interval);
264 		return;
265 	case REBOOT:
266 		parse_lease_time(cfile, &config->reboot_timeout);
267 		return;
268 	case VLAN_PCP:
269 		parse_lease_time(cfile, &tmp);
270 		config->vlan_pcp = (u_int)tmp;
271 		return;
272 	case BACKOFF_CUTOFF:
273 		parse_lease_time(cfile, &config->backoff_cutoff);
274 		return;
275 	case INITIAL_INTERVAL:
276 		parse_lease_time(cfile, &config->initial_interval);
277 		return;
278 	case SCRIPT:
279 		config->script_name = parse_string(cfile);
280 		return;
281 	case INTERFACE:
282 		if (ip)
283 			parse_warn("nested interface declaration.");
284 		parse_interface_declaration(cfile, config);
285 		return;
286 	case LEASE:
287 		parse_client_lease_statement(cfile, 1);
288 		return;
289 	case ALIAS:
290 		parse_client_lease_statement(cfile, 2);
291 		return;
292 	case REJECT:
293 		parse_reject_statement(cfile, config);
294 		return;
295 	default:
296 		break;
297 	}
298 
299 	parse_warn("expecting a statement.");
300 	skip_to_semi(cfile);
301 }
302 
303 unsigned
304 parse_X(FILE *cfile, u_int8_t *buf, unsigned max)
305 {
306 	int	 token;
307 	char	*val;
308 	unsigned len;
309 
310 	token = peek_token(&val, cfile);
311 	if (token == NUMBER_OR_NAME || token == NUMBER) {
312 		len = 0;
313 		do {
314 			token = next_token(&val, cfile);
315 			if (token != NUMBER && token != NUMBER_OR_NAME) {
316 				parse_warn("expecting hexadecimal constant.");
317 				skip_to_semi(cfile);
318 				return (0);
319 			}
320 			convert_num(&buf[len], val, 16, 8);
321 			if (len++ > max) {
322 				parse_warn("hexadecimal constant too long.");
323 				skip_to_semi(cfile);
324 				return (0);
325 			}
326 			token = peek_token(&val, cfile);
327 			if (token == COLON)
328 				token = next_token(&val, cfile);
329 		} while (token == COLON);
330 		val = (char *)buf;
331 	} else if (token == STRING) {
332 		token = next_token(&val, cfile);
333 		len = strlen(val);
334 		if (len + 1 > max) {
335 			parse_warn("string constant too long.");
336 			skip_to_semi(cfile);
337 			return (0);
338 		}
339 		memcpy(buf, val, len + 1);
340 	} else {
341 		parse_warn("expecting string or hexadecimal data");
342 		skip_to_semi(cfile);
343 		return (0);
344 	}
345 	return (len);
346 }
347 
348 /*
349  * option-list :== option_name |
350  *		   option_list COMMA option_name
351  */
352 int
353 parse_option_list(FILE *cfile, u_int8_t *list)
354 {
355 	int	 ix, i;
356 	int	 token;
357 	char	*val;
358 
359 	ix = 0;
360 	do {
361 		token = next_token(&val, cfile);
362 		if (!is_identifier(token)) {
363 			parse_warn("expected option name.");
364 			skip_to_semi(cfile);
365 			return (0);
366 		}
367 		for (i = 0; i < 256; i++)
368 			if (!strcasecmp(dhcp_options[i].name, val))
369 				break;
370 
371 		if (i == 256) {
372 			parse_warn("%s: unexpected option name.", val);
373 			skip_to_semi(cfile);
374 			return (0);
375 		}
376 		list[ix++] = i;
377 		if (ix == 256) {
378 			parse_warn("%s: too many options.", val);
379 			skip_to_semi(cfile);
380 			return (0);
381 		}
382 		token = next_token(&val, cfile);
383 	} while (token == COMMA);
384 	if (token != SEMI) {
385 		parse_warn("expecting semicolon.");
386 		skip_to_semi(cfile);
387 		return (0);
388 	}
389 	return (ix);
390 }
391 
392 /*
393  * interface-declaration :==
394  *	INTERFACE string LBRACE client-declarations RBRACE
395  */
396 void
397 parse_interface_declaration(FILE *cfile, struct client_config *outer_config)
398 {
399 	int			 token;
400 	char			*val;
401 	struct interface_info	*ip;
402 
403 	token = next_token(&val, cfile);
404 	if (token != STRING) {
405 		parse_warn("expecting interface name (in quotes).");
406 		skip_to_semi(cfile);
407 		return;
408 	}
409 
410 	ip = interface_or_dummy(val);
411 
412 	if (!ip->client)
413 		make_client_state(ip);
414 
415 	if (!ip->client->config)
416 		make_client_config(ip, outer_config);
417 
418 	token = next_token(&val, cfile);
419 	if (token != LBRACE) {
420 		parse_warn("expecting left brace.");
421 		skip_to_semi(cfile);
422 		return;
423 	}
424 
425 	do {
426 		token = peek_token(&val, cfile);
427 		if (token == EOF) {
428 			parse_warn("unterminated interface declaration.");
429 			return;
430 		}
431 		if (token == RBRACE)
432 			break;
433 		parse_client_statement(cfile, ip, ip->client->config);
434 	} while (1);
435 	token = next_token(&val, cfile);
436 }
437 
438 struct interface_info *
439 interface_or_dummy(char *name)
440 {
441 	struct interface_info	*ip;
442 
443 	/* Find the interface (if any) that matches the name. */
444 	if (!strcmp(ifi->name, name))
445 		return (ifi);
446 
447 	/* If it's not a real interface, see if it's on the dummy list. */
448 	for (ip = dummy_interfaces; ip; ip = ip->next)
449 		if (!strcmp(ip->name, name))
450 			return (ip);
451 
452 	/*
453 	 * If we didn't find an interface, make a dummy interface as a
454 	 * placeholder.
455 	 */
456 	ip = malloc(sizeof(*ip));
457 	if (!ip)
458 		error("Insufficient memory to record interface %s", name);
459 	memset(ip, 0, sizeof(*ip));
460 	strlcpy(ip->name, name, IFNAMSIZ);
461 	ip->next = dummy_interfaces;
462 	dummy_interfaces = ip;
463 	return (ip);
464 }
465 
466 void
467 make_client_state(struct interface_info *ip)
468 {
469 	ip->client = malloc(sizeof(*(ip->client)));
470 	if (!ip->client)
471 		error("no memory for state on %s", ip->name);
472 	memset(ip->client, 0, sizeof(*(ip->client)));
473 }
474 
475 void
476 make_client_config(struct interface_info *ip, struct client_config *config)
477 {
478 	ip->client->config = malloc(sizeof(struct client_config));
479 	if (!ip->client->config)
480 		error("no memory for config for %s", ip->name);
481 	memset(ip->client->config, 0, sizeof(*(ip->client->config)));
482 	memcpy(ip->client->config, config, sizeof(*config));
483 }
484 
485 /*
486  * client-lease-statement :==
487  *	RBRACE client-lease-declarations LBRACE
488  *
489  *	client-lease-declarations :==
490  *		<nil> |
491  *		client-lease-declaration |
492  *		client-lease-declarations client-lease-declaration
493  */
494 void
495 parse_client_lease_statement(FILE *cfile, int is_static)
496 {
497 	struct client_lease	*lease, *lp, *pl;
498 	struct interface_info	*ip;
499 	int			 token;
500 	char			*val;
501 
502 	token = next_token(&val, cfile);
503 	if (token != LBRACE) {
504 		parse_warn("expecting left brace.");
505 		skip_to_semi(cfile);
506 		return;
507 	}
508 
509 	lease = malloc(sizeof(struct client_lease));
510 	if (!lease)
511 		error("no memory for lease.");
512 	memset(lease, 0, sizeof(*lease));
513 	lease->is_static = is_static;
514 
515 	ip = NULL;
516 
517 	do {
518 		token = peek_token(&val, cfile);
519 		if (token == EOF) {
520 			parse_warn("unterminated lease declaration.");
521 			free_client_lease(lease);
522 			return;
523 		}
524 		if (token == RBRACE)
525 			break;
526 		parse_client_lease_declaration(cfile, lease, &ip);
527 	} while (1);
528 	token = next_token(&val, cfile);
529 
530 	/* If the lease declaration didn't include an interface
531 	 * declaration that we recognized, it's of no use to us.
532 	 */
533 	if (!ip) {
534 		free_client_lease(lease);
535 		return;
536 	}
537 
538 	/* Make sure there's a client state structure... */
539 	if (!ip->client)
540 		make_client_state(ip);
541 
542 	/* If this is an alias lease, it doesn't need to be sorted in. */
543 	if (is_static == 2) {
544 		ip->client->alias = lease;
545 		return;
546 	}
547 
548 	/*
549 	 * The new lease may supersede a lease that's not the active
550 	 * lease but is still on the lease list, so scan the lease list
551 	 * looking for a lease with the same address, and if we find it,
552 	 * toss it.
553 	 */
554 	pl = NULL;
555 	for (lp = ip->client->leases; lp; lp = lp->next) {
556 		if (lp->address.len == lease->address.len &&
557 		    !memcmp(lp->address.iabuf, lease->address.iabuf,
558 		    lease->address.len)) {
559 			if (pl)
560 				pl->next = lp->next;
561 			else
562 				ip->client->leases = lp->next;
563 			free_client_lease(lp);
564 			break;
565 		}
566 	}
567 
568 	/*
569 	 * If this is a preloaded lease, just put it on the list of
570 	 * recorded leases - don't make it the active lease.
571 	 */
572 	if (is_static) {
573 		lease->next = ip->client->leases;
574 		ip->client->leases = lease;
575 		return;
576 	}
577 
578 	/*
579 	 * The last lease in the lease file on a particular interface is
580 	 * the active lease for that interface.    Of course, we don't
581 	 * know what the last lease in the file is until we've parsed
582 	 * the whole file, so at this point, we assume that the lease we
583 	 * just parsed is the active lease for its interface.   If
584 	 * there's already an active lease for the interface, and this
585 	 * lease is for the same ip address, then we just toss the old
586 	 * active lease and replace it with this one.   If this lease is
587 	 * for a different address, then if the old active lease has
588 	 * expired, we dump it; if not, we put it on the list of leases
589 	 * for this interface which are still valid but no longer
590 	 * active.
591 	 */
592 	if (ip->client->active) {
593 		if (ip->client->active->expiry < cur_time)
594 			free_client_lease(ip->client->active);
595 		else if (ip->client->active->address.len ==
596 		    lease->address.len &&
597 		    !memcmp(ip->client->active->address.iabuf,
598 		    lease->address.iabuf, lease->address.len))
599 			free_client_lease(ip->client->active);
600 		else {
601 			ip->client->active->next = ip->client->leases;
602 			ip->client->leases = ip->client->active;
603 		}
604 	}
605 	ip->client->active = lease;
606 
607 	/* Phew. */
608 }
609 
610 /*
611  * client-lease-declaration :==
612  *	BOOTP |
613  *	INTERFACE string |
614  *	FIXED_ADDR ip_address |
615  *	FILENAME string |
616  *	SERVER_NAME string |
617  *	OPTION option-decl |
618  *	RENEW time-decl |
619  *	REBIND time-decl |
620  *	EXPIRE time-decl
621  */
622 void
623 parse_client_lease_declaration(FILE *cfile, struct client_lease *lease,
624     struct interface_info **ipp)
625 {
626 	int			 token;
627 	char			*val;
628 	struct interface_info	*ip;
629 
630 	switch (next_token(&val, cfile)) {
631 	case BOOTP:
632 		lease->is_bootp = 1;
633 		break;
634 	case INTERFACE:
635 		token = next_token(&val, cfile);
636 		if (token != STRING) {
637 			parse_warn("expecting interface name (in quotes).");
638 			skip_to_semi(cfile);
639 			return;
640 		}
641 		ip = interface_or_dummy(val);
642 		*ipp = ip;
643 		break;
644 	case FIXED_ADDR:
645 		if (!parse_ip_addr(cfile, &lease->address))
646 			return;
647 		break;
648 	case MEDIUM:
649 		parse_string_list(cfile, &lease->medium, 0);
650 		return;
651 	case FILENAME:
652 		lease->filename = parse_string(cfile);
653 		return;
654 	case NEXT_SERVER:
655 		if (!parse_ip_addr(cfile, &lease->nextserver))
656 			return;
657 		break;
658 	case SERVER_NAME:
659 		lease->server_name = parse_string(cfile);
660 		return;
661 	case RENEW:
662 		lease->renewal = parse_date(cfile);
663 		return;
664 	case REBIND:
665 		lease->rebind = parse_date(cfile);
666 		return;
667 	case EXPIRE:
668 		lease->expiry = parse_date(cfile);
669 		return;
670 	case OPTION:
671 		parse_option_decl(cfile, lease->options);
672 		return;
673 	default:
674 		parse_warn("expecting lease declaration.");
675 		skip_to_semi(cfile);
676 		return;
677 	}
678 	token = next_token(&val, cfile);
679 	if (token != SEMI) {
680 		parse_warn("expecting semicolon.");
681 		skip_to_semi(cfile);
682 	}
683 }
684 
685 struct option *
686 parse_option_decl(FILE *cfile, struct option_data *options)
687 {
688 	char		*val;
689 	int		 token;
690 	u_int8_t	 buf[4];
691 	u_int8_t	 hunkbuf[1024];
692 	unsigned	 hunkix = 0;
693 	char		*vendor;
694 	const char	*fmt;
695 	struct universe	*universe;
696 	struct option	*option;
697 	struct iaddr	 ip_addr;
698 	u_int8_t	*dp;
699 	unsigned	 len;
700 	int		 nul_term = 0;
701 
702 	token = next_token(&val, cfile);
703 	if (!is_identifier(token)) {
704 		parse_warn("expecting identifier after option keyword.");
705 		if (token != SEMI)
706 			skip_to_semi(cfile);
707 		return (NULL);
708 	}
709 	if ((vendor = strdup(val)) == NULL)
710 		error("no memory for vendor information.");
711 
712 	token = peek_token(&val, cfile);
713 	if (token == DOT) {
714 		/* Go ahead and take the DOT token... */
715 		token = next_token(&val, cfile);
716 
717 		/* The next token should be an identifier... */
718 		token = next_token(&val, cfile);
719 		if (!is_identifier(token)) {
720 			parse_warn("expecting identifier after '.'");
721 			if (token != SEMI)
722 				skip_to_semi(cfile);
723 			free(vendor);
724 			return (NULL);
725 		}
726 
727 		/* Look up the option name hash table for the specified
728 		   vendor. */
729 		universe = ((struct universe *)hash_lookup(&universe_hash,
730 		    (unsigned char *)vendor, 0));
731 		/* If it's not there, we can't parse the rest of the
732 		   declaration. */
733 		if (!universe) {
734 			parse_warn("no vendor named %s.", vendor);
735 			skip_to_semi(cfile);
736 			free(vendor);
737 			return (NULL);
738 		}
739 	} else {
740 		/* Use the default hash table, which contains all the
741 		   standard dhcp option names. */
742 		val = vendor;
743 		universe = &dhcp_universe;
744 	}
745 
746 	/* Look up the actual option info... */
747 	option = (struct option *)hash_lookup(universe->hash,
748 	    (unsigned char *)val, 0);
749 
750 	/* If we didn't get an option structure, it's an undefined option. */
751 	if (!option) {
752 		if (val == vendor)
753 			parse_warn("no option named %s", val);
754 		else
755 			parse_warn("no option named %s for vendor %s",
756 				    val, vendor);
757 		skip_to_semi(cfile);
758 		free(vendor);
759 		return (NULL);
760 	}
761 
762 	/* Free the initial identifier token. */
763 	free(vendor);
764 
765 	/* Parse the option data... */
766 	do {
767 		for (fmt = option->format; *fmt; fmt++) {
768 			if (*fmt == 'A')
769 				break;
770 			switch (*fmt) {
771 			case 'X':
772 				len = parse_X(cfile, &hunkbuf[hunkix],
773 				    sizeof(hunkbuf) - hunkix);
774 				hunkix += len;
775 				break;
776 			case 't': /* Text string... */
777 				token = next_token(&val, cfile);
778 				if (token != STRING) {
779 					parse_warn("expecting string.");
780 					skip_to_semi(cfile);
781 					return (NULL);
782 				}
783 				len = strlen(val);
784 				if (hunkix + len + 1 > sizeof(hunkbuf)) {
785 					parse_warn("option data buffer %s",
786 					    "overflow");
787 					skip_to_semi(cfile);
788 					return (NULL);
789 				}
790 				memcpy(&hunkbuf[hunkix], val, len + 1);
791 				nul_term = 1;
792 				hunkix += len;
793 				break;
794 			case 'I': /* IP address. */
795 				if (!parse_ip_addr(cfile, &ip_addr))
796 					return (NULL);
797 				len = ip_addr.len;
798 				dp = ip_addr.iabuf;
799 alloc:
800 				if (hunkix + len > sizeof(hunkbuf)) {
801 					parse_warn("option data buffer "
802 					    "overflow");
803 					skip_to_semi(cfile);
804 					return (NULL);
805 				}
806 				memcpy(&hunkbuf[hunkix], dp, len);
807 				hunkix += len;
808 				break;
809 			case 'L':	/* Unsigned 32-bit integer... */
810 			case 'l':	/* Signed 32-bit integer... */
811 				token = next_token(&val, cfile);
812 				if (token != NUMBER) {
813 need_number:
814 					parse_warn("expecting number.");
815 					if (token != SEMI)
816 						skip_to_semi(cfile);
817 					return (NULL);
818 				}
819 				convert_num(buf, val, 0, 32);
820 				len = 4;
821 				dp = buf;
822 				goto alloc;
823 			case 's':	/* Signed 16-bit integer. */
824 			case 'S':	/* Unsigned 16-bit integer. */
825 				token = next_token(&val, cfile);
826 				if (token != NUMBER)
827 					goto need_number;
828 				convert_num(buf, val, 0, 16);
829 				len = 2;
830 				dp = buf;
831 				goto alloc;
832 			case 'b':	/* Signed 8-bit integer. */
833 			case 'B':	/* Unsigned 8-bit integer. */
834 				token = next_token(&val, cfile);
835 				if (token != NUMBER)
836 					goto need_number;
837 				convert_num(buf, val, 0, 8);
838 				len = 1;
839 				dp = buf;
840 				goto alloc;
841 			case 'f': /* Boolean flag. */
842 				token = next_token(&val, cfile);
843 				if (!is_identifier(token)) {
844 					parse_warn("expecting identifier.");
845 bad_flag:
846 					if (token != SEMI)
847 						skip_to_semi(cfile);
848 					return (NULL);
849 				}
850 				if (!strcasecmp(val, "true") ||
851 				    !strcasecmp(val, "on"))
852 					buf[0] = 1;
853 				else if (!strcasecmp(val, "false") ||
854 				    !strcasecmp(val, "off"))
855 					buf[0] = 0;
856 				else {
857 					parse_warn("expecting boolean.");
858 					goto bad_flag;
859 				}
860 				len = 1;
861 				dp = buf;
862 				goto alloc;
863 			default:
864 				warning("Bad format %c in parse_option_param.",
865 				    *fmt);
866 				skip_to_semi(cfile);
867 				return (NULL);
868 			}
869 		}
870 		token = next_token(&val, cfile);
871 	} while (*fmt == 'A' && token == COMMA);
872 
873 	if (token != SEMI) {
874 		parse_warn("semicolon expected.");
875 		skip_to_semi(cfile);
876 		return (NULL);
877 	}
878 
879 	options[option->code].data = malloc(hunkix + nul_term);
880 	if (!options[option->code].data)
881 		error("out of memory allocating option data.");
882 	memcpy(options[option->code].data, hunkbuf, hunkix + nul_term);
883 	options[option->code].len = hunkix;
884 	return (option);
885 }
886 
887 void
888 parse_string_list(FILE *cfile, struct string_list **lp, int multiple)
889 {
890 	int			 token;
891 	char			*val;
892 	size_t			 valsize;
893 	struct string_list	*cur, *tmp;
894 
895 	/* Find the last medium in the media list. */
896 	if (*lp)
897 		for (cur = *lp; cur->next; cur = cur->next)
898 			;	/* nothing */
899 	else
900 		cur = NULL;
901 
902 	do {
903 		token = next_token(&val, cfile);
904 		if (token != STRING) {
905 			parse_warn("Expecting media options.");
906 			skip_to_semi(cfile);
907 			return;
908 		}
909 
910 		valsize = strlen(val) + 1;
911 		tmp = new_string_list(valsize);
912 		if (tmp == NULL)
913 			error("no memory for string list entry.");
914 		memcpy(tmp->string, val, valsize);
915 		tmp->next = NULL;
916 
917 		/* Store this medium at the end of the media list. */
918 		if (cur)
919 			cur->next = tmp;
920 		else
921 			*lp = tmp;
922 		cur = tmp;
923 
924 		token = next_token(&val, cfile);
925 	} while (multiple && token == COMMA);
926 
927 	if (token != SEMI) {
928 		parse_warn("expecting semicolon.");
929 		skip_to_semi(cfile);
930 	}
931 }
932 
933 void
934 parse_reject_statement(FILE *cfile, struct client_config *config)
935 {
936 	int			 token;
937 	char			*val;
938 	struct iaddr		 addr;
939 	struct iaddrlist	*list;
940 
941 	do {
942 		if (!parse_ip_addr(cfile, &addr)) {
943 			parse_warn("expecting IP address.");
944 			skip_to_semi(cfile);
945 			return;
946 		}
947 
948 		list = malloc(sizeof(struct iaddrlist));
949 		if (!list)
950 			error("no memory for reject list!");
951 
952 		list->addr = addr;
953 		list->next = config->reject_list;
954 		config->reject_list = list;
955 
956 		token = next_token(&val, cfile);
957 	} while (token == COMMA);
958 
959 	if (token != SEMI) {
960 		parse_warn("expecting semicolon.");
961 		skip_to_semi(cfile);
962 	}
963 }
964