cfparse.y

/*	$KAME: cfparse.y,v 1.36 2005/05/03 06:46:00 jinmei Exp $	*/

/*
 * Copyright (C) 2002 WIDE Project.
 * 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 project 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 PROJECT 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 PROJECT 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.
 */
%{
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/queue.h>
#include <sys/time.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdlib.h>
#include <string.h>

/* XXX */
#include <stdio.h>
#include <ctype.h>

#include "dhcp6.h"
#include "config.h"
#include "common.h"

extern int lineno;
extern int cfdebug;
extern int yychar;
extern int yynerrs;

void yywarn(const char *, ...)
	__attribute__((__format__(__printf__, 1, 2)));
void yyerror(const char *, ...)
	__attribute__((__format__(__printf__, 1, 2)));

#define MAKE_NAMELIST(l, n, p) do { \
	(l) = (struct cf_namelist *)malloc(sizeof(*(l))); \
	if ((l) == NULL) { \
		yywarn("can't allocate memory"); \
		if (p) cleanup_cflist(p); \
		return (-1); \
	} \
	memset((l), 0, sizeof(*(l))); \
	l->line = lineno; \
	l->name = (n); \
	l->params = (p); \
	} while (0)

#define MAKE_CFLIST(l, t, pp, pl) do { \
	(l) = (struct cf_list *)malloc(sizeof(*(l))); \
	if ((l) == NULL) { \
		yywarn("can't allocate memory"); \
		if (pp) free(pp); \
		if (pl) cleanup_cflist(pl); \
		return (-1); \
	} \
	memset((l), 0, sizeof(*(l))); \
	l->line = lineno; \
	l->type = (t); \
	l->ptr = (pp); \
	l->list = (pl); \
	l->tail = (l); \
	} while (0)

static struct cf_namelist *iflist_head, *hostlist_head, *iapdlist_head;
static struct cf_namelist *addrpoollist_head;
static struct cf_namelist *authinfolist_head, *keylist_head;
static struct cf_namelist *ianalist_head;

struct cf_list *cf_dns_list, *cf_dns_name_list, *cf_ntp_list;
struct cf_list *cf_sip_list, *cf_sip_name_list;
struct cf_list *cf_nis_list, *cf_nis_name_list;
struct cf_list *cf_nisp_list, *cf_nisp_name_list;
struct cf_list *cf_bcmcs_list, *cf_bcmcs_name_list;

extern long long cf_refreshtime;
long long cf_refreshtime = -1;

int yylex(void);
int cfswitch_buffer(char *);

struct rawoption *make_rawoption(int opnum, char *datastr);
static int add_namelist(struct cf_namelist *, struct cf_namelist **);
static void cleanup(void);
static void cleanup_namelist(struct cf_namelist *);
static void cleanup_cflist(struct cf_list *);
int cf_post_config(void);
void cf_init(void);
%}

%token INTERFACE IFNAME
%token PREFIX_INTERFACE SLA_ID SLA_LEN DUID_ID
%token ID_ASSOC IA_PD IAID IA_NA
%token ADDRESS
%token REQUEST SEND ALLOW PREFERENCE
%token HOST HOSTNAME DUID
%token OPTION RAPID_COMMIT DNS_SERVERS DNS_NAME NTP_SERVERS REFRESHTIME
%token SIP_SERVERS SIP_NAME
%token NIS_SERVERS NIS_NAME
%token NISP_SERVERS NISP_NAME
%token BCMCS_SERVERS BCMCS_NAME
%token INFO_ONLY
%token SCRIPT DELAYEDKEY
%token AUTHENTICATION PROTOCOL ALGORITHM DELAYED RECONFIG HMACMD5 MONOCOUNTER
%token AUTHNAME RDM KEY
%token KEYINFO REALM KEYID SECRET KEYNAME EXPIRE
%token ADDRPOOL POOLNAME RANGE TO ADDRESS_POOL
%token INCLUDE

%token NUMBER SLASH EOS BCL ECL STRING QSTRING PREFIX INFINITY
%token COMMA
%token RAW

%union {
	long long num;
	char* str;
	struct cf_list *list;
	struct dhcp6_prefix *prefix;
	struct dhcp6_range *range;
	struct dhcp6_poolspec *pool;
}

%type <str> IFNAME HOSTNAME AUTHNAME KEYNAME DUID_ID STRING QSTRING IAID
%type <str> POOLNAME
%type <num> NUMBER duration authproto authalg authrdm
%type <list> declaration declarations dhcpoption ifparam ifparams
%type <list> address_list address_list_ent dhcpoption_list
%type <list> iapdconf_list iapdconf prefix_interface
%type <list> ianaconf_list ianaconf
%type <list> authparam_list authparam
%type <list> keyparam_list keyparam
%type <prefix> addressparam prefixparam
%type <range> rangeparam
%type <pool> poolparam

%%
statements:
		/* empty */
	|	statements statement
	;

statement:
		interface_statement
	|	host_statement
	|	option_statement
	|	ia_statement
	|	authentication_statement
	|	key_statement
	|	addrpool_statement
	|	include_statement
	;

interface_statement:
	INTERFACE IFNAME BCL declarations ECL EOS
	{
		struct cf_namelist *ifl;

		MAKE_NAMELIST(ifl, $2, $4);

		if (add_namelist(ifl, &iflist_head))
			return (-1);
	}
	;

host_statement:
	HOST HOSTNAME BCL declarations ECL EOS
	{
		struct cf_namelist *host;

		MAKE_NAMELIST(host, $2, $4);

		if (add_namelist(host, &hostlist_head))
			return (-1);
	}
	;

option_statement:
		OPTION DNS_SERVERS address_list EOS
		{
			if (cf_dns_list == NULL)
				cf_dns_list = $3;
			else {
				cf_dns_list->tail->next = $3;
				cf_dns_list->tail = $3->tail;
			}
		}
	|	OPTION DNS_NAME QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, CFLISTENT_GENERIC, $3, NULL);

			if (cf_dns_name_list == NULL) {
				cf_dns_name_list = l;
				cf_dns_name_list->tail = l;
				cf_dns_name_list->next = NULL;
			} else {
				cf_dns_name_list->tail->next = l;
				cf_dns_name_list->tail = l->tail;
			}
		}
	|	OPTION NTP_SERVERS address_list EOS
		{
			if (cf_ntp_list == NULL)
				cf_ntp_list = $3;
			else {
				cf_ntp_list->tail->next = $3;
				cf_ntp_list->tail = $3->tail;
			}
		}
	|	OPTION SIP_SERVERS address_list EOS
		{
			if (cf_sip_list == NULL)
				cf_sip_list = $3;
			else {
				cf_sip_list->tail->next = $3;
				cf_sip_list->tail = $3->tail;
			}
		}
	|	OPTION SIP_NAME QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, CFLISTENT_GENERIC, $3, NULL);

			if (cf_sip_name_list == NULL) {
				cf_sip_name_list = l;
				cf_sip_name_list->tail = l;
				cf_sip_name_list->next = NULL;
			} else {
				cf_sip_name_list->tail->next = l;
				cf_sip_name_list->tail = l->tail;
			}
		}
	|	OPTION NIS_SERVERS address_list EOS
		{
			if (cf_nis_list == NULL)
				cf_nis_list = $3;
			else {
				cf_nis_list->tail->next = $3;
				cf_nis_list->tail = $3->tail;
			}
		}
	|	OPTION NIS_NAME QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, CFLISTENT_GENERIC, $3, NULL);

			if (cf_nis_name_list == NULL) {
				cf_nis_name_list = l;
				cf_nis_name_list->tail = l;
				cf_nis_name_list->next = NULL;
			} else {
				cf_nis_name_list->tail->next = l;
				cf_nis_name_list->tail = l->tail;
			}
		}
	|	OPTION NISP_SERVERS address_list EOS
		{
			if (cf_nisp_list == NULL)
				cf_nisp_list = $3;
			else {
				cf_nisp_list->tail->next = $3;
				cf_nisp_list->tail = $3->tail;
			}
		}
	|	OPTION NISP_NAME QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, CFLISTENT_GENERIC, $3, NULL);

			if (cf_nisp_name_list == NULL) {
				cf_nisp_name_list = l;
				cf_nisp_name_list->tail = l;
				cf_nisp_name_list->next = NULL;
			} else {
				cf_nisp_name_list->tail->next = l;
				cf_nisp_name_list->tail = l->tail;
			}
		}
	|	OPTION BCMCS_SERVERS address_list EOS
		{
			if (cf_bcmcs_list == NULL)
				cf_bcmcs_list = $3;
			else {
				cf_bcmcs_list->tail->next = $3;
				cf_bcmcs_list->tail = $3->tail;
			}
		}
	|	OPTION BCMCS_NAME QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, CFLISTENT_GENERIC, $3, NULL);

			if (cf_bcmcs_name_list == NULL) {
				cf_bcmcs_name_list = l;
				cf_bcmcs_name_list->tail = l;
				cf_bcmcs_name_list->next = NULL;
			} else {
				cf_bcmcs_name_list->tail->next = l;
				cf_bcmcs_name_list->tail = l->tail;
			}
		}
	|	OPTION REFRESHTIME NUMBER EOS
		{
			if (cf_refreshtime == -1) {
				cf_refreshtime = $3;
				if (cf_refreshtime < -1 ||
				    cf_refreshtime > 0xffffffff) {
					/*
					 * refresh time should not be negative
					 * according to the lex definition,
					 * but check it for safety.
					 */
					yyerror("refresh time is out of range");
				}
				if (cf_refreshtime < DHCP6_IRT_MINIMUM) {
					/*
					 * the value MUST NOT be smaller than
					 * IRT_MINIMUM.
					 */
					yyerror("refresh time is too small "
					    "(must not be smaller than %d)",
					    DHCP6_IRT_MINIMUM);
				}
			} else {
				yywarn("multiple refresh times (ignored)");
			}
		}
	;

ia_statement:
		ID_ASSOC IA_PD IAID BCL iapdconf_list ECL EOS
		{
			struct cf_namelist *iapd;

			MAKE_NAMELIST(iapd, $3, $5);

			if (add_namelist(iapd, &iapdlist_head))
				return (-1);
		}
	|	ID_ASSOC IA_PD BCL iapdconf_list ECL EOS
		{
			struct cf_namelist *iapd;
			char *zero;

			if ((zero = strdup("0")) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			MAKE_NAMELIST(iapd, zero, $4);

			if (add_namelist(iapd, &iapdlist_head))
				return (-1);
		}
	|	ID_ASSOC IA_NA IAID BCL ianaconf_list ECL EOS
		{
			struct cf_namelist *iana;

			MAKE_NAMELIST(iana, $3, $5);

			if (add_namelist(iana, &ianalist_head))
				return (-1);
		}
	|	ID_ASSOC IA_NA BCL ianaconf_list ECL EOS
		{
			struct cf_namelist *iana;
			char *zero;

			if ((zero = strdup("0")) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			MAKE_NAMELIST(iana, zero, $4);

			if (add_namelist(iana, &ianalist_head))
				return (-1);
		}
	;

authentication_statement:
	AUTHENTICATION AUTHNAME BCL authparam_list ECL EOS
	{
		struct cf_namelist *authinfo;

		MAKE_NAMELIST(authinfo, $2, $4);

		if (add_namelist(authinfo, &authinfolist_head))
			return (-1);
	}
	;

key_statement:
	KEYINFO KEYNAME BCL keyparam_list ECL EOS
	{
		struct cf_namelist *key;

		MAKE_NAMELIST(key, $2, $4);

		if (add_namelist(key, &keylist_head))
			return (-1);
	}
	;

include_statement:
	INCLUDE QSTRING EOS
	{
		if (cfswitch_buffer($2)) {
			free($2);
			return (-1);
		}
		free($2);
	}
	;

addrpool_statement:
	ADDRPOOL POOLNAME BCL declarations ECL EOS
	{
		struct cf_namelist *pool;

		MAKE_NAMELIST(pool, $2, $4);

		if (add_namelist(pool, &addrpoollist_head))
			return (-1);
	}
	;

address_list:
		{ $$ = NULL; }
	|	address_list address_list_ent
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

address_list_ent:
	STRING
	{
		struct cf_list *l;
		struct in6_addr a0, *a;

		if (inet_pton(AF_INET6, $1, &a0) != 1) {
			yywarn("invalid IPv6 address: %s", $1);
			free($1);
			return (-1);
		}
		if ((a = malloc(sizeof(*a))) == NULL) {
			yywarn("can't allocate memory");
			return (-1);
		}
		*a = a0;

		MAKE_CFLIST(l, CFLISTENT_GENERIC, a, NULL);

		$$ = l;
	}
	;

declarations:
		{ $$ = NULL; }
	|	declarations declaration
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

declaration:
		SEND dhcpoption_list EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_SEND, NULL, $2);

			$$ = l;
		}
	|	REQUEST dhcpoption_list EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_REQUEST, NULL, $2);

			$$ = l;
		}
	|	INFO_ONLY EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_INFO_ONLY, NULL, NULL);
			/* no value */
			$$ = l;
		}
	|	ALLOW dhcpoption EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_ALLOW, NULL, $2);

			$$ = l;
		}
	|	DUID DUID_ID EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_DUID, $2, NULL);

			$$ = l;
		}
	|	ADDRESS addressparam EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_ADDRESS, $2,NULL);

			$$ = l;
		}
	|	PREFIX prefixparam EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_PREFIX, $2, NULL);

			$$ = l;
		}
	|	PREFERENCE NUMBER EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_PREFERENCE, NULL, NULL);
			l->num = $2;

			$$ = l;
		}
	|	SCRIPT QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_SCRIPT, $2, NULL);

			$$ = l;
		}
	|	DELAYEDKEY STRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_DELAYEDKEY, $2, NULL);

			$$ = l;
		}
	|	RANGE rangeparam EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_RANGE, $2, NULL);

			$$ = l;
		}
	|	ADDRESS_POOL poolparam EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DECL_ADDRESSPOOL, $2, NULL);

			$$ = l;
		}
	;

dhcpoption_list:
		dhcpoption
		{
			$$ = $1;
		}
	|	dhcpoption COMMA dhcpoption_list
		{
			$1->next = $3;
			$1->tail = $3->tail;

			$$ = $1;
		}
	;

dhcpoption:
		RAPID_COMMIT
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_RAPID_COMMIT, NULL, NULL);
			/* no value */
			$$ = l;
		}
	|	AUTHENTICATION AUTHNAME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_AUTHINFO, NULL, NULL);
			l->ptr = $2;
			$$ = l;
		}
	|	IA_PD NUMBER
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_IA_PD, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|       IA_NA NUMBER
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_IA_NA, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|	SIP_SERVERS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_SIP, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	SIP_NAME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_SIPNAME, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	RAW NUMBER STRING
		{
			struct cf_list *l;
			struct rawoption *rawoption = make_rawoption ($2, $3);

			MAKE_CFLIST(l, DHCPOPT_RAW, NULL, NULL);
			l->ptr = rawoption;
			$$ = l;
		}
	|	DNS_SERVERS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_DNS, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	DNS_NAME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_DNSNAME, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	NTP_SERVERS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_NTP, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	REFRESHTIME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_REFRESHTIME, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	NIS_SERVERS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_NIS, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	NIS_NAME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_NISNAME, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	NISP_SERVERS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_NISP, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	NISP_NAME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_NISPNAME, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	BCMCS_SERVERS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_BCMCS, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	|	BCMCS_NAME
		{
			struct cf_list *l;

			MAKE_CFLIST(l, DHCPOPT_BCMCSNAME, NULL, NULL);
			/* currently no value */
			$$ = l;
		}
	;

rangeparam:
		STRING TO STRING
		{
			struct dhcp6_range range0, *range;

			memset(&range0, 0, sizeof(range0));
			if (inet_pton(AF_INET6, $1, &range0.min) != 1) {
				yywarn("invalid IPv6 address: %s", $1);
				free($1);
				free($3);
				return (-1);
			}
			if (inet_pton(AF_INET6, $3, &range0.max) != 1) {
				yywarn("invalid IPv6 address: %s", $3);
				free($1);
				free($3);
				return (-1);
			}
			free($1);
			free($3);

			if ((range = malloc(sizeof(*range))) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			*range = range0;

			$$ = range;
		}
	;

addressparam:
		STRING duration
		{
			struct dhcp6_prefix pconf0, *pconf;

			memset(&pconf0, 0, sizeof(pconf0));
			if (inet_pton(AF_INET6, $1, &pconf0.addr) != 1) {
				yywarn("invalid IPv6 address: %s", $1);
				free($1);
				return (-1);
			}
			free($1);
			/* validate other parameters later */
			pconf0.plen = 128; /* XXX this field is ignored */
			if ($2 < 0)
				pconf0.pltime = DHCP6_DURATION_INFINITE;
			else
				pconf0.pltime = (uint32_t)$2;
			pconf0.vltime = pconf0.pltime;

			if ((pconf = malloc(sizeof(*pconf))) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			*pconf = pconf0;

			$$ = pconf;
		}
	|	STRING duration duration
		{
			struct dhcp6_prefix pconf0, *pconf;

			memset(&pconf0, 0, sizeof(pconf0));
			if (inet_pton(AF_INET6, $1, &pconf0.addr) != 1) {
				yywarn("invalid IPv6 address: %s", $1);
				free($1);
				return (-1);
			}
			free($1);
			/* validate other parameters later */
			pconf0.plen = 128; /* XXX */
			if ($2 < 0)
				pconf0.pltime = DHCP6_DURATION_INFINITE;
			else
				pconf0.pltime = (uint32_t)$2;
			if ($3 < 0)
				pconf0.vltime = DHCP6_DURATION_INFINITE;
			else
				pconf0.vltime = (uint32_t)$3;

			if ((pconf = malloc(sizeof(*pconf))) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			*pconf = pconf0;

			$$ = pconf;
		}
	;

prefixparam:
		STRING SLASH NUMBER duration
		{
			struct dhcp6_prefix pconf0, *pconf;

			memset(&pconf0, 0, sizeof(pconf0));
			if (inet_pton(AF_INET6, $1, &pconf0.addr) != 1) {
				yywarn("invalid IPv6 address: %s", $1);
				free($1);
				return (-1);
			}
			free($1);
			/* validate other parameters later */
			pconf0.plen = $3;
			if ($4 < 0)
				pconf0.pltime = DHCP6_DURATION_INFINITE;
			else
				pconf0.pltime = (uint32_t)$4;
			pconf0.vltime = pconf0.pltime;

			if ((pconf = malloc(sizeof(*pconf))) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			*pconf = pconf0;

			$$ = pconf;
		}
	|	STRING SLASH NUMBER duration duration
		{
			struct dhcp6_prefix pconf0, *pconf;

			memset(&pconf0, 0, sizeof(pconf0));
			if (inet_pton(AF_INET6, $1, &pconf0.addr) != 1) {
				yywarn("invalid IPv6 address: %s", $1);
				free($1);
				return (-1);
			}
			free($1);
			/* validate other parameters later */
			pconf0.plen = $3;
			if ($4 < 0)
				pconf0.pltime = DHCP6_DURATION_INFINITE;
			else
				pconf0.pltime = (uint32_t)$4;
			if ($5 < 0)
				pconf0.vltime = DHCP6_DURATION_INFINITE;
			else
				pconf0.vltime = (uint32_t)$5;

			if ((pconf = malloc(sizeof(*pconf))) == NULL) {
				yywarn("can't allocate memory");
				return (-1);
			}
			*pconf = pconf0;

			$$ = pconf;
		}
	;

poolparam:
		STRING duration
		{
			struct dhcp6_poolspec* pool;

			if ((pool = malloc(sizeof(*pool))) == NULL) {
				yywarn("can't allocate memory");
				free($1);
				return (-1);
			}
			if ((pool->name = strdup($1)) == NULL) {
				yywarn("can't allocate memory");
				free($1);
				return (-1);
			}
			free($1);

			/* validate other parameters later */
			if ($2 < 0)
				pool->pltime = DHCP6_DURATION_INFINITE;
			else
				pool->pltime = (uint32_t)$2;
			pool->vltime = pool->pltime;

			$$ = pool;
		}
	|	STRING duration duration
		{
			struct dhcp6_poolspec* pool;

			if ((pool = malloc(sizeof(*pool))) == NULL) {
				yywarn("can't allocate memory");
				free($1);
				return (-1);
			}
			if ((pool->name = strdup($1)) == NULL) {
				yywarn("can't allocate memory");
				free($1);
				return (-1);
			}
			free($1);

			/* validate other parameters later */
			if ($2 < 0)
				pool->pltime = DHCP6_DURATION_INFINITE;
			else
				pool->pltime = (uint32_t)$2;
			if ($3 < 0)
				pool->vltime = DHCP6_DURATION_INFINITE;
			else
				pool->vltime = (uint32_t)$3;

			$$ = pool;
		}
	;

duration:
		INFINITY
		{
			$$ = -1;
		}
	|	NUMBER
		{
			$$ = $1;
		}
	;

iapdconf_list:
		{ $$ = NULL; }
	|	iapdconf_list iapdconf
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

iapdconf:
		prefix_interface { $$ = $1; }
	|	PREFIX prefixparam EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, IACONF_PREFIX, $2, NULL);

			$$ = l;
		}
	;

prefix_interface:
	PREFIX_INTERFACE IFNAME BCL ifparams ECL EOS
	{
		struct cf_list *ifl;

		MAKE_CFLIST(ifl, IACONF_PIF, $2, $4);
		$$ = ifl;
	}
	;

ifparams:
		{ $$ = NULL; }
	|	ifparams ifparam
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

ifparam:
		SLA_ID NUMBER EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, IFPARAM_SLA_ID, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|	SLA_LEN NUMBER EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, IFPARAM_SLA_LEN, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	;

ianaconf_list:
		{ $$ = NULL; }
	|	ianaconf_list ianaconf
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

ianaconf:
	 	ADDRESS addressparam EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, IACONF_ADDR, $2, NULL);

			$$ = l;
		}
	;

authparam_list:
		{ $$ = NULL; }
	|	authparam_list authparam
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

authparam:
		PROTOCOL authproto EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, AUTHPARAM_PROTO, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|	ALGORITHM authalg EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, AUTHPARAM_ALG, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|	RDM authrdm EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, AUTHPARAM_RDM, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|	KEY STRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, AUTHPARAM_KEY, NULL, NULL);
			l->ptr = $2;
			$$ = l;
		}
	;

authproto:
		DELAYED { $$ = DHCP6_AUTHPROTO_DELAYED; }
	|	RECONFIG { $$ = DHCP6_AUTHPROTO_RECONFIG; }
	;

authalg:
	HMACMD5 { $$ = DHCP6_AUTHALG_HMACMD5; }
	;

authrdm:
	MONOCOUNTER { $$ = DHCP6_AUTHRDM_MONOCOUNTER; }
	;

keyparam_list:
		{ $$ = NULL; }
	|	keyparam_list keyparam
		{
			struct cf_list *head;

			if ((head = $1) == NULL) {
				$2->next = NULL;
				$2->tail = $2;
				head = $2;
			} else {
				head->tail->next = $2;
				head->tail = $2->tail;
			}

			$$ = head;
		}
	;

keyparam:
		REALM QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, KEYPARAM_REALM, NULL, NULL);
			l->ptr = $2;
			$$ = l;
		}
	|	KEYID NUMBER EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, KEYPARAM_KEYID, NULL, NULL);
			l->num = $2;
			$$ = l;
		}
	|	SECRET QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, KEYPARAM_SECRET, NULL, NULL);
			l->ptr = $2;
			$$ = l;
		}
	|	EXPIRE QSTRING EOS
		{
			struct cf_list *l;

			MAKE_CFLIST(l, KEYPARAM_EXPIRE, NULL, NULL);
			l->ptr = $2;
			$$ = l;
		}
	;

%%
/* supplement routines for configuration */

struct rawoption*
make_rawoption(int opnum, char *datastr)
{
			struct rawoption *rawop;
			char *tmp;
			yywarn("Got raw option: %i %s", opnum, datastr);

			if ((rawop = malloc(sizeof(*rawop))) == NULL) {
				yywarn("RAW can't allocate memory");
				free(datastr);
				return NULL;
			}

			/* convert op num */
			rawop->opnum = opnum;

			/* convert string to lowercase */
			tmp = datastr;
			for ( ; *tmp; ++tmp) *tmp = tolower(*tmp);

			/* allocate buffer */
			int len = strlen(datastr);
			len -= len / 3; /* remove ':' from length */
			len = len / 2; /* byte length */
			rawop->datalen = len;

			if ((rawop->data = malloc(len)) == NULL) {
				yywarn("can't allocate memory");
				free(rawop);
				free(datastr);
				return NULL;
			}

			/* convert hex string to byte array */
			char *h = datastr;
			char *b = rawop->data;
			char xlate[] = "0123456789abcdef";
			int p1, p2;

			for ( ; *h; h += 3, ++b) { /* string is xx(:xx)\0 */
				p1 = (int)(strchr(xlate, *h) - xlate);
				p2 = (int)(strchr(xlate, *(h+1)) - xlate);
				*b = (char)((p1 * 16) + p2);
			}
			free(datastr);

			yywarn("Raw option %d length %d stored at %p with data at %p",
				rawop->opnum, rawop->datalen, (void*)rawop, (void*)rawop->data);

			return rawop;
}

static int
add_namelist(struct cf_namelist *new, struct cf_namelist **headp)
{
	struct cf_namelist *n;

	/* check for duplicated configuration */
	for (n = *headp; n; n = n->next) {
		if (strcmp(n->name, new->name) == 0) {
			yywarn("duplicated name: %s (ignored)",
			       new->name);
			cleanup_namelist(new);
			return (0);
		}
	}

	new->next = *headp;
	*headp = new;

	return (0);
}

/* free temporary resources */
static void
cleanup(void)
{
	cleanup_namelist(iflist_head);
	iflist_head = NULL;
	cleanup_namelist(hostlist_head);
	hostlist_head = NULL;
	cleanup_namelist(iapdlist_head);
	iapdlist_head = NULL;
	cleanup_namelist(ianalist_head);
	ianalist_head = NULL;
	cleanup_namelist(authinfolist_head);
	authinfolist_head = NULL;
	cleanup_namelist(keylist_head);
	keylist_head = NULL;
	cleanup_namelist(addrpoollist_head);
	addrpoollist_head = NULL;

	cleanup_cflist(cf_sip_list);
	cf_sip_list = NULL;
	cleanup_cflist(cf_sip_name_list);
	cf_sip_name_list = NULL;
	cleanup_cflist(cf_dns_list);
	cf_dns_list = NULL;
	cleanup_cflist(cf_dns_name_list);
	cf_dns_name_list = NULL;
	cleanup_cflist(cf_ntp_list);
	cf_ntp_list = NULL;
	cleanup_cflist(cf_nis_list);
	cf_nis_list = NULL;
	cleanup_cflist(cf_nis_name_list);
	cf_nis_name_list = NULL;
	cleanup_cflist(cf_nisp_list);
	cf_nisp_list = NULL;
	cleanup_cflist(cf_nisp_name_list);
	cf_nisp_name_list = NULL;
	cleanup_cflist(cf_bcmcs_list);
	cf_bcmcs_list = NULL;
	cleanup_cflist(cf_bcmcs_name_list);
	cf_bcmcs_name_list = NULL;
}

static void
cleanup_namelist(struct cf_namelist *head)
{
	struct cf_namelist *ifp, *ifp_next;

	for (ifp = head; ifp; ifp = ifp_next) {
		ifp_next = ifp->next;
		cleanup_cflist(ifp->params);
		free(ifp->name);
		free(ifp);
	}
}

static void
cleanup_cflist(struct cf_list *p)
{
	struct cf_list *n;

	if (p == NULL)
		return;

	n = p->next;
	if (p->type == DECL_ADDRESSPOOL) {
		free(((struct dhcp6_poolspec *)p->ptr)->name);
	}
	/* Need to clean RAWOption data buffer */
	if (p->ptr){
		switch (p->type) {
		case DHCPOPT_RAW:{
			struct rawoption *rawoption = p->ptr;
			yywarn ("Releasing raw option num %i datalen %i\n", rawoption->opnum, rawoption->datalen);
			free (rawoption->data);
		}
			break;
		default:;
		}
		free(p->ptr);
	}
	if (p->list)
		cleanup_cflist(p->list);
	free(p);

	cleanup_cflist(n);
}

#define config_fail() \
	do { cleanup(); configure_cleanup(); return (-1); } while(0)

int
cf_post_config(void)
{
	if (configure_keys(keylist_head))
		config_fail();

	if (configure_authinfo(authinfolist_head))
		config_fail();

	if (configure_ia(iapdlist_head, IATYPE_PD))
		config_fail();

	if (configure_ia(ianalist_head, IATYPE_NA))
		config_fail();

	if (configure_pool(addrpoollist_head))
		config_fail();

	if (configure_interface(iflist_head))
		config_fail();

	if (configure_host(hostlist_head))
		config_fail();

	if (configure_global_option())
		config_fail();

	configure_commit();
	cleanup();
	return (0);
}
#undef config_fail

void
cf_init(void)
{
#if YYDEBUG
	yydebug = 1;
#endif
	iflist_head = NULL;
	hostlist_head = NULL;
	iapdlist_head = NULL;
	ianalist_head = NULL;
	authinfolist_head = NULL;
	keylist_head = NULL;
	addrpoollist_head = NULL;
	cf_sip_list = NULL;
	cf_sip_name_list = NULL;
	cf_dns_list = NULL;
	cf_dns_name_list = NULL;
	cf_ntp_list = NULL;
	cf_nis_list = NULL;
	cf_nis_name_list = NULL;
	cf_nisp_list = NULL;
	cf_nisp_name_list = NULL;
	cf_bcmcs_list = NULL;
	cf_bcmcs_name_list = NULL;
}