xref: /openbsd-src/usr.sbin/dhcpd/confpars.c (revision 3fc7bd6dbd7c5727d292ef13a0ecf42ced86bb2b)

/*	$OpenBSD: confpars.c,v 1.36 2020/04/23 15:00:27 krw Exp $ */

/*
 * Copyright (c) 1995, 1996, 1997 The Internet Software Consortium.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of The Internet Software Consortium nor the names
 *    of its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * This software has been written for the Internet Software Consortium
 * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
 * Enterprises.  To learn more about the Internet Software Consortium,
 * see ``http://www.vix.com/isc''.  To learn more about Vixie
 * Enterprises, see ``http://www.vix.com''.
 */

#include <sys/types.h>
#include <sys/socket.h>

#include <net/if.h>

#include <limits.h>
#include <netdb.h>
#include <resolv.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "dhcp.h"
#include "tree.h"
#include "dhcpd.h"
#include "dhctoken.h"
#include "log.h"

int	parse_cidr(FILE *, unsigned char *, unsigned char *);

/*
 * conf-file :== parameters declarations EOF
 * parameters :== <nil> | parameter | parameters parameter
 * declarations :== <nil> | declaration | declarations declaration
 */
int
readconf(void)
{
	FILE *cfile;
	char *val;
	int token;
	int declaration = 0;

	new_parse(path_dhcpd_conf);

	/* Set up the initial dhcp option universe. */
	initialize_universes();

	/* Set up the global defaults. */
	root_group.default_lease_time = 43200; /* 12 hours. */
	root_group.max_lease_time = 86400; /* 24 hours. */
	root_group.bootp_lease_cutoff = MAX_TIME;
	root_group.boot_unknown_clients = 1;
	root_group.allow_bootp = 1;
	root_group.allow_booting = 1;
	root_group.authoritative = 1;
	root_group.echo_client_id = 1;

	if ((cfile = fopen(path_dhcpd_conf, "r")) == NULL)
		fatal("Can't open %s", path_dhcpd_conf);

	do {
		token = peek_token(&val, cfile);
		if (token == EOF)
			break;
		declaration = parse_statement(cfile, &root_group,
						 ROOT_GROUP,
						 NULL,
						 declaration);
	} while (1);
	token = next_token(&val, cfile); /* Clear the peek buffer */
	fclose(cfile);

	return !warnings_occurred;
}

/*
 * lease-file :== lease-declarations EOF
 * lease-statments :== <nil>
 *		   | lease-declaration
 *		   | lease-declarations lease-declaration
 */
void
read_leases(void)
{
	FILE *cfile;
	char *val;
	int token;

	new_parse(path_dhcpd_db);

	/*
	 * Open the lease file.   If we can't open it, fail.   The reason
	 * for this is that although on initial startup, the absence of
	 * a lease file is perfectly benign, if dhcpd has been running
	 * and this file is absent, it means that dhcpd tried and failed
	 * to rewrite the lease database.   If we proceed and the
	 * problem which caused the rewrite to fail has been fixed, but no
	 * human has corrected the database problem, then we are left
	 * thinking that no leases have been assigned to anybody, which
	 * could create severe network chaos.
	 */
	if ((cfile = fopen(path_dhcpd_db, "r")) == NULL) {
		log_warn("Can't open lease database (%s)", path_dhcpd_db);
		log_warnx("check for failed database rewrite attempt!");
		log_warnx("Please read the dhcpd.leases manual page if you");
		fatalx("don't know what to do about this.");
	}

	do {
		token = next_token(&val, cfile);
		if (token == EOF)
			break;
		if (token != TOK_LEASE) {
			log_warnx("Corrupt lease file - possible data loss!");
			skip_to_semi(cfile);
		} else {
			struct lease *lease;
			lease = parse_lease_declaration(cfile);
			if (lease)
				enter_lease(lease);
			else
				parse_warn("possibly corrupt lease file");
		}

	} while (1);
	fclose(cfile);
}

/*
 * statement :== parameter | declaration
 *
 * parameter :== timestamp
 *	     | DEFAULT_LEASE_TIME lease_time
 *	     | MAX_LEASE_TIME lease_time
 *	     | DYNAMIC_BOOTP_LEASE_CUTOFF date
 *	     | DYNAMIC_BOOTP_LEASE_LENGTH lease_time
 *	     | BOOT_UNKNOWN_CLIENTS boolean
 *	     | GET_LEASE_HOSTNAMES boolean
 *	     | USE_HOST_DECL_NAME boolean
 *	     | NEXT_SERVER ip-addr-or-hostname SEMI
 *	     | option_parameter
 *	     | SERVER-IDENTIFIER ip-addr-or-hostname SEMI
 *	     | FILENAME string-parameter
 *	     | SERVER_NAME string-parameter
 *	     | hardware-parameter
 *	     | fixed-address-parameter
 *	     | ALLOW allow-deny-keyword
 *	     | DENY allow-deny-keyword
 *	     | USE_LEASE_ADDR_FOR_DEFAULT_ROUTE boolean
 *
 * declaration :== host-declaration
 *		 | group-declaration
 *		 | shared-network-declaration
 *		 | subnet-declaration
 *		 | VENDOR_CLASS class-declaration
 *		 | USER_CLASS class-declaration
 *		 | RANGE address-range-declaration
 */
int
parse_statement(FILE *cfile, struct group *group, int type,
	struct host_decl *host_decl, int declaration)
{
	int token;
	char *val;
	struct shared_network *share;
	char *n;
	struct tree *tree;
	struct tree_cache *cache;
	struct hardware hardware;

	switch (next_token(&val, cfile)) {
	case TOK_HOST:
		if (type != HOST_DECL)
			parse_host_declaration(cfile, group);
		else {
			parse_warn("host declarations not allowed here.");
			skip_to_semi(cfile);
		}
		return 1;

	case TOK_GROUP:
		if (type != HOST_DECL)
			parse_group_declaration(cfile, group);
		else {
			parse_warn("host declarations not allowed here.");
			skip_to_semi(cfile);
		}
		return 1;

	case TOK_TIMESTAMP:
		break;

	case TOK_SHARED_NETWORK:
		if (type == SHARED_NET_DECL ||
		    type == HOST_DECL ||
		    type == SUBNET_DECL) {
			parse_warn("shared-network parameters not %s.",
				    "allowed here");
			skip_to_semi(cfile);
			break;
		}

		parse_shared_net_declaration(cfile, group);
		return 1;

	case TOK_SUBNET:
		if (type == HOST_DECL || type == SUBNET_DECL) {
			parse_warn("subnet declarations not allowed here.");
			skip_to_semi(cfile);
			return 1;
		}

		/* If we're in a subnet declaration, just do the parse. */
		if (group->shared_network) {
			parse_subnet_declaration(cfile,
			    group->shared_network);
			break;
		}

		/*
		 * Otherwise, cons up a fake shared network structure
		 * and populate it with the lone subnet.
		 */

		share = calloc(1, sizeof(struct shared_network));
		if (!share)
			fatalx("No memory for shared subnet");
		share->group = clone_group(group, "parse_statement:subnet");
		share->group->shared_network = share;

		parse_subnet_declaration(cfile, share);

		/* share->subnets is the subnet we just parsed. */
		if (share->subnets) {
			share->interface =
				share->subnets->interface;

			/* Make the shared network name from network number. */
			n = piaddr(share->subnets->net);
			share->name = strdup(n);
			if (share->name == NULL)
				fatalx("no memory for subnet name");

			/*
			 * Copy the authoritative parameter from the subnet,
			 * since there is no opportunity to declare it here.
			 */
			share->group->authoritative =
				share->subnets->group->authoritative;
			enter_shared_network(share);
		}
		return 1;

	case TOK_VENDOR_CLASS:
		parse_class_declaration(cfile, group, 0);
		return 1;

	case TOK_USER_CLASS:
		parse_class_declaration(cfile, group, 1);
		return 1;

	case TOK_DEFAULT_LEASE_TIME:
		parse_lease_time(cfile, &group->default_lease_time);
		break;

	case TOK_MAX_LEASE_TIME:
		parse_lease_time(cfile, &group->max_lease_time);
		break;

	case TOK_DYNAMIC_BOOTP_LEASE_CUTOFF:
		group->bootp_lease_cutoff = parse_date(cfile);
		break;

	case TOK_DYNAMIC_BOOTP_LEASE_LENGTH:
		parse_lease_time(cfile, &group->bootp_lease_length);
		break;

	case TOK_BOOT_UNKNOWN_CLIENTS:
		if (type == HOST_DECL)
			parse_warn("boot-unknown-clients not allowed here.");
		group->boot_unknown_clients = parse_boolean(cfile);
		break;

	case TOK_GET_LEASE_HOSTNAMES:
		if (type == HOST_DECL)
			parse_warn("get-lease-hostnames not allowed here.");
		group->get_lease_hostnames = parse_boolean(cfile);
		break;

	case TOK_ALWAYS_REPLY_RFC1048:
		group->always_reply_rfc1048 = parse_boolean(cfile);
		break;

	case TOK_ECHO_CLIENT_ID:
		group->echo_client_id = parse_boolean(cfile);
		break;

	case TOK_USE_HOST_DECL_NAMES:
		if (type == HOST_DECL)
			parse_warn("use-host-decl-names not allowed here.");
		group->use_host_decl_names = parse_boolean(cfile);
		break;

	case TOK_USE_LEASE_ADDR_FOR_DEFAULT_ROUTE:
		group->use_lease_addr_for_default_route =
			parse_boolean(cfile);
		break;

	case TOK_TOKEN_NOT:
		token = next_token(&val, cfile);
		switch (token) {
		case TOK_AUTHORITATIVE:
			if (type == HOST_DECL)
			    parse_warn("authority makes no sense here.");
			group->authoritative = 0;
			parse_semi(cfile);
			break;
		default:
			parse_warn("expecting assertion");
			skip_to_semi(cfile);
			break;
		}
		break;

	case TOK_AUTHORITATIVE:
		if (type == HOST_DECL)
		    parse_warn("authority makes no sense here.");
		group->authoritative = 1;
		parse_semi(cfile);
		break;

	case TOK_NEXT_SERVER:
		tree = parse_ip_addr_or_hostname(cfile, 0);
		if (!tree)
			break;
		cache = tree_cache(tree);
		if (!tree_evaluate (cache))
			fatalx("next-server is not known");
		group->next_server.len = 4;
		memcpy(group->next_server.iabuf,
		    cache->value, group->next_server.len);
		parse_semi(cfile);
		break;

	case TOK_OPTION:
		parse_option_param(cfile, group);
		break;

	case TOK_SERVER_IDENTIFIER:
		tree = parse_ip_addr_or_hostname(cfile, 0);
		if (!tree)
			return declaration;
		group->options[DHO_DHCP_SERVER_IDENTIFIER] = tree_cache(tree);
		token = next_token(&val, cfile);
		break;

	case TOK_FILENAME:
		group->filename = parse_string(cfile);
		break;

	case TOK_SERVER_NAME:
		group->server_name = parse_string(cfile);
		break;

	case TOK_HARDWARE:
		parse_hardware_param(cfile, &hardware);
		if (host_decl)
			host_decl->interface = hardware;
		else
			parse_warn("hardware address parameter %s",
				    "not allowed here.");
		break;

	case TOK_FIXED_ADDR:
		cache = parse_fixed_addr_param(cfile);
		if (host_decl)
			host_decl->fixed_addr = cache;
		else
			parse_warn("fixed-address parameter not %s",
				    "allowed here.");
		break;

	case TOK_RANGE:
		if (type != SUBNET_DECL || !group->subnet) {
			parse_warn("range declaration not allowed here.");
			skip_to_semi(cfile);
			return declaration;
		}
		parse_address_range(cfile, group->subnet);
		return declaration;

	case TOK_ALLOW:
		parse_allow_deny(cfile, group, 1);
		break;

	case TOK_DENY:
		parse_allow_deny(cfile, group, 0);
		break;

	default:
		if (declaration)
			parse_warn("expecting a declaration.");
		else
			parse_warn("expecting a parameter or declaration.");
		skip_to_semi(cfile);
		return declaration;
	}

	if (declaration) {
		parse_warn("parameters not allowed after first declaration.");
		return 1;
	}

	return 0;
}

/*
 * allow-deny-keyword :== BOOTP
 *			| BOOTING
 *			| DYNAMIC_BOOTP
 *			| UNKNOWN_CLIENTS
 */
void
parse_allow_deny(FILE *cfile, struct group *group, int flag)
{
	int token;
	char *val;

	token = next_token(&val, cfile);
	switch (token) {
	case TOK_BOOTP:
		group->allow_bootp = flag;
		break;

	case TOK_BOOTING:
		group->allow_booting = flag;
		break;

	case TOK_DYNAMIC_BOOTP:
		group->dynamic_bootp = flag;
		break;

	case TOK_UNKNOWN_CLIENTS:
		group->boot_unknown_clients = flag;
		break;

	default:
		parse_warn("expecting allow/deny key");
		skip_to_semi(cfile);
		return;
	}
	parse_semi(cfile);
}

/*
 * boolean :== ON SEMI | OFF SEMI | TRUE SEMI | FALSE SEMI
 */
int
parse_boolean(FILE *cfile)
{
	char *val;
	int rv;

	next_token(&val, cfile);
	if (!strcasecmp (val, "true") || !strcasecmp (val, "on"))
		rv = 1;
	else if (!strcasecmp (val, "false") || !strcasecmp (val, "off"))
		rv = 0;
	else {
		parse_warn("boolean value (true/false/on/off) expected");
		skip_to_semi(cfile);
		return 0;
	}
	parse_semi(cfile);
	return rv;
}

/*
 * Expect a left brace; if there isn't one, skip over the rest of the
 * statement and return zero; otherwise, return 1.
 */
int
parse_lbrace(FILE *cfile)
{
	int token;
	char *val;

	token = next_token(&val, cfile);
	if (token != '{') {
		parse_warn("expecting left brace.");
		skip_to_semi(cfile);
		return 0;
	}
	return 1;
}


/*
 * host-declaration :== hostname '{' parameters declarations '}'
 */
void
parse_host_declaration(FILE *cfile, struct group *group)
{
	char *val;
	int token;
	struct host_decl *host;
	char *name = parse_host_name(cfile);
	int declaration = 0;

	if (!name)
		return;

	host = calloc(1, sizeof (struct host_decl));
	if (!host)
		fatalx("can't allocate host decl struct %s.", name);

	host->name = name;
	host->group = clone_group(group, "parse_host_declaration");

	if (!parse_lbrace(cfile)) {
		free(host->name);
		free(host->group);
		free(host);
		return;
	}

	do {
		token = peek_token(&val, cfile);
		if (token == '}') {
			token = next_token(&val, cfile);
			break;
		}
		if (token == EOF) {
			token = next_token(&val, cfile);
			parse_warn("unexpected end of file");
			break;
		}
		declaration = parse_statement(cfile, host->group,
		    HOST_DECL, host, declaration);
	} while (1);

	if (!host->group->options[DHO_HOST_NAME] &&
	    host->group->use_host_decl_names) {
		host->group->options[DHO_HOST_NAME] =
		    new_tree_cache("parse_host_declaration");
		if (!host->group->options[DHO_HOST_NAME])
			fatalx("can't allocate a tree cache for hostname.");
		host->group->options[DHO_HOST_NAME]->len =
			strlen(name);
		host->group->options[DHO_HOST_NAME]->value =
			(unsigned char *)name;
		host->group->options[DHO_HOST_NAME]->buf_size =
			host->group->options[DHO_HOST_NAME]->len;
		host->group->options[DHO_HOST_NAME]->timeout = -1;
		host->group->options[DHO_HOST_NAME]->tree =
			NULL;
	}

	enter_host(host);
}

/*
 * class-declaration :== STRING '{' parameters declarations '}'
 */
void
parse_class_declaration(FILE *cfile, struct group *group, int type)
{
	char *val;
	int token;
	struct class *class;
	int declaration = 0;

	token = next_token(&val, cfile);
	if (token != TOK_STRING) {
		parse_warn("Expecting class name");
		skip_to_semi(cfile);
		return;
	}

	class = add_class (type, val);
	if (!class)
		fatalx("No memory for class %s.", val);
	class->group = clone_group(group, "parse_class_declaration");

	if (!parse_lbrace(cfile)) {
		free(class->name);
		free(class->group);
		free(class);
		return;
	}

	do {
		token = peek_token(&val, cfile);
		if (token == '}') {
			token = next_token(&val, cfile);
			break;
		} else if (token == EOF) {
			token = next_token(&val, cfile);
			parse_warn("unexpected end of file");
			break;
		} else {
			declaration = parse_statement(cfile, class->group,
			    CLASS_DECL, NULL, declaration);
		}
	} while (1);
}

/*
 * shared-network-declaration :==
 *			hostname LBRACE declarations parameters RBRACE
 */
void
parse_shared_net_declaration(FILE *cfile, struct group *group)
{
	char *val;
	int token;
	struct shared_network *share;
	char *name;
	int declaration = 0;

	share = calloc(1, sizeof(struct shared_network));
	if (!share)
		fatalx("No memory for shared subnet");
	share->leases = NULL;
	share->last_lease = NULL;
	share->insertion_point = NULL;
	share->next = NULL;
	share->interface = NULL;
	share->group = clone_group(group, "parse_shared_net_declaration");
	share->group->shared_network = share;

	/* Get the name of the shared network. */
	token = peek_token(&val, cfile);
	if (token == TOK_STRING) {
		token = next_token(&val, cfile);

		if (val[0] == 0) {
			parse_warn("zero-length shared network name");
			val = "<no-name-given>";
		}
		name = strdup(val);
		if (name == NULL)
			fatalx("no memory for shared network name");
	} else {
		name = parse_host_name(cfile);
		if (!name) {
			free(share->group);
			free(share);
			return;
		}
	}
	share->name = name;

	if (!parse_lbrace(cfile)) {
		free(share->group);
		free(share->name);
		free(share);
		return;
	}

	do {
		token = peek_token(&val, cfile);
		if (token == '}') {
			token = next_token(&val, cfile);
			if (!share->subnets) {
				free(share->group);
				free(share->name);
				free(share);
				parse_warn("empty shared-network decl");
				return;
			}
			enter_shared_network(share);
			return;
		} else if (token == EOF) {
			token = next_token(&val, cfile);
			parse_warn("unexpected end of file");
			break;
		}

		declaration = parse_statement(cfile, share->group,
		    SHARED_NET_DECL, NULL, declaration);
	} while (1);
}

/*
 * subnet-declaration :==
 *	net NETMASK netmask RBRACE parameters declarations LBRACE
 */
void
parse_subnet_declaration(FILE *cfile, struct shared_network *share)
{
	char *val;
	int token;
	struct subnet *subnet, *t, *u;
	struct iaddr iaddr;
	unsigned char addr[4];
	int len = sizeof addr;
	int declaration = 0;

	subnet = calloc(1, sizeof(struct subnet));
	if (!subnet)
		fatalx("No memory for new subnet");
	subnet->shared_network = share;
	subnet->group = clone_group(share->group, "parse_subnet_declaration");
	subnet->group->subnet = subnet;

	/* Get the network number. */
	if (!parse_numeric_aggregate(cfile, addr, &len, '.', 10, 8)) {
		free(subnet->group);
		free(subnet);
		return;
	}
	memcpy(iaddr.iabuf, addr, len);
	iaddr.len = len;
	subnet->net = iaddr;

	token = next_token(&val, cfile);
	if (token != TOK_NETMASK) {
		free(subnet->group);
		free(subnet);
		parse_warn("Expecting netmask");
		skip_to_semi(cfile);
		return;
	}

	/* Get the netmask. */
	if (!parse_numeric_aggregate(cfile, addr, &len, '.', 10, 8)) {
		free(subnet->group);
		free(subnet);
		return;
	}
	memcpy(iaddr.iabuf, addr, len);
	iaddr.len = len;
	subnet->netmask = iaddr;

	/* Save only the subnet number. */
	subnet->net = subnet_number(subnet->net, subnet->netmask);

	enter_subnet(subnet);

	if (!parse_lbrace(cfile))
		return;

	do {
		token = peek_token(&val, cfile);
		if (token == '}') {
			token = next_token(&val, cfile);
			break;
		} else if (token == EOF) {
			token = next_token(&val, cfile);
			parse_warn("unexpected end of file");
			break;
		}
		declaration = parse_statement(cfile, subnet->group,
		    SUBNET_DECL, NULL, declaration);
	} while (1);

	/*
	 * If this subnet supports dynamic bootp, flag it so in the
	 * shared_network containing it.
	 */
	if (subnet->group->dynamic_bootp)
		share->group->dynamic_bootp = 1;

	/* Add the subnet to the list of subnets in this shared net. */
	if (!share->subnets)
		share->subnets = subnet;
	else {
		u = NULL;
		for (t = share->subnets; t; t = t->next_sibling) {
			if (subnet_inner_than(subnet, t, 0)) {
				if (u)
					u->next_sibling = subnet;
				else
					share->subnets = subnet;
				subnet->next_sibling = t;
				return;
			}
			u = t;
		}
		u->next_sibling = subnet;
	}
}

/*
 * group-declaration :== RBRACE parameters declarations LBRACE
 */
void
parse_group_declaration(FILE *cfile, struct group *group)
{
	char *val;
	int token;
	struct group *g;
	int declaration = 0;

	g = clone_group(group, "parse_group_declaration");

	if (!parse_lbrace(cfile)) {
		free(g);
		return;
	}

	do {
		token = peek_token(&val, cfile);
		if (token == '}') {
			token = next_token(&val, cfile);
			break;
		} else if (token == EOF) {
			token = next_token(&val, cfile);
			parse_warn("unexpected end of file");
			break;
		}
		declaration = parse_statement(cfile, g, GROUP_DECL, NULL,
		    declaration);
	} while (1);
}

/*
 * cidr :== ip-address "/" bit-count
 * ip-address :== NUMBER [ DOT NUMBER [ DOT NUMBER [ DOT NUMBER ] ] ]
 * bit-count :== 0..32
 */
int
parse_cidr(FILE *cfile, unsigned char *subnet, unsigned char *subnetlen)
{
	uint8_t		 cidr[5];
	const char	*errstr;
	char		*val;
	long long	 numval;
	unsigned int	 i;
	int		 token;

	memset(cidr, 0, sizeof(cidr));
	i = 1;	/* Last four octets hold subnet, first octet the # of bits. */
	do {
		token = next_token(&val, cfile);
		if (i == 0)
			numval = strtonum(val, 0, 32, &errstr);
		else
			numval = strtonum(val, 0, UINT8_MAX, &errstr);
		if (errstr != NULL)
			break;
		cidr[i++] = numval;
		if (i == 1) {
			memcpy(subnet, &cidr[1], 4); /* XXX Need cidr_t */
			*subnetlen = cidr[0];
			return 1;
		}
		token = next_token(NULL, cfile);
		if (token == '/')
			i = 0;
		if (i == sizeof(cidr))
			break;
	} while (token == '.' || token == '/');

	parse_warn("expecting IPv4 CIDR block.");

	if (token != ';')
		skip_to_semi(cfile);
	return 0;
}

/*
 * ip-addr-or-hostname :== ip-address | hostname
 * ip-address :== NUMBER DOT NUMBER DOT NUMBER DOT NUMBER
 *
 * Parse an ip address or a hostname.   If uniform is zero, put in
 * a TREE_LIMIT node to catch hostnames that evaluate to more than
 * one IP address.
 */
struct tree *
parse_ip_addr_or_hostname(FILE *cfile, int uniform)
{
	char *val;
	int token;
	unsigned char addr[4];
	int len = sizeof addr;
	char *name;
	struct tree *rv;
	struct hostent *h;

	name = NULL;
	h = NULL;

	token = peek_token(&val, cfile);
	if (is_identifier(token)) {
		name = parse_host_name(cfile);
		if (name)
			h = gethostbyname(name);
		if (name && h) {
			rv = tree_const(h->h_addr_list[0], h->h_length);
			if (!uniform)
				rv = tree_limit(rv, 4);
			return rv;
		}
	}

	if (token == TOK_NUMBER_OR_NAME) {
		if (!parse_numeric_aggregate(cfile, addr, &len, '.', 10, 8)) {
			parse_warn("%s (%d): expecting IP address or hostname",
				    val, token);
			return NULL;
		}
		rv = tree_const(addr, len);
	} else {
		if (token != '{' && token != '}')
			token = next_token(&val, cfile);
		parse_warn("%s (%d): expecting IP address or hostname",
			    val, token);
		if (token != ';')
			skip_to_semi(cfile);
		return NULL;
	}

	return rv;
}


/*
 * fixed-addr-parameter :== ip-addrs-or-hostnames SEMI
 * ip-addrs-or-hostnames :== ip-addr-or-hostname
 *			   | ip-addrs-or-hostnames ip-addr-or-hostname
 */
struct tree_cache *
parse_fixed_addr_param(FILE *cfile)
{
	char *val;
	int token;
	struct tree *tree = NULL;
	struct tree *tmp;

	do {
		tmp = parse_ip_addr_or_hostname(cfile, 0);
		if (tree)
			tree = tree_concat(tree, tmp);
		else
			tree = tmp;
		token = peek_token(&val, cfile);
		if (token == ',')
			token = next_token(&val, cfile);
	} while (token == ',');

	if (!parse_semi(cfile))
		return NULL;
	return tree_cache(tree);
}

/*
 * option_parameter :== identifier DOT identifier <syntax> SEMI
 *		      | identifier <syntax> SEMI
 *
 * Option syntax is handled specially through format strings, so it
 * would be painful to come up with BNF for it. However, it always
 * starts as above and ends in a SEMI.
 */
void
parse_option_param(FILE *cfile, struct group *group)
{
	char *val;
	int token;
	unsigned char buf[4];
	unsigned char cprefix;
	char *vendor;
	char *fmt;
	struct universe *universe;
	struct option *option;
	struct tree *tree = NULL;
	struct tree *t;

	token = next_token(&val, cfile);
	if (!is_identifier(token)) {
		parse_warn("expecting identifier after option keyword.");
		if (token != ';')
			skip_to_semi(cfile);
		return;
	}
	vendor = strdup(val);
	if (vendor == NULL)
		fatalx("no memory for vendor token.");
	token = peek_token(&val, cfile);
	if (token == '.') {
		/* Go ahead and take the DOT token. */
		token = next_token(&val, cfile);

		/* The next token should be an identifier. */
		token = next_token(&val, cfile);
		if (!is_identifier(token)) {
			parse_warn("expecting identifier after '.'");
			if (token != ';')
				skip_to_semi(cfile);
			free(vendor);
			return;
		}

		/*
		 * Look up the option name hash table for the specified
		 * vendor.
		 */
		universe = ((struct universe *)hash_lookup(&universe_hash,
		    (unsigned char *)vendor, 0));
		/*
		 * If it's not there, we can't parse the rest of the
		 * declaration.
		 */
		if (!universe) {
			parse_warn("no vendor named %s.", vendor);
			skip_to_semi(cfile);
			free(vendor);
			return;
		}
	} else {
		/*
		 * Use the default hash table, which contains all the
		 * standard dhcp option names.
		 */
		val = vendor;
		universe = &dhcp_universe;
	}

	/* Look up the actual option info. */
	option = (struct option *)hash_lookup(universe->hash,
	    (unsigned char *)val, 0);

	/* If we didn't get an option structure, it's an undefined option. */
	if (!option) {
		if (val == vendor)
			parse_warn("no option named %s", val);
		else
			parse_warn("no option named %s for vendor %s",
				    val, vendor);
		skip_to_semi(cfile);
		free(vendor);
		return;
	}

	/* Free the initial identifier token. */
	free(vendor);

	/* Parse the option data. */
	do {
		/*
		 * Set a flag if this is an array of a simple type (i.e.,
		 * not an array of pairs of IP addresses, or something
		 * like that.
		 */
		int uniform = option->format[1] == 'A';

		for (fmt = option->format; *fmt; fmt++) {
			if (*fmt == 'A')
				break;
			switch (*fmt) {
			case 'X':
				token = peek_token(&val, cfile);
				if (token == TOK_NUMBER_OR_NAME) {
					do {
						token = next_token
							(&val, cfile);
						if (token !=
						    TOK_NUMBER_OR_NAME) {
							parse_warn("expecting "
							    "hex number.");
							if (token != ';')
								skip_to_semi(
								    cfile);
							return;
						}
						convert_num(buf, val, 16, 8);
						tree = tree_concat(tree,
						    tree_const(buf, 1));
						token = peek_token(&val,
						    cfile);
						if (token == ':')
							token =
							    next_token(&val,
							    cfile);
					} while (token == ':');
				} else if (token == TOK_STRING) {
					token = next_token(&val, cfile);
					tree = tree_concat(tree,
					    tree_const((unsigned char *)val,
					    strlen(val)));
				} else {
					parse_warn("expecting string %s.",
					    "or hexadecimal data");
					skip_to_semi(cfile);
					return;
				}
				break;

			case 't': /* Text string. */
				token = next_token(&val, cfile);
				if (token != TOK_STRING
				    && !is_identifier(token)) {
					parse_warn("expecting string.");
					if (token != ';')
						skip_to_semi(cfile);
					return;
				}
				tree = tree_concat(tree,
				    tree_const((unsigned char *)val,
				    strlen(val)));
				break;

			case 'I': /* IP address or hostname. */
				t = parse_ip_addr_or_hostname(cfile, uniform);
				if (!t)
					return;
				tree = tree_concat(tree, t);
				break;

			case 'L': /* Unsigned 32-bit integer. */
			case 'l': /* Signed 32-bit integer. */
				token = next_token(&val, cfile);
				if (token != TOK_NUMBER && token !=
				    TOK_NUMBER_OR_NAME) {
					parse_warn("expecting number.");
					if (token != ';')
						skip_to_semi(cfile);
					return;
				}
				convert_num(buf, val, 0, 32);
				tree = tree_concat(tree, tree_const(buf, 4));
				break;
			case 's': /* Signed 16-bit integer. */
			case 'S': /* Unsigned 16-bit integer. */
				token = next_token(&val, cfile);
				if (token != TOK_NUMBER && token !=
				    TOK_NUMBER_OR_NAME) {
					parse_warn("expecting number.");
					if (token != ';')
						skip_to_semi(cfile);
					return;
				}
				convert_num(buf, val, 0, 16);
				tree = tree_concat(tree, tree_const(buf, 2));
				break;
			case 'b': /* Signed 8-bit integer. */
			case 'B': /* Unsigned 8-bit integer. */
				token = next_token(&val, cfile);
				if (token != TOK_NUMBER && token !=
				    TOK_NUMBER_OR_NAME) {
					parse_warn("expecting number.");
					if (token != ';')
						skip_to_semi(cfile);
					return;
				}
				convert_num(buf, val, 0, 8);
				tree = tree_concat(tree, tree_const(buf, 1));
				break;
			case 'f': /* Boolean flag. */
				token = next_token(&val, cfile);
				if (!is_identifier(token)) {
					parse_warn("expecting identifier.");
					if (token != ';')
						skip_to_semi(cfile);
					return;
				}
				if (!strcasecmp(val, "true")
				    || !strcasecmp(val, "on"))
					buf[0] = 1;
				else if (!strcasecmp(val, "false")
					 || !strcasecmp(val, "off"))
					buf[0] = 0;
				else {
					parse_warn("expecting boolean.");
					if (token != ';')
						skip_to_semi(cfile);
					return;
				}
				tree = tree_concat(tree, tree_const(buf, 1));
				break;
			case 'C':
				if (!parse_cidr(cfile, buf, &cprefix))
					return;
				tree = tree_concat(tree, tree_const(&cprefix,
				    sizeof(cprefix)));
				if (cprefix > 0)
					tree = tree_concat(tree, tree_const(
					    buf, (cprefix + 7) / 8));
				break;
			case 'D':
				t = parse_domain_and_comp(cfile);
				if (!t)
					return;
				tree = tree_concat(tree, t);
				break;
			default:
				log_warnx("Bad format %c in "
				    "parse_option_param.", *fmt);
				skip_to_semi(cfile);
				return;
			}
		}
		if (*fmt == 'A') {
			token = peek_token(&val, cfile);
			if (token == ',') {
				token = next_token(&val, cfile);
				continue;
			}
			break;
		}
	} while (*fmt == 'A');

	token = next_token(&val, cfile);
	if (token != ';') {
		parse_warn("semicolon expected.");
		skip_to_semi(cfile);
		return;
	}
	group->options[option->code] = tree_cache(tree);
}

/*
 * lease_declaration :== LEASE ip_address LBRACE lease_parameters RBRACE
 *
 * lease_parameters :== <nil>
 *		      | lease_parameter
 *		      | lease_parameters lease_parameter
 *
 * lease_parameter :== STARTS date
 *		     | ENDS date
 *		     | TIMESTAMP date
 *		     | HARDWARE hardware-parameter
 *		     | UID hex_numbers SEMI
 *		     | HOSTNAME hostname SEMI
 *		     | CLIENT_HOSTNAME hostname SEMI
 *		     | CLASS identifier SEMI
 *		     | DYNAMIC_BOOTP SEMI
 */
struct lease *
parse_lease_declaration(FILE *cfile)
{
	char *val;
	int token;
	unsigned char addr[4];
	int len = sizeof addr;
	int seenmask = 0;
	int seenbit;
	char tbuf[32];
	static struct lease lease;

	/* Zap the lease structure. */
	memset(&lease, 0, sizeof lease);

	/* Get the address for which the lease has been issued. */
	if (!parse_numeric_aggregate(cfile, addr, &len, '.', 10, 8))
		return NULL;
	memcpy(lease.ip_addr.iabuf, addr, len);
	lease.ip_addr.len = len;

	if (!parse_lbrace(cfile))
		return NULL;

	do {
		token = next_token(&val, cfile);
		if (token == '}')
			break;
		else if (token == EOF) {
			parse_warn("unexpected end of file");
			break;
		}
		strlcpy(tbuf, val, sizeof tbuf);

		/* Parse any of the times associated with the lease. */
		if (token == TOK_STARTS || token == TOK_ENDS || token ==
		    TOK_TIMESTAMP) {
			time_t t;
			t = parse_date(cfile);
			switch (token) {
			case TOK_STARTS:
				seenbit = 1;
				lease.starts = t;
				break;

			case TOK_ENDS:
				seenbit = 2;
				lease.ends = t;
				break;

			case TOK_TIMESTAMP:
				seenbit = 4;
				lease.timestamp = t;
				break;

			default:
				/*NOTREACHED*/
				seenbit = 0;
				break;
			}
		} else {
			switch (token) {
				/* Colon-separated hexadecimal octets. */
			case TOK_UID:
				seenbit = 8;
				token = peek_token(&val, cfile);
				if (token == TOK_STRING) {
					token = next_token(&val, cfile);
					lease.uid_len = strlen(val);
					lease.uid = malloc(lease.uid_len);
					if (!lease.uid) {
						log_warnx("no space for uid");
						return NULL;
					}
					memcpy(lease.uid, val, lease.uid_len);
					parse_semi(cfile);
				} else {
					lease.uid_len = 0;
					lease.uid =
					    parse_numeric_aggregate(cfile,
					    NULL, &lease.uid_len, ':', 16, 8);
					if (!lease.uid) {
						log_warnx("no space for uid");
						return NULL;
					}
					if (lease.uid_len == 0) {
						lease.uid = NULL;
						parse_warn("zero-length uid");
						seenbit = 0;
						break;
					}
				}
				if (!lease.uid)
					fatalx("No memory for lease uid");
				break;

			case TOK_CLASS:
				seenbit = 32;
				token = next_token(&val, cfile);
				if (!is_identifier(token)) {
					if (token != ';')
						skip_to_semi(cfile);
					return NULL;
				}
				/* for now, we aren't using this. */
				break;

			case TOK_HARDWARE:
				seenbit = 64;
				parse_hardware_param(cfile,
				    &lease.hardware_addr);
				break;

			case TOK_DYNAMIC_BOOTP:
				seenbit = 128;
				lease.flags |= BOOTP_LEASE;
				break;

			case TOK_ABANDONED:
				seenbit = 256;
				lease.flags |= ABANDONED_LEASE;
				break;

			case TOK_HOSTNAME:
				seenbit = 512;
				token = peek_token(&val, cfile);
				if (token == TOK_STRING)
					lease.hostname = parse_string(cfile);
				else
					lease.hostname =
					    parse_host_name(cfile);
				if (!lease.hostname) {
					seenbit = 0;
					return NULL;
				}
				break;

			case TOK_CLIENT_HOSTNAME:
				seenbit = 1024;
				token = peek_token(&val, cfile);
				if (token == TOK_STRING)
					lease.client_hostname =
					    parse_string(cfile);
				else
					lease.client_hostname =
					    parse_host_name(cfile);
				break;

			default:
				skip_to_semi(cfile);
				seenbit = 0;
				return NULL;
			}

			if (token != TOK_HARDWARE && token != TOK_STRING) {
				token = next_token(&val, cfile);
				if (token != ';') {
					parse_warn("semicolon expected.");
					skip_to_semi(cfile);
					return NULL;
				}
			}
		}
		if (seenmask & seenbit) {
			parse_warn("Too many %s parameters in lease %s\n",
			    tbuf, piaddr(lease.ip_addr));
		} else
			seenmask |= seenbit;

	} while (1);
	return &lease;
}

/*
 * address-range-declaration :== ip-address ip-address SEMI
 *			       | DYNAMIC_BOOTP ip-address ip-address SEMI
 */
void
parse_address_range(FILE *cfile, struct subnet *subnet)
{
	struct iaddr low, high;
	unsigned char addr[4];
	int len = sizeof addr, token, dynamic = 0;
	char *val;

	if ((token = peek_token(&val, cfile)) == TOK_DYNAMIC_BOOTP) {
		token = next_token(&val, cfile);
		subnet->group->dynamic_bootp = dynamic = 1;
	}

	/* Get the bottom address in the range. */
	if (!parse_numeric_aggregate(cfile, addr, &len, '.', 10, 8))
		return;
	memcpy(low.iabuf, addr, len);
	low.len = len;

	/* Only one address? */
	token = peek_token(&val, cfile);
	if (token == ';')
		high = low;
	else {
		/* Get the top address in the range. */
		if (!parse_numeric_aggregate(cfile, addr, &len, '.', 10, 8))
			return;
		memcpy(high.iabuf, addr, len);
		high.len = len;
	}

	token = next_token(&val, cfile);
	if (token != ';') {
		parse_warn("semicolon expected.");
		skip_to_semi(cfile);
		return;
	}

	/* Create the new address range. */
	new_address_range(low, high, subnet, dynamic);
}

static void
push_domain_list(char ***domains, size_t *count, char *domain)
{
	*domains = reallocarray(*domains, *count + 1, sizeof **domains);
	if (!*domains)
		fatalx("Can't allocate domain list");

	(*domains)[*count] = domain;
	++*count;
}

static void
free_domain_list(char **domains, size_t count)
{
	size_t i;

	for (i = 0; i < count; i++)
		free(domains[i]);
	free(domains);
}

struct tree *
parse_domain_and_comp(FILE *cfile)
{
	struct tree	 *rv = NULL;
	char		**domains = NULL;
	char		 *val, *domain;
	unsigned char	 *buf = NULL;
	unsigned char	**bufptrs = NULL;
	size_t		  bufsiz = 0, bufn = 0, count = 0, i;
	int		  token = ';';

	do {
		if (token == ',')
			token = next_token(&val, cfile);

		token = next_token(&val, cfile);
		if (token != TOK_STRING) {
			parse_warn("string expected");
			goto error;
		}
		domain = strdup(val);
		if (domain == NULL)
			fatalx("Can't allocate domain to compress");
		push_domain_list(&domains, &count, domain);

		/*
		 * openbsd.org normally compresses to [7]openbsd[3]org[0].
		 * +2 to string length provides space for leading and
		 * trailing (root) prefix lengths not already accounted for
		 * by dots, and also provides sufficient space for pointer
		 * compression.
		 */
		bufsiz = bufsiz + 2 + strlen(domain);
		token = peek_token(NULL, cfile);
	} while (token == ',');

	buf = malloc(bufsiz);
	if (!buf)
		fatalx("Can't allocate compressed domain buffer");
	bufptrs = calloc(count + 1, sizeof *bufptrs);
	if (!bufptrs)
		fatalx("Can't allocate compressed pointer list");
	bufptrs[0] = buf;

	/* dn_comp takes an int for the output buffer size */
	if (!(bufsiz <= INT_MAX))
		fatalx("Size of compressed domain buffer too large");
	for (i = 0; i < count; i++) {
		int n;

		/* see bufsiz <= INT_MAX assertion, above */
		n = dn_comp(domains[i], &buf[bufn], bufsiz - bufn, bufptrs,
		    &bufptrs[count + 1]);
		if (n == -1)
			fatalx("Can't compress domain");
		bufn += (size_t)n;
	}

	rv = tree_const(buf, bufn);
error:
	free_domain_list(domains, count);
	free(buf);
	free(bufptrs);
	return rv;
}