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