1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2001-2003 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <stdio.h> 30 #include <string.h> 31 #include <stdlib.h> 32 #include <ctype.h> 33 #include <fcntl.h> 34 #include <unistd.h> 35 #include <locale.h> 36 37 #include "ldap_parse.h" 38 #include "nis_parse_ldap_conf.h" 39 40 /* other attribute functions */ 41 static char *getIndex(const char **s_cur, const char *end_s); 42 static bool_t get_ttls(const char *s, const char *s_end, 43 __nis_table_mapping_t *t_mapping); 44 static __nis_object_dn_t *parse_object_dn(const char *s, const char *end); 45 static int parse_name_fields(const char *name_s, const char *name_s_end, 46 __nis_table_mapping_t *t_mapping); 47 static void get_mapping_rule(const char *s, int len, 48 __nis_table_mapping_t *tbl, bool_t to_ldap); 49 static bool_t get_deleteDisp(const char *s_begin, const char *s_end, 50 __nis_object_dn_t *obj_dn); 51 52 /* mapping rule functions */ 53 static const char *get_lhs(const char *s, const char *end_s, 54 __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type); 55 static const char *get_lhs_match(const char *s, const char *end_s, 56 __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type); 57 static const char *get_lhs_paren_item(const char *s, const char *end_s, 58 __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type); 59 static const char *get_rhs(const char *s, const char *end_s, 60 __nis_mapping_rlhs_t *lhs, __nis_mapping_item_type_t item_type); 61 static const char *get_mapping_item(const char *s, const char *end_s, 62 __nis_mapping_item_t *item, __nis_mapping_item_type_t type); 63 static const char *get_print_mapping_element(const char *s, 64 const char *end_s, char *fmt_string, __nis_mapping_element_t *e, 65 __nis_mapping_item_type_t item_type); 66 static const char *get_subElement(const char *s, const char *end_s, 67 __nis_mapping_sub_element_t *subelement, 68 __nis_mapping_item_type_t type); 69 static bool_t get_mapping_format(const char *fmt_string, 70 __nis_mapping_format_t **fmt, int *nfmt, int *numItems, 71 bool_t print_mapping); 72 extern __yp_domain_context_t ypDomains; 73 74 /* 75 * FUNCTION: add_mapping_attribute 76 * 77 * Adds the attribute value to __nis_table_mapping_t 78 * if the value is not yet set for the given database. 79 * 80 * RETURN VALUE: 0 on success, -1 on failure 81 * 82 * INPUT: attribute number and value 83 */ 84 85 int 86 add_mapping_attribute( 87 config_key attrib_num, 88 const char *attrib_val, 89 int attrib_len, 90 __nis_table_mapping_t **table_mapping) 91 { 92 const char *s; 93 const char *attrib_end; 94 const char *db_id_end; 95 const char *begin_token; 96 const char *end_token; 97 char *index_string; 98 __nis_object_dn_t *objectDN; 99 __nis_table_mapping_t *t_mapping; 100 __nis_table_mapping_t *t; 101 102 bool_t new_mapping = FALSE; 103 int nm; 104 char *tmp_dbId; 105 106 attrib_end = attrib_val + attrib_len; 107 for (s = attrib_val; s < attrib_end; s++) 108 if (*s == COLON_CHAR) 109 break; 110 111 if (s == attrib_end || *attrib_val == COLON_CHAR) { 112 p_error = parse_unexpected_data_end_rule; 113 return (-1); 114 } 115 116 db_id_end = s; 117 while (s > attrib_val && is_whitespace(s[-1])) 118 s--; 119 120 if (s == attrib_val) { 121 p_error = parse_unexpected_data_end_rule; 122 return (-1); 123 } 124 125 if (yp2ldap) { 126 tmp_dbId = s_strndup(attrib_val, s - attrib_val); 127 if (tmp_dbId == NULL) { 128 p_error = parse_no_mem_error; 129 return (-1); 130 } 131 if (strchr(tmp_dbId, COMMA_CHAR)) { 132 /* domain explicitly specified */ 133 nm = check_domain_specific_order(tmp_dbId, 134 attrib_num, *table_mapping, &ypDomains); 135 /* 136 * No logging is needed here, as 137 * check_domain_specific_order 138 * will log any appropriate errors. 139 */ 140 if (nm != 0) { 141 free(tmp_dbId); 142 return (-1); 143 } 144 } 145 free(tmp_dbId); 146 } 147 148 if ((t_mapping = find_table_mapping(attrib_val, 149 s - attrib_val, *table_mapping)) == NULL) { 150 /* No mapping with this id, create one */ 151 t_mapping = (__nis_table_mapping_t *) 152 s_calloc(1, sizeof (__nis_table_mapping_t)); 153 154 if (t_mapping == NULL) { 155 p_error = parse_no_mem_error; 156 return (-1); 157 } 158 (void) initialize_table_mapping(t_mapping); 159 160 /* dbId is the label before the colon */ 161 t_mapping->dbId = s_strndup(attrib_val, s - attrib_val); 162 if (t_mapping->dbId == NULL) { 163 p_error = parse_no_mem_error; 164 free(t_mapping); 165 return (-1); 166 } 167 new_mapping = TRUE; 168 } else { 169 /* a table mapping already exists, use it */ 170 new_mapping = FALSE; 171 } 172 173 s = db_id_end + 1; 174 while (s < attrib_end && is_whitespace(*s)) 175 s++; 176 177 switch (attrib_num) { 178 case key_yp_map_flags: 179 if (t_mapping->usedns_flag != 0 || 180 t_mapping->securemap_flag != 0) { 181 warn_duplicate_map(t_mapping->dbId, 182 attrib_num); 183 break; 184 } 185 while (is_whitespace(*s) && s < attrib_end) 186 s++; 187 while (s < attrib_end) { 188 if (s < attrib_end && *s == 'b') 189 t_mapping->usedns_flag = 1; 190 if (s < attrib_end && *s == 's') 191 t_mapping->securemap_flag = 1; 192 s++; 193 } 194 break; 195 case key_yp_comment_char: 196 if (t_mapping->commentChar != 197 DEFAULT_COMMENT_CHAR) { 198 warn_duplicate_map(t_mapping->dbId, attrib_num); 199 break; 200 } 201 while (is_whitespace(*s) && s < attrib_end) 202 s++; 203 if (s < attrib_end && (s+1) < attrib_end && 204 (s+2) <= attrib_end) { 205 while (is_whitespace(attrib_end[-1])) 206 attrib_end--; 207 while (*s != SINGLE_QUOTE_CHAR) 208 s++; 209 if (*s == SINGLE_QUOTE_CHAR && 210 *(s+2) == SINGLE_QUOTE_CHAR) { 211 t_mapping->commentChar = *(s+1); 212 } else if (*s == SINGLE_QUOTE_CHAR && 213 *(s+1) == SINGLE_QUOTE_CHAR) { 214 t_mapping->commentChar = NULL; 215 } else { 216 /* anything else is an error */ 217 p_error = parse_bad_yp_comment_error; 218 } 219 break; 220 } else { 221 p_error = parse_bad_yp_comment_error; 222 break; 223 } 224 case key_yp_repeated_field_separators: 225 while (s < attrib_end && is_whitespace(*s)) 226 s++; 227 if (s < attrib_end) { 228 while (is_whitespace(attrib_end[-1])) 229 attrib_end--; 230 while (s < attrib_end && 231 *s != DOUBLE_QUOTE_CHAR) 232 s++; 233 s++; 234 begin_token = s; 235 while (s < attrib_end && 236 *s != DOUBLE_QUOTE_CHAR) { 237 if (*s == ESCAPE_CHAR) 238 s++; 239 s++; 240 } 241 t_mapping->separatorStr = 242 s_strndup(begin_token, s - begin_token); 243 if (t_mapping->separatorStr == NULL) 244 break; 245 } else { 246 p_error = parse_bad_field_separator_error; 247 } 248 break; 249 case key_yp_name_fields: 250 case key_yp_split_field: 251 if (t_mapping->e || t_mapping->numSplits > 0) { 252 warn_duplicate_map(t_mapping->dbId, 253 attrib_num); 254 break; 255 } 256 if (parse_name_fields(s, attrib_end, t_mapping)) { 257 p_error = parse_bad_name_field; 258 } 259 break; 260 case key_yp_db_id_map: 261 case key_db_id_map: 262 if (t_mapping->objName != NULL) { 263 warn_duplicate_map(t_mapping->dbId, attrib_num); 264 break; 265 } 266 267 if (s < attrib_end && *s == OPEN_BRACKET) { 268 index_string = getIndex(&s, attrib_end); 269 if (index_string == NULL) 270 break; 271 (void) parse_index(index_string, 272 index_string + strlen(index_string), 273 &t_mapping->index); 274 free(index_string); 275 if (p_error != no_parse_error) 276 break; 277 } 278 while (is_whitespace(*s) && s < attrib_end) 279 s++; 280 if (s < attrib_end) { 281 while (is_whitespace(attrib_end[-1])) 282 attrib_end--; 283 t_mapping->objName = 284 s_strndup_esc(s, attrib_end - s); 285 } else { 286 if (yp2ldap) { 287 p_error = parse_bad_map_error; 288 } else { 289 t_mapping->objName = s_strndup(s, 0); 290 } 291 } 292 break; 293 294 case key_yp_entry_ttl: 295 case key_entry_ttl: 296 if (t_mapping->initTtlLo != (time_t)NO_VALUE_SET) { 297 warn_duplicate_map(t_mapping->dbId, attrib_num); 298 break; 299 } 300 301 if (!get_ttls(s, attrib_end, t_mapping)) 302 p_error = parse_bad_ttl_format_error; 303 break; 304 305 case key_yp_ldap_object_dn: 306 case key_ldap_object_dn: 307 if (t_mapping->objectDN != NULL) { 308 warn_duplicate_map(t_mapping->dbId, attrib_num); 309 break; 310 } 311 objectDN = parse_object_dn(s, attrib_end); 312 if (objectDN == NULL) 313 break; 314 t_mapping->objectDN = objectDN; 315 t_mapping->seq_num = seq_num++; 316 break; 317 318 case key_nis_to_ldap_map: 319 case key_nisplus_to_ldap_map: 320 if (t_mapping->ruleToLDAP != 0) { 321 warn_duplicate_map(t_mapping->dbId, attrib_num); 322 break; 323 } 324 325 get_mapping_rule(s, attrib_end - s, t_mapping, TRUE); 326 break; 327 328 case key_ldap_to_nis_map: 329 case key_ldap_to_nisplus_map: 330 if (t_mapping->ruleFromLDAP != NULL) { 331 warn_duplicate_map(t_mapping->dbId, attrib_num); 332 break; 333 } 334 335 get_mapping_rule(s, attrib_end - s, t_mapping, FALSE); 336 break; 337 338 default: 339 p_error = parse_internal_error; 340 break; 341 } 342 if (p_error == no_parse_error) { 343 if (new_mapping) { 344 if (*table_mapping == NULL) 345 *table_mapping = t_mapping; 346 else { 347 for (t = *table_mapping; t->next != NULL; 348 t = t->next) 349 ; 350 t->next = t_mapping; 351 } 352 } 353 } else { 354 if (new_mapping) 355 free_table_mapping(t_mapping); 356 } 357 return (p_error == no_parse_error ? 0 : -1); 358 } 359 360 /* 361 * FUNCTION: add_ypdomains_attribute 362 * 363 * Adds the yp domains information to the __yp_domain_context_t 364 * structure. 365 * 366 * RETURN: 0 on success, -1 on failure 367 * 368 * INPUT: attribute number and value 369 */ 370 371 int 372 add_ypdomains_attribute( 373 config_key attrib_num, 374 const char *attrib_val, 375 int attrib_len, 376 __yp_domain_context_t *ypDomains) 377 { 378 const char *s; 379 const char *attrib_end; 380 int numDomains = 0; 381 int i; 382 char *tmp_str; 383 int ret = 0; 384 385 attrib_end = attrib_val + attrib_len; 386 for (s = attrib_val; s < attrib_end; s++) { 387 if (*s == COLON_CHAR) { 388 break; 389 } 390 } 391 while (s > attrib_val && is_whitespace(s[-1])) 392 s--; 393 394 if (s == attrib_val) { 395 p_error = parse_unexpected_data_end_rule; 396 return (-1); 397 } 398 399 if (ypDomains == NULL) { 400 /* 401 * No point allocating. We cant return the resulting structure, 402 * so just return failure. Should not ever happen because we 403 * are always called with a pointer to the global ypDomains 404 * structure. 405 */ 406 return (-1); 407 } 408 409 switch (attrib_num) { 410 case key_yp_domain_context: 411 numDomains = ypDomains->numDomains; 412 ypDomains->domainLabels = 413 (char **)s_realloc(ypDomains->domainLabels, 414 (numDomains + 1) * 415 sizeof (ypDomains->domainLabels[0])); 416 if (ypDomains->domainLabels == NULL) { 417 p_error = parse_no_mem_error; 418 free_yp_domain_context(ypDomains); 419 break; 420 } 421 ypDomains->domainLabels[numDomains] = 422 s_strndup(attrib_val, s - attrib_val); 423 if (ypDomains->domainLabels[numDomains] == NULL) { 424 p_error = parse_no_mem_error; 425 free_yp_domain_context(ypDomains); 426 break; 427 } 428 ypDomains->numDomains = numDomains + 1; 429 while (s < attrib_end && is_whitespace(*s)) 430 s++; 431 if (*s == COLON_CHAR) 432 s++; 433 while (s < attrib_end && is_whitespace(*s)) 434 s++; 435 ypDomains->domains = 436 (char **)s_realloc(ypDomains->domains, 437 (numDomains + 1) * 438 sizeof (ypDomains->domains[0])); 439 if (ypDomains->domains == NULL) { 440 p_error = parse_no_mem_error; 441 free_yp_domain_context(ypDomains); 442 break; 443 } 444 445 if (s < attrib_end) { 446 while (is_whitespace(attrib_end[-1])) 447 attrib_end--; 448 ypDomains->domains[numDomains] = 449 s_strndup_esc(s, attrib_end - s); 450 if (ypDomains->domains[numDomains] == NULL) { 451 p_error = parse_no_mem_error; 452 free_yp_domain_context(ypDomains); 453 break; 454 } 455 } else { 456 p_error = parse_unexpected_yp_domain_end_error; 457 free(ypDomains->domainLabels[numDomains]); 458 ypDomains->domainLabels[numDomains] = NULL; 459 ypDomains->numDomains--; 460 free_yp_domain_context(ypDomains); 461 } 462 break; 463 case key_yppasswdd_domains: 464 ypDomains->yppasswddDomainLabels = 465 (char **)s_realloc( 466 ypDomains->yppasswddDomainLabels, 467 (ypDomains->numYppasswdd + 1) * 468 sizeof (ypDomains->yppasswddDomainLabels[0])); 469 if (ypDomains->yppasswddDomainLabels == NULL) { 470 p_error = parse_no_mem_error; 471 break; 472 } 473 ypDomains->yppasswddDomainLabels 474 [ypDomains->numYppasswdd] = 475 s_strndup(attrib_val, s - attrib_val); 476 if (ypDomains->yppasswddDomainLabels 477 [ypDomains->numYppasswdd] == NULL) { 478 p_error = parse_no_mem_error; 479 } 480 ypDomains->numYppasswdd++; 481 break; 482 } 483 484 return (p_error == no_parse_error ? 0 : -1); 485 } 486 487 /* 488 * FUNCTION: get_ttls 489 * 490 * Parse time to live attribute 491 * 492 * RETURN VALUE: TRUE on success, FALSE on failure 493 * 494 * INPUT: the attribute value 495 */ 496 497 static bool_t 498 get_ttls( 499 const char *s, 500 const char *s_end, 501 __nis_table_mapping_t *t_mapping) 502 { 503 time_t initTtlHi = 0; 504 time_t initTtlLo = 0; 505 time_t ttl = 0; 506 time_t digit; 507 508 /* 509 * attribute should be of the form 510 * initialTTLlo ":" initialTTLhi ":" runningTTL 511 */ 512 513 if (s == s_end) { 514 p_error = parse_bad_ttl_format_error; 515 return (FALSE); 516 } 517 518 if (isdigit(*s)) { 519 while (s < s_end && isdigit(*s)) { 520 digit = (*s++) - '0'; 521 if (WILL_OVERFLOW_TIME(initTtlLo, digit)) 522 initTtlLo = TIME_MAX; 523 else 524 initTtlLo = initTtlLo * 10 + digit; 525 } 526 } else { 527 initTtlLo = ONE_HOUR; 528 } 529 530 while (s < s_end && is_whitespace(*s)) 531 s++; 532 if (s + 1 >= s_end || *s++ != COLON_CHAR) { 533 p_error = parse_bad_ttl_format_error; 534 return (FALSE); 535 } 536 537 while (s < s_end && is_whitespace(*s)) 538 s++; 539 if (isdigit(*s)) { 540 while (s < s_end && isdigit(*s)) { 541 digit = (*s++) - '0'; 542 if (WILL_OVERFLOW_TIME(initTtlHi, digit)) 543 initTtlHi = TIME_MAX; 544 else 545 initTtlHi = initTtlHi * 10 + digit; 546 } 547 } else { 548 initTtlHi = initTtlLo; 549 } 550 551 while (s < s_end && is_whitespace(*s)) 552 s++; 553 if (s >= s_end || *s++ != COLON_CHAR) { 554 p_error = parse_bad_ttl_format_error; 555 return (FALSE); 556 } 557 558 while (s < s_end && is_whitespace(*s)) 559 s++; 560 if (isdigit(*s)) { 561 while (s < s_end && isdigit(*s)) { 562 digit = (*s++) - '0'; 563 if (WILL_OVERFLOW_TIME(ttl, digit)) 564 ttl = TIME_MAX; 565 else 566 ttl = ttl * 10 + digit; 567 } 568 } else { 569 ttl = ONE_HOUR; 570 } 571 while (s < s_end && is_whitespace(*s)) 572 s++; 573 if (s != s_end) { 574 p_error = parse_bad_ttl_format_error; 575 return (FALSE); 576 } 577 578 t_mapping->initTtlLo = initTtlLo; 579 t_mapping->initTtlHi = initTtlHi; 580 t_mapping->ttl = ttl; 581 return (TRUE); 582 } 583 584 /* 585 * FUNCTION: parse_name_fields 586 * 587 * Parse yp name fields 588 * 589 * RETURN VALUE: 0 on success, non-zero on failure 590 * 591 * INPUTS: attrib_value and attribute_end pointers. 592 */ 593 594 static int 595 parse_name_fields(const char *name_s, 596 const char *name_s_end, 597 __nis_table_mapping_t *t_map) 598 { 599 int i, n = 0; 600 int nElements = 0; 601 int numSplits = 0; 602 int parse_next_line = 1; 603 int itm_count = 0; 604 const char *begin_fmt; 605 const char *end_fmt; 606 const char *begin_token; 607 const char *end_token; 608 char *fmt_string = NULL; 609 __nis_mapping_format_t *base = NULL; 610 __nis_mapping_item_t *item = NULL; 611 __nis_mapping_element_t *elmnt = NULL; 612 __nis_mapping_item_type_t item_type = mit_nisplus; 613 token_type token; 614 615 t_map->numColumns = 0; 616 617 for (; parse_next_line > 0; parse_next_line--) { 618 nElements = 0; 619 item = NULL; 620 base = NULL; 621 while (name_s < name_s_end && *name_s != OPEN_PAREN_CHAR) 622 name_s++; 623 if (name_s == name_s_end) { 624 p_error = parse_unexpected_data_end_rule; 625 return (1); 626 } 627 while (name_s < name_s_end && *name_s != DOUBLE_QUOTE_CHAR) 628 name_s++; 629 if (name_s == name_s_end) { 630 p_error = parse_unexpected_data_end_rule; 631 return (1); 632 } 633 begin_fmt = ++name_s; /* start of format string */ 634 while (name_s < name_s_end && *name_s != DOUBLE_QUOTE_CHAR) 635 name_s++; 636 if (name_s == name_s_end) { 637 p_error = parse_unexpected_data_end_rule; 638 return (1); 639 } 640 end_fmt = name_s; 641 fmt_string = s_strndup(begin_fmt, end_fmt - begin_fmt); 642 if (fmt_string == NULL) { 643 p_error = parse_no_mem_error; 644 return (2); 645 } 646 if (!get_mapping_format(fmt_string, &base, &n, NULL, FALSE)) { 647 p_error = parse_internal_error; 648 free(fmt_string); 649 fmt_string = NULL; 650 return (3); 651 } 652 free(fmt_string); 653 fmt_string = NULL; 654 for (n = 0; base[n].type != mmt_end; n++) { 655 if (base[n].type != mmt_item && base[n].type 656 != mmt_berstring) { 657 if (base[n].type == mmt_berstring_null) 658 base[n].type = mmt_berstring; 659 continue; 660 } 661 while (name_s < name_s_end && *name_s != COMMA_CHAR) 662 name_s++; 663 name_s++; /* now at comma char */ 664 while (name_s < name_s_end && is_whitespace(*name_s)) 665 name_s++; 666 begin_token = name_s++; 667 end_token = name_s_end; 668 name_s = get_next_token( 669 &begin_token, &end_token, &token); 670 if (name_s == NULL) { 671 p_error = parse_item_expected_error; 672 return (4); 673 } 674 if (token != string_token) { 675 p_error = parse_item_expected_error; 676 return (5); 677 } 678 item = (__nis_mapping_item_t *)s_realloc(item, 679 (nElements + 1) * 680 sizeof (__nis_mapping_item_t)); 681 if (item == NULL) { 682 p_error = parse_no_mem_error; 683 return (2); 684 } 685 name_s = get_mapping_item(begin_token, name_s_end, 686 &item[nElements], item_type); 687 if (name_s == NULL) { 688 p_error = parse_unmatched_escape; 689 for (n = 0; n < (nElements + 1); n++) 690 free_mapping_item(&item[n]); 691 free_mapping_format(base); 692 return (4); 693 } 694 nElements++; 695 } 696 if (p_error != no_parse_error) { 697 for (n = 0; n < (nElements + 1); n++) 698 free_mapping_item(&item[n]); 699 free_mapping_format(base); 700 return (6); 701 } 702 name_s = skip_token(name_s, name_s_end, close_paren_token); 703 if (name_s == NULL) { 704 p_error = parse_close_paren_expected_error; 705 for (n = 0; n < (nElements + 1); n++) 706 free_mapping_item(&item[n]); 707 free_mapping_format(base); 708 return (4); 709 } 710 while (name_s < name_s_end && is_whitespace(*name_s)) 711 name_s++; 712 if (*name_s == COMMA_CHAR) 713 parse_next_line++; 714 715 if (nElements == 0) { 716 p_error = parse_no_match_item; 717 for (n = 0; n < (nElements + 1); n++) 718 free_mapping_item(&item[n]); 719 free_mapping_format(base); 720 return (7); 721 } 722 elmnt = (__nis_mapping_element_t *)s_realloc(elmnt, 723 (numSplits + 1) * 724 sizeof (__nis_mapping_element_t)); 725 if (elmnt == NULL) { 726 for (n = 0; n < (nElements + 1); n++) 727 free_mapping_item(&item[n]); 728 free_mapping_format(base); 729 p_error = parse_no_mem_error; 730 return (2); 731 } 732 elmnt[numSplits].type = me_match; 733 elmnt[numSplits].element.match.numItems = nElements; 734 elmnt[numSplits].element.match.item = item; 735 elmnt[numSplits].element.match.fmt = base; 736 item = NULL; 737 base = NULL; 738 739 t_map->e = elmnt; 740 t_map->numSplits = numSplits; 741 n = t_map->numColumns; 742 743 for (i = n, itm_count = 0; i < n + nElements; i++) { 744 if (t_map->e[numSplits].element. 745 match.item[itm_count].name) { 746 if (!add_column(t_map, 747 t_map->e[numSplits].element. 748 match.item[itm_count].name)) 749 return (1); 750 itm_count++; 751 } else { 752 p_error = parse_internal_error; 753 for (n = 0; n < (nElements + 1); n++) 754 free_mapping_item(&item[n]); 755 free_mapping_format(base); 756 free_mapping_element(elmnt); 757 return (1); 758 } 759 } 760 numSplits++; 761 } 762 elmnt = NULL; 763 764 if (item != NULL) { 765 for (n = 0; n < t_map->numColumns; n++) { 766 free_mapping_item(&item[n]); 767 } 768 free(item); 769 } 770 if (elmnt != NULL) 771 free_mapping_element(elmnt); 772 if (base != NULL) 773 free_mapping_format(base); 774 775 return (p_error == no_parse_error ? 0 : -1); 776 } 777 778 /* 779 * FUNCTION: parse_object_dn 780 * 781 * Parse object dn attribute 782 * 783 * RETURN VALUE: __nis_object_dn_t on success 784 * NULL on failure 785 * 786 * INPUT: the attribute value 787 */ 788 789 static __nis_object_dn_t * 790 parse_object_dn(const char *s, const char *end) 791 { 792 const char *s_begin; 793 const char *s_end; 794 object_dn_token token; 795 parse_object_dn_state dn_state = dn_begin_parse; 796 __nis_object_dn_t *obj_dn = NULL; 797 __nis_object_dn_t *next = NULL; 798 __nis_object_dn_t *last = NULL; 799 800 /* 801 * The attribute should be of form 802 * objectDN *( ";" objectDN ) 803 * objectDN = readObjectSpec [":"[writeObjectSpec]] 804 * readObjectSpec = [baseAndScope [filterAttrValList]] 805 * writeObjectSpec = [baseAndScope [attrValList [":" deleteDisp]]] 806 */ 807 808 while (s < end) { 809 s_begin = s; 810 s_end = end; 811 s = get_next_object_dn_token(&s_begin, &s_end, &token); 812 if (s == NULL) 813 break; 814 815 if (token == dn_no_token || token == dn_semi_token) { 816 if (obj_dn == NULL) 817 obj_dn = next; 818 else 819 last->next = next; 820 last = next; 821 next = NULL; 822 if (token == dn_no_token) 823 break; 824 dn_state = dn_begin_parse; 825 } 826 if (next == NULL) { 827 next = (__nis_object_dn_t *) 828 s_calloc(1, sizeof (__nis_object_dn_t)); 829 if (next == NULL) 830 break; 831 next->read.scope = LDAP_SCOPE_ONELEVEL; 832 next->write.scope = LDAP_SCOPE_UNKNOWN; 833 next->delDisp = dd_always; 834 } 835 if (token == dn_semi_token) 836 continue; 837 838 switch (dn_state) { 839 case dn_begin_parse: 840 if (token == dn_ques_token) 841 dn_state = dn_got_read_q_scope; 842 else if (token == dn_colon_token) { 843 dn_state = dn_got_write_colon; 844 next->write.scope = LDAP_SCOPE_ONELEVEL; 845 } else { 846 if (!validate_dn(s_begin, s_end - s_begin)) 847 break; 848 next->read.base = 849 s_strndup_esc(s_begin, s_end - s_begin); 850 dn_state = dn_got_read_dn; 851 } 852 break; 853 case dn_got_read_dn: 854 if (token == dn_ques_token) 855 dn_state = dn_got_read_q_scope; 856 else if (token == dn_colon_token) { 857 dn_state = dn_got_write_colon; 858 next->write.scope = LDAP_SCOPE_ONELEVEL; 859 } else 860 p_error = parse_object_dn_syntax_error; 861 break; 862 case dn_got_read_q_scope: 863 if (token == dn_ques_token) 864 dn_state = dn_got_read_q_filter; 865 else if (token == dn_colon_token) { 866 dn_state = dn_got_write_colon; 867 next->write.scope = LDAP_SCOPE_ONELEVEL; 868 } else if (token == dn_base_token) { 869 next->read.scope = LDAP_SCOPE_BASE; 870 dn_state = dn_got_read_scope; 871 } else if (token == dn_one_token) { 872 next->read.scope = LDAP_SCOPE_ONELEVEL; 873 dn_state = dn_got_read_scope; 874 } else if (token == dn_sub_token) { 875 next->read.scope = LDAP_SCOPE_SUBTREE; 876 dn_state = dn_got_read_scope; 877 } else { 878 p_error = parse_invalid_scope; 879 } 880 break; 881 case dn_got_read_scope: 882 if (token == dn_ques_token) 883 dn_state = dn_got_read_q_filter; 884 else if (token == dn_colon_token) { 885 dn_state = dn_got_write_colon; 886 next->write.scope = LDAP_SCOPE_ONELEVEL; 887 } else 888 p_error = parse_object_dn_syntax_error; 889 break; 890 case dn_got_read_q_filter: 891 if (token == dn_ques_token) { 892 p_error = parse_object_dn_syntax_error; 893 } else if (token == dn_colon_token) { 894 dn_state = dn_got_write_colon; 895 next->write.scope = LDAP_SCOPE_ONELEVEL; 896 } else { 897 if (!validate_ldap_filter(s_begin, s_end)) 898 break; 899 next->read.attrs = 900 s_strndup_esc(s_begin, s_end - s_begin); 901 dn_state = dn_got_read_filter; 902 } 903 break; 904 case dn_got_read_filter: 905 if (token == dn_ques_token) { 906 p_error = parse_object_dn_syntax_error; 907 } else if (token == dn_colon_token) { 908 dn_state = dn_got_write_colon; 909 next->write.scope = LDAP_SCOPE_ONELEVEL; 910 } else 911 p_error = parse_object_dn_syntax_error; 912 break; 913 case dn_got_write_colon: 914 if (token == dn_ques_token) 915 dn_state = dn_got_write_q_scope; 916 else if (token == dn_colon_token) { 917 dn_state = dn_got_delete_colon; 918 } else { 919 if (!validate_dn(s_begin, s_end - s_begin)) 920 break; 921 next->write.base = 922 s_strndup_esc(s_begin, s_end - s_begin); 923 dn_state = dn_got_write_dn; 924 } 925 break; 926 case dn_got_write_dn: 927 if (token == dn_ques_token) 928 dn_state = dn_got_write_q_scope; 929 else if (token == dn_colon_token) { 930 dn_state = dn_got_delete_colon; 931 } else 932 p_error = parse_object_dn_syntax_error; 933 break; 934 case dn_got_write_q_scope: 935 if (token == dn_ques_token) 936 dn_state = dn_got_write_q_filter; 937 else if (token == dn_colon_token) { 938 dn_state = dn_got_delete_colon; 939 } else if (token == dn_base_token) { 940 next->write.scope = LDAP_SCOPE_BASE; 941 dn_state = dn_got_write_scope; 942 } else if (token == dn_one_token) { 943 next->write.scope = LDAP_SCOPE_ONELEVEL; 944 dn_state = dn_got_write_scope; 945 } else if (token == dn_sub_token) { 946 next->write.scope = LDAP_SCOPE_SUBTREE; 947 dn_state = dn_got_write_scope; 948 } else { 949 p_error = parse_invalid_scope; 950 } 951 break; 952 case dn_got_write_scope: 953 if (token == dn_ques_token) 954 dn_state = dn_got_write_q_filter; 955 else if (token == dn_colon_token) { 956 dn_state = dn_got_delete_colon; 957 } else 958 p_error = parse_object_dn_syntax_error; 959 break; 960 case dn_got_write_q_filter: 961 if (token == dn_ques_token) { 962 p_error = parse_object_dn_syntax_error; 963 } else if (token == dn_colon_token) { 964 dn_state = dn_got_delete_colon; 965 } else { 966 if (!validate_ldap_filter(s_begin, s_end)) 967 break; 968 next->write.attrs = 969 s_strndup_esc(s_begin, s_end - s_begin); 970 dn_state = dn_got_write_filter; 971 } 972 break; 973 case dn_got_write_filter: 974 if (token == dn_ques_token) { 975 p_error = parse_object_dn_syntax_error; 976 } else if (token == dn_colon_token) { 977 dn_state = dn_got_delete_colon; 978 979 } else 980 p_error = parse_semi_expected_error; 981 break; 982 case dn_got_delete_colon: 983 if (token == dn_ques_token) { 984 p_error = parse_object_dn_syntax_error; 985 } else if (token == dn_colon_token) { 986 p_error = parse_object_dn_syntax_error; 987 } else { 988 if (!get_deleteDisp(s_begin, s_end, next)) 989 break; 990 dn_state = dn_got_delete_dsp; 991 } 992 break; 993 case dn_got_delete_dsp: 994 p_error = parse_object_dn_syntax_error; 995 break; 996 } 997 998 if (p_error != no_parse_error) 999 break; 1000 } 1001 if (p_error != no_parse_error) { 1002 if (obj_dn != NULL) 1003 free_object_dn(obj_dn); 1004 if (next != NULL) 1005 free_object_dn(next); 1006 obj_dn = NULL; 1007 } else if (next != NULL) { 1008 if (obj_dn == NULL) 1009 obj_dn = next; 1010 else 1011 last->next = next; 1012 } else if (obj_dn == NULL) 1013 obj_dn = (__nis_object_dn_t *) 1014 s_calloc(1, sizeof (__nis_object_dn_t)); 1015 1016 return (obj_dn); 1017 } 1018 1019 /* 1020 * FUNCTION: get_mapping_rule 1021 * 1022 * Parse mapping rule attributes 1023 * 1024 * RETURN VALUE: None. Errors determined by p_error 1025 * 1026 * INPUT: the attribute value and mapping rule type 1027 */ 1028 1029 static void 1030 get_mapping_rule( 1031 const char *s, 1032 int len, 1033 __nis_table_mapping_t *tbl, 1034 bool_t to_ldap) 1035 { 1036 const char *end_s = s + len; 1037 const char *begin_token; 1038 const char *end_token; 1039 __nis_mapping_rule_t **rule = NULL; 1040 __nis_mapping_rule_t *next = NULL; 1041 /* __nis_mapping_rule_t **r; */ 1042 token_type t; 1043 int nRules = 0; 1044 const char *s1; 1045 int i; 1046 1047 /* 1048 * The attribute value is of the form 1049 * colattrspec *("," colattrspec) 1050 * colattrspec = lhs "=" rhs 1051 * lhs = lval | namespeclist 1052 * rhs = rval | [namespec] 1053 */ 1054 1055 for (;;) { 1056 if ((next = (__nis_mapping_rule_t *) 1057 s_calloc(1, sizeof (__nis_mapping_rule_t))) == NULL) 1058 break; 1059 1060 s = get_lhs(s, end_s, &next->lhs, 1061 to_ldap ? mit_ldap : mit_nisplus); 1062 if (s == NULL) 1063 break; 1064 1065 begin_token = s; 1066 end_token = end_s; 1067 s1 = get_next_token(&begin_token, &end_token, &t); 1068 if (s1 == NULL) 1069 break; 1070 if (!(to_ldap && (t == comma_token || t == no_token))) { 1071 s = get_rhs(s, end_s, &next->rhs, 1072 to_ldap ? mit_nisplus : mit_ldap); 1073 if (s == NULL) 1074 break; 1075 } 1076 1077 if (next->lhs.numElements > 1 && 1078 (next->rhs.numElements != 1 || 1079 next->rhs.element[0].type != me_split)) { 1080 p_error = parse_lhs_rhs_type_mismatch; 1081 break; 1082 } 1083 if (rule == NULL) { 1084 rule = (__nis_mapping_rule_t **) 1085 malloc(sizeof (__nis_mapping_rule_t *)); 1086 if (rule == NULL) 1087 break; 1088 } else { 1089 rule = (__nis_mapping_rule_t **)s_realloc(rule, 1090 (nRules + 1) * 1091 sizeof (__nis_mapping_rule_t *)); 1092 if (rule == NULL) 1093 break; 1094 } 1095 1096 rule[nRules++] = next; 1097 next = NULL; 1098 1099 begin_token = s; 1100 end_token = end_s; 1101 s = get_next_token(&begin_token, &end_token, &t); 1102 if (s == NULL) 1103 break; 1104 if (t == comma_token) 1105 continue; 1106 if (t != no_token) { 1107 p_error = parse_unexpected_data_end_rule; 1108 break; 1109 } 1110 if (to_ldap) { 1111 tbl->numRulesToLDAP = nRules; 1112 tbl->ruleToLDAP = rule; 1113 } else { 1114 tbl->numRulesFromLDAP = nRules; 1115 tbl->ruleFromLDAP = rule; 1116 } 1117 return; 1118 } 1119 1120 if (rule) { 1121 for (i = 0; i < nRules; i++) 1122 free_mapping_rule(rule[i]); 1123 free(rule); 1124 } 1125 if (next) 1126 free_mapping_rule(next); 1127 } 1128 1129 /* 1130 * FUNCTION: get_lhs 1131 * 1132 * Parse left hand side of mapping rule attribute 1133 * 1134 * RETURN VALUE: NULL if error 1135 * position of beginning rhs 1136 * 1137 * INPUT: the attribute value and mapping rule type 1138 */ 1139 1140 static const char * 1141 get_lhs(const char *s, 1142 const char *end_s, 1143 __nis_mapping_rlhs_t *lhs, 1144 __nis_mapping_item_type_t item_type) 1145 { 1146 token_type t; 1147 const char *begin_token; 1148 const char *end_token; 1149 const char *sav_s; 1150 __nis_mapping_element_t *e = NULL; 1151 1152 /* 1153 * lhs can be expressed as: 1154 * item 1155 * (item) 1156 * (item list) 1157 * (fmt, item list) 1158 * 1159 * lhs = lval | namespeclist 1160 * lval = "(" formatspec "," namespec *("," namespec) ")" 1161 * namespeclist = namespec | "(" namespec *("," namespec) ")" 1162 */ 1163 1164 for (; p_error == no_parse_error; ) { 1165 begin_token = s; 1166 end_token = end_s; 1167 s = get_next_token(&begin_token, &end_token, &t); 1168 if (s == NULL) 1169 break; 1170 if (t == no_token) { 1171 p_error = parse_unexpected_data_end_rule; 1172 break; 1173 } 1174 1175 e = (__nis_mapping_element_t *) 1176 s_calloc(1, sizeof (__nis_mapping_element_t)); 1177 if (e == NULL) 1178 break; 1179 1180 if (t == open_paren_token) { 1181 free(e); 1182 e = NULL; 1183 1184 begin_token = s; 1185 end_token = end_s; 1186 sav_s = s; 1187 s = get_next_token(&begin_token, &end_token, &t); 1188 if (s == NULL) 1189 break; 1190 1191 if (t == quoted_string_token) { 1192 s = get_lhs_match(sav_s, end_s, lhs, item_type); 1193 if (s == NULL) 1194 break; 1195 } else if (t == string_token) { 1196 s = get_lhs_paren_item(sav_s, end_s, lhs, 1197 item_type); 1198 if (s == NULL) 1199 break; 1200 } else { 1201 p_error = parse_bad_lhs_format_error; 1202 break; 1203 } 1204 } else if (t == string_token) { 1205 s = get_mapping_item(begin_token, end_s, 1206 &e->element.item, item_type); 1207 if (s == NULL) 1208 break; 1209 e->type = me_item; 1210 if (!add_element(e, lhs)) 1211 break; 1212 e = NULL; 1213 } else { 1214 p_error = parse_bad_lhs_format_error; 1215 break; 1216 } 1217 1218 s = skip_token(s, end_s, equal_token); 1219 if (s == NULL) 1220 break; 1221 if (p_error == no_parse_error) 1222 return (s); 1223 } 1224 if (e != NULL) 1225 free_mapping_element(e); 1226 1227 return (NULL); 1228 } 1229 1230 /* 1231 * FUNCTION: get_lhs_match 1232 * 1233 * Parse left hand side of mapping rule attribute in case of 1234 * matching rule 1235 * 1236 * RETURN VALUE: NULL if error 1237 * position of beginning rhs 1238 * 1239 * INPUT: the attribute value and mapping rule type 1240 */ 1241 1242 static const char * 1243 get_lhs_match( 1244 const char *s, 1245 const char *end_s, 1246 __nis_mapping_rlhs_t *lhs, 1247 __nis_mapping_item_type_t item_type) 1248 { 1249 token_type t; 1250 const char *begin_token; 1251 const char *end_token; 1252 int n = 0; 1253 int nElements = 0; 1254 char *fmt_string = NULL; 1255 __nis_mapping_format_t *base = NULL; 1256 __nis_mapping_item_t *item = NULL; 1257 __nis_mapping_item_t *itm; 1258 __nis_mapping_element_t *e; 1259 1260 /* 1261 * lval = "(" formatspec "," namespec *("," namespec) ")" 1262 */ 1263 1264 for (; p_error == no_parse_error; ) { 1265 begin_token = s; 1266 end_token = end_s; 1267 s = get_next_token(&begin_token, &end_token, &t); 1268 if (s == NULL || t != quoted_string_token) { 1269 p_error = parse_internal_error; 1270 break; 1271 } 1272 1273 1274 fmt_string = s_strndup(begin_token, end_token - begin_token); 1275 if (fmt_string == NULL) 1276 break; 1277 1278 if (!get_mapping_format(fmt_string, &base, &n, NULL, FALSE)) 1279 break; 1280 1281 for (n = 0; base[n].type != mmt_end; n++) { 1282 if (base[n].type != mmt_item && 1283 base[n].type != mmt_berstring) { 1284 if (base[n].type == mmt_berstring_null) 1285 base[n].type = mmt_berstring; 1286 continue; 1287 } 1288 s = skip_token(s, end_s, comma_token); 1289 if (s == NULL) { 1290 p_error = parse_not_enough_extract_items; 1291 break; 1292 } 1293 begin_token = s; 1294 end_token = end_s; 1295 s = get_next_token(&begin_token, &end_token, &t); 1296 if (s == NULL) 1297 break; 1298 if (t != string_token) { 1299 p_error = parse_item_expected_error; 1300 break; 1301 } 1302 itm = (__nis_mapping_item_t *) 1303 s_realloc(item, (nElements + 1) * 1304 sizeof (__nis_mapping_item_t)); 1305 if (itm == NULL) 1306 break; 1307 item = itm; 1308 1309 s = get_mapping_item(begin_token, end_s, 1310 &item[nElements], item_type); 1311 if (s == NULL) 1312 break; 1313 nElements++; 1314 } 1315 if (p_error != no_parse_error) 1316 break; 1317 1318 s = skip_token(s, end_s, close_paren_token); 1319 if (s == NULL) 1320 break; 1321 free(fmt_string); 1322 fmt_string = NULL; 1323 1324 if (nElements == 0) { 1325 p_error = parse_no_match_item; 1326 break; 1327 } 1328 e = (__nis_mapping_element_t *)s_calloc(1, 1329 sizeof (__nis_mapping_element_t)); 1330 if (e == NULL) 1331 break; 1332 e->type = me_match; 1333 e->element.match.numItems = nElements; 1334 e->element.match.item = item; 1335 e->element.match.fmt = base; 1336 lhs->numElements = 1; 1337 lhs->element = e; 1338 1339 if (p_error == no_parse_error) 1340 return (s); 1341 } 1342 if (item == NULL) { 1343 for (n = 0; n < nElements; n++) 1344 free_mapping_item(&item[n]); 1345 free(item); 1346 } 1347 if (fmt_string != NULL) 1348 free(fmt_string); 1349 if (base != NULL) 1350 free_mapping_format(base); 1351 1352 return (NULL); 1353 } 1354 1355 /* 1356 * FUNCTION: get_lhs_paren_item 1357 * 1358 * Parse left hand side of mapping rule attribute in case of 1359 * (item1, ..., item-n) 1360 * 1361 * RETURN VALUE: NULL if error 1362 * position of beginning rhs 1363 * 1364 * INPUT: the attribute value and mapping rule type 1365 */ 1366 1367 static const char * 1368 get_lhs_paren_item( 1369 const char *s, 1370 const char *end_s, 1371 __nis_mapping_rlhs_t *lhs, 1372 __nis_mapping_item_type_t item_type) 1373 { 1374 token_type t; 1375 const char *begin_token; 1376 const char *end_token; 1377 __nis_mapping_element_t *e = NULL; 1378 int n = 0; 1379 int i; 1380 1381 /* 1382 * "(" namespec *("," namespec) ")" 1383 */ 1384 1385 for (;;) { 1386 e = (__nis_mapping_element_t *)s_realloc(e, (n + 1) * 1387 sizeof (__nis_mapping_element_t)); 1388 if (e == NULL) 1389 break; 1390 1391 s = get_mapping_item(s, end_s, &e[n].element.item, 1392 item_type); 1393 if (s == NULL) 1394 break; 1395 e[n].type = me_item; 1396 n++; 1397 1398 begin_token = s; 1399 end_token = end_s; 1400 s = get_next_token(&begin_token, &end_token, &t); 1401 if (s != NULL && t == close_paren_token) { 1402 lhs->numElements = n; 1403 if (n == 1) 1404 e[0].element.item.repeat = TRUE; 1405 lhs->element = e; 1406 return (s); 1407 } 1408 if (s == NULL || t != comma_token) { 1409 p_error = parse_comma_expected_error; 1410 break; 1411 } 1412 } 1413 for (i = 0; i < n; i++) 1414 free_mapping_element(&e[i]); 1415 if (e != NULL) 1416 free(e); 1417 return (NULL); 1418 } 1419 1420 /* 1421 * FUNCTION: get_rhs 1422 * 1423 * Parse right hand side of mapping rule attribute 1424 * 1425 * RETURN VALUE: NULL if error 1426 * position of beginning next mapping rule 1427 * 1428 * INPUT: the attribute value and mapping rule type 1429 */ 1430 1431 static const char * 1432 get_rhs( 1433 const char *s, 1434 const char *end_s, 1435 __nis_mapping_rlhs_t *rhs, 1436 __nis_mapping_item_type_t item_type) 1437 { 1438 /* 1439 * This handles the following cases: 1440 * name me_item 1441 * (name) me_item 1442 * (fmt, name-list) me_print 1443 * (item, fmt) me_extract 1444 */ 1445 1446 token_type t; 1447 const char *begin_token; 1448 const char *end_token; 1449 char *str = NULL; 1450 __nis_mapping_format_t *fmt = NULL; 1451 __nis_mapping_element_t *e = NULL; 1452 __nis_mapping_item_t item; 1453 int n; 1454 1455 (void) memset(&item, 0, sizeof (item)); 1456 1457 for (; p_error == no_parse_error; ) { 1458 begin_token = s; 1459 end_token = end_s; 1460 s = get_next_token(&begin_token, &end_token, &t); 1461 if (s == NULL) 1462 break; 1463 1464 e = (__nis_mapping_element_t *) 1465 s_calloc(1, sizeof (__nis_mapping_element_t)); 1466 if (e == NULL) 1467 break; 1468 1469 if (t == string_token) { 1470 s = get_mapping_item(begin_token, end_s, 1471 &e->element.item, item_type); 1472 } else if (t == open_paren_token) { 1473 begin_token = s; 1474 end_token = end_s; 1475 s = get_next_token(&begin_token, &end_token, &t); 1476 if (s == NULL) 1477 break; 1478 if (t == string_token) { 1479 /* (item, fmt) - me_extract */ 1480 /* (item, "c") - me_split */ 1481 s = get_mapping_item(begin_token, end_s, 1482 &item, item_type); 1483 if (s == NULL) 1484 break; 1485 begin_token = s; 1486 end_token = end_s; 1487 s = get_next_token(&begin_token, &end_token, 1488 &t); 1489 if (s == NULL) 1490 break; 1491 else if (t == close_paren_token) { 1492 item.repeat = TRUE; 1493 e->element.item = item; 1494 e->type = me_item; 1495 rhs->numElements = 1; 1496 rhs->element = e; 1497 return (s); 1498 } else if (t != comma_token) { 1499 p_error = parse_comma_expected_error; 1500 break; 1501 } 1502 1503 begin_token = s; 1504 end_token = end_s; 1505 s = get_next_token(&begin_token, &end_token, 1506 &t); 1507 if (s == NULL || t != quoted_string_token) { 1508 p_error = 1509 parse_format_string_expected_error; 1510 break; 1511 } 1512 1513 if (end_token == begin_token + 1 || 1514 *begin_token == ESCAPE_CHAR && 1515 end_token == begin_token + 2) { 1516 e->type = me_split; 1517 e->element.split.item = item; 1518 e->element.split.delim = *begin_token; 1519 } else { 1520 str = s_strndup(begin_token, 1521 end_token - begin_token); 1522 if (str == NULL) 1523 break; 1524 if (!get_mapping_format(str, &fmt, 1525 NULL, &n, FALSE)) 1526 break; 1527 free(str); 1528 str = NULL; 1529 if (n != 1) { 1530 p_error = 1531 parse_bad_extract_format_spec; 1532 break; 1533 } 1534 e->type = me_extract; 1535 e->element.extract.item = item; 1536 e->element.extract.fmt = fmt; 1537 } 1538 s = skip_token(s, end_s, close_paren_token); 1539 } else if (t == quoted_string_token) { 1540 /* (fmt, name-list) - me_print */ 1541 str = s_strndup(begin_token, 1542 end_token - begin_token); 1543 if (str == NULL) 1544 break; 1545 1546 s = get_print_mapping_element(s, end_s, 1547 str, e, item_type); 1548 free(str); 1549 str = NULL; 1550 } else { 1551 p_error = parse_start_rhs_unrecognized; 1552 break; 1553 } 1554 } else { 1555 p_error = parse_start_rhs_unrecognized; 1556 break; 1557 } 1558 if (s == NULL) 1559 break; 1560 rhs->numElements = 1; 1561 rhs->element = e; 1562 if (p_error == no_parse_error) 1563 return (s); 1564 } 1565 if (str) 1566 free(str); 1567 if (fmt != NULL) 1568 free_mapping_format(fmt); 1569 if (e != NULL) 1570 free_mapping_element(e); 1571 free_mapping_item(&item); 1572 1573 return (NULL); 1574 } 1575 1576 /* 1577 * FUNCTION: get_print_mapping_element 1578 * 1579 * Parse a print mapping rule attribute in case of the form 1580 * (fmt, name-list) 1581 * 1582 * RETURN VALUE: NULL if error 1583 * position of beginning next mapping rule 1584 * 1585 * INPUT: the attribute value and mapping rule type 1586 */ 1587 1588 static const char * 1589 get_print_mapping_element( 1590 const char *s, 1591 const char *end_s, 1592 char *fmt_string, 1593 __nis_mapping_element_t *e, 1594 __nis_mapping_item_type_t item_type) 1595 { 1596 token_type t; 1597 const char *begin_token; 1598 const char *end_token; 1599 char elide; 1600 bool_t doElide; 1601 __nis_mapping_format_t *base = NULL; 1602 __nis_mapping_sub_element_t *subElement = NULL; 1603 int n = 0; 1604 int nSub = 0; 1605 int numSubElements; 1606 1607 for (; p_error == no_parse_error; ) { 1608 if (!get_mapping_format(fmt_string, &base, &n, 1609 &numSubElements, TRUE)) 1610 break; 1611 subElement = (__nis_mapping_sub_element_t *) 1612 s_calloc(numSubElements, 1613 sizeof (__nis_mapping_sub_element_t)); 1614 if (subElement == NULL) 1615 break; 1616 for (n = 0; base[n].type != mmt_end; n++) { 1617 if (base[n].type != mmt_item && 1618 base[n].type != mmt_berstring) { 1619 if (base[n].type == mmt_berstring_null) 1620 base[n].type = mmt_berstring; 1621 continue; 1622 } 1623 if (nSub < numSubElements) { 1624 s = skip_token(s, end_s, comma_token); 1625 if (s == NULL) { 1626 p_error = parse_bad_print_format; 1627 break; 1628 } 1629 } 1630 1631 /* namelist may have parens around it */ 1632 s = get_subElement(s, end_s, &subElement[nSub], 1633 item_type); 1634 if (s == NULL) 1635 break; 1636 nSub++; 1637 } 1638 if (p_error != no_parse_error) 1639 break; 1640 1641 begin_token = s; 1642 end_token = end_s; 1643 s = get_next_token(&begin_token, &end_token, &t); 1644 if (s == NULL || t == no_token) { 1645 p_error = parse_unexpected_data_end_rule; 1646 break; 1647 } else if (t == close_paren_token) { 1648 doElide = FALSE; 1649 elide = '\0'; 1650 } else if (t == comma_token) { 1651 begin_token = s; 1652 end_token = end_s; 1653 s = get_next_token(&begin_token, &end_token, &t); 1654 if (s != NULL && t == quoted_string_token && 1655 (end_token == begin_token + 1 || 1656 *begin_token == ESCAPE_CHAR && 1657 end_token == begin_token + 2)) { 1658 if (numSubElements != 1 || 1659 subElement->type == me_extract || 1660 subElement->type == me_split) { 1661 p_error = parse_cannot_elide; 1662 break; 1663 } 1664 if (subElement->type == me_item && 1665 !subElement->element.item.repeat) { 1666 p_error = parse_cannot_elide; 1667 break; 1668 } 1669 elide = *begin_token; 1670 doElide = TRUE; 1671 1672 } else { 1673 p_error = parse_bad_elide_char; 1674 break; 1675 } 1676 s = skip_token(s, end_s, close_paren_token); 1677 if (s == NULL) 1678 break; 1679 } 1680 1681 e->type = me_print; 1682 e->element.print.fmt = base; 1683 e->element.print.numSubElements = numSubElements; 1684 e->element.print.subElement = subElement; 1685 e->element.print.elide = elide; 1686 e->element.print.doElide = doElide; 1687 1688 if (p_error == no_parse_error) 1689 return (s); 1690 } 1691 if (base) 1692 free_mapping_format(base); 1693 if (subElement != NULL) { 1694 for (n = 0; n < numSubElements; n++) 1695 free_mapping_sub_element(&subElement[n]); 1696 free(subElement); 1697 } 1698 1699 return (NULL); 1700 } 1701 1702 /* 1703 * FUNCTION: get_mapping_item 1704 * 1705 * Parse attribute string to get mapping item 1706 * 1707 * RETURN VALUE: NULL if error 1708 * position of beginning next token after item 1709 * 1710 * INPUT: the attribute value and mapping rule type 1711 */ 1712 1713 static const char * 1714 get_mapping_item( 1715 const char *s, 1716 const char *end_s, 1717 __nis_mapping_item_t *item, 1718 __nis_mapping_item_type_t type) 1719 { 1720 token_type t; 1721 const char *begin_token; 1722 const char *end_token; 1723 char *name = NULL; 1724 char *index_string; 1725 const char *s_sav; 1726 int len; 1727 1728 (void) memset(item, 0, sizeof (*item)); 1729 1730 /* 1731 * A namepec is defined as follows: 1732 * namespec = ["ldap:"] attrspec [searchTriple] | 1733 * ["nis+:"] colspec [objectspec] 1734 * 1735 * The form of the item is assumed to be as follows: 1736 * ["ldap:"] attrspec [searchTriple] 1737 * attrspec = attribute | "(" attribute ")" 1738 * searchTriple = ":" [baseDN] ["?" [scope] ["?" [filter]]] 1739 * baseDN = Base DN for search 1740 * scope = "base" | "one" | "sub" 1741 * filter = LDAP search filter 1742 * 1743 * The form of the objectspec is as follows: 1744 * ["nis+:"] colspec [objectspec] 1745 * objectspec = objectname | "[" indexlist "]" tablename 1746 * objectname = The name of a NIS+ object 1747 * tablename = The name of a NIS+ table 1748 * indexlist = colspec ["," colspec] 1749 * colspec = colname "=" colvalue 1750 * colname = The name of a column in the table 1751 * colvalue = colvaluestring | \" colvaluestring \" 1752 */ 1753 1754 for (; p_error == no_parse_error; ) { 1755 while (s < end_s && is_whitespace(*s)) 1756 s++; 1757 len = end_s - s; 1758 if (yp2ldap) { 1759 if ((begin_token = skip_string("ldap:", s, 1760 len)) != NULL) { 1761 item->type = mit_ldap; 1762 } else if ((begin_token = skip_string("yp:", s, 1763 len)) != NULL) { 1764 item->type = mit_nisplus; 1765 } else { 1766 item->type = type; 1767 begin_token = s; 1768 } 1769 } else { 1770 if ((begin_token = skip_string("ldap:", s, 1771 len)) != NULL) { 1772 item->type = mit_ldap; 1773 } else if ((begin_token = skip_string("nis+:", s, 1774 len)) != NULL) { 1775 item->type = mit_nisplus; 1776 } else if ((begin_token = skip_string("nisplus:", s, 1777 len)) != NULL) { 1778 item->type = mit_nisplus; 1779 } else { 1780 item->type = type; 1781 begin_token = s; 1782 } 1783 } 1784 1785 end_token = end_s; 1786 s = get_next_token(&begin_token, &end_token, &t); 1787 if (s == NULL || t != string_token) { 1788 p_error = parse_bad_item_format; 1789 break; 1790 } 1791 1792 item->name = s_strndup_esc(begin_token, 1793 end_token - begin_token); 1794 if (item->name == NULL) 1795 break; 1796 if (item->type == mit_ldap) { 1797 item->searchSpec.triple.scope = LDAP_SCOPE_UNKNOWN; 1798 begin_token = s; 1799 end_token = end_s; 1800 s_sav = s; 1801 s = get_next_token(&begin_token, &end_token, &t); 1802 if (s != NULL && t == colon_token) { 1803 s = get_search_triple(s, end_s, 1804 &item->searchSpec.triple); 1805 if (s == NULL) 1806 break; 1807 } else 1808 s = s_sav; 1809 } else if (item->type == mit_nisplus) { 1810 while (s < end_s && is_whitespace(*s)) 1811 s++; 1812 1813 if (s < end_s && *s == OPEN_BRACKET) { 1814 index_string = getIndex(&s, end_s); 1815 if (index_string == NULL) 1816 break; 1817 (void) parse_index(index_string, 1818 index_string + strlen(index_string), 1819 &item->searchSpec.obj.index); 1820 free(index_string); 1821 if (p_error != no_parse_error) 1822 break; 1823 } 1824 s_sav = s; 1825 begin_token = s; 1826 end_token = end_s; 1827 s = get_next_token(&begin_token, &end_token, &t); 1828 if (s != NULL && t == string_token) { 1829 name = s_strndup_esc(begin_token, 1830 end_token - begin_token); 1831 if (name == NULL) 1832 break; 1833 item->searchSpec.obj.name = name; 1834 } else 1835 s = s_sav; 1836 } 1837 if (p_error == no_parse_error) 1838 return (s); 1839 } 1840 free_mapping_item(item); 1841 (void) memset(item, 0, sizeof (*item)); 1842 if (name == NULL) 1843 free(name); 1844 return (NULL); 1845 } 1846 1847 static const char * 1848 get_print_sub_element(const char *s, 1849 const char *end_s, 1850 __nis_mapping_item_type_t type, 1851 __nis_mapping_sub_element_t *sub) 1852 { 1853 1854 int k; 1855 int n; 1856 const char *begin_token; 1857 const char *end_token; 1858 token_type t; 1859 __nis_mapping_format_t *base; 1860 __nis_mapping_item_t *print_item; 1861 1862 k = 0; 1863 base = sub->element.print.fmt; 1864 print_item = sub->element.print.item; 1865 sub->element.print.doElide = FALSE; 1866 sub->element.print.elide = '\0'; 1867 1868 for (n = 0; base[n].type != mmt_end; n++) { 1869 if (base[n].type != mmt_item && base[n].type != mmt_berstring) { 1870 if (base[n].type == mmt_berstring_null) 1871 base[n].type = mmt_berstring; 1872 continue; 1873 } 1874 s = skip_token(s, end_s, comma_token); 1875 if (s == NULL) { 1876 p_error = parse_bad_print_format; 1877 break; 1878 } 1879 1880 begin_token = s; 1881 end_token = end_s; 1882 s = get_next_token(&begin_token, &end_token, &t); 1883 if (s == NULL) 1884 break; 1885 /* 1886 * Determine if of the form 1887 * ("fmt", (item), "delim") or 1888 * ("fmt", item1, item2, ..., item n) 1889 */ 1890 if (t == open_paren_token) { 1891 if (sub->element.print.numItems != 1) { 1892 p_error = parse_invalid_print_arg; 1893 break; 1894 } 1895 s = get_mapping_item(s, end_s, &print_item[k++], type); 1896 s = skip_token(s, end_s, close_paren_token); 1897 s = skip_token(s, end_s, comma_token); 1898 if (s == NULL) { 1899 p_error = parse_bad_print_format; 1900 break; 1901 } 1902 begin_token = s; 1903 end_token = end_s; 1904 s = get_next_token(&begin_token, &end_token, &t); 1905 if (s == NULL) 1906 break; 1907 if (t != quoted_string_token || 1908 begin_token + 1 != end_token) { 1909 p_error = parse_bad_elide_char; 1910 break; 1911 } 1912 sub->element.print.elide = *begin_token; 1913 sub->element.print.doElide = TRUE; 1914 print_item[0].repeat = TRUE; 1915 break; 1916 } 1917 s = get_mapping_item(begin_token, end_s, 1918 &print_item[k++], type); 1919 if (s == NULL) 1920 break; 1921 1922 if (p_error != no_parse_error) 1923 break; 1924 } 1925 1926 return (p_error == no_parse_error ? s : NULL); 1927 } 1928 1929 /* 1930 * FUNCTION: get_subElement 1931 * 1932 * Parse attribute string to get sub element item 1933 * 1934 * RETURN VALUE: NULL if error 1935 * position of beginning next token after item 1936 * 1937 * INPUT: the attribute value and mapping rule type 1938 */ 1939 1940 static const char * 1941 get_subElement( 1942 const char *s, 1943 const char *end_s, 1944 __nis_mapping_sub_element_t *subelement, 1945 __nis_mapping_item_type_t type) 1946 { 1947 token_type t; 1948 const char *begin_token; 1949 const char *end_token; 1950 char *fmt_string; 1951 __nis_mapping_item_t item; 1952 __nis_mapping_element_type_t e_type; 1953 __nis_mapping_item_t *print_item = NULL; 1954 __nis_mapping_format_t *base = NULL; 1955 int n = 0; 1956 int numItems = 0; 1957 unsigned char delim; 1958 __nis_mapping_sub_element_t sub; 1959 1960 /* 1961 * What is the form of we are expecting here 1962 * item me_item 1963 * (item) me_item 1964 * ("fmt", item1, item2, ..., item n) me_print 1965 * ("fmt", (item), "elide") me_print 1966 * (name, "delim") me_split 1967 * (item, "fmt") me_extract 1968 */ 1969 (void) memset(&item, 0, sizeof (item)); 1970 1971 for (; p_error == no_parse_error; ) { 1972 begin_token = s; 1973 end_token = end_s; 1974 s = get_next_token(&begin_token, &end_token, &t); 1975 if (s == NULL) 1976 break; 1977 if (t == string_token) { /* me_item */ 1978 s = get_mapping_item(begin_token, end_s, 1979 &subelement->element.item, type); 1980 if (s == NULL) 1981 break; 1982 subelement->type = me_item; 1983 return (s); 1984 } else if (t != open_paren_token) { 1985 p_error = parse_item_expected_error; 1986 break; 1987 } 1988 1989 begin_token = s; 1990 end_token = end_s; 1991 s = get_next_token(&begin_token, &end_token, &t); 1992 if (s == NULL) 1993 break; 1994 1995 if (t != string_token && t != quoted_string_token) { 1996 p_error = parse_item_expected_error; 1997 break; 1998 } 1999 e_type = me_print; 2000 if (t == string_token) { 2001 /* me_item, me_extract or me_split */ 2002 s = get_mapping_item(begin_token, end_s, &item, type); 2003 if (s == NULL) 2004 break; 2005 2006 begin_token = s; 2007 end_token = end_s; 2008 s = get_next_token(&begin_token, &end_token, &t); 2009 if (s == NULL) { 2010 p_error = parse_unexpected_data_end_rule; 2011 break; 2012 } else if (t == close_paren_token) { 2013 subelement->type = me_item; 2014 item.repeat = TRUE; 2015 subelement->element.item = item; 2016 if (yp2ldap) { 2017 while (s < end_s && is_whitespace(*s)) 2018 s++; 2019 if (s == end_s) { 2020 p_error = 2021 parse_unexpected_data_end_rule; 2022 break; 2023 } 2024 if (*s == DASH_CHAR && s < end_s) { 2025 s++; 2026 while (s < end_s && 2027 is_whitespace(*s)) 2028 s++; 2029 begin_token = s; 2030 end_token = end_s; 2031 2032 subelement->element.item.exItem 2033 = 2034 (__nis_mapping_item_t *) 2035 s_malloc(sizeof (__nis_mapping_item_t)); 2036 if (!subelement-> 2037 element.item.exItem) 2038 break; 2039 s = get_mapping_item(s, end_s, 2040 subelement-> 2041 element.item.exItem, 2042 type); 2043 if (s == NULL) { 2044 p_error = 2045 parse_internal_error; 2046 free_mapping_item( 2047 subelement-> 2048 element.item.exItem); 2049 subelement-> 2050 element.item.exItem = 2051 NULL; 2052 break; 2053 } 2054 } 2055 } 2056 return (s); 2057 } else if (t != comma_token) { 2058 p_error = parse_comma_expected_error; 2059 break; 2060 } 2061 2062 begin_token = s; 2063 end_token = end_s; 2064 s = get_next_token(&begin_token, &end_token, &t); 2065 if (s == NULL || t != quoted_string_token) { 2066 p_error = parse_format_string_expected_error; 2067 break; 2068 } 2069 if (end_token == begin_token + 1 || 2070 *begin_token == ESCAPE_CHAR && 2071 end_token == begin_token + 2) { 2072 /* me_split */ 2073 delim = (unsigned char)end_token[-1]; 2074 s = skip_token(s, end_s, close_paren_token); 2075 if (s == NULL) 2076 break; 2077 subelement->element.split.item = item; 2078 subelement->element.split.delim = delim; 2079 subelement->type = me_split; 2080 return (s); 2081 } 2082 e_type = me_extract; 2083 } 2084 fmt_string = s_strndup(begin_token, end_token - begin_token); 2085 if (fmt_string == NULL) 2086 break; 2087 if (!get_mapping_format(fmt_string, &base, &n, &numItems, 2088 e_type == me_print)) { 2089 free(fmt_string); 2090 break; 2091 } 2092 free(fmt_string); 2093 2094 if (numItems != 1 && e_type == me_extract) { 2095 p_error = numItems == 0 ? 2096 parse_not_enough_extract_items : 2097 parse_too_many_extract_items; 2098 break; 2099 } else if (numItems > 0 && e_type == me_print) { 2100 print_item = (__nis_mapping_item_t *)s_calloc(numItems, 2101 sizeof (__nis_mapping_item_t)); 2102 if (print_item == NULL) 2103 break; 2104 } 2105 2106 if (e_type == me_print) { 2107 sub.element.print.numItems = numItems; 2108 sub.element.print.fmt = base; 2109 sub.element.print.item = print_item; 2110 s = get_print_sub_element(s, end_s, type, &sub); 2111 if (s == NULL) 2112 break; 2113 } 2114 s = skip_token(s, end_s, close_paren_token); 2115 if (s == NULL) 2116 break; 2117 2118 subelement->type = e_type; 2119 if (e_type == me_extract) { 2120 subelement->element.extract.fmt = base; 2121 subelement->element.extract.item = item; 2122 } else { 2123 subelement->type = me_print; 2124 subelement->element.print.fmt = base; 2125 subelement->element.print.numItems = numItems; 2126 subelement->element.print.item = print_item; 2127 subelement->element.print.doElide = 2128 sub.element.print.doElide; 2129 subelement->element.print.elide = 2130 sub.element.print.elide; 2131 } 2132 if (p_error == no_parse_error) 2133 return (s); 2134 } 2135 free_mapping_item(&item); 2136 if (base != NULL) 2137 free_mapping_format(base); 2138 if (print_item) { 2139 for (n = 0; n < numItems; n++) 2140 free_mapping_item(&print_item[n]); 2141 free(print_item); 2142 } 2143 2144 return (NULL); 2145 } 2146 2147 /* 2148 * FUNCTION: skip_get_dn 2149 * 2150 * Get first token after dn 2151 * 2152 * RETURN VALUE: NULL if error (not valid dn) 2153 * position of beginning next token after dn 2154 * 2155 * INPUT: the attribute value 2156 */ 2157 2158 const char * 2159 skip_get_dn(const char *dn, const char *end) 2160 { 2161 size_t len = 0; 2162 bool_t in_quote = FALSE; 2163 bool_t goteq = FALSE; 2164 bool_t gotch = FALSE; 2165 bool_t done = FALSE; 2166 bool_t last_comma = FALSE; 2167 const char *last_dn = dn; 2168 2169 while (!done) { 2170 dn += len; 2171 if (last_comma) { 2172 last_dn = dn; 2173 last_comma = FALSE; 2174 } 2175 if (dn >= end) 2176 break; 2177 len = 1; 2178 switch (*dn) { 2179 case ESCAPE_CHAR: 2180 len = 2; 2181 gotch = TRUE; 2182 break; 2183 case DOUBLE_QUOTE_CHAR: 2184 in_quote = !in_quote; 2185 break; 2186 case QUESTION_MARK: 2187 case CLOSE_PAREN_CHAR: 2188 case COLON_CHAR: 2189 done = !in_quote; 2190 /* FALLTHRU */ 2191 case SEMI_COLON_CHAR: 2192 case PLUS_SIGN: 2193 case COMMA_CHAR: 2194 if (!in_quote) { 2195 if (!goteq || !gotch) 2196 return (last_dn); 2197 goteq = FALSE; 2198 gotch = FALSE; 2199 if (*dn != PLUS_SIGN) 2200 last_dn = dn; 2201 last_comma = *dn == COMMA_CHAR; 2202 } else { 2203 gotch = TRUE; 2204 } 2205 break; 2206 case EQUAL_CHAR: 2207 if (!in_quote) { 2208 if (!gotch || goteq) 2209 return (NULL); 2210 goteq = TRUE; 2211 gotch = FALSE; 2212 } else { 2213 gotch = TRUE; 2214 } 2215 break; 2216 default: 2217 if (!is_whitespace(*dn)) 2218 gotch = TRUE; 2219 break; 2220 } 2221 } 2222 2223 if (dn == end) { 2224 if (!in_quote && goteq && gotch) 2225 last_dn = dn; 2226 } 2227 2228 return (last_dn); 2229 } 2230 2231 /* 2232 * FUNCTION: get_ldap_filter_element 2233 * 2234 * Get an ldap filter element for a given string 2235 * 2236 * RETURN VALUE: NULL if error 2237 * __nis_mapping_element_t if success 2238 * 2239 * INPUT: the string to parse 2240 */ 2241 2242 static __nis_mapping_element_t * 2243 get_ldap_filter_element( 2244 const char *s, 2245 const char *end_s 2246 ) 2247 { 2248 token_type t; 2249 const char *begin_token; 2250 const char *end_token; 2251 char *format_str; 2252 __nis_mapping_element_t *e = NULL; 2253 2254 begin_token = s; 2255 end_token = end_s; 2256 s = get_next_token(&begin_token, &end_token, &t); 2257 if (s == NULL || t != open_paren_token) 2258 return (NULL); 2259 2260 begin_token = s; 2261 end_token = end_s; 2262 s = get_next_token(&begin_token, &end_token, &t); 2263 if (s == NULL || t != quoted_string_token) 2264 return (NULL); 2265 2266 format_str = s_strndup(begin_token, end_token - begin_token); 2267 if (format_str == NULL) 2268 return (NULL); 2269 e = (__nis_mapping_element_t *) 2270 s_calloc(1, sizeof (__nis_mapping_element_t)); 2271 if (e != NULL) { 2272 (void) get_print_mapping_element(s, end_s, 2273 format_str, e, mit_nisplus); 2274 if (p_error != no_parse_error) { 2275 free_mapping_element(e); 2276 e = NULL; 2277 } 2278 } 2279 free(format_str); 2280 return (e); 2281 } 2282 2283 /* 2284 * FUNCTION: get_search_triple 2285 * 2286 * Get the search triple or if NULL determine if valid 2287 * 2288 * RETURN VALUE: NULL if error 2289 * position of beginning next token after 2290 * search triple 2291 * 2292 * INPUT: the attribute value 2293 */ 2294 2295 const char * 2296 get_search_triple( 2297 const char *s, 2298 const char *end_s, 2299 __nis_search_triple_t *triple 2300 ) 2301 { 2302 const char *begin_token; 2303 const char *end_token; 2304 char *search_base = NULL; 2305 int scope = LDAP_SCOPE_ONELEVEL; 2306 char *filter = NULL; 2307 const char *s1; 2308 __nis_mapping_element_t 2309 *element = NULL; 2310 2311 /* 2312 * The form of the searchTriple is assumed to be as follows: 2313 * searchTriple = [baseDN] ["?" [scope] ["?" [filter]]] 2314 * baseDN = Base DN for search 2315 * scope = "base" | "one" | "sub" 2316 * filter = LDAP search filter 2317 */ 2318 for (; p_error == no_parse_error; ) { 2319 while (s < end_s && is_whitespace(*s)) 2320 s++; 2321 if (s == end_s) 2322 break; 2323 2324 if (!IS_TERMINAL_CHAR(*s)) { 2325 begin_token = s; 2326 s = skip_get_dn(begin_token, end_s); 2327 if (s == NULL) { 2328 p_error = parse_invalid_dn; 2329 break; 2330 } 2331 if (triple != NULL) { 2332 search_base = s_strndup(begin_token, 2333 s - begin_token); 2334 if (search_base == NULL) 2335 break; 2336 } 2337 while (s < end_s && is_whitespace(*s)) 2338 s++; 2339 if (s == end_s) 2340 break; 2341 } 2342 2343 if (!IS_TERMINAL_CHAR(*s)) { 2344 p_error = parse_bad_ldap_item_format; 2345 break; 2346 } 2347 if (*s != QUESTION_MARK) 2348 break; 2349 2350 s++; 2351 while (s < end_s && is_whitespace(*s)) 2352 s++; 2353 if (s == end_s) 2354 break; 2355 2356 /* base, one, or sub, or empty value */ 2357 if (!IS_TERMINAL_CHAR(*s)) { 2358 if ((s1 = skip_string("base", s, end_s - s)) != NULL) { 2359 scope = LDAP_SCOPE_BASE; 2360 } else if ((s1 = skip_string("one", s, end_s - s)) != 2361 NULL) { 2362 scope = LDAP_SCOPE_ONELEVEL; 2363 } else if ((s1 = skip_string("sub", s, end_s - s)) != 2364 NULL) { 2365 scope = LDAP_SCOPE_SUBTREE; 2366 } else if (s + 1 < end_s && *s != QUESTION_MARK) { 2367 p_error = parse_invalid_scope; 2368 break; 2369 } 2370 if (s1 != NULL) 2371 s = s1; 2372 while (s < end_s && is_whitespace(*s)) 2373 s++; 2374 } 2375 2376 if (s == end_s) 2377 break; 2378 if (*s != QUESTION_MARK) 2379 break; 2380 s++; 2381 while (s < end_s && is_whitespace(*s)) 2382 s++; 2383 if (s == end_s || IS_TERMINAL_CHAR(*s)) 2384 break; 2385 2386 /* LDAP search filter */ 2387 if (*s == OPEN_PAREN_CHAR) { 2388 begin_token = s; 2389 end_token = end_s; 2390 s = get_ldap_filter(&begin_token, &end_token); 2391 if (s == NULL) 2392 break; 2393 s = end_token; 2394 element = get_ldap_filter_element(begin_token, end_token); 2395 if (element != NULL) 2396 break; 2397 } else { 2398 begin_token = s; 2399 end_token = end_s; 2400 s = get_ava_list(&begin_token, &end_token, TRUE); 2401 if (s == NULL) 2402 break; 2403 s = end_token; 2404 } 2405 if (triple != NULL) 2406 filter = s_strndup(begin_token, s - begin_token); 2407 if (p_error == no_parse_error) 2408 break; 2409 } 2410 if (p_error == no_parse_error && triple != NULL) { 2411 triple->base = search_base; 2412 triple->scope = scope; 2413 triple->attrs = filter; 2414 triple->element = element; 2415 element = NULL; 2416 filter = NULL; 2417 search_base = NULL; 2418 } 2419 2420 if (search_base != NULL) 2421 free(search_base); 2422 if (filter != NULL) 2423 free(filter); 2424 if (element != NULL) { 2425 free_mapping_element(element); 2426 free(element); 2427 } 2428 return (p_error == no_parse_error ? s : NULL); 2429 } 2430 2431 /* 2432 * FUNCTION: get_mapping_format 2433 * 2434 * Get the __nis_mapping_format_t from the string 2435 * 2436 * RETURN VALUE: FALSE if error 2437 * TRUE if __nis_mapping_format_t returned 2438 * 2439 * INPUT: the format string 2440 */ 2441 2442 static bool_t 2443 get_mapping_format( 2444 const char *fmt_string, 2445 __nis_mapping_format_t **fmt, 2446 int *nfmt, 2447 int *numItems, 2448 bool_t print_mapping) 2449 { 2450 const char *f = fmt_string; 2451 const char *ef; 2452 __nis_mapping_format_t *b; 2453 __nis_mapping_format_t *base = NULL; 2454 int n = 0; 2455 int nItems = 0; 2456 2457 f = fmt_string; 2458 ef = f + strlen(f); 2459 base = (__nis_mapping_format_t *) 2460 s_calloc(1, sizeof (__nis_mapping_format_t)); 2461 2462 if (base == NULL) 2463 return (FALSE); 2464 base->type = mmt_begin; 2465 n++; 2466 2467 for (;;) { 2468 b = (__nis_mapping_format_t *)s_realloc( 2469 base, (n + 1) * sizeof (__nis_mapping_format_t)); 2470 2471 if (b == NULL) 2472 break; 2473 base = b; 2474 base[n].type = mmt_end; 2475 if (f == ef) { 2476 if (nfmt) 2477 *nfmt = n + 1; 2478 *fmt = base; 2479 if (numItems) 2480 *numItems = nItems; 2481 return (TRUE); 2482 } 2483 if (print_mapping) 2484 f = get_next_print_format_item(f, ef, &base[n]); 2485 else 2486 f = get_next_extract_format_item(f, ef, &base[n]); 2487 2488 2489 if (f == NULL) 2490 break; 2491 if (base[n].type == mmt_item || 2492 base[n].type == mmt_berstring) 2493 nItems++; 2494 n++; 2495 } 2496 if (base != NULL) 2497 free_mapping_format(base); 2498 return (FALSE); 2499 } 2500 2501 /* 2502 * FUNCTION: getIndex 2503 * 2504 * Returns a string containing the index 2505 * 2506 * RETURN VALUE: NULL if error 2507 * a string containing the index 2508 * 2509 * INPUT: attribute containing the index 2510 */ 2511 2512 static char * 2513 getIndex(const char **s_cur, const char *s_end) 2514 { 2515 const char *s = *s_cur + 1; 2516 const char *s1; 2517 char *s_index; 2518 char *s_index1; 2519 char *s_index_end; 2520 int n_brackets = 1; 2521 bool_t in_quotes = FALSE; 2522 char *index = NULL; 2523 2524 while (s < s_end && is_whitespace(*s)) 2525 s++; 2526 for (s1 = s; s1 < s_end; s1++) { 2527 if (*s1 == ESCAPE_CHAR) 2528 s1++; 2529 else if (*s1 == DOUBLE_QUOTE_CHAR) { 2530 in_quotes = !in_quotes; 2531 } else if (in_quotes) 2532 ; 2533 else if (*s1 == CLOSE_BRACKET) { 2534 if (--n_brackets == 0) 2535 break; 2536 } else if (*s1 == OPEN_BRACKET) 2537 n_brackets++; 2538 } 2539 2540 if (n_brackets == 0) { 2541 index = s_strndup(s, s1 - s); 2542 if (index != NULL) { 2543 s_index_end = index + (s1 - s); 2544 s_index1 = index; 2545 for (s_index = index; s_index < s_index_end; 2546 s_index++) { 2547 if (*s_index == ESCAPE_CHAR) { 2548 *s_index1++ = *s_index++; 2549 } else if (*s_index == DOUBLE_QUOTE_CHAR) { 2550 in_quotes = !in_quotes; 2551 } else if (!in_quotes && 2552 is_whitespace(*s_index)) { 2553 continue; 2554 } 2555 *s_index1++ = *s_index; 2556 } 2557 *s_index1 = *s_index; 2558 2559 s = s1 + 1; 2560 2561 while (s < s_end && is_whitespace(*s)) 2562 s++; 2563 *s_cur = s; 2564 } 2565 } else 2566 p_error = parse_mismatched_brackets; 2567 2568 return (index); 2569 } 2570 2571 /* 2572 * FUNCTION: parse_index 2573 * 2574 * Parse attribute string to get __nis_index_t 2575 * 2576 * RETURN VALUE: FALSE if error 2577 * TRUE if __nis_index_t returned 2578 * 2579 * INPUT: the attribute value to parse 2580 */ 2581 2582 bool_t 2583 parse_index(const char *s, const char *end_s, __nis_index_t *index) 2584 { 2585 const char *begin_token; 2586 const char *end_token; 2587 char *name_str = NULL; 2588 char **name; 2589 char *fmt_string = NULL; 2590 __nis_mapping_format_t *v = NULL; 2591 __nis_mapping_format_t **value; 2592 token_type t; 2593 int n = 0; 2594 2595 if (index != NULL) 2596 (void) memset(index, 0, sizeof (*index)); 2597 2598 while (s < end_s) { 2599 if (n > 0) { 2600 s = skip_token(s, end_s, comma_token); 2601 if (s == NULL) { 2602 p_error = parse_bad_index_format; 2603 break; 2604 } 2605 } 2606 begin_token = s; 2607 end_token = end_s; 2608 s = get_next_token(&begin_token, &end_token, &t); 2609 if (s == NULL) 2610 break; 2611 if (t != string_token) { 2612 p_error = parse_bad_index_format; 2613 break; 2614 } 2615 s = skip_token(s, end_s, equal_token); 2616 if (s == NULL) { 2617 p_error = parse_bad_index_format; 2618 break; 2619 } 2620 if (index != NULL) { 2621 name_str = s_strndup_esc(begin_token, 2622 end_token - begin_token); 2623 if (name_str == NULL) 2624 break; 2625 } 2626 begin_token = s; 2627 end_token = end_s; 2628 s = get_next_token(&begin_token, &end_token, &t); 2629 if (s == NULL) 2630 break; 2631 if (t != string_token && t != quoted_string_token) { 2632 p_error = parse_bad_index_format; 2633 break; 2634 } 2635 fmt_string = s_strndup(begin_token, end_token - begin_token); 2636 if (fmt_string == NULL) 2637 break; 2638 if (!get_mapping_format(fmt_string, &v, NULL, NULL, FALSE)) 2639 break; 2640 free(fmt_string); 2641 fmt_string = NULL; 2642 if (index != NULL) { 2643 name = s_realloc(index->name, 2644 (n + 1) * sizeof (char *)); 2645 if (name == NULL) 2646 break; 2647 value = s_realloc(index->value, 2648 (n + 1) * sizeof (__nis_mapping_format_t *)); 2649 if (value == NULL) 2650 break; 2651 name[n] = name_str; 2652 name_str = NULL; 2653 value[n] = v; 2654 v = NULL; 2655 index->numIndexes = ++n; 2656 index->name = name; 2657 index->value = value; 2658 } else if (v != NULL) { 2659 free_mapping_format(v); 2660 v = NULL; 2661 } 2662 } 2663 if (p_error != no_parse_error) { 2664 if (name_str != NULL) 2665 free(name_str); 2666 if (v != NULL) 2667 free_mapping_format(v); 2668 if (fmt_string != NULL) 2669 free(fmt_string); 2670 if (index != NULL) 2671 free_index(index); 2672 } 2673 return (p_error != no_parse_error); 2674 } 2675 2676 /* 2677 * FUNCTION: get_deleteDisp 2678 * 2679 * Parse deleteDisp. Sets p_error if an error occurred. 2680 * 2681 * RETURN VALUE: TRUE on success 2682 * FAILURE on failure 2683 * 2684 * INPUT: begin and end of string and __nis_object_dn_t 2685 */ 2686 2687 static bool_t 2688 get_deleteDisp(const char *s_begin, const char *s_end, 2689 __nis_object_dn_t *obj_dn) 2690 { 2691 /* 2692 * deleteDisp: "always" | perDbId | "never" 2693 * perDbId: "dbid" "=" delDatabaseId 2694 */ 2695 2696 if (same_string("always", s_begin, s_end - s_begin)) { 2697 obj_dn->delDisp = dd_always; 2698 } else if (same_string("never", s_begin, s_end - s_begin)) { 2699 obj_dn->delDisp = dd_never; 2700 } else if ((s_begin = skip_string("dbid", s_begin, s_end - s_begin)) 2701 != NULL) { 2702 obj_dn->delDisp = dd_perDbId; 2703 while (s_begin < s_end && is_whitespace(*s_begin)) 2704 s_begin++; 2705 if (s_begin == s_end || *s_begin != EQUAL_CHAR) { 2706 p_error = parse_object_dn_syntax_error; 2707 } else { 2708 s_begin++; 2709 while (s_begin < s_end && is_whitespace(*s_begin)) 2710 s_begin++; 2711 while (s_begin < s_end && is_whitespace(s_end[-1])) 2712 s_end--; 2713 if (s_begin == s_end) { 2714 p_error = parse_object_dn_syntax_error; 2715 } else { 2716 obj_dn->dbIdName = 2717 s_strndup(s_begin, s_end - s_begin); 2718 } 2719 } 2720 } else { 2721 p_error = parse_object_dn_syntax_error; 2722 } 2723 return (p_error == no_parse_error); 2724 } 2725