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