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