sbin/ifconfig/parse.c

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