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 2015 Gary Mills 24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 #include <stdio.h> 29 #include <string.h> 30 #include <stdlib.h> 31 #include <ctype.h> 32 #include <fcntl.h> 33 #include <errno.h> 34 #include <syslog.h> 35 36 #include "ldap_parse.h" 37 #include "nis_parse_ldap_conf.h" 38 #include "nis_parse_ldap_util.h" 39 #include "ldap_util.h" 40 41 /* Forward declarations */ 42 int getfullmapname(char **, const char *); 43 int checkfullmapname(const char *, const char *, __nis_table_mapping_t **, 44 __nis_table_mapping_t **); 45 int append_domainContext(__nis_table_mapping_t **, char *, char *); 46 47 static int merge_table_mapping(__nis_table_mapping_t *in, 48 __nis_table_mapping_t *out); 49 __nis_table_mapping_t *new_merged_mapping(const char *, 50 __nis_table_mapping_t *intbl); 51 static int append_mapping_rule(__nis_mapping_rule_t *src_rule, 52 __nis_table_mapping_t *tbl, int flag); 53 54 55 static int copy_object_dn(__nis_object_dn_t *in, 56 __nis_object_dn_t *newdn); 57 58 /* 59 * FUNCTION: initialize_table_mapping 60 * 61 * Initialize the __nis_table_mapping_t structure. 62 * 63 * INPUT: __nis_table_mapping_t 64 * 65 */ 66 void 67 initialize_table_mapping( 68 __nis_table_mapping_t *mapping) 69 { 70 if (mapping != NULL) { 71 mapping->dbId = NULL; 72 73 mapping->index.numIndexes = 0; 74 mapping->index.name = NULL; 75 mapping->index.value = NULL; 76 77 mapping->numColumns = 0; 78 mapping->column = NULL; 79 80 mapping->initTtlLo = (time_t)NO_VALUE_SET; 81 mapping->initTtlHi = (time_t)NO_VALUE_SET; 82 mapping->ttl = (time_t)NO_VALUE_SET; 83 84 mapping->usedns_flag = 0; 85 mapping->securemap_flag = 0; 86 mapping->commentChar = DEFAULT_COMMENT_CHAR; 87 mapping->numSplits = 0; 88 89 mapping->objectDN = NULL; 90 91 mapping->separatorStr = DEFAULT_SEP_STRING; 92 93 mapping->numRulesFromLDAP = 0; 94 mapping->numRulesToLDAP = 0; 95 96 mapping->ruleFromLDAP = NULL; 97 mapping->ruleToLDAP = NULL; 98 99 mapping->e = NULL; 100 mapping->objName = NULL; 101 mapping->objPath = NULL; 102 mapping->obj = NULL; 103 mapping->isMaster = 0; 104 mapping->seq_num = NO_VALUE_SET; 105 } 106 } 107 108 /* 109 * FUNCTION: initialize_yp_parse_structs 110 * 111 * Initialize the __yp_domain_context_t structure. 112 * 113 * INPUT: __yp_domain_context_t 114 * 115 */ 116 void 117 initialize_yp_parse_structs( 118 __yp_domain_context_t *ypDomains) 119 { 120 ypDomains->numDomains = 0; 121 ypDomains->domainLabels = NULL; 122 ypDomains->domains = NULL; 123 ypDomains->numYppasswdd = 0; 124 ypDomains->yppasswddDomainLabels = NULL; 125 } 126 127 /* 128 * FUNCTION: merge_table_mapping 129 * 130 * Merges information from one table_mapping struct 131 * into another 132 * 133 * INPUT: Source and Destination table_mapping structs. 134 * RETURN: 0 on success and > 0 on error. 135 */ 136 137 static int 138 merge_table_mapping( 139 __nis_table_mapping_t *in, 140 __nis_table_mapping_t *out) 141 { 142 int i; 143 int orig_num_rules; 144 int append; 145 146 if (in == NULL) 147 return (1); 148 149 if (in->dbId == NULL) 150 return (1); 151 152 /* 153 * If 'in' is generic (non-expanded) and 'out' is domain-specific, 154 * then rules from 'in' should not be appended to those in 'out'. 155 */ 156 if (!strchr(in->dbId, COMMA_CHAR) && strchr(out->dbId, COMMA_CHAR)) 157 append = 0; 158 else 159 append = 1; 160 161 162 if (!out->index.numIndexes && in->index.numIndexes > 0) { 163 if (!dup_index(&in->index, &out->index)) 164 return (1); 165 } 166 167 /* add_column() increments numColumns, so we don't */ 168 if (!out->numColumns && in->numColumns > 0) { 169 for (i = 0; i < in->numColumns; i++) { 170 if (!add_column(out, in->column[i])) 171 return (1); 172 } 173 } 174 175 if (out->commentChar == DEFAULT_COMMENT_CHAR && 176 in->commentChar != DEFAULT_COMMENT_CHAR) 177 out->commentChar = in->commentChar; 178 179 if (out->usedns_flag == 0) 180 out->usedns_flag = in->usedns_flag; 181 182 if (out->securemap_flag == 0) 183 out->securemap_flag = in->securemap_flag; 184 185 if ((strcmp(out->separatorStr, DEFAULT_SEP_STRING) == 0) && 186 (strcmp(in->separatorStr, DEFAULT_SEP_STRING) != 0)) { 187 out->separatorStr = s_strdup(in->separatorStr); 188 if (!out->separatorStr) 189 return (2); 190 } 191 192 if (!out->numSplits && !out->e && in->e) { 193 out->numSplits = in->numSplits; 194 out->e = (__nis_mapping_element_t *) 195 s_calloc(1, (in->numSplits+1) * 196 sizeof (__nis_mapping_element_t)); 197 if (!out->e) 198 return (2); 199 for (i = 0; i <= in->numSplits; i++) { 200 if (!dup_mapping_element(&in->e[i], &out->e[i])) { 201 for (; i > 0; i--) { 202 free_mapping_element(&out->e[i - 1]); 203 } 204 out->e = NULL; 205 return (1); 206 } 207 } 208 } 209 210 if (out->initTtlLo == (time_t)NO_VALUE_SET && 211 in->initTtlLo != (time_t)NO_VALUE_SET) 212 out->initTtlLo = in->initTtlLo; 213 214 if (out->initTtlHi == (time_t)NO_VALUE_SET && 215 in->initTtlHi != (time_t)NO_VALUE_SET) 216 out->initTtlHi = in->initTtlHi; 217 218 if (out->ttl == (time_t)NO_VALUE_SET && 219 in->ttl != (time_t)NO_VALUE_SET) 220 out->ttl = in->ttl; 221 222 if (!out->numRulesFromLDAP && in->numRulesFromLDAP) { 223 out->ruleFromLDAP = dup_mapping_rules(in->ruleFromLDAP, 224 in->numRulesFromLDAP); 225 if (!out->ruleFromLDAP) 226 return (1); 227 out->numRulesFromLDAP = in->numRulesFromLDAP; 228 } else if (append && out->numRulesFromLDAP && in->numRulesFromLDAP) { 229 orig_num_rules = out->numRulesFromLDAP; 230 for (i = 0; i < in->numRulesFromLDAP; i++) { 231 if (append_mapping_rule(in->ruleFromLDAP[i], out, 0)) { 232 for (i = out->numRulesFromLDAP; 233 i > orig_num_rules; i--) { 234 free_mapping_rule(out->ruleFromLDAP[i]); 235 out->ruleFromLDAP[i] = NULL; 236 } 237 return (1); 238 239 } 240 } 241 } 242 243 if (!out->numRulesToLDAP && in->numRulesToLDAP) { 244 out->ruleToLDAP = dup_mapping_rules(in->ruleToLDAP, 245 in->numRulesToLDAP); 246 if (!out->ruleToLDAP) 247 return (1); 248 out->numRulesToLDAP = in->numRulesToLDAP; 249 } else if (append && out->numRulesToLDAP && in->numRulesToLDAP) { 250 orig_num_rules = out->numRulesToLDAP; 251 for (i = 0; i < in->numRulesToLDAP; i++) { 252 if (append_mapping_rule(in->ruleToLDAP[i], out, 1)) { 253 for (i = out->numRulesToLDAP; 254 i > orig_num_rules; i--) { 255 free_mapping_rule(out->ruleToLDAP[i]); 256 out->ruleToLDAP[i] = NULL; 257 } 258 return (1); 259 } 260 } 261 } 262 if (!out->objectDN && in->objectDN) { 263 out->objectDN = (__nis_object_dn_t *) 264 s_calloc(1, sizeof (__nis_object_dn_t)); 265 if (!out->objectDN) 266 return (2); 267 if (copy_object_dn(in->objectDN, out->objectDN)) { 268 free_object_dn(out->objectDN); 269 out->objectDN = NULL; 270 return (1); 271 } 272 } 273 274 if (!out->objName && in->objName) { 275 if (!strchr(in->objName, SPACE_CHAR)) { 276 /* objName has no space- a single map dbIdMapping */ 277 out->objName = s_strndup(in->objName, 278 strlen(in->objName)); 279 if (!out->objName) 280 return (2); 281 } 282 } 283 284 if (!out->objName && out->dbId) { 285 out->objName = s_strndup(out->dbId, strlen(out->dbId)); 286 if (!out->objName) 287 return (2); 288 } 289 290 if (out->seq_num == NO_VALUE_SET && in->seq_num >= 0) 291 out->seq_num = in->seq_num; 292 293 return (p_error == no_parse_error ? 0 : 1); 294 } 295 296 /* 297 * FUNCTION: copy_object_dn 298 * 299 * Copies a __nis_object_dn_t structure. 300 * 301 * RETURN: 0 on success, > 0 on failure. 302 * 303 * NOTE: The caller MUST free newdn using 304 * free_object_dn() if return value != 0 (error condition) 305 */ 306 307 static int 308 copy_object_dn(__nis_object_dn_t *in, __nis_object_dn_t *newdn) 309 { 310 if (in == NULL) { 311 p_error = parse_no_object_dn; 312 return (1); 313 } 314 while (in != NULL) { 315 if (in->read.base == NULL) { 316 newdn->read.base = NULL; 317 } else { 318 newdn->read.base = s_strndup( 319 in->read.base, strlen(in->read.base)); 320 if (newdn->read.base == NULL) 321 return (2); 322 } 323 newdn->read.scope = in->read.scope; 324 if (in->read.attrs) { 325 newdn->read.attrs = s_strndup( 326 in->read.attrs, strlen(in->read.attrs)); 327 if (newdn->read.attrs == NULL) { 328 return (2); 329 } 330 } else { 331 newdn->read.attrs = NULL; 332 } 333 newdn->read.element = in->read.element; 334 if (in->write.base != NULL) { 335 newdn->write.base = s_strndup( 336 in->write.base, strlen(in->write.base)); 337 if (newdn->write.base == NULL) 338 return (2); 339 } else { 340 newdn->write.base = NULL; 341 } 342 newdn->write.scope = in->write.scope; 343 if (in->write.attrs != NULL) { 344 newdn->write.attrs = s_strndup( 345 in->write.attrs, strlen(in->write.attrs)); 346 if (newdn->write.attrs == NULL) { 347 return (2); 348 } 349 } else { 350 newdn->write.attrs = NULL; 351 } 352 newdn->write.element = in->write.element; 353 if (in->dbIdName) { 354 newdn->dbIdName = s_strndup(in->dbIdName, 355 strlen(in->dbIdName)); 356 if (newdn->dbIdName == NULL) 357 return (2); 358 } 359 360 if (in->delDisp) 361 newdn->delDisp = in->delDisp; 362 363 if (in->dbId && in->numDbIds > 0) { 364 newdn->dbId = dup_mapping_rules(in->dbId, 365 in->numDbIds); 366 if (!newdn->dbId) 367 return (1); 368 newdn->numDbIds = in->numDbIds; 369 } 370 if (in->next != NULL) { 371 newdn->next = (__nis_object_dn_t *)s_calloc(1, 372 sizeof (__nis_object_dn_t)); 373 if (newdn->next == NULL) 374 return (1); 375 newdn = newdn->next; 376 in = in->next; 377 } else { 378 return (0); 379 } 380 } /* End of while on in */ 381 382 return (0); 383 } 384 385 /* 386 * FUNCTION: free_yp_domain_context 387 * 388 * Frees __yp_domain_context_t 389 * 390 * INPUT: __yp_domain_context_t 391 */ 392 void 393 free_yp_domain_context(__yp_domain_context_t *domains) 394 { 395 int i; 396 397 if (domains != NULL) { 398 for (i = 0; i < domains->numDomains; i++) { 399 if (domains->domains[i] != NULL) { 400 free(domains->domains[i]); 401 domains->domains[i] = NULL; 402 } 403 if (domains->domainLabels[i] != NULL) { 404 free(domains->domainLabels[i]); 405 domains->domainLabels[i] = NULL; 406 } 407 } 408 domains->domains = NULL; 409 domains->domainLabels = NULL; 410 for (i = 0; i < domains->numYppasswdd; i++) { 411 if (domains->yppasswddDomainLabels[i] != NULL) { 412 free(domains->yppasswddDomainLabels[i]); 413 domains->yppasswddDomainLabels[i] = 414 NULL; 415 } 416 } 417 domains->yppasswddDomainLabels = NULL; 418 domains->numDomains = 0; 419 domains = NULL; 420 } 421 } 422 423 /* 424 * FUNCTION: second_parser_pass 425 * 426 * Prepares the linked list of table_mappings for processing 427 * by finish_parse(), adding, merging and deleting structures 428 * as necessary. Also adds dummy objectDN info. for splitField's. 429 * 430 * RETURN VALUE: 0 on success, > 0 on failure. 431 */ 432 int 433 second_parser_pass(__nis_table_mapping_t **table_mapping) 434 { 435 __nis_table_mapping_t *t, *t2; 436 __nis_table_mapping_t *t_new = NULL, *tg; 437 __nis_table_mapping_t *prev = NULL; 438 char *objs, *dom; 439 char *objName = NULL; 440 char *lasts; 441 char *tobj, *alias, *dupalias, *tmp; 442 char *myself = "second_parser_pass"; 443 int i = 0, len; 444 445 prev = NULL; 446 for (t = *table_mapping; t != NULL; ) { 447 /* 448 * Temporarily using this field to flag deletion. 449 * 0 : don't delete 450 * 1 : delete 451 * The mapping structure will be deleted in final_parser_pass 452 */ 453 t->isMaster = 0; 454 455 if (!t->dbId) { 456 p_error = parse_bad_map_error; 457 logmsg(MSG_NOTIMECHECK, LOG_ERR, 458 "%s: no dbId field", myself); 459 return (1); 460 } 461 tg = NULL; 462 dom = strchr(t->dbId, COMMA_CHAR); 463 if (t->objName != NULL) { 464 objName = strdup(t->objName); 465 if (objName == NULL) { 466 p_error = parse_no_mem_error; 467 logmsg(MSG_NOMEM, LOG_ERR, 468 "%s: Cannot allocate memory for objName", 469 myself); 470 return (1); 471 } 472 objs = (char *)strtok_r(objName, " ", &lasts); 473 /* Get the generic mapping */ 474 if (dom != NULL) { 475 tg = find_table_mapping(t->dbId, dom - t->dbId, 476 *table_mapping); 477 } 478 } else { 479 objs = NULL; 480 if (dom == NULL) { 481 t->objName = s_strndup(t->dbId, 482 strlen(t->dbId)); 483 if (!t->objName) { 484 logmsg(MSG_NOMEM, LOG_ERR, 485 "%s: Cannot allocate memory for " 486 "t->objName", myself); 487 objs = NULL; 488 return (2); 489 } 490 } else { 491 /* Force relationship for domain specific */ 492 493 /* Get the generic mapping */ 494 tg = find_table_mapping(t->dbId, dom - t->dbId, 495 *table_mapping); 496 if (tg == NULL || tg->objName == NULL) { 497 /* If not found, use dbId for objName */ 498 t->objName = s_strndup(t->dbId, 499 strlen(t->dbId)); 500 if (t->objName == NULL) { 501 logmsg(MSG_NOMEM, LOG_ERR, 502 "%s: Cannot allocate memory for t->objName", 503 myself); 504 return (2); 505 } 506 } else { 507 dom++; 508 tobj = s_strndup(tg->objName, 509 strlen(tg->objName)); 510 if (tobj == NULL) { 511 logmsg(MSG_NOMEM, LOG_ERR, 512 "%s: Cannot allocate memory for t->objName", 513 myself); 514 return (2); 515 } 516 alias = (char *)strtok_r(tobj, " ", 517 &lasts); 518 519 /* Loop 'breaks' on errors */ 520 while (alias) { 521 tmp = NULL; 522 dupalias = s_strndup(alias, 523 strlen(alias)); 524 if (!dupalias) 525 break; 526 if (getfullmapname(&dupalias, 527 dom)) { 528 i = 1; 529 break; 530 } 531 if (t->objName == NULL) 532 t->objName = dupalias; 533 else { 534 len = strlen(t->objName) 535 + strlen(dupalias) + 536 2; 537 tmp = s_calloc(1, len); 538 if (tmp == NULL) 539 break; 540 snprintf(tmp, len, 541 "%s %s", 542 t->objName, 543 dupalias); 544 free(dupalias); 545 dupalias = NULL; 546 free(t->objName); 547 t->objName = tmp; 548 } 549 alias = (char *)strtok_r(NULL, 550 " ", &lasts); 551 } 552 553 if (tobj) 554 free(tobj); 555 556 if (alias || 557 (objName = s_strdup(t->objName)) 558 == NULL) { 559 if (i) 560 logmsg(MSG_NOTIMECHECK, 561 LOG_ERR, 562 "%s: getfullmapname failed for %s for domain \"%s\"", 563 myself, dupalias, 564 dom); 565 else { 566 p_error = 567 parse_no_mem_error; 568 logmsg(MSG_NOMEM, 569 LOG_ERR, 570 "%s: Cannot allocate memory", 571 myself); 572 } 573 if (dupalias) 574 free(dupalias); 575 if (t->objName) 576 free(t->objName); 577 return (2); 578 579 } 580 objs = (char *)strtok_r(objName, " ", 581 &lasts); 582 } 583 } 584 } 585 586 if (tg != NULL) { 587 if (merge_table_mapping(tg, t)) { 588 logmsg(MSG_NOTIMECHECK, LOG_ERR, 589 "Error merging information from the %s to the %s mapping structure", 590 tg->dbId, t->dbId); 591 objs = NULL; 592 if (objName) 593 free(objName); 594 return (1); 595 } 596 } 597 598 /* 599 * If objName is "map1 map2" then do the second pass. 600 * If it is just "map1" however skip the expansion. 601 * Also skip it if t->objName is null. 602 */ 603 if (objs && strncasecmp(objs, t->objName, 604 strlen(t->objName))) { 605 t2 = find_table_mapping(objs, strlen(objs), 606 *table_mapping); 607 if (t2) { 608 if (merge_table_mapping(t, t2)) { 609 logmsg(MSG_NOTIMECHECK, LOG_ERR, 610 "Error merging information from the %s to the %s mapping structure", 611 t->dbId, t2->dbId); 612 objs = NULL; 613 if (objName) 614 free(objName); 615 return (1); 616 } 617 t->isMaster = 1; 618 } else { 619 t_new = new_merged_mapping(objs, t); 620 if (t_new) { 621 t->isMaster = 1; 622 if (prev != NULL) 623 prev->next = t_new; 624 else 625 *table_mapping = t_new; 626 prev = t_new; 627 prev->next = t; 628 } else { 629 logmsg(MSG_NOTIMECHECK, LOG_ERR, 630 "Error creating a new mapping structure %s", 631 objs); 632 objs = NULL; 633 if (objName) 634 free(objName); 635 return (1); 636 } 637 } 638 while ((objs = (char *)strtok_r(NULL, " ", &lasts)) 639 != NULL) { 640 t2 = find_table_mapping(objs, strlen(objs), 641 *table_mapping); 642 if (t2) { 643 if (merge_table_mapping(t, t2)) { 644 logmsg(MSG_NOTIMECHECK, LOG_ERR, 645 "Error merging information from the %s to the %s mapping structure", 646 t->dbId, t2->dbId); 647 objs = NULL; 648 if (objName) 649 free(objName); 650 return (1); 651 } 652 t->isMaster = 1; 653 } else { 654 /* 655 * create a new t_map with dbId = objs 656 * and copy t->* into new t_map 657 */ 658 t_new = new_merged_mapping(objs, t); 659 if (t_new) { 660 t->isMaster = 1; 661 if (prev != NULL) 662 prev->next = t_new; 663 else 664 *table_mapping = t_new; 665 prev = t_new; 666 prev->next = t; 667 } else { 668 logmsg(MSG_NOTIMECHECK, LOG_ERR, 669 "Error creating a new mapping structure %s", 670 objs); 671 objs = NULL; 672 if (objName) 673 free(objName); 674 return (1); 675 } 676 } 677 } 678 } /* if objs!= NULL */ 679 680 prev = t; 681 t = t->next; 682 683 if (objName) { 684 free(objName); 685 objName = NULL; 686 objs = NULL; 687 } 688 } /* for t = table_mapping loop */ 689 return (0); 690 } 691 692 __nis_table_mapping_t * 693 new_merged_mapping(const char *match, 694 __nis_table_mapping_t *intbl) 695 { 696 697 __nis_table_mapping_t *outtable = NULL; 698 699 outtable = (__nis_table_mapping_t *) 700 s_calloc(1, sizeof (__nis_table_mapping_t)); 701 if (outtable == NULL) 702 return (NULL); 703 initialize_table_mapping(outtable); 704 outtable->dbId = s_strndup(match, strlen(match)); 705 if (outtable->dbId == NULL) { 706 free_table_mapping(outtable); 707 outtable = NULL; 708 return (NULL); 709 } 710 if (merge_table_mapping(intbl, outtable)) { 711 free_table_mapping(outtable); 712 outtable = NULL; 713 } 714 return (outtable); 715 } 716 717 /* 718 * FUNCTION: final_parser_pass 719 * 720 * completes the final expansion of t_map structures linked list. 721 * all structures will have a non-null objPath as well as a objName 722 * in the form of "mapname . domainname ." or "splitfieldname . 723 * domainname .". 724 * 725 * RETURN VALUE: 0 on success, -1 on failure, -2 on fatal error. 726 */ 727 int 728 final_parser_pass( 729 __nis_table_mapping_t **table_mapping, 730 __yp_domain_context_t *ypDomains) 731 { 732 __nis_table_mapping_t *t; 733 __nis_table_mapping_t *t1, *returned_map; 734 __nis_table_mapping_t *prev = NULL; 735 int i; 736 char *myself = "final_parser_pass"; 737 int nm; 738 bool_t r; 739 int del_tbl_flag = 0; 740 741 if (ypDomains) { 742 if (!ypDomains->numDomains) { 743 p_error = parse_internal_error; 744 logmsg(MSG_NOTIMECHECK, LOG_ERR, 745 "%s:No domains specified.", myself); 746 return (-1); 747 } 748 } else { 749 p_error = parse_internal_error; 750 logmsg(MSG_NOTIMECHECK, LOG_ERR, 751 "%s:No domain structure supplied.", myself); 752 return (-1); 753 } 754 prev = NULL; 755 756 for (t = *table_mapping; t != NULL; ) { 757 758 /* Delete if marked for deletion by second_parser_pass */ 759 if (t->isMaster == 1) { 760 if (prev != NULL) 761 prev->next = t->next; 762 else 763 *table_mapping = t->next; 764 t1 = t; 765 t = t->next; 766 free_table_mapping(t1); 767 continue; 768 } 769 770 if (!t->objName && t->dbId) { 771 t->objName = s_strndup(t->dbId, strlen(t->dbId)); 772 if (!t->objName) { 773 logmsg(MSG_NOMEM, LOG_ERR, 774 "%s:Could not allocate.", myself); 775 return (-1); 776 } 777 } 778 i = ypDomains->numDomains; 779 while (i > 0) { 780 if (i == 1) { 781 /* modify existing table_mapping's */ 782 nm = checkfullmapname(t->dbId, 783 ypDomains->domainLabels[0], 784 table_mapping, &returned_map); 785 if (nm == 1) { 786 /* delete this mapping structure */ 787 logmsg(MSG_NOTIMECHECK, 788 LOG_WARNING, 789 "Mapping structure %s,%s " 790 "already exists.", 791 t->dbId, 792 ypDomains->domainLabels[0]); 793 if (merge_table_mapping(t, 794 returned_map)) { 795 logmsg(MSG_NOTIMECHECK, LOG_ERR, 796 "Error merging information " 797 "from the %s to the %s " 798 "mapping structure.", 799 t->dbId, 800 returned_map->dbId); 801 return (-1); 802 } 803 if (del_tbl_flag == 0) 804 del_tbl_flag = 1; 805 } else if (nm == -1) { 806 logmsg(MSG_NOTIMECHECK, LOG_ERR, 807 "Error searching for %s,%s structure", 808 t->dbId, 809 ypDomains->domainLabels[0]); 810 return (-1); 811 } else if (nm == 0 || nm == 2) { 812 if ((append_domainContext(&t, 813 ypDomains->domainLabels[0], 814 ypDomains->domains[0])) != 0) { 815 logmsg(MSG_NOTIMECHECK, LOG_ERR, 816 "Error appending domainContext %s", 817 ypDomains->domainLabels[0]); 818 return (-1); 819 } 820 del_tbl_flag = 0; 821 } 822 } else { /* if (i > 1) */ 823 /* need to create new table_mapping's */ 824 nm = checkfullmapname(t->dbId, 825 ypDomains->domainLabels[i - 1], 826 table_mapping, &returned_map); 827 if (nm == -1) { 828 logmsg(MSG_NOTIMECHECK, LOG_ERR, 829 "Error searching for %s,%s structure", 830 t->dbId, 831 ypDomains->domainLabels[i - 1]); 832 return (-1); 833 } else if (nm == 0) { 834 t1 = new_merged_mapping(t->dbId, t); 835 /* we clone ourselves */ 836 if (t1) { 837 if ((append_domainContext(&t1, 838 ypDomains->domainLabels[i - 1], 839 ypDomains->domains[i - 1])) != 0) { 840 logmsg(MSG_NOTIMECHECK, LOG_ERR, 841 "Error appending domainContext %s", 842 ypDomains->domainLabels[i - 1]); 843 free(t1); 844 return (-1); 845 } 846 if (prev != NULL) { 847 t1->next = prev->next; 848 prev->next = t1; 849 prev = prev->next; 850 } else { 851 t1->next = 852 *table_mapping; 853 *table_mapping = t1; 854 prev = t1; 855 } 856 } else { /* if !t1 */ 857 p_error = parse_internal_error; 858 logmsg(MSG_NOTIMECHECK, LOG_ERR, 859 "%s:Could not create new table -" 860 " check all instances of %s for errors", 861 myself, t->dbId); 862 return (-1); 863 } 864 } else if (nm == 1) { 865 logmsg(MSG_NOTIMECHECK, LOG_WARNING, 866 "Mapping structure %s,%s already exists.", 867 t->dbId, 868 ypDomains->domainLabels[i - 1]); 869 /* 870 * We should be deleting this, but can't 871 * really do it here, because we need to 872 * match with the domainLabels[0] case 873 * too. So we will just flag it for now. 874 */ 875 if (merge_table_mapping(t, 876 returned_map)) { 877 logmsg(MSG_NOTIMECHECK, LOG_ERR, 878 "Error merging information from the %s to the %s mapping structure.", 879 t->dbId, 880 returned_map->dbId); 881 return (-1); 882 } 883 del_tbl_flag = 1; 884 } else if (nm == 2) { 885 if ((append_domainContext(&t, 886 ypDomains->domainLabels[i - 1], 887 ypDomains->domains[i - 1])) != 0) { 888 logmsg(MSG_NOTIMECHECK, LOG_ERR, 889 "Error appending domainContext %s", 890 ypDomains->domainLabels[i - 1]); 891 return (-1); 892 } 893 } /* end of "if (nm == 0)" */ 894 } /* end of else if (i > 1) */ 895 896 897 /* 898 * 'merge_table_mapping' only copies unexpanded 899 * objectDN values into returned_map. Hence, 900 * read.base and write.base in returned_map 901 * needs to be expanded. 902 */ 903 if (nm == 1 && returned_map && returned_map->objectDN) { 904 r = make_fqdn( 905 returned_map->objectDN, 906 ypDomains->domains[i - 1]); 907 if (r == TRUE && 908 returned_map->objectDN->write.base) { 909 r = make_full_dn( 910 &returned_map->objectDN->write.base, 911 ypDomains->domains[i - 1]); 912 } 913 914 if (r == FALSE) { 915 logmsg(MSG_NOTIMECHECK, LOG_ERR, 916 "Error appending domainContext " 917 "%s to %s", 918 ypDomains->domainLabels[i - 1], 919 returned_map->dbId); 920 return (-2); 921 } 922 } 923 i--; 924 } /* end of while i > 0 loop */ 925 926 if (del_tbl_flag == 1) { 927 if (prev != NULL) { 928 prev->next = t->next; 929 free_table_mapping(t); 930 t = prev->next; 931 } else { 932 *table_mapping = t->next; 933 free_table_mapping(t); 934 t = *table_mapping; 935 } 936 del_tbl_flag = 0; 937 } else { 938 prev = t; 939 t = t->next; 940 } 941 } /* end of table mapping loop */ 942 943 for (t = *table_mapping; t != NULL; t = t->next) { 944 if (!t->dbId) { 945 logmsg(MSG_NOTIMECHECK, LOG_ERR, 946 "%s:Fatal error: structure with no dbId found.", 947 myself); 948 return (-2); 949 } 950 append_dot(&t->dbId); 951 if (!t->objectDN) { 952 p_error = parse_internal_error; 953 logmsg(MSG_NOTIMECHECK, LOG_ERR, 954 "%s:No objectDN for %s.", myself, t->dbId); 955 return (-1); 956 } 957 } 958 959 return (0); 960 } 961 962 /* 963 * FUNCTION: append_mapping_rule 964 * 965 * Appends mapping rules to a table_mapping structure 966 * with previously existing rules. flag controls whether 967 * the functions works on the rules From or To LDAP. 968 * 969 * RETURN VALUE: 0 on success, >= 1 on failure. 970 */ 971 972 static int 973 append_mapping_rule(__nis_mapping_rule_t *src_rule, 974 __nis_table_mapping_t *dst, int flag) 975 { 976 __nis_mapping_rule_t **rules = NULL; 977 978 if (flag == 0) { 979 if (dst->ruleFromLDAP == NULL) { 980 p_error = parse_internal_error; 981 return (1); 982 } 983 rules = (__nis_mapping_rule_t **) 984 s_realloc(dst->ruleFromLDAP, 985 (dst->numRulesFromLDAP + 1) * 986 sizeof (__nis_mapping_rule_t *)); 987 if (rules == NULL) 988 return (2); 989 dst->ruleFromLDAP = rules; 990 rules[dst->numRulesFromLDAP] = dup_mapping_rule(src_rule); 991 if (rules[dst->numRulesFromLDAP] == NULL) { 992 p_error = parse_no_mem_error; 993 return (2); 994 } 995 dst->numRulesFromLDAP++; 996 } else if (flag == 1) { 997 if (dst->ruleToLDAP == NULL) { 998 p_error = parse_internal_error; 999 return (1); 1000 } 1001 rules = (__nis_mapping_rule_t **) 1002 s_realloc(dst->ruleToLDAP, 1003 (dst->numRulesToLDAP + 1) * 1004 sizeof (__nis_mapping_rule_t *)); 1005 if (rules == NULL) 1006 return (2); 1007 dst->ruleToLDAP = rules; 1008 rules[dst->numRulesToLDAP] = dup_mapping_rule(src_rule); 1009 if (rules[dst->numRulesToLDAP] == NULL) { 1010 p_error = parse_no_mem_error; 1011 return (2); 1012 } 1013 dst->numRulesToLDAP++; 1014 } else 1015 return (1); 1016 1017 return (0); 1018 } 1019 1020 /* 1021 * FUNCTION: check_domain_specific_order 1022 * 1023 * Makes sure that an attribute with explicitly specified 1024 * nisLDAPdomainContext is found before its non-domain 1025 * specific counterpart. 1026 * 1027 * RETURN VALUE: 0 normal exit 1028 * 1 if domain specific attribute found 1029 * after non-domain specific one. 1030 * -1 some error condition 1031 */ 1032 1033 int 1034 check_domain_specific_order(const char *sd, 1035 config_key attrib_num, 1036 __nis_table_mapping_t *table_mapping, 1037 __yp_domain_context_t *ypDomains) 1038 { 1039 __nis_table_mapping_t *t; 1040 char *myself = "check_domain_specific_order"; 1041 char *type; 1042 char *dbId = 0; 1043 int i, len; 1044 int match = 0; 1045 1046 if (ypDomains) { 1047 if (!ypDomains->numDomains) { 1048 logmsg(MSG_NOTIMECHECK, LOG_ERR, 1049 "%s:No domains specified.", myself); 1050 return (-1); 1051 } 1052 } else { 1053 logmsg(MSG_NOTIMECHECK, LOG_ERR, 1054 "%s:No domain structure supplied.", myself); 1055 return (-1); 1056 } 1057 1058 for (i = 0; i < ypDomains->numDomains; i++) { 1059 for (t = table_mapping; t != NULL; t = t->next) { 1060 len = strlen(sd); 1061 if ((strcasecmp(t->dbId, sd) == 0) && (len == 1062 strlen(t->dbId))) 1063 /* prevent from matching against itself */ 1064 continue; 1065 dbId = s_strndup(t->dbId, strlen(t->dbId)); 1066 if (dbId == NULL) { 1067 logmsg(MSG_NOMEM, LOG_ERR, 1068 "%s:Memory allocation error.", myself); 1069 return (-1); 1070 } 1071 1072 if (getfullmapname(&dbId, 1073 ypDomains->domainLabels[i])) { 1074 logmsg(MSG_NOTIMECHECK, LOG_ERR, 1075 "Error getting fully qualified name for %s", 1076 dbId); 1077 free(dbId); 1078 return (-1); 1079 } 1080 if ((strcasecmp(dbId, sd) == 0) && (len == 1081 strlen(dbId))) { 1082 match = 0; 1083 switch (attrib_num) { 1084 case key_yp_map_flags: 1085 if (t->usedns_flag != 0 || 1086 t->securemap_flag != 0) 1087 match = 1; 1088 type = YP_MAP_FLAGS; 1089 break; 1090 case key_yp_comment_char: 1091 if (t->commentChar != 1092 DEFAULT_COMMENT_CHAR) 1093 match = 1; 1094 type = YP_COMMENT_CHAR; 1095 break; 1096 case key_yp_repeated_field_separators: 1097 if (strcmp(t->separatorStr, 1098 DEFAULT_SEP_STRING) != 0) 1099 match = 1; 1100 type = 1101 YP_REPEATED_FIELD_SEPARATORS; 1102 break; 1103 case key_yp_name_fields: 1104 if (t->e && t->numColumns) 1105 match = 1; 1106 type = YP_NAME_FIELDS; 1107 case key_yp_split_field: 1108 if (t->e && t->numColumns) 1109 match = 1; 1110 type = YP_SPLIT_FIELD; 1111 break; 1112 case key_yp_db_id_map: 1113 if (t->objName) 1114 match = 1; 1115 type = YP_DB_ID_MAP; 1116 break; 1117 case key_yp_entry_ttl: 1118 if (t->initTtlLo != 1119 (time_t)NO_VALUE_SET) 1120 match = 1; 1121 type = YP_ENTRY_TTL; 1122 break; 1123 case key_yp_ldap_object_dn: 1124 if (t->objectDN) 1125 match = 1; 1126 type = YP_LDAP_OBJECT_DN; 1127 break; 1128 case key_nis_to_ldap_map: 1129 if (t->ruleToLDAP) 1130 match = 1; 1131 type = NIS_TO_LDAP_MAP; 1132 break; 1133 case key_ldap_to_nis_map: 1134 if (t->ruleFromLDAP) 1135 match = 1; 1136 type = LDAP_TO_NIS_MAP; 1137 break; 1138 default: 1139 type = "unknown"; 1140 match = 0; 1141 break; 1142 } /* end of switch */ 1143 if (match) { 1144 logmsg(MSG_NOTIMECHECK, LOG_ERR, 1145 "Relative attribute '%s' of type '%s' found before fully qualified one '%s'", 1146 t->dbId, type, sd); 1147 free(dbId); 1148 dbId = NULL; 1149 return (1); 1150 } 1151 } /* end of strncasecmp */ 1152 free(dbId); 1153 dbId = NULL; 1154 } /* end of t loop */ 1155 } /* end of i loop */ 1156 if (dbId) 1157 free(dbId); 1158 dbId = NULL; 1159 return (0); 1160 } 1161 1162 int 1163 getfullmapname(char **mapname, const char *domainname) 1164 { 1165 char *maps = *mapname; 1166 int maplen = strlen(maps); 1167 int domainlen = strlen(domainname); 1168 1169 if (!maplen || !domainlen || 1170 maps[maplen - 1] == PERIOD_CHAR) 1171 return (1); 1172 else if (strchr(maps, COMMA_CHAR)) { 1173 /* map already has a domain part, do nothing */ 1174 return (0); 1175 } else { 1176 append_comma(&maps); 1177 maplen = strlen(maps); 1178 maps = realloc(maps, (maplen + domainlen + 1)); 1179 if (maps != NULL) { 1180 if (strlcat(maps, domainname, (maplen + domainlen + 1)) 1181 >= (maplen + domainlen + 1)) 1182 return (1); 1183 *mapname = maps; 1184 return (0); 1185 } else 1186 return (1); 1187 } 1188 } 1189 1190 /* 1191 * FUNCTION: checkfullmapname 1192 * 1193 * Tries to find out if by appending the table mapping structures 1194 * with each of the provided nisLDAPdomainContexts, an already 1195 * existing fqdn table mapping structure results. That would be the 1196 * case when a full qualified domain specific attribute was present. 1197 * 1198 * Note that per NISLDAPmapping(4) such an attribute MUST be listed 1199 * in the mapping file BEFORE its non-fqdn counterpart. 1200 * 1201 * RETURNS: 0 normal exit, 1 if an existing structure found, -1 for all 1202 * errors, 2 if already fqdn. If returning 1 the existing structure is 1203 * in found_map. 1204 */ 1205 1206 int 1207 checkfullmapname(const char *mapname, const char *domainname, 1208 __nis_table_mapping_t **table_mapping, 1209 __nis_table_mapping_t **found_map) 1210 { 1211 char *map; 1212 1213 *found_map = NULL; 1214 1215 /* This function does not alter mapname */ 1216 1217 if (!mapname || !domainname || *table_mapping == NULL) 1218 return (-1); 1219 1220 if (strchr(mapname, COMMA_CHAR)) 1221 return (2); 1222 1223 if ((map = s_strndup(mapname, strlen(mapname))) == 0) 1224 return (-1); 1225 1226 if (getfullmapname(&map, domainname)) { 1227 free(map); 1228 return (-1); 1229 } 1230 1231 *found_map = find_table_mapping(map, strlen(map), *table_mapping); 1232 if (*found_map) { 1233 free(map); 1234 return (1); 1235 } 1236 1237 free(map); 1238 return (0); 1239 } 1240 1241 /* 1242 * FUNCTION: append_domainContext 1243 * 1244 * Higher level function to append the domains to the appropriate 1245 * fields in a table mapping structure. Calls either getfullmapname() 1246 * or make_full_dn() to do the actual append. 1247 * 1248 * RETURNS: 0 on success, -1 on any error. 1249 */ 1250 1251 int 1252 append_domainContext(__nis_table_mapping_t **table_map, 1253 char *DomainLabel, char *Domain) 1254 { 1255 __nis_table_mapping_t *tmp_map = *table_map; 1256 char *lasts; 1257 char *tmp_dbId = NULL; 1258 char *id = NULL; 1259 int domain_specific = 0; 1260 char *myself = "append_domainContext"; 1261 1262 if (!DomainLabel || !Domain || !tmp_map) 1263 return (-1); 1264 if (tmp_map->dbId == NULL || tmp_map->objName == NULL) { 1265 p_error = parse_bad_map_error; 1266 return (-1); 1267 } 1268 tmp_dbId = s_strndup(tmp_map->dbId, strlen(tmp_map->dbId)); 1269 if (!tmp_dbId) 1270 return (-1); 1271 if (strchr(tmp_map->dbId, COMMA_CHAR)) { 1272 domain_specific = 1; 1273 id = (char *)strtok_r(tmp_dbId, COMMA_STRING, &lasts); 1274 if (id) 1275 id = (char *)strtok_r(NULL, COMMA_STRING, &lasts); 1276 else { 1277 free(tmp_dbId); 1278 return (-1); 1279 } 1280 if (!id) { 1281 free(tmp_dbId); 1282 return (-1); 1283 } 1284 if (strcasecmp(id, DomainLabel)) { 1285 free(tmp_dbId); 1286 return (0); 1287 } 1288 } else { 1289 if (getfullmapname(&tmp_map->dbId, DomainLabel)) { 1290 free(tmp_dbId); 1291 return (-1); 1292 } 1293 append_dot(&tmp_map->dbId); 1294 } 1295 if (tmp_dbId) 1296 free(tmp_dbId); 1297 tmp_dbId = NULL; 1298 1299 if (getfullmapname(&tmp_map->objName, DomainLabel)) 1300 return (-1); 1301 append_dot(&tmp_map->objName); 1302 1303 /* 1304 * If domain specific mapping doesn't have objectDN, 1305 * then don't touch. Most probably, pass for the generic mapping 1306 * will handle this by coping over it's own objectDN 1307 */ 1308 if (domain_specific && tmp_map->objectDN == NULL) 1309 return (0); 1310 1311 if (tmp_map->objectDN == NULL) { 1312 /* Allocate memory to objectDN */ 1313 tmp_map->objectDN = (__nis_object_dn_t *) 1314 s_calloc(1, sizeof (__nis_object_dn_t)); 1315 if (tmp_map->objectDN == NULL) { 1316 logmsg(MSG_NOMEM, LOG_ERR, 1317 "%s: Cannot allocate memory for objectDN", 1318 myself); 1319 return (2); 1320 } 1321 tmp_map->objectDN->read.base = NULL; 1322 tmp_map->objectDN->write.base = NULL; 1323 tmp_map->objectDN->read.attrs = NULL; 1324 tmp_map->objectDN->write.attrs = NULL; 1325 tmp_map->objectDN->read.scope = LDAP_SCOPE_ONELEVEL; 1326 tmp_map->objectDN->write.scope = LDAP_SCOPE_UNKNOWN; 1327 } 1328 1329 if (!make_fqdn(tmp_map->objectDN, Domain)) 1330 return (-1); 1331 if (tmp_map->objectDN->write.base) { 1332 if (!make_full_dn(&tmp_map->objectDN->write.base, Domain)) 1333 return (-1); 1334 } 1335 1336 return (0); 1337 } 1338