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