Home | History | Annotate | Line # | Download | only in ifconfig
parse.c revision 1.7
      1 /*	$NetBSD: parse.c,v 1.7 2008/05/12 21:54:51 dyoung Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2008 David Young.  All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 #include <err.h>
     29 #include <errno.h>
     30 #include <limits.h>
     31 #include <netdb.h>
     32 #include <stddef.h>
     33 #include <stdio.h>
     34 #include <stdlib.h>
     35 #include <string.h>
     36 
     37 #include <arpa/inet.h>
     38 #include <sys/param.h>
     39 #include <net/if.h>
     40 #include <net/if_dl.h>
     41 #include <netatalk/at.h>
     42 #include <netiso/iso.h>
     43 
     44 #include "env.h"
     45 #include "parse.h"
     46 #include "util.h"
     47 
     48 #define dbg_warnx(__fmt, ...)	/* empty */
     49 
     50 static int parser_default_init(struct parser *);
     51 static int pbranch_init(struct parser *);
     52 static int pkw_init(struct parser *);
     53 
     54 static int pterm_match(const struct parser *, const struct match *,
     55     struct match *, int, const char *);
     56 
     57 static int paddr_match(const struct parser *, const struct match *,
     58     struct match *, int, const char *);
     59 
     60 static int pbranch_match(const struct parser *, const struct match *,
     61     struct match *, int, const char *);
     62 
     63 static int piface_match(const struct parser *, const struct match *,
     64     struct match *, int, const char *);
     65 
     66 static int pstr_match(const struct parser *, const struct match *,
     67     struct match *, int, const char *);
     68 
     69 static int pinteger_match(const struct parser *, const struct match *,
     70     struct match *, int, const char *);
     71 
     72 static int pkw_match(const struct parser *, const struct match *,
     73     struct match *, int, const char *);
     74 
     75 const struct parser_methods pterm_methods = {
     76 	  .pm_match = pterm_match
     77 	, .pm_init = NULL
     78 };
     79 
     80 const struct parser_methods pstr_methods = {
     81 	  .pm_match = pstr_match
     82 	, .pm_init = parser_default_init
     83 };
     84 
     85 const struct parser_methods pinteger_methods = {
     86 	  .pm_match = pinteger_match
     87 	, .pm_init = parser_default_init
     88 };
     89 
     90 const struct parser_methods paddr_methods = {
     91 	  .pm_match = paddr_match
     92 	, .pm_init = parser_default_init
     93 };
     94 
     95 const struct parser_methods piface_methods = {
     96 	  .pm_match = piface_match
     97 	, .pm_init = parser_default_init
     98 };
     99 
    100 const struct parser_methods pbranch_methods = {
    101 	  .pm_match = pbranch_match
    102 	, .pm_init = pbranch_init
    103 };
    104 
    105 const struct parser_methods pkw_methods = {
    106 	  .pm_match = pkw_match
    107 	, .pm_init = pkw_init
    108 };
    109 
    110 static int
    111 match_setenv(const struct match *im, struct match *om, const char *key,
    112     prop_object_t o)
    113 {
    114 	if (im == NULL)
    115 		om->m_env = prop_dictionary_create();
    116 	else
    117 		om->m_env = prop_dictionary_copy(im->m_env);
    118 
    119 	if (om->m_env == NULL)
    120 		goto delobj;
    121 
    122 	if (key != NULL && !prop_dictionary_set(om->m_env, key, o))
    123 		goto deldict;
    124 
    125 	if (o != NULL)
    126 		prop_object_release((prop_object_t)o);
    127 
    128 	return 0;
    129 deldict:
    130 	prop_object_release((prop_object_t)om->m_env);
    131 	om->m_env = NULL;
    132 delobj:
    133 	prop_object_release((prop_object_t)o);
    134 	errno = ENOMEM;
    135 	return -1;
    136 }
    137 
    138 int
    139 pstr_match(const struct parser *p, const struct match *im, struct match *om,
    140     int argidx, const char *arg)
    141 {
    142 	prop_object_t o;
    143 	const struct pstr *ps = (const struct pstr *)p;
    144 	uint8_t buf[128];
    145 	int len;
    146 
    147 	if (arg == NULL) {
    148 		errno = EINVAL;
    149 		return -1;
    150 	}
    151 
    152 	len = (int)sizeof(buf);
    153 	if (get_string(arg, NULL, buf, &len) == NULL) {
    154 		errno = EINVAL;
    155 		return -1;
    156 	}
    157 
    158 	o = (prop_object_t)prop_data_create_data(buf, len);
    159 
    160 	if (o == NULL) {
    161 		errno = ENOMEM;
    162 		return -1;
    163 	}
    164 
    165 	if (match_setenv(im, om, ps->ps_key, o) == -1)
    166 		return -1;
    167 
    168 	om->m_argidx = argidx;
    169 	om->m_parser = p;
    170 	om->m_nextparser = p->p_nextparser;
    171 
    172 	return 0;
    173 }
    174 
    175 int
    176 pinteger_match(const struct parser *p, const struct match *im, struct match *om,
    177     int argidx, const char *arg)
    178 {
    179 	prop_object_t o;
    180 	const struct pinteger *pi = (const struct pinteger *)p;
    181 	char *end;
    182 	int64_t val;
    183 
    184 	if (arg == NULL) {
    185 		errno = EINVAL;
    186 		return -1;
    187 	}
    188 
    189 	val = strtoimax(arg, &end, pi->pi_base);
    190 	if ((val == INTMAX_MIN || val == INTMAX_MAX) && errno == ERANGE)
    191 		return -1;
    192 
    193 	if (*end != '\0') {
    194 		errno = EINVAL;
    195 		return -1;
    196 	}
    197 
    198 	if (val < pi->pi_min || val > pi->pi_max) {
    199 		errno = ERANGE;
    200 		return -1;
    201 	}
    202 
    203 	o = (prop_object_t)prop_number_create_integer(val);
    204 
    205 	if (o == NULL) {
    206 		errno = ENOMEM;
    207 		return -1;
    208 	}
    209 
    210 	if (match_setenv(im, om, pi->pi_key, o) == -1)
    211 		return -1;
    212 
    213 	om->m_argidx = argidx;
    214 	om->m_parser = p;
    215 	om->m_nextparser = p->p_nextparser;
    216 
    217 	return 0;
    218 }
    219 
    220 static int
    221 parse_linkaddr(const char *addr, struct sockaddr_storage *ss)
    222 {
    223 	static const size_t maxlen =
    224 	    sizeof(*ss) - offsetof(struct sockaddr_dl, sdl_data[0]);
    225 	enum {
    226 		LLADDR_S_INITIAL = 0,
    227 		LLADDR_S_ONE_OCTET = 1,
    228 		LLADDR_S_TWO_OCTETS = 2,
    229 		LLADDR_S_COLON = 3
    230 	} state = LLADDR_S_INITIAL;
    231 	uint8_t octet = 0, val;
    232 	struct sockaddr_dl *sdl;
    233 	const char *p;
    234 	int i;
    235 
    236 	memset(ss, 0, sizeof(*ss));
    237 	ss->ss_family = AF_LINK;
    238 	sdl = (struct sockaddr_dl *)ss;
    239 
    240 	for (i = 0, p = addr; i < maxlen; p++) {
    241 		dbg_warnx("%s.%d: *p == %c, state %d", __func__, __LINE__, *p,
    242 		    state);
    243 		if (*p == '\0') {
    244 			dbg_warnx("%s.%d", __func__, __LINE__);
    245 			if (state != LLADDR_S_ONE_OCTET &&
    246 			    state != LLADDR_S_TWO_OCTETS)
    247 				return -1;
    248 			dbg_warnx("%s.%d", __func__, __LINE__);
    249 			sdl->sdl_data[i++] = octet;
    250 			sdl->sdl_len =
    251 			    offsetof(struct sockaddr_dl, sdl_data[i]);
    252 			sdl->sdl_alen = i;
    253 			return 0;
    254 		}
    255 		if (*p == ':') {
    256 			dbg_warnx("%s.%d", __func__, __LINE__);
    257 			if (state != LLADDR_S_ONE_OCTET &&
    258 			    state != LLADDR_S_TWO_OCTETS)
    259 				return -1;
    260 			dbg_warnx("%s.%d", __func__, __LINE__);
    261 			sdl->sdl_data[i++] = octet;
    262 			state = LLADDR_S_COLON;
    263 			continue;
    264 		}
    265 		if ('a' <= *p && *p <= 'f')
    266 			val = 10 + *p - 'a';
    267 		else if ('A' <= *p && *p <= 'F')
    268 			val = 10 + *p - 'A';
    269 		else if ('0' <= *p && *p <= '9')
    270 			val = *p - '0';
    271 		else
    272 			return -1;
    273 
    274 		dbg_warnx("%s.%d", __func__, __LINE__);
    275 		if (state == LLADDR_S_ONE_OCTET) {
    276 			state = LLADDR_S_TWO_OCTETS;
    277 			octet <<= 4;
    278 			octet |= val;
    279 		} else if (state != LLADDR_S_INITIAL && state != LLADDR_S_COLON)
    280 			return -1;
    281 		else {
    282 			state = LLADDR_S_ONE_OCTET;
    283 			octet = val;
    284 		}
    285 		dbg_warnx("%s.%d", __func__, __LINE__);
    286 	}
    287 	return -1;
    288 }
    289 
    290 static int
    291 paddr_match(const struct parser *p, const struct match *im, struct match *om,
    292     int argidx, const char *arg0)
    293 {
    294 	unsigned int net, node;
    295 	int nread;
    296 	union {
    297 		struct sockaddr sa;
    298 		struct sockaddr_at sat;
    299 		struct sockaddr_iso siso;
    300 		struct sockaddr_in sin;
    301 		struct sockaddr_storage ss;
    302 	} u;
    303 	const struct paddr *pa = (const struct paddr *)p;
    304 	prop_data_t d;
    305 	prop_object_t o;
    306 	int64_t af0;
    307 	int af, rc;
    308 	struct paddr_prefix *pfx, *mask;
    309 	const struct sockaddr *sa = NULL;
    310 	struct addrinfo hints, *result = NULL;
    311 	char *arg, *end, *plen = NULL, *servname0;
    312 	const char *servname;
    313 	long prefixlen = -1;
    314 	size_t len;
    315 
    316 	if (arg0 == NULL) {
    317 		errno = EINVAL;
    318 		return -1;
    319 	}
    320 
    321 	if (pa->pa_activator != NULL &&
    322 	    prop_dictionary_get(im->m_env, pa->pa_activator) == NULL)
    323 		return -1;
    324 
    325 	if (pa->pa_deactivator != NULL &&
    326 	    prop_dictionary_get(im->m_env, pa->pa_deactivator) != NULL)
    327 		return -1;
    328 
    329 	if (!prop_dictionary_get_int64(im->m_env, "af", &af0))
    330 		af = AF_UNSPEC;
    331 	else
    332 		af = af0;
    333 
    334 	switch (af) {
    335 	case AF_UNSPEC:
    336 	case AF_INET:
    337 	case AF_INET6:
    338 		if ((arg = strdup(arg0)) == NULL)
    339 			return -1;
    340 
    341 		servname0 = arg;
    342 		(void)strsep(&servname0, ",");
    343 		servname = (servname0 == NULL) ? "0" : servname0;
    344 
    345 		if (pa->pa_maskkey == NULL)
    346 			;
    347 		else if ((plen = strrchr(arg, '/')) != NULL)
    348 			*plen++ = '\0';
    349 
    350 		memset(&u, 0, sizeof(u));
    351 
    352 		memset(&hints, 0, sizeof(hints));
    353 
    354 		hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;
    355 		hints.ai_family = af;
    356 		hints.ai_socktype = SOCK_DGRAM;
    357 
    358 		for (;;) {
    359 			rc = getaddrinfo(arg, servname, &hints, &result);
    360 			if (rc == 0) {
    361 				if (result->ai_next == NULL)
    362 					sa = result->ai_addr;
    363 				else
    364 					errno = EMLINK;
    365 				break;
    366 			} else if ((hints.ai_flags & AI_NUMERICHOST) != 0 &&
    367 			    (af == AF_INET || af == AF_UNSPEC) &&
    368 			    inet_aton(arg, &u.sin.sin_addr) == 1) {
    369 				u.sin.sin_family = AF_INET;
    370 				u.sin.sin_len = sizeof(u.sin);
    371 				sa = &u.sa;
    372 				break;
    373 			} else if ((hints.ai_flags & AI_NUMERICHOST) == 0 ||
    374 				 rc != EAI_NONAME) {
    375 				errno = ENOENT;
    376 				break;
    377 			}
    378 			hints.ai_flags &= ~AI_NUMERICHOST;
    379 		}
    380 
    381 
    382 		if (plen == NULL)
    383 			prefixlen = -1;
    384 		else {
    385 			prefixlen = strtol(plen, &end, 10);
    386 			if (end != NULL && *end != '\0')
    387 				sa = NULL;
    388 			if (prefixlen < 0 || prefixlen >= UINT8_MAX) {
    389 				errno = ERANGE;
    390 				sa = NULL;
    391 			}
    392 		}
    393 
    394 		free(arg);
    395 		if (sa != NULL || af != AF_UNSPEC)
    396 			break;
    397 		/*FALLTHROUGH*/
    398 	case AF_APPLETALK:
    399 		if (sscanf(arg0, "%u.%u%n", &net, &node, &nread) == 2 &&
    400 		    net != 0 && net <= 0xffff && node != 0 && node <= 0xfe &&
    401 		    arg0[nread] == '\0') {
    402 			u.sat.sat_family = AF_APPLETALK;
    403 			u.sat.sat_len = sizeof(u.sat);
    404 			u.sat.sat_addr.s_net = htons(net);
    405 			u.sat.sat_addr.s_node = node;
    406 			sa = &u.sa;
    407 		}
    408 		if (af != AF_UNSPEC)
    409 			break;
    410 		/*FALLTHROUGH*/
    411 	case AF_ISO:
    412 		u.siso.siso_len = sizeof(u.siso);
    413 		u.siso.siso_family = AF_ISO;
    414 		/* XXX iso_addr(3) matches ANYTHING! */
    415 		u.siso.siso_addr = *iso_addr(arg0);
    416 		sa = &u.sa;
    417 		break;
    418 	case AF_LINK:
    419 		if (parse_linkaddr(arg0, &u.ss) == -1)
    420 			sa = NULL;
    421 		else
    422 			sa = &u.sa;
    423 		break;
    424 	}
    425 
    426 	if (sa == NULL)
    427 		return -1;
    428 
    429 	len = offsetof(struct paddr_prefix, pfx_addr) + sa->sa_len;
    430 
    431 	if ((pfx = malloc(len)) == NULL)
    432 		return -1;
    433 
    434 #if 0
    435 	{
    436 		int i;
    437 
    438 		for (i = 0; i < sa->sa_len; i++)
    439 			printf(" %02x", ((const uint8_t *)sa)[i]);
    440 		printf("\n");
    441 	}
    442 #endif
    443 
    444 	pfx->pfx_len = (int16_t)prefixlen;
    445 	memcpy(&pfx->pfx_addr, sa, sa->sa_len);
    446 	af = sa->sa_family;
    447 
    448 	if (result != NULL)
    449 		freeaddrinfo(result);
    450 
    451 	o = (prop_object_t)prop_data_create_data(pfx, len);
    452 
    453 	free(pfx);
    454 
    455 	if (o == NULL)
    456 		return -1;
    457 
    458 	if (match_setenv(im, om, pa->pa_addrkey, o) == -1)
    459 		return -1;
    460 
    461 	if (pa->pa_maskkey != NULL && plen != NULL) {
    462 		size_t masklen;
    463 
    464 		if ((mask = prefixlen_to_mask(af, prefixlen)) == NULL) {
    465 			err(EXIT_FAILURE, "%s: prefixlen_to_mask(%d, %ld)",
    466 			    __func__, af, prefixlen);
    467 			return -1;
    468 		}
    469 
    470 		masklen = offsetof(struct paddr_prefix, pfx_addr) +
    471 		    mask->pfx_addr.sa_len;
    472 
    473 		d = prop_data_create_data(mask, masklen);
    474 		free(mask);
    475 
    476 		if (d == NULL) {
    477 			err(EXIT_FAILURE, "%s: prop_data_create_data",
    478 			    __func__);
    479 			return -1;
    480 		}
    481 
    482 		rc = prop_dictionary_set(om->m_env, pa->pa_maskkey,
    483 		    (prop_object_t)d) ? 0 : -1;
    484 
    485 		prop_object_release((prop_object_t)d);
    486 
    487 		if (rc != 0) {
    488 			err(EXIT_FAILURE, "%s: prop_dictionary_set", __func__);
    489 			return rc;
    490 		}
    491 	}
    492 
    493 	om->m_argidx = argidx;
    494 	om->m_parser = p;
    495 	om->m_nextparser = p->p_nextparser;
    496 	return 0;
    497 }
    498 
    499 static int
    500 pterm_match(const struct parser *p, const struct match *im,
    501     struct match *om, int argidx, const char *arg)
    502 {
    503 	const struct pterm *pt = (const struct pterm *)p;
    504 	prop_bool_t b;
    505 
    506 	if (arg != NULL) {
    507 		errno = EINVAL;
    508 		return -1;
    509 	}
    510 	b = prop_bool_create(true);
    511 
    512 	if (match_setenv(im, om, pt->pt_key, (prop_object_t)b) == -1)
    513 		return -1;
    514 
    515 	om->m_argidx = argidx;
    516 	om->m_parser = p;
    517 	om->m_nextparser = NULL;
    518 	return 0;
    519 }
    520 
    521 static int
    522 piface_match(const struct parser *p, const struct match *im,
    523     struct match *om, int argidx, const char *arg)
    524 {
    525 	const struct piface *pif = (const struct piface *)p;
    526 	prop_object_t o;
    527 
    528 	if (arg == NULL || strlen(arg) > IFNAMSIZ) {
    529 		errno = EINVAL;
    530 		return -1;
    531 	}
    532 
    533 	if ((o = (prop_object_t)prop_string_create_cstring(arg)) == NULL) {
    534 		errno = ENOMEM;
    535 		return -1;
    536 	}
    537 
    538 	if (match_setenv(im, om, pif->pif_key, o) == -1)
    539 		return -1;
    540 
    541 	om->m_argidx = argidx;
    542 	om->m_parser = p;
    543 	om->m_nextparser = p->p_nextparser;
    544 	return 0;
    545 }
    546 
    547 static void
    548 match_cleanup(struct match *dst)
    549 {
    550 	if (dst->m_env != NULL)
    551 		prop_object_release((prop_object_t)dst->m_env);
    552 	memset(dst, 0, sizeof(*dst));
    553 }
    554 
    555 static void
    556 match_copy(struct match *dst, const struct match *src)
    557 {
    558 	match_cleanup(dst);
    559 
    560 	prop_object_retain((prop_object_t)src->m_env);
    561 	*dst = *src;
    562 }
    563 
    564 static int
    565 pbranch_match(const struct parser *p, const struct match *im,
    566     struct match *om, int argidx, const char *arg)
    567 {
    568 	const struct parser *nextp;
    569 	struct branch *b;
    570 	const struct pbranch *pb = (const struct pbranch *)p;
    571 	struct match tmpm;
    572 	int nforbid = 0, nmatch = 0, rc;
    573 	parser_match_t matchfunc;
    574 
    575 	memset(&tmpm, 0, sizeof(tmpm));
    576 
    577 	SIMPLEQ_FOREACH(b, &pb->pb_branches, b_next) {
    578 		dbg_warnx("%s: b->b_nextparser %p", __func__,
    579 		    (const void *)b->b_nextparser);
    580 		nextp = b->b_nextparser;
    581 		if (nextp == NULL) {
    582 			if (arg == NULL) {
    583 				nmatch++;
    584 				match_setenv(im, om, NULL, NULL);
    585 				om->m_nextparser = NULL;
    586 				om->m_parser = p;
    587 				om->m_argidx = argidx;
    588 			}
    589 			continue;
    590 		}
    591 		matchfunc = nextp->p_methods->pm_match;
    592 		rc = (*matchfunc)(nextp, im, &tmpm, argidx, arg);
    593 		if (rc == 0) {
    594 			match_copy(om, &tmpm);
    595 			match_cleanup(&tmpm);
    596 			nmatch++;
    597 			dbg_warnx("%s: branch %s ok", __func__, nextp->p_name);
    598 			if (pb->pb_match_first)
    599 				break;
    600 		} else if (rc == 1) {
    601 			nforbid++;
    602 			if (pb->pb_match_first)
    603 				break;
    604 		} else {
    605 			dbg_warnx("%s: fail branch %s", __func__,
    606 			    nextp->p_name);
    607 		}
    608 	}
    609 	switch (nmatch) {
    610 	case 0:
    611 		errno = ENOENT;
    612 		return (nforbid == 0) ? -1 : 1;
    613 	case 1:
    614 		dbg_warnx("%s: branch ok", __func__);
    615 		return 0;
    616 	default:
    617 		match_cleanup(om);
    618 		errno = EMLINK;
    619 		return -1;
    620 	}
    621 }
    622 
    623 static int
    624 pkw_match(const struct parser *p, const struct match *im,
    625     struct match *om, int argidx, const char *arg)
    626 {
    627 	prop_object_t o = NULL;
    628 	struct kwinst *k;
    629 	union kwval *u = NULL;
    630 	const struct pkw *pk = (const struct pkw *)p;
    631 
    632 	if (arg == NULL) {
    633 		errno = EINVAL;
    634 		return -1;
    635 	}
    636 
    637 	SIMPLEQ_FOREACH(k, &pk->pk_keywords, k_next) {
    638 		if (k->k_act != NULL &&
    639 		    prop_dictionary_get(im->m_env, k->k_act) == NULL)
    640 			continue;
    641 
    642 		if (k->k_neg && arg[0] == '-' &&
    643 		    strcmp(k->k_word, arg + 1) == 0)
    644 			u = &k->k_negu;
    645 		else if (strcmp(k->k_word, arg) == 0)
    646 			u = &k->k_u;
    647 		else
    648 			continue;
    649 
    650 		if (k->k_altdeact != NULL &&
    651 		    prop_dictionary_get(im->m_env, k->k_altdeact) != NULL)
    652 			return 1;
    653 
    654 		if (k->k_deact != NULL &&
    655 		    prop_dictionary_get(im->m_env, k->k_deact) != NULL)
    656 			return 1;
    657 		break;
    658 	}
    659 	if (k == NULL) {
    660 		errno = ENOENT;
    661 		return -1;
    662 	}
    663 	switch (k->k_type) {
    664 	case KW_T_NONE:
    665 		break;
    666 	case KW_T_BOOL:
    667 		o = (prop_object_t)prop_bool_create(u->u_bool);
    668 		if (o == NULL)
    669 			goto err;
    670 		break;
    671 	case KW_T_NUM:
    672 		o = (prop_object_t)prop_number_create_integer(u->u_num);
    673 		if (o == NULL)
    674 			goto err;
    675 		break;
    676 	case KW_T_OBJ:
    677 		o = u->u_obj;
    678 		break;
    679 	case KW_T_STR:
    680 		o = (prop_object_t)prop_data_create_data_nocopy(u->u_str,
    681 		    strlen(u->u_str));
    682 		if (o == NULL)
    683 			goto err;
    684 		break;
    685 	default:
    686 		errx(EXIT_FAILURE, "unknown keyword type %d", k->k_type);
    687 	}
    688 
    689 	if (match_setenv(im, om, (o == NULL) ? NULL : k->k_key, o) == -1)
    690 		return -1;
    691 
    692 	om->m_argidx = argidx;
    693 	om->m_parser = p;
    694 	om->m_nextparser = k->k_nextparser;
    695 	om->m_exec = k->k_exec;
    696 	return 0;
    697 err:
    698 	errno = ENOMEM;
    699 	return -1;
    700 }
    701 
    702 struct paddr *
    703 paddr_create(const char *name, parser_exec_t pexec, const char *addrkey,
    704     const char *maskkey, struct parser *next)
    705 {
    706 	struct paddr *pa;
    707 
    708 	if ((pa = calloc(sizeof(*pa), 1)) == NULL)
    709 		return NULL;
    710 
    711 	pa->pa_parser.p_methods = &paddr_methods;
    712 	pa->pa_parser.p_exec = pexec;
    713 	pa->pa_parser.p_name = name;
    714 	pa->pa_parser.p_nextparser = next;
    715 
    716 	pa->pa_addrkey = addrkey;
    717 	pa->pa_maskkey = maskkey;
    718 
    719 	return pa;
    720 }
    721 
    722 struct piface *
    723 piface_create(const char *name, parser_exec_t pexec, const char *defkey,
    724     struct parser *defnext)
    725 {
    726 	struct piface *pif;
    727 
    728 	if ((pif = calloc(sizeof(*pif), 1)) == NULL)
    729 		return NULL;
    730 
    731 	pif->pif_parser.p_methods = &piface_methods;
    732 	pif->pif_parser.p_exec = pexec;
    733 	pif->pif_parser.p_name = name;
    734 	pif->pif_parser.p_nextparser = defnext;
    735 
    736 	pif->pif_key = defkey;
    737 
    738 	return pif;
    739 }
    740 
    741 int
    742 pbranch_setbranches(struct pbranch *pb, const struct branch *brs, size_t nbr)
    743 {
    744 	struct branch *b;
    745 	int i;
    746 
    747 	dbg_warnx("%s: nbr %zu", __func__, nbr);
    748 
    749 	while ((b = SIMPLEQ_FIRST(&pb->pb_branches)) != NULL) {
    750 		SIMPLEQ_REMOVE_HEAD(&pb->pb_branches, b_next);
    751 		free(b);
    752 	}
    753 
    754 	for (i = 0; i < nbr; i++) {
    755 		if ((b = malloc(sizeof(*b))) == NULL)
    756 			goto err;
    757 		*b = brs[i];
    758 		dbg_warnx("%s: b->b_nextparser %p", __func__,
    759 		    (const void *)b->b_nextparser);
    760 		SIMPLEQ_INSERT_TAIL(&pb->pb_branches, b, b_next);
    761 	}
    762 
    763 	return 0;
    764 err:
    765 	while ((b = SIMPLEQ_FIRST(&pb->pb_branches)) != NULL) {
    766 		SIMPLEQ_REMOVE_HEAD(&pb->pb_branches, b_next);
    767 		free(b);
    768 	}
    769 	return -1;
    770 }
    771 
    772 static int
    773 pbranch_init(struct parser *p)
    774 {
    775 	struct branch *b;
    776 	struct pbranch *pb = (struct pbranch *)p;
    777 	struct parser *np;
    778 
    779 	if (pb->pb_nbrinit == 0 || !SIMPLEQ_EMPTY(&pb->pb_branches))
    780 		return 0;
    781 
    782 	if (pbranch_setbranches(pb, pb->pb_brinit, pb->pb_nbrinit) == -1)
    783 		return -1;
    784 
    785 	SIMPLEQ_FOREACH(b, &pb->pb_branches, b_next) {
    786 		np = b->b_nextparser;
    787 		if (np != NULL && parser_init(np) == -1)
    788 			return -1;
    789 	}
    790 	return 0;
    791 }
    792 
    793 struct pbranch *
    794 pbranch_create(const char *name, const struct branch *brs, size_t nbr,
    795     bool match_first)
    796 {
    797 	struct pbranch *pb;
    798 
    799 	dbg_warnx("%s: nbr %zu", __func__, nbr);
    800 
    801 	if ((pb = calloc(1, sizeof(*pb))) == NULL)
    802 		return NULL;
    803 
    804 	pb->pb_parser.p_methods = &pbranch_methods;
    805 	pb->pb_parser.p_name = name;
    806 
    807 	SIMPLEQ_INIT(&pb->pb_branches);
    808 
    809 	if (pbranch_setbranches(pb, brs, nbr) == -1)
    810 		goto post_pb_err;
    811 
    812 	pb->pb_match_first = match_first;
    813 	return pb;
    814 post_pb_err:
    815 	free(pb);
    816 	return NULL;
    817 }
    818 
    819 static int
    820 parser_default_init(struct parser *p)
    821 {
    822 	struct parser *np;
    823 
    824 	np = p->p_nextparser;
    825 	if (np != NULL && parser_init(np) == -1)
    826 		return -1;
    827 
    828 	return 0;
    829 }
    830 
    831 static int
    832 pkw_setwords(struct pkw *pk, parser_exec_t defexec, const char *defkey,
    833     const struct kwinst *kws, size_t nkw, struct parser *defnext)
    834 {
    835 	struct kwinst *k;
    836 	int i;
    837 
    838 	for (i = 0; i < nkw; i++) {
    839 		if ((k = malloc(sizeof(*k))) == NULL)
    840 			goto post_pk_err;
    841 		*k = kws[i];
    842 		if (k->k_nextparser == NULL)
    843 			k->k_nextparser = defnext;
    844 		if (k->k_key == NULL)
    845 			k->k_key = defkey;
    846 		if (k->k_exec == NULL)
    847 			k->k_exec = defexec;
    848 		SIMPLEQ_INSERT_TAIL(&pk->pk_keywords, k, k_next);
    849 	}
    850 	return 0;
    851 
    852 post_pk_err:
    853 	while ((k = SIMPLEQ_FIRST(&pk->pk_keywords)) != NULL) {
    854 		SIMPLEQ_REMOVE_HEAD(&pk->pk_keywords, k_next);
    855 		free(k);
    856 	}
    857 	return -1;
    858 }
    859 
    860 static int
    861 pkw_init(struct parser *p)
    862 {
    863 	struct kwinst *k;
    864 	struct pkw *pk = (struct pkw *)p;
    865 	struct parser *np;
    866 
    867 	if (pk->pk_nkwinit == 0 || !SIMPLEQ_EMPTY(&pk->pk_keywords))
    868 		return 0;
    869 	if (pkw_setwords(pk, pk->pk_execinit, pk->pk_keyinit, pk->pk_kwinit,
    870 	    pk->pk_nkwinit, pk->pk_nextinit) == -1)
    871 		return -1;
    872 	SIMPLEQ_FOREACH(k, &pk->pk_keywords, k_next) {
    873 		np = k->k_nextparser;
    874 		if (np != NULL && parser_init(np) == -1)
    875 			return -1;
    876 	}
    877 	return 0;
    878 }
    879 
    880 struct pkw *
    881 pkw_create(const char *name, parser_exec_t defexec, const char *defkey,
    882     const struct kwinst *kws, size_t nkw, struct parser *defnext)
    883 {
    884 	struct pkw *pk;
    885 
    886 	if ((pk = calloc(1, sizeof(*pk))) == NULL)
    887 		return NULL;
    888 
    889 	pk->pk_parser.p_methods = &pkw_methods;
    890 	pk->pk_parser.p_exec = defexec;
    891 	pk->pk_parser.p_name = name;
    892 
    893 	SIMPLEQ_INIT(&pk->pk_keywords);
    894 
    895 	if (pkw_setwords(pk, defexec, defkey, kws, nkw, defnext) == -1)
    896 		goto err;
    897 
    898 	return pk;
    899 err:
    900 	free(pk);
    901 	return NULL;
    902 }
    903 
    904 int
    905 parse(int argc, char **argv, const struct parser *p0, struct match *matches,
    906     size_t *nmatch, int *narg)
    907 {
    908 	int i, rc = 0;
    909 	struct match *lastm = NULL, *m = matches;
    910 	const struct parser *p = p0;
    911 
    912 	for (i = 0; i < argc && p != NULL; i++) {
    913 		if (m - matches >= *nmatch) {
    914 			errno = EFBIG;
    915 			rc = -1;
    916 			break;
    917 		}
    918 		rc = (*p->p_methods->pm_match)(p, lastm, m, i, argv[i]);
    919 		if (rc != 0)
    920 			goto out;
    921 		p = m->m_nextparser;
    922 		lastm = m++;
    923 	}
    924 	for (; m - matches < *nmatch && p != NULL; ) {
    925 		rc = (*p->p_methods->pm_match)(p, lastm, m, i, NULL);
    926 		if (rc != 0)
    927 			break;
    928 		p = m->m_nextparser;
    929 		lastm = m++;
    930 	}
    931 out:
    932 	*nmatch = m - matches;
    933 	*narg = i;
    934 	return rc;
    935 }
    936 
    937 int
    938 matches_exec(const struct match *matches, prop_dictionary_t xenv, size_t nmatch)
    939 {
    940 	int i, rc = 0;
    941 	const struct match *m;
    942 	parser_exec_t pexec;
    943 	prop_dictionary_t d;
    944 
    945 	for (i = 0; i < nmatch; i++) {
    946 		m = &matches[i];
    947 		dbg_warnx("%s.%d: i %d", __func__, __LINE__, i);
    948 		pexec = (m->m_parser->p_exec != NULL)
    949 		    ? m->m_parser->p_exec : m->m_exec;
    950 		if (pexec == NULL)
    951 			continue;
    952 		dbg_warnx("%s.%d: m->m_parser->p_name %s", __func__, __LINE__,
    953 		    m->m_parser->p_name);
    954 		d = prop_dictionary_augment(m->m_env, xenv);
    955 		rc = (*pexec)(d, xenv);
    956 		prop_object_release((prop_object_t)d);
    957 		if (rc == -1)
    958 			break;
    959 	}
    960 	return rc;
    961 }
    962