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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright 2012 Milan Jurik. All rights reserved. 25 */ 26 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <locale.h> /* gettext */ 30 #include <dlfcn.h> 31 #include <string.h> 32 #include <sys/varargs.h> 33 #include <errno.h> 34 #include "nscd_db.h" 35 #include "nscd_config.h" 36 #include "nscd_cfgdef.h" 37 #include "nscd_log.h" 38 39 typedef struct { 40 rwlock_t *global; 41 rwlock_t *alldb; 42 rwlock_t *nswdb; 43 } nscd_cfg_lock_t; 44 45 static rwlock_t cfg_paramDB_rwlock = DEFAULTRWLOCK; 46 static nscd_db_t *cfg_paramDB = NULL; 47 48 static nscd_cfg_global_data_t *nscd_cfg_global_current; 49 static nscd_cfg_nsw_db_data_t *nscd_cfg_nsw_db_data_current; 50 static nscd_cfg_nsw_db_data_t *nscd_cfg_nsw_alldb_current; 51 static rwlock_t *nscd_cfg_global_rwlock; 52 static rwlock_t *nscd_cfg_nsw_db_data_rwlock; 53 static rwlock_t *nscd_cfg_nsw_alldb_rwlock; 54 55 extern int _nscd_cfg_num_nsw_src_all; 56 extern nscd_cfg_id_t *_nscd_cfg_nsw_src_all; 57 58 nscd_cfg_error_t * 59 _nscd_cfg_make_error( 60 nscd_rc_t rc, 61 char *msg) 62 { 63 64 nscd_cfg_error_t *ret; 65 int size, msglen; 66 67 msglen = (msg != NULL ? strlen(msg) + 1 : 0); 68 69 size = sizeof (nscd_cfg_error_t) + msglen; 70 71 ret = calloc(1, size); 72 if (ret == NULL) 73 return (NULL); 74 75 ret->rc = rc; 76 if (msg != NULL) { 77 ret->msg = (char *)ret + 78 sizeof (nscd_cfg_error_t); 79 (void) memcpy(ret->msg, msg, msglen); 80 } 81 82 return (ret); 83 } 84 85 static nscd_rc_t 86 _nscd_cfg_get_list( 87 nscd_cfg_list_t **list, 88 nscd_cfg_list_type_t type) 89 { 90 char *me = "_nscd_cfg_get_list"; 91 int i, num, size; 92 nscd_cfg_id_t *l; 93 nscd_cfg_list_t *ret; 94 nscd_cfg_param_desc_t *pl; 95 nscd_cfg_stat_desc_t *sl; 96 void *p; 97 98 if (list == NULL) { 99 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 100 (me, "invalid argument: list = %p\n", list); 101 102 return (NSCD_INVALID_ARGUMENT); 103 } 104 *list = NULL; 105 106 switch (type) { 107 case NSCD_CFG_LIST_NSW_DB: 108 109 num = _nscd_cfg_num_nsw_db; 110 l = &_nscd_cfg_nsw_db[0]; 111 break; 112 113 case NSCD_CFG_LIST_NSW_SRC: 114 115 num = _nscd_cfg_num_nsw_src_all; 116 l = _nscd_cfg_nsw_src_all; 117 break; 118 119 case NSCD_CFG_LIST_PARAM: 120 121 num = _nscd_cfg_num_param; 122 pl = &_nscd_cfg_param_desc[0]; 123 break; 124 125 case NSCD_CFG_LIST_STAT: 126 127 num = _nscd_cfg_num_stat; 128 sl = &_nscd_cfg_stat_desc[0]; 129 break; 130 131 default: 132 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 133 (me, "invalid argument: type (%d)\n", type); 134 135 return (NSCD_INVALID_ARGUMENT); 136 } 137 138 size = sizeof (nscd_cfg_list_t) + sizeof (nscd_cfg_id_t *) * (num + 1); 139 140 ret = calloc(1, size); 141 if (ret == NULL) 142 return (NSCD_NO_MEMORY); 143 144 ret->num = num; 145 p = (char *)ret + sizeof (nscd_cfg_list_t); 146 ret->list = (nscd_cfg_id_t **)p; 147 148 if (type == NSCD_CFG_LIST_PARAM) { 149 for (i = 0; i <= num; i++) 150 ret->list[i] = (nscd_cfg_id_t *)&pl[i]; 151 } else if (type == NSCD_CFG_LIST_STAT) { 152 for (i = 0; i <= num; i++) 153 ret->list[i] = (nscd_cfg_id_t *)&sl[i]; 154 } else { 155 for (i = 0; i <= num; i++) 156 ret->list[i] = &l[i]; 157 } 158 159 *list = ret; 160 161 return (NSCD_SUCCESS); 162 } 163 164 nscd_rc_t 165 _nscd_cfg_get_param_desc_list( 166 nscd_cfg_param_desc_list_t **list) 167 { 168 return (_nscd_cfg_get_list((nscd_cfg_list_t **)list, 169 NSCD_CFG_LIST_PARAM)); 170 } 171 172 /* 173 * FUNCTION: _nscd_cfg_create_paramDB 174 * 175 * Create the internal config parameter database 176 */ 177 static nscd_db_t * 178 _nscd_cfg_create_paramDB() 179 { 180 181 nscd_db_t *ret; 182 183 (void) rw_wrlock(&cfg_paramDB_rwlock); 184 185 ret = _nscd_alloc_db(NSCD_DB_SIZE_MEDIUM); 186 187 if (ret != NULL) 188 cfg_paramDB = ret; 189 190 (void) rw_unlock(&cfg_paramDB_rwlock); 191 192 return (ret); 193 } 194 195 /* 196 * FUNCTION: _nscd_cfg_add_index_entry 197 * 198 * Add a config index entry (a name to index mapping) 199 * to the internal configuration database. 200 */ 201 static nscd_rc_t 202 _nscd_cfg_add_index_entry( 203 char *name, 204 int index, 205 nscd_cfg_list_type_t type) 206 { 207 int *idx; 208 int size; 209 int dbe_type; 210 nscd_db_entry_t *db_entry; 211 212 if (name == NULL) 213 return (NSCD_INVALID_ARGUMENT); 214 215 if (type == NSCD_CFG_LIST_NSW_DB) 216 dbe_type = NSCD_DATA_CFG_NSW_DB_INDEX; 217 else if (type == NSCD_CFG_LIST_NSW_SRC) 218 dbe_type = NSCD_DATA_CFG_NSW_SRC_INDEX; 219 else if (type == NSCD_CFG_LIST_PARAM) 220 dbe_type = NSCD_DATA_CFG_PARAM_INDEX; 221 else if (type == NSCD_CFG_LIST_STAT) 222 dbe_type = NSCD_DATA_CFG_STAT_INDEX; 223 224 size = sizeof (int); 225 226 db_entry = _nscd_alloc_db_entry(dbe_type, (const char *)name, 227 size, 1, 1); 228 if (db_entry == NULL) 229 return (NSCD_NO_MEMORY); 230 231 idx = (int *)*(db_entry->data_array); 232 *idx = index; 233 234 (void) rw_wrlock(&cfg_paramDB_rwlock); 235 (void) _nscd_add_db_entry(cfg_paramDB, name, db_entry, 236 NSCD_ADD_DB_ENTRY_FIRST); 237 (void) rw_unlock(&cfg_paramDB_rwlock); 238 239 return (NSCD_SUCCESS); 240 } 241 242 /* 243 * FUNCTION: _nscd_cfg_get_index 244 * 245 * Get the index of a config data item by searching the internal config 246 * database. Do not free the returned data. 247 */ 248 static int 249 _nscd_cfg_get_index( 250 char *name, 251 nscd_cfg_list_type_t type) 252 { 253 int index = -1, dbe_type; 254 const nscd_db_entry_t *db_entry; 255 256 if (name == NULL) 257 return (-1); 258 259 if (type == NSCD_CFG_LIST_NSW_DB) 260 dbe_type = NSCD_DATA_CFG_NSW_DB_INDEX; 261 else if (type == NSCD_CFG_LIST_NSW_SRC) 262 dbe_type = NSCD_DATA_CFG_NSW_SRC_INDEX; 263 else if (type == NSCD_CFG_LIST_PARAM) 264 dbe_type = NSCD_DATA_CFG_PARAM_INDEX; 265 else if (type == NSCD_CFG_LIST_STAT) 266 dbe_type = NSCD_DATA_CFG_STAT_INDEX; 267 else 268 return (-1); 269 270 db_entry = _nscd_get_db_entry(cfg_paramDB, dbe_type, 271 (const char *)name, NSCD_GET_FIRST_DB_ENTRY, 0); 272 273 if (db_entry != NULL) 274 index = *(int *)*(db_entry->data_array); 275 276 return (index); 277 } 278 279 static nscd_rc_t 280 _nscd_cfg_verify_group_info( 281 nscd_cfg_group_info_t *g_info, 282 nscd_cfg_param_desc_t *gdesc) 283 { 284 285 char *me = "_nscd_cfg_verify_group_info"; 286 void *vp; 287 nscd_cfg_group_info_t *gi; 288 289 if (_nscd_cfg_flag_is_set(gdesc->pflag, NSCD_CFG_PFLAG_GLOBAL)) { 290 vp = (char *)&nscd_cfg_global_default + 291 gdesc->g_offset; 292 gi = (nscd_cfg_group_info_t *)vp; 293 } else { 294 vp = (char *)&nscd_cfg_nsw_db_data_default + 295 gdesc->g_offset; 296 gi = (nscd_cfg_group_info_t *)vp; 297 298 } 299 300 if (g_info->num_param == gi->num_param && 301 _nscd_cfg_bitmap_is_equal(g_info->bitmap, gi->bitmap)) 302 return (NSCD_SUCCESS); 303 304 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 305 (me, "ERROR: group (%s) info mismatched: group info " 306 "(%d, %#6.4x) not equal to that of default configuration data " 307 "(%d, %#6.4x)\n", gdesc->id.name, g_info->num_param, 308 _nscd_cfg_bitmap_value(g_info->bitmap), gi->num_param, 309 _nscd_cfg_bitmap_value(gi->bitmap)); 310 311 return (NSCD_CFG_PARAM_DESC_ERROR); 312 313 } 314 315 316 static nscd_rc_t 317 _nscd_cfg_init_nsw() 318 { 319 char *me = "_nscd_cfg_init_nsw"; 320 int i, j, idx, rc, num; 321 nscd_cfg_id_t *id; 322 nscd_cfg_list_type_t type[2] = { NSCD_CFG_LIST_NSW_DB, 323 NSCD_CFG_LIST_NSW_SRC }; 324 325 nscd_cfg_id_t *list[2] = { _nscd_cfg_nsw_db, NULL}; 326 327 list[1] = _nscd_cfg_nsw_src_all; 328 329 for (j = 0; j < 2; j++) { 330 331 if (j == 0) 332 num = _nscd_cfg_num_nsw_db + 1; 333 else 334 num = _nscd_cfg_num_nsw_src_all; 335 336 for (i = 0; i < num; i++) { 337 338 /* 339 * _nscd_cfg_nsw_alldb is the id for the 340 * special ALLDB (defaults for all db) 341 */ 342 if (j == 0 && i == _nscd_cfg_num_nsw_db) { 343 id = &_nscd_cfg_nsw_alldb; 344 idx = NSCD_CFG_NSW_ALLDB_INDEX; 345 } else { 346 id = &(list[j])[i]; 347 id->index = idx = i; 348 } 349 350 if (id->name == NULL) 351 continue; 352 353 if ((rc = _nscd_cfg_add_index_entry(id->name, 354 idx, type[j])) != NSCD_SUCCESS) { 355 356 _NSCD_LOG(NSCD_LOG_CONFIG, 357 NSCD_LOG_LEVEL_ERROR) 358 (me, "unable to add index entry for " 359 "nsswitch entry %s\n", id->name); 360 361 _nscd_free_db(cfg_paramDB); 362 return (rc); 363 } 364 } 365 } 366 367 return (NSCD_SUCCESS); 368 } 369 370 static nscd_rc_t 371 _nscd_cfg_init_param() 372 { 373 char *me = "_nscd_cfg_init_param"; 374 int i, gi, fn = 0; 375 nscd_cfg_id_t *id; 376 nscd_cfg_param_desc_t *desc, *gdesc = NULL; 377 nscd_cfg_group_info_t g_info; 378 nscd_cfg_list_type_t type = NSCD_CFG_LIST_PARAM; 379 nscd_rc_t rc; 380 void *nfunc, *vfunc; 381 382 if (_nscd_cfg_create_paramDB() == NULL) 383 return (NSCD_NO_MEMORY); 384 385 desc = &_nscd_cfg_param_desc[0]; 386 387 /* 388 * need to loop to the last (+1) param description 389 * which is a fake group and which marks the end 390 * of list. It is used to signal the end of the 391 * previous group so that the proper data will be 392 * set for that group 393 */ 394 for (i = 0; i < _nscd_cfg_num_param + 1; i++, desc++) { 395 396 id = (nscd_cfg_id_t *)desc; 397 398 if (_nscd_cfg_flag_is_set(desc->pflag, 399 NSCD_CFG_PFLAG_GROUP)) { 400 401 if (gdesc != NULL) { 402 g_info.num_param = fn; 403 gdesc->p_fn = fn; 404 405 if ((rc = _nscd_cfg_verify_group_info( 406 &g_info, gdesc)) != NSCD_SUCCESS) 407 return (rc); 408 } 409 410 gi = i; 411 fn = 0; 412 gdesc = desc; 413 g_info.bitmap = NSCD_CFG_BITMAP_ZERO; 414 415 /* 416 * set the notify/verify functions 417 */ 418 nfunc = (void *)gdesc->notify; 419 vfunc = (void *)gdesc->verify; 420 } else { 421 if (i == 0) { 422 423 _NSCD_LOG(NSCD_LOG_CONFIG, 424 NSCD_LOG_LEVEL_ERROR) 425 (me, "ERROR: first parameter " 426 "description is not for a group\n"); 427 428 return (NSCD_CFG_PARAM_DESC_ERROR); 429 } 430 431 /* 432 * set bitmap: the rightmost bit represents 433 * the first member (index = 0) in the group, 434 * the next bit is for the second member 435 * (index = 1), and so on 436 */ 437 _nscd_cfg_bitmap_set_nth(g_info.bitmap, fn); 438 439 desc->p_fn = fn++; 440 441 /* 442 * set the notify/verify functions 443 */ 444 if (desc->notify == NSCD_CFG_FUNC_NOTIFY_AS_GROUP) { 445 (void) memcpy(&desc->notify, &nfunc, 446 sizeof (void *)); 447 } 448 if (desc->verify == NSCD_CFG_FUNC_VERIFY_AS_GROUP) { 449 (void) memcpy(&desc->verify, &vfunc, 450 sizeof (void *)); 451 } 452 } 453 454 /* if end of list reached, we are done */ 455 if (i == _nscd_cfg_num_param) 456 break; 457 458 desc->g_index = gi; 459 460 id->index = i; 461 462 if ((rc = _nscd_cfg_add_index_entry(id->name, 463 i, type)) != NSCD_SUCCESS) { 464 465 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 466 (me, "unable to add index entry for parameter " 467 "%s\n", id->name); 468 469 _nscd_free_db(cfg_paramDB); 470 return (rc); 471 } else { 472 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 473 (me, "index entry for parameter " 474 "%s added\n", id->name); 475 } 476 } 477 478 return (_nscd_cfg_init_nsw()); 479 } 480 481 static nscd_rc_t 482 _nscd_cfg_init_stat() 483 { 484 char *me = "_nscd_cfg_init_stat"; 485 int i, gi, fn = 0; 486 nscd_cfg_id_t *id; 487 nscd_cfg_stat_desc_t *desc, *gdesc = NULL; 488 nscd_cfg_group_info_t g_info; 489 nscd_cfg_list_type_t type = NSCD_CFG_LIST_STAT; 490 nscd_rc_t rc; 491 void *gsfunc; 492 493 desc = &_nscd_cfg_stat_desc[0]; 494 495 /* 496 * need to loop to the last (+1) stat description 497 * which is a fake group and which marks the end 498 * of list. It is used to signal the end of the 499 * previous group so that the proper data will be 500 * set for that group 501 */ 502 for (i = 0; i < _nscd_cfg_num_stat + 1; i++, desc++) { 503 504 id = (nscd_cfg_id_t *)desc; 505 506 if (_nscd_cfg_flag_is_set(desc->sflag, 507 NSCD_CFG_SFLAG_GROUP)) { 508 509 if (gdesc != NULL) { 510 g_info.num_param = fn; 511 gdesc->s_fn = fn; 512 513 if (g_info.num_param != 514 gdesc->gi.num_param || 515 !_nscd_cfg_bitmap_is_equal( 516 g_info.bitmap, gdesc->gi.bitmap)) { 517 518 _NSCD_LOG(NSCD_LOG_CONFIG, 519 NSCD_LOG_LEVEL_ERROR) 520 (me, "ERROR: group (%s) " 521 "info mismatched: " 522 "group info (%d, %#6.4x) not " 523 "equal to the predefined one " 524 "(%d, %#6.4x)\n", gdesc->id.name, 525 g_info.num_param, 526 _nscd_cfg_bitmap_value( 527 g_info.bitmap), 528 gdesc->gi.num_param, 529 _nscd_cfg_bitmap_value( 530 gdesc->gi.bitmap)); 531 532 exit(1); 533 return (NSCD_CFG_STAT_DESC_ERROR); 534 } 535 } 536 537 gi = i; 538 fn = 0; 539 gdesc = desc; 540 g_info.bitmap = NSCD_CFG_BITMAP_ZERO; 541 542 /* 543 * set the get_stat function 544 */ 545 gsfunc = (void *)gdesc->get_stat; 546 } else { 547 if (i == 0) { 548 549 _NSCD_LOG(NSCD_LOG_CONFIG, 550 NSCD_LOG_LEVEL_ERROR) 551 (me, "ERROR: first stat " 552 "description is not for a group\n"); 553 554 return (NSCD_CFG_STAT_DESC_ERROR); 555 } 556 557 /* 558 * set bitmap: the rightmost bit represents 559 * the first member (index = 0) in the group, 560 * the next bit is for the second member 561 * (index = 1), and so on 562 */ 563 _nscd_cfg_bitmap_set_nth(g_info.bitmap, fn); 564 565 desc->s_fn = fn++; 566 567 /* 568 * set the get_stat function 569 */ 570 if (desc->get_stat == NSCD_CFG_FUNC_GET_STAT_AS_GROUP) { 571 (void) memcpy(&desc->get_stat, &gsfunc, 572 sizeof (void *)); 573 } 574 } 575 576 /* if end of list reached, we are done */ 577 if (i == _nscd_cfg_num_stat) 578 break; 579 580 desc->g_index = gi; 581 582 id->index = i; 583 584 if ((rc = _nscd_cfg_add_index_entry(id->name, 585 i, type)) != NSCD_SUCCESS) { 586 587 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 588 (me, "unable to add index entry for stat " 589 "description %s\n", id->name); 590 591 _nscd_free_db(cfg_paramDB); 592 return (rc); 593 } else { 594 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 595 (me, "index entry for stat description " 596 "%s added\n", id->name); 597 } 598 } 599 600 return (NSCD_SUCCESS); 601 } 602 603 static nscd_rc_t 604 _nscd_cfg_copy_vlen_data( 605 void *data, 606 void **new_data_p, 607 nscd_cfg_param_desc_t *desc, 608 int *data_len, 609 nscd_bool_t in) 610 { 611 int len, dlen; 612 nscd_cfg_vlen_data_t *v = NULL; 613 614 *new_data_p = NULL; 615 *data_len = 0; 616 617 /* it is OK if there is nothing to copy */ 618 if (data == NULL) 619 return (NSCD_SUCCESS); 620 621 /* 622 * if copy to the config store we need to allocate space 623 * for the extra vlen header 624 */ 625 if (desc->type == NSCD_CFG_DATA_STRING) { 626 len = dlen = strlen((char *)data) + 1; 627 if (in == nscd_true) 628 len += sizeof (nscd_cfg_vlen_data_t); 629 } else { 630 /* 631 * should not be here, since for now 632 * only string variable length data 633 * is supported 634 */ 635 *new_data_p = NULL; 636 return (NSCD_CFG_PARAM_DESC_ERROR); 637 } 638 639 v = calloc(1, len); 640 if (v == NULL) { 641 *new_data_p = NULL; 642 return (NSCD_NO_MEMORY); 643 } 644 645 /* 646 * if copy to the config store, set up 647 * the extra vlen header in which the 648 * pointer to, and length of, the real 649 * data are kept. The pointer to the real 650 * data, not the vlen header, is returned. 651 */ 652 if (in == nscd_true) { 653 v->ptr = (char *)v + sizeof (nscd_cfg_vlen_data_t); 654 v->len = dlen; 655 (void) memcpy(v->ptr, data, dlen); 656 *new_data_p = v->ptr; 657 } else { 658 (void) memcpy(v, data, dlen); 659 *new_data_p = v; 660 } 661 *data_len = dlen; 662 663 return (NSCD_SUCCESS); 664 } 665 666 static void 667 _nscd_cfg_free_vlen_data_int( 668 void *data) 669 { 670 nscd_cfg_vlen_data_t *v = NULL; 671 void *p; 672 673 if (data == NULL) 674 return; 675 676 p = (char *)data - sizeof (nscd_cfg_vlen_data_t); 677 v = (nscd_cfg_vlen_data_t *)p; 678 if (v->ptr == data) 679 free(v); 680 } 681 682 static nscd_rc_t 683 _nscd_cfg_set_vlen_data_int( 684 void *src, 685 void *dest, 686 nscd_bool_t global) 687 { 688 int i, offset, dlen = 0; 689 void *s, *d, *new; 690 void *cptr; 691 nscd_rc_t rc; 692 nscd_cfg_param_desc_t *desc; 693 694 desc = &_nscd_cfg_param_desc[0]; 695 for (i = 0; i < _nscd_cfg_num_param; i++, desc++) { 696 697 if (global == nscd_true && 698 _nscd_cfg_flag_is_not_set(desc->pflag, 699 NSCD_CFG_PFLAG_GLOBAL)) 700 continue; 701 else if (global != nscd_true && 702 _nscd_cfg_flag_is_set(desc->pflag, 703 NSCD_CFG_PFLAG_GLOBAL)) 704 continue; 705 706 if (_nscd_cfg_flag_is_set(desc->pflag, 707 NSCD_CFG_PFLAG_VLEN_DATA)) { 708 709 offset = desc->g_offset + desc->p_offset; 710 711 s = (char *)src + offset; 712 cptr = *(char **)s; 713 714 rc = _nscd_cfg_copy_vlen_data(cptr, &new, 715 desc, &dlen, nscd_true); 716 if (rc != NSCD_SUCCESS) 717 return (rc); 718 719 d = (char *)dest + offset; 720 /* free the old vlen data */ 721 if (*(char **)d == NULL) 722 _nscd_cfg_free_vlen_data_int(*(char **)d); 723 724 *(char **)d = new; 725 } 726 } 727 728 return (NSCD_SUCCESS); 729 } 730 731 static void * 732 _nscd_cfg_locate_vlen_data( 733 void *cfg_data, 734 int *len) 735 { 736 void *ptr, *ret; 737 738 ptr = *(char **)cfg_data; 739 ret = ptr; 740 if (ret == NULL) { 741 *len = 0; 742 return (NULL); 743 } 744 ptr = (char *)ptr - sizeof (nscd_cfg_vlen_data_t); 745 *len = ((nscd_cfg_vlen_data_t *)ptr)->len; 746 747 return (ret); 748 } 749 750 static void 751 _nscd_cfg_lock( 752 nscd_bool_t is_read, 753 nscd_cfg_lock_t *cfglock) 754 { 755 756 int (*lockfunc)(rwlock_t *); 757 758 if (cfglock == NULL) 759 return; 760 761 if (is_read == nscd_true) 762 lockfunc = rw_rdlock; 763 else 764 lockfunc = rw_wrlock; 765 766 if (cfglock->global != NULL) { 767 768 (lockfunc)(cfglock->global); 769 return; 770 } 771 772 if (cfglock->alldb != NULL) 773 (lockfunc)(cfglock->alldb); 774 775 if (cfglock->nswdb != NULL) 776 (lockfunc)(cfglock->nswdb); 777 } 778 779 static void 780 _nscd_cfg_unlock( 781 nscd_cfg_lock_t *cfglock) 782 { 783 if (cfglock == NULL) 784 return; 785 786 if (cfglock->global != NULL) { 787 788 (void) rw_unlock(cfglock->global); 789 free(cfglock); 790 return; 791 } 792 793 if (cfglock->nswdb != NULL) 794 (void) rw_unlock(cfglock->nswdb); 795 796 if (cfglock->alldb != NULL) 797 (void) rw_unlock(cfglock->alldb); 798 799 free(cfglock); 800 } 801 802 /* 803 * If vlen_data_addr is given, it will be set to the 804 * address of the pointer pointing to the vlen data. 805 * 'cfglock' will be set to point to the reader/writer 806 * lock(s) protecting the (group) configuration data. 807 */ 808 static nscd_rc_t 809 _nscd_cfg_locate_cfg_data( 810 void **cfg_data, 811 nscd_bool_t is_read, 812 nscd_cfg_param_desc_t *desc, 813 nscd_cfg_id_t *nswdb, 814 nscd_bool_t get_group, 815 void **vlen_data_addr, 816 int *len, 817 nscd_cfg_lock_t **cfglock) 818 { 819 int offset; 820 821 *cfg_data = NULL; 822 if (len != NULL) 823 *len = 0; 824 if (vlen_data_addr != NULL) 825 *vlen_data_addr = NULL; 826 827 if (cfglock != NULL) { 828 *cfglock = calloc(1, sizeof (nscd_cfg_lock_t)); 829 if (*cfglock == NULL) 830 return (NSCD_NO_MEMORY); 831 } 832 833 /* assume if nswdb is NULL, the param is a global one */ 834 if (nswdb == NULL) { 835 836 offset = desc->g_offset; 837 if (get_group != nscd_true) 838 offset += desc->p_offset; 839 *cfg_data = (char *)nscd_cfg_global_current + offset; 840 841 if (cfglock != NULL) 842 (*cfglock)->global = nscd_cfg_global_rwlock; 843 844 } else if (nswdb->index == NSCD_CFG_NSW_ALLDB_INDEX) { 845 846 offset = desc->g_offset; 847 if (get_group != nscd_true) 848 offset += desc->p_offset; 849 *cfg_data = (char *)nscd_cfg_nsw_alldb_current + 850 offset; 851 852 if (cfglock != NULL) 853 (*cfglock)->alldb = nscd_cfg_nsw_alldb_rwlock; 854 855 } else { 856 857 offset = nswdb->index * 858 (sizeof (nscd_cfg_nsw_db_data_t)) + desc->g_offset; 859 if (get_group != nscd_true) 860 offset += desc->p_offset; 861 *cfg_data = (char *)nscd_cfg_nsw_db_data_current + 862 offset; 863 864 if (cfglock != NULL) { 865 (*cfglock)->nswdb = 866 &nscd_cfg_nsw_db_data_rwlock[nswdb->index]; 867 868 (*cfglock)->alldb = nscd_cfg_nsw_alldb_rwlock; 869 } 870 } 871 872 /* lock the config data */ 873 if (cfglock != NULL) 874 _nscd_cfg_lock(is_read, *cfglock); 875 876 if (get_group != nscd_true && 877 _nscd_cfg_flag_is_not_set(desc->pflag, 878 NSCD_CFG_PFLAG_GROUP) && 879 (_nscd_cfg_flag_is_set(desc->pflag, 880 NSCD_CFG_PFLAG_VLEN_DATA))) { 881 if (vlen_data_addr != NULL) 882 *vlen_data_addr = *cfg_data; 883 *cfg_data = _nscd_cfg_locate_vlen_data(*cfg_data, len); 884 return (NSCD_SUCCESS); 885 } 886 887 if (len != NULL) { 888 if (get_group == nscd_true) 889 *len = desc->g_size; 890 else 891 *len = desc->p_size; 892 } 893 894 return (NSCD_SUCCESS); 895 } 896 897 /* 898 * perform the preliminary (range) check on 'data' based on the 899 * datatype (desc->datatype) of the config parameter 900 */ 901 nscd_rc_t 902 _nscd_cfg_prelim_check( 903 nscd_cfg_param_desc_t *desc, 904 void *data, 905 nscd_cfg_error_t **errorp) 906 { 907 908 char *me = "_nscd_cfg_prelim_check"; 909 char msg[NSCD_CFG_MAX_ERR_MSG_LEN]; 910 nscd_cfg_str_check_t *sc; 911 nscd_cfg_int_check_t *ic; 912 nscd_cfg_bitmap_check_t *bmc; 913 nscd_rc_t rc = NSCD_CFG_PRELIM_CHECK_FAILED; 914 915 if ((nscd_cfg_str_check_t *)desc->p_check == NULL) 916 return (NSCD_SUCCESS); 917 918 switch (desc->type) { 919 920 case NSCD_CFG_DATA_STRING: 921 922 sc = (nscd_cfg_str_check_t *)desc->p_check; 923 if (sc->must_not_null == nscd_true && data == NULL) { 924 925 if (errorp == NULL) 926 break; 927 928 (void) snprintf(msg, sizeof (msg), 929 gettext("data must be specified for %s"), 930 desc->id.name); 931 932 break; 933 } 934 935 if (data == NULL) { 936 rc = NSCD_SUCCESS; 937 break; 938 } 939 940 if (sc->maxlen != 0 && 941 strlen((char *)data) > sc->maxlen) { 942 943 if (errorp == NULL) 944 break; 945 946 (void) snprintf(msg, sizeof (msg), 947 gettext("length of data (%s) for %s larger " 948 "than %d"), 949 (char *)data, desc->id.name, sc->maxlen); 950 break; 951 } 952 953 rc = NSCD_SUCCESS; 954 955 break; 956 957 case NSCD_CFG_DATA_INTEGER: 958 959 ic = (nscd_cfg_int_check_t *)desc->p_check; 960 if (*(int *)data > ic->max || 961 *(int *)data < ic->min) { 962 963 if (errorp == NULL) 964 break; 965 966 (void) snprintf(msg, sizeof (msg), 967 gettext("data (%d) for %s out of range " 968 "(%d - %d)"), 969 *(int *)data, desc->id.name, 970 ic->min, ic->max); 971 972 break; 973 } 974 975 rc = NSCD_SUCCESS; 976 977 break; 978 979 case NSCD_CFG_DATA_BITMAP: 980 981 bmc = (nscd_cfg_bitmap_check_t *)desc->p_check; 982 if (_nscd_cfg_bitmap_value(*(nscd_cfg_bitmap_t *)data) & 983 ~(bmc->valid_bits)) { 984 985 if (errorp == NULL) 986 break; 987 988 (void) snprintf(msg, sizeof (msg), 989 gettext("data (%#6.4x) for %s contain bit " 990 "not in 0x%x"), 991 _nscd_cfg_bitmap_value( 992 *(nscd_cfg_bitmap_t *)data), 993 desc->id.name, 994 _nscd_cfg_bitmap_value(bmc->valid_bits)); 995 break; 996 } 997 998 rc = NSCD_SUCCESS; 999 1000 break; 1001 } 1002 1003 if (rc != NSCD_SUCCESS && errorp != NULL) { 1004 *errorp = _nscd_cfg_make_error(rc, msg); 1005 1006 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 1007 (me, "invalid argument: %s\n", (*errorp)->msg); 1008 } 1009 1010 return (rc); 1011 } 1012 1013 static nscd_rc_t 1014 _nscd_cfg_notify_i( 1015 nscd_cfg_param_desc_t *desc, 1016 nscd_cfg_id_t *nswdb, 1017 int *skip, 1018 nscd_cfg_error_t **errorp) 1019 { 1020 1021 char *me = "_nscd_cfg_notify_i"; 1022 int i, num, skip_bk; 1023 void *cfg_data, *cdata; 1024 void *cookie = NULL; 1025 nscd_rc_t rc; 1026 nscd_cfg_flag_t dflag, dflag1; 1027 nscd_cfg_bitmap_t bitmap_c, bitmap_s, *bitmap_addr; 1028 nscd_cfg_group_info_t *gi; 1029 1030 if (errorp != NULL) 1031 *errorp = NULL; 1032 1033 if (skip == NULL) 1034 skip = &skip_bk; 1035 1036 *skip = 0; 1037 1038 if (_nscd_cfg_flag_is_not_set(desc->pflag, 1039 NSCD_CFG_PFLAG_GROUP)) { 1040 1041 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1042 (me, "ERROR: expect parameter description for group, " 1043 "but receive parameter description is for %s\n", 1044 desc->id.name); 1045 1046 return (NSCD_CFG_PARAM_DESC_ERROR); 1047 } 1048 1049 /* 1050 * Set data flag going with data to be sent to the 1051 * verify/notify routines. Allowing the config flag 1052 * be exipandable, set the bits one by one. 1053 */ 1054 dflag = NSCD_CFG_FLAG_ZERO; 1055 dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_STATIC_DATA); 1056 dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_INIT); 1057 dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_GROUP); 1058 if (_nscd_cfg_flag_is_set(desc->pflag, 1059 NSCD_CFG_PFLAG_INIT_SET_ALL_DB)) 1060 dflag = _nscd_cfg_flag_set(dflag, 1061 NSCD_CFG_DFLAG_SET_ALL_DB); 1062 1063 /* get to the group data in the config store */ 1064 rc = _nscd_cfg_locate_cfg_data(&cfg_data, nscd_true, 1065 desc, nswdb, nscd_true, NULL, NULL, NULL); 1066 if (rc != NSCD_SUCCESS) 1067 goto error; 1068 1069 /* 1070 * the static bitmap associated with the group 1071 * may be replaced before sending to the components, 1072 * so save the bitmap for later use 1073 */ 1074 gi = _nscd_cfg_get_gi(cfg_data); 1075 bitmap_c = gi->bitmap; 1076 bitmap_addr = &(gi->bitmap); 1077 1078 /* 1079 * the elements in this group will all be handled 1080 * so the caller can skip them 1081 */ 1082 *skip = desc->p_fn; 1083 1084 if (_nscd_cfg_flag_is_set(desc->pflag, 1085 NSCD_CFG_PFLAG_INIT_SEND_WHOLE_GROUP)) 1086 /* send the entire group just once */ 1087 num = 1; 1088 1089 else { /* send individual members one by one */ 1090 1091 num = desc->p_fn; 1092 1093 /* 1094 * skip the first desc which is for the group 1095 * and get to the desc for the first member 1096 */ 1097 desc++; 1098 1099 dflag = _nscd_cfg_flag_unset(dflag, 1100 NSCD_CFG_DFLAG_GROUP); 1101 } 1102 1103 dflag1 = dflag; 1104 for (i = 0; i < num; i++, desc++) { 1105 1106 dflag = dflag1; 1107 1108 if (_nscd_cfg_flag_is_set(desc->pflag, 1109 NSCD_CFG_PFLAG_SEND_BIT_SELECTED)) { 1110 1111 /* set the bitmap to select just this member */ 1112 bitmap_s = NSCD_CFG_BITMAP_ZERO; 1113 _nscd_cfg_bitmap_set_nth(bitmap_s, i); 1114 /* replace the bitmap in the cfg data */ 1115 _nscd_cfg_bitmap_set(bitmap_addr, bitmap_s); 1116 1117 /* 1118 * send the whole group but with only one 1119 * member selected 1120 */ 1121 cdata = cfg_data; 1122 1123 dflag = _nscd_cfg_flag_set(dflag, 1124 NSCD_CFG_DFLAG_GROUP); 1125 dflag = _nscd_cfg_flag_set(dflag, 1126 NSCD_CFG_DFLAG_BIT_SELECTED); 1127 } else { 1128 /* 1129 * send param data or group data: 1130 * param data - non-xero desc->p_offset 1131 * group data - zero desc->p_offset 1132 */ 1133 cdata = (char *)cfg_data + desc->p_offset; 1134 1135 /* 1136 * if variable length data, need to send pointer 1137 * to the data (not the address of the pointer) 1138 */ 1139 if (_nscd_cfg_flag_is_set(desc->pflag, 1140 NSCD_CFG_PFLAG_VLEN_DATA)) 1141 cdata = *(char **)cdata; 1142 } 1143 1144 if (desc->verify != NULL) { 1145 dflag = _nscd_cfg_flag_set(dflag, 1146 NSCD_CFG_DFLAG_VERIFY); 1147 rc = desc->verify(cdata, desc, nswdb, 1148 dflag, errorp, &cookie); 1149 if (rc != NSCD_SUCCESS) 1150 goto error; 1151 } 1152 1153 if (desc->notify != NULL) { 1154 dflag = _nscd_cfg_flag_set(dflag, 1155 NSCD_CFG_DFLAG_NOTIFY); 1156 1157 rc = desc->notify(cfg_data, desc, nswdb, 1158 dflag, errorp, cookie); 1159 if (rc != NSCD_SUCCESS) 1160 goto error; 1161 } 1162 } 1163 1164 rc = NSCD_SUCCESS; 1165 1166 /* restore the bitmap in the cfg data */ 1167 _nscd_cfg_bitmap_set(bitmap_addr, bitmap_c); 1168 1169 error: 1170 1171 return (rc); 1172 1173 } 1174 1175 static nscd_rc_t 1176 _nscd_cfg_notify_init( 1177 nscd_cfg_error_t **errorp) 1178 { 1179 int i, j, skip; 1180 nscd_rc_t rc; 1181 nscd_cfg_id_t *nswdb = NULL; 1182 nscd_cfg_param_desc_t *desc; 1183 1184 if (errorp != NULL) 1185 *errorp = NULL; 1186 1187 for (i = 0; i < _nscd_cfg_num_param; i++) { 1188 1189 desc = &_nscd_cfg_param_desc[i]; 1190 1191 if (_nscd_cfg_flag_is_set(desc->pflag, 1192 NSCD_CFG_PFLAG_GLOBAL)) { /* global cfg data */ 1193 1194 rc = _nscd_cfg_notify_i(desc, NULL, &skip, errorp); 1195 } else { 1196 1197 /* 1198 * if use defaults for all nsswitch database, 1199 * send the config data to verify/notify once 1200 */ 1201 if (_nscd_cfg_flag_is_set(desc->pflag, 1202 NSCD_CFG_PFLAG_INIT_SET_ALL_DB)) { 1203 1204 nswdb = &_nscd_cfg_nsw_alldb; 1205 1206 rc = _nscd_cfg_notify_i(desc, nswdb, 1207 &skip, errorp); 1208 } else { /* send data once for each nsw db */ 1209 1210 for (j = 0; j < _nscd_cfg_num_nsw_db; j++) { 1211 1212 nswdb = &_nscd_cfg_nsw_db[j]; 1213 1214 rc = _nscd_cfg_notify_i(desc, 1215 nswdb, &skip, errorp); 1216 1217 if (rc != NSCD_SUCCESS) 1218 break; 1219 } 1220 } 1221 } 1222 1223 if (rc != NSCD_SUCCESS) 1224 return (rc); 1225 1226 i += skip; 1227 } 1228 1229 return (NSCD_SUCCESS); 1230 } 1231 1232 nscd_rc_t 1233 _nscd_cfg_init( 1234 nscd_cfg_error_t **errorp) 1235 { 1236 1237 int i, j, datalen; 1238 int dbi = 0, dbj = 0; 1239 char *dest, *src; 1240 char *dbni = NULL, *dbnj = NULL; 1241 nscd_rc_t rc; 1242 nscd_cfg_nsw_spc_default_t *spc; 1243 1244 if (errorp != NULL) 1245 *errorp = NULL; 1246 1247 rc = _nscd_cfg_init_param(); 1248 if (rc != NSCD_SUCCESS) 1249 return (rc); 1250 1251 rc = _nscd_cfg_init_stat(); 1252 if (rc != NSCD_SUCCESS) 1253 return (rc); 1254 1255 nscd_cfg_global_current = calloc(1, 1256 sizeof (nscd_cfg_global_data_t)); 1257 if (nscd_cfg_global_current == NULL) 1258 return (NSCD_NO_MEMORY); 1259 1260 nscd_cfg_nsw_alldb_current = calloc(1, 1261 sizeof (nscd_cfg_nsw_db_data_t)); 1262 if (nscd_cfg_nsw_alldb_current == NULL) 1263 return (NSCD_NO_MEMORY); 1264 1265 nscd_cfg_nsw_db_data_current = calloc(_nscd_cfg_num_nsw_db, 1266 sizeof (nscd_cfg_nsw_db_data_t)); 1267 if (nscd_cfg_nsw_db_data_current == NULL) 1268 return (NSCD_NO_MEMORY); 1269 1270 nscd_cfg_global_rwlock = calloc(1, sizeof (rwlock_t)); 1271 if (nscd_cfg_global_rwlock == NULL) 1272 return (NSCD_NO_MEMORY); 1273 (void) rwlock_init(nscd_cfg_global_rwlock, USYNC_THREAD, NULL); 1274 1275 *nscd_cfg_global_current = nscd_cfg_global_default; 1276 1277 rc = _nscd_cfg_set_vlen_data_int(&nscd_cfg_global_default, 1278 nscd_cfg_global_current, nscd_true); 1279 if (rc != NSCD_SUCCESS) 1280 return (rc); 1281 1282 nscd_cfg_nsw_db_data_rwlock = calloc(_nscd_cfg_num_nsw_db, 1283 sizeof (rwlock_t)); 1284 if (nscd_cfg_nsw_db_data_rwlock == NULL) 1285 return (NSCD_NO_MEMORY); 1286 1287 /* set per switch db config to the default for all db's */ 1288 for (i = 0; i < _nscd_cfg_num_nsw_db; i++) { 1289 1290 nscd_cfg_nsw_db_data_current[i] = 1291 nscd_cfg_nsw_db_data_default; 1292 1293 (void) rwlock_init(&nscd_cfg_nsw_db_data_rwlock[i], 1294 0, NULL); 1295 } 1296 1297 /* add db specific defaults */ 1298 for (i = 0; i < _nscd_cfg_num_nsw_default; i++) { 1299 1300 if (_nscd_cfg_nsw_spc_default[i].data == NULL) 1301 continue; 1302 1303 if (_nscd_cfg_nsw_spc_default[i].db != dbni) { 1304 for (j = 0; j < _nscd_cfg_num_nsw_db; j++) { 1305 1306 if (strcmp(_nscd_cfg_nsw_db[j].name, 1307 _nscd_cfg_nsw_spc_default[i].db) != 0) 1308 continue; 1309 1310 dbi = _nscd_cfg_nsw_db[j].index; 1311 dbni = _nscd_cfg_nsw_db[j].name; 1312 break; 1313 } 1314 } 1315 1316 dest = (char *)&nscd_cfg_nsw_db_data_current[dbi] + 1317 _nscd_cfg_nsw_spc_default[i].group_off + 1318 _nscd_cfg_nsw_spc_default[i].param_off; 1319 1320 src = _nscd_cfg_nsw_spc_default[i].data; 1321 datalen = _nscd_cfg_nsw_spc_default[i].data_len; 1322 1323 (void) memcpy(dest, src, datalen); 1324 } 1325 1326 /* add db specific defaults via links */ 1327 for (i = 0; i < _nscd_cfg_num_link_default; i++) { 1328 1329 if (_nscd_cfg_nsw_link_default[i].data == NULL) 1330 continue; 1331 1332 spc = _nscd_cfg_nsw_link_default[i].data; 1333 1334 if (_nscd_cfg_nsw_link_default[i].db != dbni) { 1335 for (j = 0; j < _nscd_cfg_num_nsw_db; j++) { 1336 1337 if (strcmp(_nscd_cfg_nsw_db[j].name, 1338 _nscd_cfg_nsw_link_default[i].db) != 0) 1339 continue; 1340 1341 dbi = _nscd_cfg_nsw_db[j].index; 1342 dbni = _nscd_cfg_nsw_db[j].name; 1343 break; 1344 } 1345 } 1346 1347 dest = (char *)&nscd_cfg_nsw_db_data_current[dbi] + 1348 _nscd_cfg_nsw_link_default[i].group_off + 1349 _nscd_cfg_nsw_link_default[i].param_off; 1350 1351 if (_nscd_cfg_nsw_db[j].name != dbnj) { 1352 for (j = 0; j < _nscd_cfg_num_nsw_db; j++) { 1353 1354 if (strcmp(spc->db, 1355 _nscd_cfg_nsw_db[j].name) != 0) 1356 continue; 1357 1358 dbnj = _nscd_cfg_nsw_db[j].name; 1359 dbj = _nscd_cfg_nsw_db[j].index; 1360 break; 1361 } 1362 } 1363 1364 src = (char *)&nscd_cfg_nsw_db_data_current[dbj] + 1365 spc->group_off + spc->param_off; 1366 datalen = spc->data_len; 1367 1368 (void) memcpy(dest, src, datalen); 1369 } 1370 1371 /* fix up variable length fields */ 1372 for (i = 0; i < _nscd_cfg_num_nsw_db; i++) { 1373 1374 rc = _nscd_cfg_set_vlen_data_int( 1375 &nscd_cfg_nsw_db_data_current[i], 1376 &nscd_cfg_nsw_db_data_current[i], nscd_false); 1377 if (rc != NSCD_SUCCESS) 1378 return (rc); 1379 } 1380 1381 nscd_cfg_nsw_alldb_rwlock = calloc(1, sizeof (rwlock_t)); 1382 if (nscd_cfg_nsw_alldb_rwlock == NULL) 1383 return (NSCD_NO_MEMORY); 1384 1385 (void) rwlock_init(nscd_cfg_nsw_alldb_rwlock, 0, NULL); 1386 1387 rc = _nscd_cfg_set_vlen_data_int( 1388 &nscd_cfg_nsw_db_data_default, 1389 nscd_cfg_nsw_alldb_current, nscd_false); 1390 if (rc != NSCD_SUCCESS) 1391 return (rc); 1392 1393 /* 1394 * notify and send the configuration data to 1395 * the nscd components 1396 */ 1397 rc = _nscd_cfg_notify_init(errorp); 1398 if (rc != NSCD_SUCCESS) 1399 return (rc); 1400 1401 return (NSCD_SUCCESS); 1402 } 1403 1404 static nscd_rc_t 1405 _nscd_cfg_get_handle_common( 1406 nscd_cfg_list_type_t type, 1407 char *name, 1408 char *nswdb_name, 1409 nscd_cfg_handle_t **handle, 1410 nscd_cfg_error_t **errorp) 1411 { 1412 1413 int i, is_global; 1414 char *desc_str; 1415 nscd_cfg_handle_t *h; 1416 nscd_cfg_param_desc_t *pdesc; 1417 nscd_cfg_stat_desc_t *sdesc; 1418 char *me = "_nscd_cfg_get_handle_common"; 1419 char msg[NSCD_CFG_MAX_ERR_MSG_LEN]; 1420 nscd_rc_t rc = NSCD_INVALID_ARGUMENT; 1421 1422 if (handle == NULL) { 1423 1424 (void) snprintf(msg, sizeof (msg), 1425 gettext("address of handle not specified")); 1426 if (errorp) 1427 *errorp = _nscd_cfg_make_error(rc, msg); 1428 1429 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 1430 (me, "invalid argument: %s\n", msg); 1431 1432 return (rc); 1433 } 1434 1435 *handle = NULL; 1436 1437 if (name == NULL) { 1438 1439 (void) snprintf(msg, sizeof (msg), 1440 gettext("name not specified")); 1441 if (errorp) 1442 *errorp = _nscd_cfg_make_error(rc, msg); 1443 1444 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 1445 (me, "invalid argument: %s\n"); 1446 1447 return (rc); 1448 } 1449 1450 h = calloc(1, sizeof (nscd_cfg_handle_t)); 1451 if (h == NULL) 1452 return (NSCD_NO_MEMORY); 1453 h->type = type; 1454 1455 if (type == NSCD_CFG_LIST_PARAM) 1456 desc_str = gettext("configuration parameter"); 1457 else 1458 desc_str = gettext("statistics"); 1459 1460 /* get param or stat descriptor */ 1461 i = _nscd_cfg_get_index(name, type); 1462 if (i != -1) { 1463 1464 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 1465 (me, "%s: index of %s is %d\n", desc_str, name, i); 1466 1467 if (type == NSCD_CFG_LIST_PARAM) { 1468 pdesc = &_nscd_cfg_param_desc[i]; 1469 (void) memcpy(&h->desc, &pdesc, sizeof (pdesc)); 1470 is_global = _nscd_cfg_flag_is_set( 1471 pdesc->pflag, NSCD_CFG_PFLAG_GLOBAL); 1472 1473 /* hidden params are not exposed */ 1474 if (_nscd_cfg_flag_is_set( 1475 pdesc->pflag, NSCD_CFG_PFLAG_HIDDEN)) 1476 i = -1; 1477 1478 if (_nscd_cfg_flag_is_set(pdesc->pflag, 1479 NSCD_CFG_PFLAG_OBSOLETE)) { 1480 _NSCD_LOG(NSCD_LOG_CONFIG, 1481 NSCD_LOG_LEVEL_WARNING) 1482 (me, gettext("%s: %s is obsolete and " 1483 "will be ignored\n"), 1484 desc_str, name); 1485 } 1486 } else { 1487 sdesc = &_nscd_cfg_stat_desc[i]; 1488 (void) memcpy(&h->desc, &sdesc, sizeof (sdesc)); 1489 is_global = _nscd_cfg_flag_is_set( 1490 sdesc->sflag, NSCD_CFG_SFLAG_GLOBAL); 1491 } 1492 } 1493 1494 if (i == -1) { 1495 1496 (void) snprintf(msg, sizeof (msg), 1497 gettext("%s: unknown name \"%s\""), desc_str, name); 1498 if (errorp) 1499 *errorp = _nscd_cfg_make_error(rc, msg); 1500 1501 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1502 (me, "%s\n", msg); 1503 1504 free(h); 1505 return (rc); 1506 } 1507 1508 /* 1509 * if the param/stat is not a global one, we need to 1510 * know which nsswitch database we are dealing with 1511 */ 1512 if (is_global == 0) { 1513 if (nswdb_name == NULL) { 1514 1515 (void) snprintf(msg, sizeof (msg), 1516 gettext("%s: switch database name not specified"), 1517 desc_str); 1518 if (errorp) 1519 *errorp = _nscd_cfg_make_error(rc, msg); 1520 1521 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1522 (me, "%s for non-global param or stat %s\n", 1523 msg, name); 1524 1525 free(h); 1526 return (rc); 1527 } 1528 } else { 1529 1530 if (nswdb_name != NULL) { 1531 1532 (void) snprintf(msg, sizeof (msg), 1533 gettext("%s: switch database specified for " 1534 "global data"), desc_str); 1535 if (errorp) 1536 *errorp = _nscd_cfg_make_error(rc, msg); 1537 1538 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1539 (me, "%s %s\n", msg, name); 1540 1541 free(h); 1542 return (rc); 1543 } 1544 1545 *handle = h; 1546 return (NSCD_SUCCESS); 1547 } 1548 1549 /* get nsw DB id */ 1550 i = _nscd_cfg_get_index(nswdb_name, NSCD_CFG_LIST_NSW_DB); 1551 if (i != -1) { 1552 1553 if (i == NSCD_CFG_NSW_ALLDB_INDEX) 1554 h->nswdb = &_nscd_cfg_nsw_alldb; 1555 else 1556 h->nswdb = &_nscd_cfg_nsw_db[i]; 1557 1558 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG) 1559 (me, "%s: index of %s is %d\n", 1560 desc_str, nswdb_name, i); 1561 } else { 1562 1563 (void) snprintf(msg, sizeof (msg), 1564 gettext("%s: unknown switch database name \"%s\""), 1565 desc_str, nswdb_name); 1566 if (errorp) 1567 *errorp = _nscd_cfg_make_error(rc, msg); 1568 1569 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1570 (me, "%s\n", msg); 1571 1572 free(h); 1573 return (NSCD_CFG_UNSUPPORTED_SWITCH_DB); 1574 } 1575 1576 *handle = h; 1577 1578 return (NSCD_SUCCESS); 1579 } 1580 1581 nscd_rc_t 1582 _nscd_cfg_get_handle( 1583 char *param_name, 1584 char *nswdb_name, 1585 nscd_cfg_handle_t **handle, 1586 nscd_cfg_error_t **errorp) 1587 { 1588 1589 return (_nscd_cfg_get_handle_common(NSCD_CFG_LIST_PARAM, 1590 param_name, nswdb_name, handle, errorp)); 1591 } 1592 1593 nscd_rc_t 1594 _nscd_cfg_get_stat_handle( 1595 char *stat_name, 1596 char *nswdb_name, 1597 nscd_cfg_handle_t **handle, 1598 nscd_cfg_error_t **errorp) 1599 { 1600 1601 return (_nscd_cfg_get_handle_common(NSCD_CFG_LIST_STAT, 1602 stat_name, nswdb_name, handle, errorp)); 1603 } 1604 1605 void 1606 _nscd_cfg_free_handle( 1607 nscd_cfg_handle_t *handle) 1608 { 1609 1610 free(handle); 1611 1612 } 1613 1614 static void 1615 _nscd_cfg_free_vlen_data_group( 1616 nscd_cfg_param_desc_t *gdesc, 1617 void *group_data, 1618 nscd_bool_t in) 1619 { 1620 int num; 1621 void *dest, *ptr; 1622 nscd_cfg_param_desc_t *desc; 1623 1624 desc = gdesc; 1625 1626 num = ((nscd_cfg_group_info_t *)group_data)->num_param; 1627 1628 while (num-- > 0) { 1629 1630 desc++; 1631 1632 /* skip fixed length data */ 1633 if (_nscd_cfg_flag_is_not_set(desc->pflag, 1634 NSCD_CFG_PFLAG_VLEN_DATA)) 1635 continue; 1636 1637 dest = (char *)group_data + desc->p_offset; 1638 ptr = *(char **)dest; 1639 if (ptr == NULL) 1640 continue; 1641 if (in == nscd_true) 1642 _nscd_cfg_free_vlen_data_int(ptr); 1643 else 1644 free(ptr); 1645 } 1646 } 1647 1648 void 1649 _nscd_cfg_free_param_data( 1650 void *data) 1651 { 1652 1653 if (data == NULL) 1654 return; 1655 1656 free(data); 1657 } 1658 1659 void 1660 _nscd_cfg_free_group_data( 1661 nscd_cfg_handle_t *handle, 1662 void *data) 1663 { 1664 1665 nscd_cfg_param_desc_t *desc; 1666 nscd_cfg_group_info_t *gi; 1667 1668 if (handle == NULL || data == NULL) 1669 return; 1670 1671 desc = _nscd_cfg_get_desc(handle); 1672 gi = (nscd_cfg_group_info_t *)data; 1673 if (desc->p_fn != gi->num_param) 1674 return; 1675 1676 _nscd_cfg_free_vlen_data_group(desc, data, nscd_false); 1677 1678 free(data); 1679 } 1680 1681 void 1682 _nscd_cfg_free_error( 1683 nscd_cfg_error_t *error) 1684 { 1685 1686 if (error == NULL) 1687 return; 1688 1689 free(error); 1690 } 1691 1692 static nscd_rc_t 1693 _nscd_cfg_copy_param_data( 1694 nscd_cfg_param_desc_t *desc, 1695 void *dest, 1696 void *pdata, 1697 nscd_bool_t in, 1698 nscd_bool_t set_addr) 1699 { 1700 1701 char *me = "_nscd_cfg_copy_param_data"; 1702 void *tmp; 1703 int dlen; 1704 nscd_rc_t rc = NSCD_SUCCESS; 1705 1706 if (desc == NULL || dest == NULL) { 1707 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1708 (me, "input desc == %p, dest == %p\n", desc, dest); 1709 return (NSCD_INVALID_ARGUMENT); 1710 } 1711 1712 /* fixed length data */ 1713 if (_nscd_cfg_flag_is_not_set(desc->pflag, 1714 NSCD_CFG_PFLAG_VLEN_DATA)) { 1715 (void) memcpy(dest, pdata, desc->p_size); 1716 goto done; 1717 } 1718 1719 1720 /* variable length data from this point on */ 1721 1722 /* make a copy of the variable length data */ 1723 rc = _nscd_cfg_copy_vlen_data(pdata, &tmp, desc, &dlen, in); 1724 if (rc != NSCD_SUCCESS) 1725 goto done; 1726 1727 if (in == nscd_true) { /* data to internal */ 1728 1729 /* free the variable length data in the config store */ 1730 if (*(char **)dest != NULL) 1731 _nscd_cfg_free_vlen_data_int(*(char **)dest); 1732 } 1733 1734 if (set_addr == nscd_true) { 1735 /* 1736 * set the addr of the vlen data 1737 */ 1738 *(char **)dest = tmp; 1739 } else { 1740 /* 1741 * copy the data content (not address) 1742 */ 1743 (void) memcpy(dest, tmp, dlen); 1744 } 1745 1746 done: 1747 1748 return (rc); 1749 } 1750 1751 static nscd_rc_t 1752 _nscd_cfg_copy_group_data_in( 1753 nscd_cfg_param_desc_t *gdesc, 1754 nscd_cfg_group_info_t *gi, 1755 void *group_dest, 1756 void *group_src) 1757 { 1758 int i, num; 1759 nscd_cfg_param_desc_t *desc; 1760 void *src, *dest; 1761 1762 i = 0; 1763 num = gi->num_param; 1764 desc = gdesc; 1765 1766 while (num-- > 0) { 1767 1768 desc++; 1769 1770 /* if member not selected by bitmap, skip */ 1771 if (_nscd_cfg_bitmap_is_not_set(gi->bitmap, i++)) 1772 continue; 1773 1774 src = (char *)group_src + desc->p_offset; 1775 dest = (char *)group_dest + desc->p_offset; 1776 1777 /* 1778 * if variable length data, free and replace the old 1779 * with the new 1780 */ 1781 if (_nscd_cfg_flag_is_set(desc->pflag, 1782 NSCD_CFG_PFLAG_VLEN_DATA)) { 1783 _nscd_cfg_free_vlen_data_int(*(char **)dest); 1784 *(char **)dest = *(char **)src; 1785 *(char **)src = NULL; 1786 } else { 1787 /* 1788 * fixed length data, just copy it 1789 */ 1790 (void) memcpy(dest, src, desc->p_size); 1791 } 1792 } 1793 1794 return (NSCD_SUCCESS); 1795 } 1796 1797 static nscd_rc_t 1798 _nscd_cfg_copy_group_data_out( 1799 nscd_cfg_param_desc_t *gdesc, 1800 void *group_dest, 1801 void *group_src) 1802 { 1803 1804 char *me = "_nscd_cfg_copy_group_data_out"; 1805 void *src, *dest; 1806 int dlen; 1807 int num; 1808 nscd_cfg_group_info_t *gi; 1809 nscd_rc_t rc = NSCD_SUCCESS; 1810 nscd_cfg_param_desc_t *desc; 1811 1812 if (group_dest == NULL) { 1813 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1814 (me, "input group_dest = NULL\n"); 1815 return (NSCD_INVALID_ARGUMENT); 1816 } 1817 1818 gi = _nscd_cfg_get_gi(group_src); 1819 num = gi->num_param; 1820 desc = gdesc; 1821 1822 while (num-- > 0) { 1823 1824 desc++; 1825 1826 dest = (char *)group_dest + desc->p_offset; 1827 src = (char *)group_src + desc->p_offset; 1828 1829 /* 1830 * if variable length data, get the real 1831 * address and length of the data 1832 */ 1833 if (_nscd_cfg_flag_is_set(desc->pflag, 1834 NSCD_CFG_PFLAG_VLEN_DATA)) { 1835 src = _nscd_cfg_locate_vlen_data(src, &dlen); 1836 if (dlen == 0) 1837 continue; 1838 } 1839 1840 /* 1841 * The nscd_true asks _nscd_cfg_copy_param_data 1842 * to set addr of the vlen data in 'dest' rather 1843 * than copying the data content 1844 */ 1845 rc = _nscd_cfg_copy_param_data(desc, dest, src, 1846 nscd_false, nscd_true); 1847 if (rc != NSCD_SUCCESS) { 1848 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1849 (me, "unable to copy param data for %s\n", 1850 desc->id.name); 1851 1852 _nscd_cfg_free_vlen_data_group(gdesc, 1853 group_dest, nscd_false); 1854 1855 free(group_dest); 1856 1857 return (rc); 1858 } 1859 } 1860 1861 /* 1862 * set group bitmap 1863 */ 1864 (void) memcpy(group_dest, group_src, 1865 sizeof (nscd_cfg_group_info_t)); 1866 1867 return (rc); 1868 } 1869 1870 1871 /* 1872 * group_cfg is needed always; group_src may be NULL if 1873 * param_index not zero and pdata not NULL; group_cfg and 1874 * pdata should not be both non-NULL 1875 */ 1876 static nscd_rc_t 1877 _nscd_cfg_copy_group_data_merge( 1878 nscd_cfg_param_desc_t *gdesc, 1879 void **group_dest, 1880 void *group_src, 1881 void *group_cfg, 1882 int param_index, 1883 void *pdata) 1884 { 1885 1886 char *me = "_nscd_cfg_copy_group_data_merge"; 1887 void *src, *dest, *tmp_dest = NULL; 1888 int num, i = 0; 1889 nscd_cfg_group_info_t *gi; 1890 nscd_rc_t rc = NSCD_SUCCESS; 1891 nscd_cfg_param_desc_t *desc; 1892 nscd_cfg_bitmap_t bitmap; 1893 1894 if (group_dest == NULL) { 1895 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1896 (me, "input **group_dest == NULL\n"); 1897 return (NSCD_INVALID_ARGUMENT); 1898 } 1899 1900 if (group_cfg == NULL) { 1901 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1902 (me, "input **group_cfg == NULL\n"); 1903 return (NSCD_INVALID_ARGUMENT); 1904 } 1905 1906 if (param_index != 0 && pdata == NULL) { 1907 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1908 (me, "param_index != NULL but pdata == %p\n", pdata); 1909 return (NSCD_INVALID_ARGUMENT); 1910 } 1911 1912 tmp_dest = calloc(1, gdesc->g_size); 1913 if (tmp_dest == NULL) 1914 return (NSCD_NO_MEMORY); 1915 1916 if (group_src != NULL) 1917 gi = _nscd_cfg_get_gi(group_src); 1918 else { 1919 gi = _nscd_cfg_get_gi(group_cfg); 1920 bitmap = NSCD_CFG_BITMAP_ZERO; 1921 } 1922 1923 num = gi->num_param; 1924 desc = gdesc; 1925 1926 while (num-- > 0) { 1927 1928 desc++; 1929 1930 dest = (char *)tmp_dest + desc->p_offset; 1931 1932 /* 1933 * if member not selected by bitmap in group_src, 1934 * get the member data in group_cfg 1935 */ 1936 if (_nscd_cfg_bitmap_is_not_set(gi->bitmap, i++) || 1937 group_src == NULL) { 1938 src = (char *)group_cfg + desc->p_offset; 1939 } else 1940 src = (char *)group_src + desc->p_offset; 1941 1942 if (desc->id.index == param_index) { 1943 1944 /* use the param data in pdata if provided */ 1945 src = pdata; 1946 _nscd_cfg_bitmap_set_nth(bitmap, i); 1947 } 1948 1949 /* 1950 * if variable length data, get to the data 1951 * instead of pointer to the data 1952 */ 1953 if (_nscd_cfg_flag_is_set(desc->pflag, 1954 NSCD_CFG_PFLAG_VLEN_DATA)) 1955 src = *(char **)src; 1956 1957 /* 1958 * nscd_true asks _nscd_cfg_copy_param_data to 1959 * set addr of the vlen data in 'dest' rather 1960 * than copying the data content 1961 */ 1962 rc = _nscd_cfg_copy_param_data(desc, dest, src, 1963 nscd_true, nscd_true); 1964 if (rc != NSCD_SUCCESS) { 1965 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 1966 (me, "unable to copy param data for %s\n", 1967 desc->id.name); 1968 1969 _nscd_cfg_free_vlen_data_group(gdesc, 1970 tmp_dest, nscd_true); 1971 1972 free(tmp_dest); 1973 1974 return (rc); 1975 } 1976 } 1977 1978 *group_dest = tmp_dest; 1979 1980 /* 1981 * set bitmap: if input is group data, use the one 1982 * given; if input is param data, use the one computed 1983 * above 1984 */ 1985 if (group_src != NULL) 1986 (void) memcpy(*group_dest, group_src, 1987 sizeof (nscd_cfg_group_info_t)); 1988 else { 1989 gi = _nscd_cfg_get_gi(*group_dest); 1990 _nscd_cfg_bitmap_set(&gi->bitmap, bitmap); 1991 } 1992 1993 return (rc); 1994 } 1995 1996 /* ARGSUSED */ 1997 nscd_rc_t 1998 _nscd_cfg_get( 1999 nscd_cfg_handle_t *handle, 2000 void **data, 2001 int *data_len, 2002 nscd_cfg_error_t **errorp) 2003 { 2004 char *me = "_nscd_cfg_get"; 2005 int dlen; 2006 nscd_rc_t rc = NSCD_SUCCESS; 2007 nscd_cfg_id_t *nswdb; 2008 nscd_cfg_param_desc_t *desc; 2009 void *cfg_data, *ptr = NULL; 2010 nscd_bool_t get_group = nscd_false; 2011 nscd_bool_t out = nscd_false; 2012 nscd_cfg_lock_t *lock = NULL; 2013 2014 if (data_len != NULL) 2015 *data_len = 0; 2016 2017 if (data == NULL) { 2018 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2019 (me, "input data = %p\n", data); 2020 return (NSCD_INVALID_ARGUMENT); 2021 } 2022 2023 *data = NULL; 2024 2025 if (handle == NULL) { 2026 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2027 (me, "handle is NULL\n"); 2028 return (NSCD_INVALID_ARGUMENT); 2029 } 2030 2031 nswdb = handle->nswdb; 2032 desc = (nscd_cfg_param_desc_t *)handle->desc; 2033 2034 if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP)) 2035 get_group = nscd_true; 2036 2037 /* 2038 * locate the current value of the param or group 2039 * and lock the config data for reading 2040 */ 2041 rc = _nscd_cfg_locate_cfg_data(&cfg_data, nscd_true, desc, 2042 nswdb, get_group, NULL, &dlen, &lock); 2043 if (rc != NSCD_SUCCESS) { 2044 2045 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2046 (me, "unable to locate config data\n"); 2047 return (rc); 2048 2049 } else if (cfg_data == NULL) /* NULL vlen data */ 2050 goto done; 2051 2052 ptr = calloc(1, dlen); 2053 if (ptr == NULL) { 2054 rc = NSCD_NO_MEMORY; 2055 goto error_exit; 2056 } 2057 2058 if (get_group == nscd_true) { 2059 2060 rc = _nscd_cfg_copy_group_data_out(desc, ptr, cfg_data); 2061 if (rc != NSCD_SUCCESS) { 2062 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2063 (me, "unable to copy group data %p: " 2064 "error = %d\n", cfg_data, rc); 2065 2066 goto error_exit; 2067 } 2068 } else { 2069 /* 2070 * nscd_false asks _nscd_cfg_copy_param_data to 2071 * copy the data content rather than just setting 2072 * the addr of the vlen data in 'ptr' 2073 */ 2074 rc = _nscd_cfg_copy_param_data(desc, ptr, cfg_data, 2075 out, nscd_false); 2076 2077 if (rc != NSCD_SUCCESS) { 2078 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2079 (me, "unable to copy param data %p: " 2080 "error = %d\n", cfg_data, rc); 2081 2082 goto error_exit; 2083 } 2084 } 2085 2086 *data = ptr; 2087 2088 done: 2089 2090 if (data_len != NULL) 2091 *data_len = dlen; 2092 2093 _nscd_cfg_unlock(lock); 2094 2095 return (NSCD_SUCCESS); 2096 2097 error_exit: 2098 2099 _nscd_cfg_unlock(lock); 2100 if (ptr != NULL) 2101 free(ptr); 2102 2103 return (rc); 2104 } 2105 2106 /* 2107 * three type of data: 2108 * 1 - single param 2109 * desc is that of the param 2110 * 2 - single param to be sent in a group 2111 * a single bit is set in the bitmap, 2112 * desc is that of the group 2113 * 3 - group data 2114 * one of more bits are set in the bitmap, 2115 * desc is that of the group 2116 */ 2117 static nscd_rc_t 2118 _nscd_cfg_notify_s( 2119 nscd_cfg_param_desc_t *desc, 2120 nscd_cfg_id_t *nswdb, 2121 void *data, 2122 nscd_cfg_error_t **errorp) 2123 { 2124 int i, num, is_group = 0; 2125 void *cookie = NULL; 2126 void *cdata; 2127 nscd_rc_t rc; 2128 nscd_cfg_flag_t dflag, dflag1; 2129 nscd_cfg_bitmap_t bitmap_s, bitmap_in, *bitmap_addr = NULL; 2130 nscd_cfg_group_info_t *gi; 2131 2132 if (errorp != NULL) 2133 *errorp = NULL; 2134 2135 /* 2136 * Set data flag going with data to be sent to the 2137 * verify/notify routines. To allow the config flag 2138 * be exipandable, set the bits one by one. 2139 */ 2140 dflag = NSCD_CFG_FLAG_ZERO; 2141 dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_STATIC_DATA); 2142 if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP)) { 2143 dflag = _nscd_cfg_flag_set(dflag, NSCD_CFG_DFLAG_GROUP); 2144 is_group = 1; 2145 } 2146 if (nswdb != NULL && 2147 strcmp(NSCD_CFG_NSW_ALLDB, nswdb->name) == 0) 2148 dflag = _nscd_cfg_flag_set(dflag, 2149 NSCD_CFG_DFLAG_SET_ALL_DB); 2150 2151 /* 2152 * the bitmap in the input data may be replaced before 2153 * sending to the components, so save the bitmap for 2154 * later use 2155 */ 2156 if (is_group == 1) { 2157 gi = _nscd_cfg_get_gi(data); 2158 bitmap_in = gi->bitmap; 2159 bitmap_addr = &(gi->bitmap); 2160 2161 if (_nscd_cfg_flag_is_set(desc->pflag, 2162 NSCD_CFG_PFLAG_INIT_SEND_WHOLE_GROUP)) 2163 /* send the entire group just once */ 2164 num = 1; 2165 2166 else { /* send individual members one by one */ 2167 2168 num = desc->p_fn; 2169 2170 /* 2171 * skip the first desc which is for the group 2172 * and get to the desc for the first member 2173 */ 2174 desc++; 2175 2176 dflag = _nscd_cfg_flag_unset(dflag, 2177 NSCD_CFG_DFLAG_GROUP); 2178 } 2179 } else { 2180 /* not group data, send the member once */ 2181 num = 1; 2182 } 2183 2184 dflag1 = dflag; 2185 for (i = 0; i < num; i++, desc++) { 2186 2187 dflag = dflag1; 2188 2189 if (is_group == 0) { 2190 cdata = data; 2191 goto verify_data; 2192 } 2193 2194 if (_nscd_cfg_flag_is_set(desc->pflag, 2195 NSCD_CFG_PFLAG_SEND_BIT_SELECTED)) { 2196 2197 /* set the bitmap to select just this member */ 2198 bitmap_s = NSCD_CFG_BITMAP_ZERO; 2199 _nscd_cfg_bitmap_set_nth(bitmap_s, i); 2200 /* replace the bitmap in the input data */ 2201 _nscd_cfg_bitmap_set(bitmap_addr, bitmap_s); 2202 2203 /* 2204 * send the whole group but with only one 2205 * member selected 2206 */ 2207 cdata = data; 2208 2209 dflag = _nscd_cfg_flag_set(dflag, 2210 NSCD_CFG_DFLAG_GROUP); 2211 dflag = _nscd_cfg_flag_set(dflag, 2212 NSCD_CFG_DFLAG_BIT_SELECTED); 2213 } else { 2214 /* 2215 * send param data or group data: 2216 * param data - non-xero desc->p_offset 2217 * group data - zero desc->p_offset 2218 */ 2219 cdata = (char *)data + desc->p_offset; 2220 2221 /* 2222 * if variable length data, need to send pointer 2223 * to the data (not the address of the pointer) 2224 */ 2225 if (_nscd_cfg_flag_is_set(desc->pflag, 2226 NSCD_CFG_PFLAG_VLEN_DATA)) 2227 cdata = *(char **)cdata; 2228 } 2229 2230 verify_data: 2231 2232 if (desc->verify != NULL) { 2233 dflag = _nscd_cfg_flag_set(dflag, 2234 NSCD_CFG_DFLAG_VERIFY); 2235 rc = desc->verify(cdata, desc, nswdb, 2236 dflag, errorp, &cookie); 2237 if (rc != NSCD_SUCCESS) 2238 goto error_exit; 2239 } 2240 2241 if (desc->notify != NULL) { 2242 dflag = _nscd_cfg_flag_set(dflag, 2243 NSCD_CFG_DFLAG_NOTIFY); 2244 2245 rc = desc->notify(data, desc, nswdb, 2246 dflag, errorp, cookie); 2247 if (rc != NSCD_SUCCESS) 2248 goto error_exit; 2249 } 2250 } 2251 2252 rc = NSCD_SUCCESS; 2253 2254 error_exit: 2255 2256 /* restore the bitmap in the input data */ 2257 if (bitmap_addr != NULL) 2258 _nscd_cfg_bitmap_set(bitmap_addr, bitmap_in); 2259 2260 return (rc); 2261 } 2262 2263 /* 2264 * Convert string 'str' to data based on the data type in 'desc'. 2265 * 'data' points to the buffer in which the converted data 2266 * is placed. '*data_p' points to the buffer, or in the case 2267 * of a string data type, points to the untoched string (i.e., 2268 * 'str'). 2269 */ 2270 nscd_rc_t 2271 _nscd_cfg_str_to_data( 2272 nscd_cfg_param_desc_t *desc, 2273 char *str, 2274 void *data, 2275 void **data_p, 2276 nscd_cfg_error_t **errorp) 2277 { 2278 2279 char *me = "_nscd_cfg_str_to_data"; 2280 char *c; 2281 nscd_cfg_bitmap_t bitmap; 2282 char msg[NSCD_CFG_MAX_ERR_MSG_LEN]; 2283 nscd_rc_t rc = NSCD_CFG_DATA_CONVERSION_FAILED; 2284 2285 if (desc == NULL || str == NULL || data == NULL) { 2286 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2287 (me, "ERROR: one of the following is NULL " 2288 "desc = %p, str = %p, data = %p, data_p = %p\n", 2289 desc, str, data, data_p); 2290 2291 return (NSCD_INVALID_ARGUMENT); 2292 } 2293 *data_p = data; 2294 2295 /* if description is that of a group, return error */ 2296 if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP)) { 2297 2298 (void) snprintf(msg, sizeof (msg), 2299 gettext("single data specified for group %s"), desc->id.name); 2300 2301 if (errorp != NULL) 2302 *errorp = _nscd_cfg_make_error(NSCD_INVALID_ARGUMENT, 2303 msg); 2304 2305 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2306 (me, "ERROR: %s)\n", msg); 2307 2308 return (NSCD_INVALID_ARGUMENT); 2309 2310 } 2311 2312 if (desc->type == NSCD_CFG_DATA_STRING) { 2313 if (strcmp(str, NSCD_NULL) == 0) 2314 *(char **)data_p = NULL; 2315 else { 2316 /* remove the " char if quoted string */ 2317 if (str[0] == '"') { 2318 c = str + strlen(str) - 1; 2319 if (*c == '"') 2320 *c = '\0'; 2321 *(char **)data_p = str + 1; 2322 } else 2323 *(char **)data_p = str; 2324 2325 } 2326 return (NSCD_SUCCESS); 2327 } 2328 2329 if (str == NULL) { 2330 2331 (void) snprintf(msg, sizeof (msg), 2332 gettext("data must be specified for %s"), desc->id.name); 2333 2334 if (errorp != NULL) 2335 *errorp = _nscd_cfg_make_error(NSCD_INVALID_ARGUMENT, 2336 msg); 2337 2338 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2339 (me, "ERROR: %s\n", msg); 2340 2341 return (NSCD_INVALID_ARGUMENT); 2342 2343 } 2344 2345 switch (desc->type) { 2346 2347 case NSCD_CFG_DATA_BOOLEAN: 2348 2349 if (strcasecmp(str, "yes") == 0) 2350 *(nscd_bool_t *)data = nscd_true; 2351 else if (strcasecmp(str, "no") == 0) 2352 *(nscd_bool_t *)data = nscd_false; 2353 else { 2354 2355 (void) snprintf(msg, sizeof (msg), 2356 gettext("data (%s) must be 'yes' or 'no' for %s"), 2357 str, desc->id.name); 2358 2359 if (errorp != NULL) 2360 *errorp = _nscd_cfg_make_error(NSCD_INVALID_ARGUMENT, 2361 msg); 2362 2363 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2364 (me, "ERROR: %s\n", msg); 2365 2366 return (NSCD_INVALID_ARGUMENT); 2367 } 2368 2369 break; 2370 2371 case NSCD_CFG_DATA_INTEGER: 2372 2373 errno = 0; 2374 *(int *)data = (int)strtol(str, NULL, 10); 2375 if (errno != 0) { 2376 2377 (void) snprintf(msg, sizeof (msg), 2378 gettext("unable to convert data (%s) for %s"), 2379 str, desc->id.name); 2380 2381 if (errorp != NULL) 2382 *errorp = _nscd_cfg_make_error(rc, msg); 2383 2384 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2385 (me, "ERROR: %s\n", msg); 2386 2387 return (rc); 2388 } 2389 2390 break; 2391 2392 case NSCD_CFG_DATA_BITMAP: 2393 2394 errno = 0; 2395 bitmap = (nscd_cfg_bitmap_t)strtol(str, NULL, 10); 2396 if (errno != 0) { 2397 2398 (void) snprintf(msg, sizeof (msg), 2399 gettext("unable to convert data (%s) for %s"), 2400 str, desc->id.name); 2401 2402 if (errorp != NULL) 2403 *errorp = _nscd_cfg_make_error(rc, msg); 2404 2405 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2406 (me, "ERROR: %s\n", msg); 2407 2408 return (rc); 2409 } 2410 2411 _nscd_cfg_bitmap_set(data, bitmap); 2412 2413 break; 2414 2415 } 2416 2417 return (NSCD_SUCCESS); 2418 } 2419 2420 2421 nscd_rc_t 2422 _nscd_cfg_set( 2423 nscd_cfg_handle_t *handle, 2424 void *data, 2425 nscd_cfg_error_t **errorp) 2426 { 2427 char *me = "_nscd_cfg_set"; 2428 int dlen; 2429 nscd_cfg_id_t *nswdb; 2430 nscd_cfg_param_desc_t *desc, *gdesc; 2431 nscd_cfg_group_info_t *gi; 2432 char *nswdb_name, *param_name; 2433 void *pdata = NULL; 2434 void *cfg_data, *vdata_addr = NULL; 2435 nscd_bool_t get_group = 0; 2436 nscd_bool_t in = nscd_true; 2437 nscd_cfg_lock_t *lock = NULL; 2438 nscd_rc_t rc = NSCD_SUCCESS; 2439 2440 if (handle == NULL) { 2441 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2442 (me, "handle is NULL\n"); 2443 return (NSCD_INVALID_ARGUMENT); 2444 } 2445 2446 nswdb = handle->nswdb; 2447 desc = (nscd_cfg_param_desc_t *)handle->desc; 2448 if (nswdb == NULL) 2449 nswdb_name = "global"; 2450 else 2451 nswdb_name = nswdb->name; 2452 param_name = desc->id.name; 2453 2454 if (data == NULL && _nscd_cfg_flag_is_not_set(desc->pflag, 2455 NSCD_CFG_PFLAG_VLEN_DATA)) { 2456 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2457 (me, "data == NULL\n"); 2458 return (NSCD_INVALID_ARGUMENT); 2459 } 2460 2461 if (_nscd_cfg_flag_is_set(desc->pflag, 2462 NSCD_CFG_PFLAG_UPDATE_SEND_WHOLE_GROUP) || 2463 _nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP)) 2464 get_group = nscd_true; 2465 2466 /* 2467 * locate the current value of the param or group 2468 * and lock the config data for writing 2469 */ 2470 rc = _nscd_cfg_locate_cfg_data(&cfg_data, nscd_false, desc, 2471 nswdb, get_group, &vdata_addr, &dlen, &lock); 2472 if (rc != NSCD_SUCCESS) { 2473 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2474 (me, "unable to locate config data (rc = %d)\n", rc); 2475 return (rc); 2476 } 2477 2478 if (_nscd_cfg_flag_is_set(desc->pflag, NSCD_CFG_PFLAG_GROUP) && 2479 ((nscd_cfg_group_info_t *)cfg_data)->num_param != 2480 ((nscd_cfg_group_info_t *)data)->num_param) { 2481 2482 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2483 (me, "number of parameters in group <%s : %s> not equal: " 2484 "%d in input data, should be %d\n", 2485 NSCD_STR_OR_GLOBAL(nswdb_name), 2486 NSCD_STR_OR_NULL(param_name), 2487 ((nscd_cfg_group_info_t *)data)->num_param, 2488 ((nscd_cfg_group_info_t *)cfg_data)->num_param); 2489 2490 rc = NSCD_INVALID_ARGUMENT; 2491 goto error_exit; 2492 } 2493 2494 /* 2495 * if variable length data, we want the address 2496 * of the pointer pointing to the data 2497 */ 2498 if (vdata_addr != NULL) 2499 cfg_data = vdata_addr; 2500 2501 /* 2502 * just copy in the specified data, if no need 2503 * to verify the data or notify the associated 2504 * component 2505 */ 2506 if (get_group == nscd_true) { 2507 2508 gdesc = &_nscd_cfg_param_desc[desc->g_index]; 2509 2510 rc = _nscd_cfg_copy_group_data_merge( 2511 gdesc, &pdata, data, cfg_data, 2512 desc->id.index, data); 2513 2514 if (rc != NSCD_SUCCESS) { 2515 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2516 (me, "unable to copy group data <%s : %s>\n", 2517 NSCD_STR_OR_GLOBAL(nswdb_name), 2518 NSCD_STR_OR_NULL(param_name)); 2519 2520 goto error_exit; 2521 } 2522 2523 rc = _nscd_cfg_notify_s(gdesc, nswdb, 2524 pdata, errorp); 2525 2526 } else 2527 rc = _nscd_cfg_notify_s(desc, nswdb, data, 2528 errorp); 2529 2530 if (rc != NSCD_SUCCESS) { 2531 2532 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2533 (me, "verifying/notifying of new configuration " 2534 "parameter <%s : %s> failed. %s\n", 2535 NSCD_STR_OR_GLOBAL(nswdb_name), 2536 param_name, (*errorp && (*errorp)->msg) ? 2537 (*errorp)->msg : ""); 2538 2539 goto error_exit; 2540 } 2541 2542 /* 2543 * Move the new config into the config store 2544 */ 2545 rc = NSCD_CFG_SET_PARAM_FAILED; 2546 if (_nscd_cfg_flag_is_set(desc->pflag, 2547 NSCD_CFG_PFLAG_GROUP)) { 2548 gi = _nscd_cfg_get_gi(pdata); 2549 rc = _nscd_cfg_copy_group_data_in(gdesc, gi, 2550 cfg_data, pdata); 2551 } else { 2552 /* 2553 * nscd_true asks _nscd_cfg_copy_param_data to 2554 * set addr of the vlen data in 'cfg_data' rather 2555 * than copying the data content 2556 */ 2557 if (pdata != NULL) 2558 _nscd_cfg_free_vlen_data_group(gdesc, 2559 pdata, in); 2560 2561 rc = _nscd_cfg_copy_param_data(desc, 2562 cfg_data, data, in, nscd_true); 2563 } 2564 2565 if (rc != NSCD_SUCCESS) { 2566 2567 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2568 (me, "unable to make new param data <%s : %s> current\n", 2569 NSCD_STR_OR_GLOBAL(nswdb_name), 2570 NSCD_STR_OR_NULL(param_name)); 2571 } 2572 2573 error_exit: 2574 2575 _nscd_cfg_unlock(lock); 2576 2577 return (rc); 2578 } 2579 2580 nscd_rc_t 2581 _nscd_cfg_set_linked( 2582 nscd_cfg_handle_t *handle, 2583 void *data, 2584 nscd_cfg_error_t **errorp) 2585 { 2586 char *me = "_nscd_cfg_set_linked"; 2587 nscd_cfg_id_t *nswdb; 2588 nscd_cfg_handle_t *hl; 2589 nscd_cfg_param_desc_t *desc; 2590 char *nswdb_name, *param_name, *dbl; 2591 nscd_rc_t rc = NSCD_SUCCESS; 2592 nscd_cfg_nsw_spc_default_t *spc; 2593 int i; 2594 char msg[NSCD_CFG_MAX_ERR_MSG_LEN]; 2595 2596 if (handle == NULL) { 2597 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2598 (me, "handle is NULL\n"); 2599 return (NSCD_INVALID_ARGUMENT); 2600 } 2601 2602 nswdb = handle->nswdb; 2603 desc = (nscd_cfg_param_desc_t *)handle->desc; 2604 2605 /* 2606 * no need to do the special linking thing, 2607 * if a global param, or a group, or not a linked param 2608 */ 2609 if (nswdb == NULL || _nscd_cfg_flag_is_set(desc->pflag, 2610 NSCD_CFG_PFLAG_GROUP) || 2611 _nscd_cfg_flag_is_not_set(desc->pflag, 2612 NSCD_CFG_PFLAG_LINKED)) 2613 return (_nscd_cfg_set(handle, data, errorp)); 2614 else 2615 nswdb_name = nswdb->name; 2616 param_name = desc->id.name; 2617 2618 /* 2619 * if a param is linked to another, it can not be 2620 * changed directly 2621 */ 2622 for (i = 0; i < _nscd_cfg_num_link_default; i++) { 2623 2624 if (_nscd_cfg_nsw_link_default[i].data == NULL) 2625 continue; 2626 2627 if (strcmp(_nscd_cfg_nsw_link_default[i].db, 2628 nswdb_name) == 0 && 2629 _nscd_cfg_nsw_link_default[i].group_off == 2630 desc->g_offset && 2631 _nscd_cfg_nsw_link_default[i].param_off == 2632 desc->p_offset) { 2633 2634 rc = NSCD_CFG_READ_ONLY; 2635 2636 (void) snprintf(msg, sizeof (msg), 2637 gettext("value of \'%s\' not changeable, " 2638 "change that of \'%s\' instead"), 2639 nswdb->name, "passwd"); 2640 2641 if (errorp != NULL) 2642 *errorp = _nscd_cfg_make_error(rc, msg); 2643 2644 _NSCD_LOG(NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_ERROR) 2645 (me, "ERROR: %s\n", msg); 2646 2647 return (rc); 2648 } 2649 } 2650 2651 /* 2652 * if a param is linked from another, it should be verify 2653 * and changed first 2654 */ 2655 for (i = 0; i < _nscd_cfg_num_link_default; i++) { 2656 2657 if (_nscd_cfg_nsw_link_default[i].data == NULL) 2658 continue; 2659 2660 spc = _nscd_cfg_nsw_link_default[i].data; 2661 2662 if (strcmp(spc->db, nswdb_name) == 0 && 2663 spc->group_off == desc->g_offset && 2664 spc->param_off == desc->p_offset) { 2665 2666 rc = _nscd_cfg_set(handle, data, errorp); 2667 if (rc != NSCD_SUCCESS) 2668 return (rc); 2669 break; 2670 } 2671 } 2672 2673 /* 2674 * then change all those linked to the one that has been changed 2675 */ 2676 for (i = 0; i < _nscd_cfg_num_link_default; i++) { 2677 2678 if (_nscd_cfg_nsw_link_default[i].data == NULL) 2679 continue; 2680 2681 spc = _nscd_cfg_nsw_link_default[i].data; 2682 2683 if (strcmp(spc->db, nswdb_name) == 0 && 2684 spc->group_off == desc->g_offset && 2685 spc->param_off == desc->p_offset && 2686 _nscd_cfg_nsw_link_default[i].group_off == 2687 desc->g_offset && 2688 _nscd_cfg_nsw_link_default[i].param_off == 2689 desc->p_offset) { 2690 2691 dbl = _nscd_cfg_nsw_link_default[i].db; 2692 2693 rc = _nscd_cfg_get_handle(param_name, dbl, 2694 &hl, errorp); 2695 if (rc != NSCD_SUCCESS) 2696 return (rc); 2697 rc = _nscd_cfg_set(hl, data, errorp); 2698 _nscd_cfg_free_handle(hl); 2699 if (rc != NSCD_SUCCESS) 2700 return (rc); 2701 } 2702 } 2703 2704 return (_nscd_cfg_set(handle, data, errorp)); 2705 } 2706 2707 /* 2708 * Return a list of comma-separated database names that 2709 * have at least one of the input sources (the srcs array) 2710 * appears in their configured nsswitch policy string. 2711 * That is, if srcs contains "ldap" and "passwd: files ldap" 2712 * "group: files ldap" are in /etc/nsswitch.conf, then 2713 * "passwd,group" will be returned. The return string 2714 * should be freed by the caller. 2715 * 2716 * For compat nsswitch configuration, "group" and/or 2717 * "passwd,user_attr,shadow,audit_user" (not "group_compat" 2718 * or "passwd_compat") will be returned. Note that the 2719 * user_attr, shadow, and audit_user databases share the 2720 * same policy with the passwd database. 2721 * 2722 * For example, if srcs has "ldap" and in /etc/nsswitch.conf, 2723 * there are: 2724 * passwd: compat 2725 * passwd_compat: ldap 2726 * group: compat 2727 * group_compat: ldap 2728 * netgroup: ldap 2729 * then "netgroup,passwd,group,user_attr,shadow,audit_user" 2730 * will be returned. 2731 */ 2732 char * 2733 _nscd_srcs_in_db_nsw_policy( 2734 int num_src, 2735 char **srcs) 2736 { 2737 uint8_t i, j, n = 0, nc = 0; 2738 uint8_t compat_grp = 0, compat_pwd = 0; 2739 uint8_t *db; 2740 uint8_t *db_compat; 2741 int dlen = 0; 2742 nscd_cfg_nsw_db_data_t *dbcfg; 2743 nscd_cfg_switch_t *sw; 2744 char *outstr = NULL; 2745 char *dbname; 2746 2747 db = (uint8_t *)calloc(_nscd_cfg_num_nsw_db, sizeof (uint8_t)); 2748 if (db == NULL) 2749 return (NULL); 2750 2751 db_compat = (uint8_t *)calloc(_nscd_cfg_num_nsw_db, 2752 sizeof (uint8_t)); 2753 if (db_compat == NULL) { 2754 free(db); 2755 return (NULL); 2756 } 2757 2758 for (i = 0; i < _nscd_cfg_num_nsw_db; i++) { 2759 2760 (void) rw_rdlock(&nscd_cfg_nsw_db_data_rwlock[i]); 2761 2762 dbcfg = &nscd_cfg_nsw_db_data_current[i]; 2763 sw = &dbcfg->sw; 2764 if (sw->nsw_config_string == NULL) { 2765 (void) rw_unlock(&nscd_cfg_nsw_db_data_rwlock[i]); 2766 continue; 2767 } 2768 2769 dbname = _nscd_cfg_nsw_db[i].name; 2770 for (j = 0; j < num_src; j++) { 2771 if (strstr(sw->nsw_config_string, srcs[j]) != 2772 NULL) { 2773 db[n++] = i; 2774 dlen += strlen(dbname) + 1; 2775 } else if (strcmp(sw->nsw_config_string, 2776 "compat") == 0) { 2777 if (strcmp(dbname, "passwd") == 0) { 2778 compat_pwd = 1; 2779 dlen += 7; 2780 } else if (strcmp(dbname, "group") == 0) { 2781 compat_grp = 1; 2782 dlen += 6; 2783 } else { 2784 db_compat[nc++] = i; 2785 dlen += strlen(dbname) + 1; 2786 2787 } 2788 } 2789 } 2790 (void) rw_unlock(&nscd_cfg_nsw_db_data_rwlock[i]); 2791 } 2792 2793 if (dlen != 0) 2794 outstr = (char *)calloc(1, dlen); 2795 if (outstr == NULL) { 2796 free(db_compat); 2797 free(db); 2798 return (NULL); 2799 } 2800 2801 for (j = 0; j < n; j++) { 2802 dbname = _nscd_cfg_nsw_db[db[j]].name; 2803 if (strstr(dbname, "group_compat") != NULL) { 2804 if (compat_grp == 1) 2805 dbname = "group"; 2806 else 2807 continue; 2808 } else if (strstr(dbname, "passwd_compat") != NULL) { 2809 if (compat_pwd == 1) 2810 dbname = "passwd"; 2811 else 2812 continue; 2813 } 2814 2815 (void) strlcat(outstr, dbname, dlen); 2816 (void) strlcat(outstr, ",", dlen); 2817 } 2818 2819 for (j = 0; j < nc; j++) { 2820 dbname = _nscd_cfg_nsw_db[db_compat[j]].name; 2821 if (compat_pwd == 1) { 2822 (void) strlcat(outstr, dbname, dlen); 2823 (void) strlcat(outstr, ",", dlen); 2824 } 2825 } 2826 2827 /* remove the last comma */ 2828 i = strlen(outstr) - 1; 2829 if (outstr[i] == ',') 2830 outstr[i] = '\0'; 2831 2832 free(db); 2833 free(db_compat); 2834 return (outstr); 2835 2836 } 2837