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 /* 23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * This is the client layer for svc.configd. All direct protocol interactions 28 * are handled here. 29 * 30 * Essentially, the job of this layer is to turn the idempotent protocol 31 * into a series of non-idempotent calls into the object layer, while 32 * also handling the necessary locking. 33 */ 34 35 #include <alloca.h> 36 #include <assert.h> 37 #include <bsm/adt_event.h> 38 #include <door.h> 39 #include <errno.h> 40 #include <libintl.h> 41 #include <limits.h> 42 #include <pthread.h> 43 #include <stdio.h> 44 #include <stdlib.h> 45 #include <string.h> 46 #include <syslog.h> 47 #include <ucred.h> 48 #include <unistd.h> 49 50 #include <libuutil.h> 51 52 #include "configd.h" 53 #include "repcache_protocol.h" 54 55 #define INVALID_CHANGEID (0) 56 #define INVALID_DOORID ((door_id_t)-1) 57 #define INVALID_RESULT ((rep_protocol_responseid_t)INT_MIN) 58 59 /* 60 * lint doesn't like constant assertions 61 */ 62 #ifdef lint 63 #define assert_nolint(x) (void)0 64 #else 65 #define assert_nolint(x) assert(x) 66 #endif 67 68 /* 69 * Protects client linkage and the freelist 70 */ 71 #define CLIENT_HASH_SIZE 64 72 73 #pragma align 64(client_hash) 74 static client_bucket_t client_hash[CLIENT_HASH_SIZE]; 75 76 static uu_avl_pool_t *entity_pool; 77 static uu_avl_pool_t *iter_pool; 78 static uu_list_pool_t *client_pool; 79 80 #define CLIENT_HASH(id) (&client_hash[((id) & (CLIENT_HASH_SIZE - 1))]) 81 82 uint_t request_log_size = 1024; /* tunable, before we start */ 83 84 static pthread_mutex_t request_log_lock = PTHREAD_MUTEX_INITIALIZER; 85 static uint_t request_log_cur; 86 request_log_entry_t *request_log; 87 88 static uint32_t client_maxid; 89 static pthread_mutex_t client_lock; /* protects client_maxid */ 90 91 static request_log_entry_t * 92 get_log(void) 93 { 94 thread_info_t *ti = thread_self(); 95 return (&ti->ti_log); 96 } 97 98 void 99 log_enter(request_log_entry_t *rlp) 100 { 101 if (rlp->rl_start != 0 && request_log != NULL) { 102 request_log_entry_t *logrlp; 103 104 (void) pthread_mutex_lock(&request_log_lock); 105 assert(request_log_cur < request_log_size); 106 logrlp = &request_log[request_log_cur++]; 107 if (request_log_cur == request_log_size) 108 request_log_cur = 0; 109 (void) memcpy(logrlp, rlp, sizeof (*rlp)); 110 (void) pthread_mutex_unlock(&request_log_lock); 111 } 112 } 113 114 /* 115 * Note that the svc.configd dmod will join all of the per-thread log entries 116 * with the main log, so that even if the log is disabled, there is some 117 * information available. 118 */ 119 static request_log_entry_t * 120 start_log(uint32_t clientid) 121 { 122 request_log_entry_t *rlp = get_log(); 123 124 log_enter(rlp); 125 126 (void) memset(rlp, 0, sizeof (*rlp)); 127 rlp->rl_start = gethrtime(); 128 rlp->rl_tid = pthread_self(); 129 rlp->rl_clientid = clientid; 130 131 return (rlp); 132 } 133 134 void 135 end_log(void) 136 { 137 request_log_entry_t *rlp = get_log(); 138 139 rlp->rl_end = gethrtime(); 140 } 141 142 static void 143 add_log_ptr(request_log_entry_t *rlp, enum rc_ptr_type type, uint32_t id, 144 void *ptr) 145 { 146 request_log_ptr_t *rpp; 147 148 if (rlp == NULL) 149 return; 150 151 if (rlp->rl_num_ptrs >= MAX_PTRS) 152 return; 153 154 rpp = &rlp->rl_ptrs[rlp->rl_num_ptrs++]; 155 rpp->rlp_type = type; 156 rpp->rlp_id = id; 157 rpp->rlp_ptr = ptr; 158 159 /* 160 * For entities, it's useful to have the node pointer at the start 161 * of the request. 162 */ 163 if (type == RC_PTR_TYPE_ENTITY && ptr != NULL) 164 rpp->rlp_data = ((repcache_entity_t *)ptr)->re_node.rnp_node; 165 } 166 167 int 168 client_is_privileged(void) 169 { 170 thread_info_t *ti = thread_self(); 171 172 ucred_t *uc; 173 174 if (ti->ti_active_client != NULL && 175 ti->ti_active_client->rc_all_auths) 176 return (1); 177 178 if ((uc = get_ucred()) == NULL) 179 return (0); 180 181 return (ucred_is_privileged(uc)); 182 } 183 184 /*ARGSUSED*/ 185 static int 186 client_compare(const void *lc_arg, const void *rc_arg, void *private) 187 { 188 uint32_t l_id = ((const repcache_client_t *)lc_arg)->rc_id; 189 uint32_t r_id = ((const repcache_client_t *)rc_arg)->rc_id; 190 191 if (l_id > r_id) 192 return (1); 193 if (l_id < r_id) 194 return (-1); 195 return (0); 196 } 197 198 /*ARGSUSED*/ 199 static int 200 entity_compare(const void *lc_arg, const void *rc_arg, void *private) 201 { 202 uint32_t l_id = ((const repcache_entity_t *)lc_arg)->re_id; 203 uint32_t r_id = ((const repcache_entity_t *)rc_arg)->re_id; 204 205 if (l_id > r_id) 206 return (1); 207 if (l_id < r_id) 208 return (-1); 209 return (0); 210 } 211 212 /*ARGSUSED*/ 213 static int 214 iter_compare(const void *lc_arg, const void *rc_arg, void *private) 215 { 216 uint32_t l_id = ((const repcache_iter_t *)lc_arg)->ri_id; 217 uint32_t r_id = ((const repcache_iter_t *)rc_arg)->ri_id; 218 219 if (l_id > r_id) 220 return (1); 221 if (l_id < r_id) 222 return (-1); 223 return (0); 224 } 225 226 static int 227 client_hash_init(void) 228 { 229 int x; 230 231 assert_nolint(offsetof(repcache_entity_t, re_id) == 0); 232 entity_pool = uu_avl_pool_create("repcache_entitys", 233 sizeof (repcache_entity_t), offsetof(repcache_entity_t, re_link), 234 entity_compare, UU_AVL_POOL_DEBUG); 235 236 assert_nolint(offsetof(repcache_iter_t, ri_id) == 0); 237 iter_pool = uu_avl_pool_create("repcache_iters", 238 sizeof (repcache_iter_t), offsetof(repcache_iter_t, ri_link), 239 iter_compare, UU_AVL_POOL_DEBUG); 240 241 assert_nolint(offsetof(repcache_client_t, rc_id) == 0); 242 client_pool = uu_list_pool_create("repcache_clients", 243 sizeof (repcache_client_t), offsetof(repcache_client_t, rc_link), 244 client_compare, UU_LIST_POOL_DEBUG); 245 246 if (entity_pool == NULL || iter_pool == NULL || client_pool == NULL) 247 return (0); 248 249 for (x = 0; x < CLIENT_HASH_SIZE; x++) { 250 uu_list_t *lp = uu_list_create(client_pool, &client_hash[x], 251 UU_LIST_SORTED); 252 if (lp == NULL) 253 return (0); 254 255 (void) pthread_mutex_init(&client_hash[x].cb_lock, NULL); 256 client_hash[x].cb_list = lp; 257 } 258 259 return (1); 260 } 261 262 static repcache_client_t * 263 client_alloc(void) 264 { 265 repcache_client_t *cp; 266 cp = uu_zalloc(sizeof (*cp)); 267 if (cp == NULL) 268 return (NULL); 269 270 cp->rc_entities = uu_avl_create(entity_pool, cp, 0); 271 if (cp->rc_entities == NULL) 272 goto fail; 273 274 cp->rc_iters = uu_avl_create(iter_pool, cp, 0); 275 if (cp->rc_iters == NULL) 276 goto fail; 277 278 uu_list_node_init(cp, &cp->rc_link, client_pool); 279 280 cp->rc_doorfd = -1; 281 cp->rc_doorid = INVALID_DOORID; 282 283 (void) pthread_mutex_init(&cp->rc_lock, NULL); 284 (void) pthread_mutex_init(&cp->rc_annotate_lock, NULL); 285 286 rc_node_ptr_init(&cp->rc_notify_ptr); 287 288 return (cp); 289 290 fail: 291 if (cp->rc_iters != NULL) 292 uu_avl_destroy(cp->rc_iters); 293 if (cp->rc_entities != NULL) 294 uu_avl_destroy(cp->rc_entities); 295 uu_free(cp); 296 return (NULL); 297 } 298 299 static void 300 client_free(repcache_client_t *cp) 301 { 302 assert(cp->rc_insert_thr == 0); 303 assert(cp->rc_refcnt == 0); 304 assert(cp->rc_doorfd == -1); 305 assert(cp->rc_doorid == INVALID_DOORID); 306 assert(uu_avl_first(cp->rc_entities) == NULL); 307 assert(uu_avl_first(cp->rc_iters) == NULL); 308 uu_avl_destroy(cp->rc_entities); 309 uu_avl_destroy(cp->rc_iters); 310 uu_list_node_fini(cp, &cp->rc_link, client_pool); 311 (void) pthread_mutex_destroy(&cp->rc_lock); 312 (void) pthread_mutex_destroy(&cp->rc_annotate_lock); 313 rc_node_ptr_free_mem(&cp->rc_notify_ptr); 314 uu_free(cp); 315 } 316 317 static void 318 client_insert(repcache_client_t *cp) 319 { 320 client_bucket_t *bp = CLIENT_HASH(cp->rc_id); 321 uu_list_index_t idx; 322 323 assert(cp->rc_id > 0); 324 325 (void) pthread_mutex_lock(&bp->cb_lock); 326 /* 327 * We assume it does not already exist 328 */ 329 (void) uu_list_find(bp->cb_list, cp, NULL, &idx); 330 uu_list_insert(bp->cb_list, cp, idx); 331 332 (void) pthread_mutex_unlock(&bp->cb_lock); 333 } 334 335 static repcache_client_t * 336 client_lookup(uint32_t id) 337 { 338 client_bucket_t *bp = CLIENT_HASH(id); 339 repcache_client_t *cp; 340 341 (void) pthread_mutex_lock(&bp->cb_lock); 342 343 cp = uu_list_find(bp->cb_list, &id, NULL, NULL); 344 345 /* 346 * Bump the reference count 347 */ 348 if (cp != NULL) { 349 (void) pthread_mutex_lock(&cp->rc_lock); 350 assert(!(cp->rc_flags & RC_CLIENT_DEAD)); 351 cp->rc_refcnt++; 352 (void) pthread_mutex_unlock(&cp->rc_lock); 353 } 354 (void) pthread_mutex_unlock(&bp->cb_lock); 355 356 return (cp); 357 } 358 359 static void 360 client_release(repcache_client_t *cp) 361 { 362 (void) pthread_mutex_lock(&cp->rc_lock); 363 assert(cp->rc_refcnt > 0); 364 assert(cp->rc_insert_thr != pthread_self()); 365 366 --cp->rc_refcnt; 367 (void) pthread_cond_broadcast(&cp->rc_cv); 368 (void) pthread_mutex_unlock(&cp->rc_lock); 369 } 370 371 /* 372 * We only allow one thread to be inserting at a time, to prevent 373 * insert/insert races. 374 */ 375 static void 376 client_start_insert(repcache_client_t *cp) 377 { 378 (void) pthread_mutex_lock(&cp->rc_lock); 379 assert(cp->rc_refcnt > 0); 380 381 while (cp->rc_insert_thr != 0) { 382 assert(cp->rc_insert_thr != pthread_self()); 383 (void) pthread_cond_wait(&cp->rc_cv, &cp->rc_lock); 384 } 385 cp->rc_insert_thr = pthread_self(); 386 (void) pthread_mutex_unlock(&cp->rc_lock); 387 } 388 389 static void 390 client_end_insert(repcache_client_t *cp) 391 { 392 (void) pthread_mutex_lock(&cp->rc_lock); 393 assert(cp->rc_insert_thr == pthread_self()); 394 cp->rc_insert_thr = 0; 395 (void) pthread_cond_broadcast(&cp->rc_cv); 396 (void) pthread_mutex_unlock(&cp->rc_lock); 397 } 398 399 /*ARGSUSED*/ 400 static repcache_entity_t * 401 entity_alloc(repcache_client_t *cp) 402 { 403 repcache_entity_t *ep = uu_zalloc(sizeof (repcache_entity_t)); 404 if (ep != NULL) { 405 uu_avl_node_init(ep, &ep->re_link, entity_pool); 406 } 407 return (ep); 408 } 409 410 static void 411 entity_add(repcache_client_t *cp, repcache_entity_t *ep) 412 { 413 uu_avl_index_t idx; 414 415 (void) pthread_mutex_lock(&cp->rc_lock); 416 assert(cp->rc_insert_thr == pthread_self()); 417 418 (void) uu_avl_find(cp->rc_entities, ep, NULL, &idx); 419 uu_avl_insert(cp->rc_entities, ep, idx); 420 421 (void) pthread_mutex_unlock(&cp->rc_lock); 422 } 423 424 static repcache_entity_t * 425 entity_find(repcache_client_t *cp, uint32_t id) 426 { 427 repcache_entity_t *ep; 428 429 (void) pthread_mutex_lock(&cp->rc_lock); 430 ep = uu_avl_find(cp->rc_entities, &id, NULL, NULL); 431 if (ep != NULL) { 432 add_log_ptr(get_log(), RC_PTR_TYPE_ENTITY, id, ep); 433 (void) pthread_mutex_lock(&ep->re_lock); 434 } 435 (void) pthread_mutex_unlock(&cp->rc_lock); 436 437 return (ep); 438 } 439 440 /* 441 * Fails with 442 * _DUPLICATE_ID - the ids are equal 443 * _UNKNOWN_ID - an id does not designate an active register 444 */ 445 static int 446 entity_find2(repcache_client_t *cp, uint32_t id1, repcache_entity_t **out1, 447 uint32_t id2, repcache_entity_t **out2) 448 { 449 repcache_entity_t *e1, *e2; 450 request_log_entry_t *rlp; 451 452 if (id1 == id2) 453 return (REP_PROTOCOL_FAIL_DUPLICATE_ID); 454 455 (void) pthread_mutex_lock(&cp->rc_lock); 456 e1 = uu_avl_find(cp->rc_entities, &id1, NULL, NULL); 457 e2 = uu_avl_find(cp->rc_entities, &id2, NULL, NULL); 458 if (e1 == NULL || e2 == NULL) { 459 (void) pthread_mutex_unlock(&cp->rc_lock); 460 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 461 } 462 463 assert(e1 != e2); 464 465 /* 466 * locks are ordered by id number 467 */ 468 if (id1 < id2) { 469 (void) pthread_mutex_lock(&e1->re_lock); 470 (void) pthread_mutex_lock(&e2->re_lock); 471 } else { 472 (void) pthread_mutex_lock(&e2->re_lock); 473 (void) pthread_mutex_lock(&e1->re_lock); 474 } 475 *out1 = e1; 476 *out2 = e2; 477 478 (void) pthread_mutex_unlock(&cp->rc_lock); 479 480 if ((rlp = get_log()) != NULL) { 481 add_log_ptr(rlp, RC_PTR_TYPE_ENTITY, id1, e1); 482 add_log_ptr(rlp, RC_PTR_TYPE_ENTITY, id2, e2); 483 } 484 485 return (REP_PROTOCOL_SUCCESS); 486 } 487 488 static void 489 entity_release(repcache_entity_t *ep) 490 { 491 assert(ep->re_node.rnp_node == NULL || 492 !MUTEX_HELD(&ep->re_node.rnp_node->rn_lock)); 493 (void) pthread_mutex_unlock(&ep->re_lock); 494 } 495 496 static void 497 entity_destroy(repcache_entity_t *entity) 498 { 499 (void) pthread_mutex_lock(&entity->re_lock); 500 rc_node_clear(&entity->re_node, 0); 501 (void) pthread_mutex_unlock(&entity->re_lock); 502 503 uu_avl_node_fini(entity, &entity->re_link, entity_pool); 504 (void) pthread_mutex_destroy(&entity->re_lock); 505 rc_node_ptr_free_mem(&entity->re_node); 506 uu_free(entity); 507 } 508 509 static void 510 entity_remove(repcache_client_t *cp, uint32_t id) 511 { 512 repcache_entity_t *entity; 513 514 (void) pthread_mutex_lock(&cp->rc_lock); 515 entity = uu_avl_find(cp->rc_entities, &id, NULL, NULL); 516 if (entity != NULL) { 517 add_log_ptr(get_log(), RC_PTR_TYPE_ENTITY, id, entity); 518 519 uu_avl_remove(cp->rc_entities, entity); 520 } 521 (void) pthread_mutex_unlock(&cp->rc_lock); 522 523 if (entity != NULL) 524 entity_destroy(entity); 525 } 526 527 static void 528 entity_cleanup(repcache_client_t *cp) 529 { 530 repcache_entity_t *ep; 531 void *cookie = NULL; 532 533 (void) pthread_mutex_lock(&cp->rc_lock); 534 while ((ep = uu_avl_teardown(cp->rc_entities, &cookie)) != NULL) { 535 (void) pthread_mutex_unlock(&cp->rc_lock); 536 entity_destroy(ep); 537 (void) pthread_mutex_lock(&cp->rc_lock); 538 } 539 (void) pthread_mutex_unlock(&cp->rc_lock); 540 } 541 542 /*ARGSUSED*/ 543 static repcache_iter_t * 544 iter_alloc(repcache_client_t *cp) 545 { 546 repcache_iter_t *iter; 547 iter = uu_zalloc(sizeof (repcache_iter_t)); 548 if (iter != NULL) 549 uu_avl_node_init(iter, &iter->ri_link, iter_pool); 550 return (iter); 551 } 552 553 static void 554 iter_add(repcache_client_t *cp, repcache_iter_t *iter) 555 { 556 uu_list_index_t idx; 557 558 (void) pthread_mutex_lock(&cp->rc_lock); 559 assert(cp->rc_insert_thr == pthread_self()); 560 561 (void) uu_avl_find(cp->rc_iters, iter, NULL, &idx); 562 uu_avl_insert(cp->rc_iters, iter, idx); 563 564 (void) pthread_mutex_unlock(&cp->rc_lock); 565 } 566 567 static repcache_iter_t * 568 iter_find(repcache_client_t *cp, uint32_t id) 569 { 570 repcache_iter_t *iter; 571 572 (void) pthread_mutex_lock(&cp->rc_lock); 573 574 iter = uu_avl_find(cp->rc_iters, &id, NULL, NULL); 575 if (iter != NULL) { 576 add_log_ptr(get_log(), RC_PTR_TYPE_ITER, id, iter); 577 (void) pthread_mutex_lock(&iter->ri_lock); 578 } 579 (void) pthread_mutex_unlock(&cp->rc_lock); 580 581 return (iter); 582 } 583 584 /* 585 * Fails with 586 * _UNKNOWN_ID - iter_id or entity_id does not designate an active register 587 */ 588 static int 589 iter_find_w_entity(repcache_client_t *cp, uint32_t iter_id, 590 repcache_iter_t **iterp, uint32_t entity_id, repcache_entity_t **epp) 591 { 592 repcache_iter_t *iter; 593 repcache_entity_t *ep; 594 request_log_entry_t *rlp; 595 596 (void) pthread_mutex_lock(&cp->rc_lock); 597 iter = uu_avl_find(cp->rc_iters, &iter_id, NULL, NULL); 598 ep = uu_avl_find(cp->rc_entities, &entity_id, NULL, NULL); 599 600 assert(iter == NULL || !MUTEX_HELD(&iter->ri_lock)); 601 assert(ep == NULL || !MUTEX_HELD(&ep->re_lock)); 602 603 if (iter == NULL || ep == NULL) { 604 (void) pthread_mutex_unlock(&cp->rc_lock); 605 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 606 } 607 608 (void) pthread_mutex_lock(&iter->ri_lock); 609 (void) pthread_mutex_lock(&ep->re_lock); 610 611 (void) pthread_mutex_unlock(&cp->rc_lock); 612 613 *iterp = iter; 614 *epp = ep; 615 616 if ((rlp = get_log()) != NULL) { 617 add_log_ptr(rlp, RC_PTR_TYPE_ENTITY, entity_id, ep); 618 add_log_ptr(rlp, RC_PTR_TYPE_ITER, iter_id, iter); 619 } 620 621 return (REP_PROTOCOL_SUCCESS); 622 } 623 624 static void 625 iter_release(repcache_iter_t *iter) 626 { 627 (void) pthread_mutex_unlock(&iter->ri_lock); 628 } 629 630 static void 631 iter_destroy(repcache_iter_t *iter) 632 { 633 (void) pthread_mutex_lock(&iter->ri_lock); 634 rc_iter_destroy(&iter->ri_iter); 635 (void) pthread_mutex_unlock(&iter->ri_lock); 636 637 uu_avl_node_fini(iter, &iter->ri_link, iter_pool); 638 (void) pthread_mutex_destroy(&iter->ri_lock); 639 uu_free(iter); 640 } 641 642 static void 643 iter_remove(repcache_client_t *cp, uint32_t id) 644 { 645 repcache_iter_t *iter; 646 647 (void) pthread_mutex_lock(&cp->rc_lock); 648 iter = uu_avl_find(cp->rc_iters, &id, NULL, NULL); 649 if (iter != NULL) 650 uu_avl_remove(cp->rc_iters, iter); 651 (void) pthread_mutex_unlock(&cp->rc_lock); 652 653 if (iter != NULL) 654 iter_destroy(iter); 655 } 656 657 static void 658 iter_cleanup(repcache_client_t *cp) 659 { 660 repcache_iter_t *iter; 661 void *cookie = NULL; 662 663 (void) pthread_mutex_lock(&cp->rc_lock); 664 while ((iter = uu_avl_teardown(cp->rc_iters, &cookie)) != NULL) { 665 (void) pthread_mutex_unlock(&cp->rc_lock); 666 iter_destroy(iter); 667 (void) pthread_mutex_lock(&cp->rc_lock); 668 } 669 (void) pthread_mutex_unlock(&cp->rc_lock); 670 } 671 672 /* 673 * Ensure that the passed client id is no longer usable, wait for any 674 * outstanding invocations to complete, then destroy the client 675 * structure. 676 */ 677 static void 678 client_destroy(uint32_t id) 679 { 680 client_bucket_t *bp = CLIENT_HASH(id); 681 repcache_client_t *cp; 682 683 (void) pthread_mutex_lock(&bp->cb_lock); 684 685 cp = uu_list_find(bp->cb_list, &id, NULL, NULL); 686 687 if (cp == NULL) { 688 (void) pthread_mutex_unlock(&bp->cb_lock); 689 return; 690 } 691 692 uu_list_remove(bp->cb_list, cp); 693 694 (void) pthread_mutex_unlock(&bp->cb_lock); 695 696 /* kick the waiters out */ 697 rc_notify_info_fini(&cp->rc_notify_info); 698 699 (void) pthread_mutex_lock(&cp->rc_lock); 700 assert(!(cp->rc_flags & RC_CLIENT_DEAD)); 701 cp->rc_flags |= RC_CLIENT_DEAD; 702 703 if (cp->rc_doorfd != -1) { 704 if (door_revoke(cp->rc_doorfd) < 0) 705 perror("door_revoke"); 706 cp->rc_doorfd = -1; 707 cp->rc_doorid = INVALID_DOORID; 708 } 709 710 while (cp->rc_refcnt > 0) 711 (void) pthread_cond_wait(&cp->rc_cv, &cp->rc_lock); 712 713 assert(cp->rc_insert_thr == 0 && cp->rc_notify_thr == 0); 714 (void) pthread_mutex_unlock(&cp->rc_lock); 715 716 /* 717 * destroy outstanding objects 718 */ 719 entity_cleanup(cp); 720 iter_cleanup(cp); 721 722 /* 723 * clean up notifications 724 */ 725 rc_pg_notify_fini(&cp->rc_pg_notify); 726 727 /* 728 * clean up annotations 729 */ 730 if (cp->rc_operation != NULL) 731 free((void *)cp->rc_operation); 732 if (cp->rc_file != NULL) 733 free((void *)cp->rc_file); 734 735 /* 736 * End audit session. 737 */ 738 (void) adt_end_session(cp->rc_adt_session); 739 740 client_free(cp); 741 } 742 743 /* 744 * Fails with 745 * _TYPE_MISMATCH - the entity is already set up with a different type 746 * _NO_RESOURCES - out of memory 747 */ 748 static int 749 entity_setup(repcache_client_t *cp, struct rep_protocol_entity_setup *rpr) 750 { 751 repcache_entity_t *ep; 752 uint32_t type; 753 754 client_start_insert(cp); 755 756 if ((ep = entity_find(cp, rpr->rpr_entityid)) != NULL) { 757 type = ep->re_type; 758 entity_release(ep); 759 760 client_end_insert(cp); 761 762 if (type != rpr->rpr_entitytype) 763 return (REP_PROTOCOL_FAIL_TYPE_MISMATCH); 764 return (REP_PROTOCOL_SUCCESS); 765 } 766 767 switch (type = rpr->rpr_entitytype) { 768 case REP_PROTOCOL_ENTITY_SCOPE: 769 case REP_PROTOCOL_ENTITY_SERVICE: 770 case REP_PROTOCOL_ENTITY_INSTANCE: 771 case REP_PROTOCOL_ENTITY_SNAPSHOT: 772 case REP_PROTOCOL_ENTITY_SNAPLEVEL: 773 case REP_PROTOCOL_ENTITY_PROPERTYGRP: 774 case REP_PROTOCOL_ENTITY_PROPERTY: 775 break; 776 default: 777 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 778 } 779 780 ep = entity_alloc(cp); 781 if (ep == NULL) { 782 client_end_insert(cp); 783 return (REP_PROTOCOL_FAIL_NO_RESOURCES); 784 } 785 786 ep->re_id = rpr->rpr_entityid; 787 ep->re_changeid = INVALID_CHANGEID; 788 789 ep->re_type = type; 790 rc_node_ptr_init(&ep->re_node); 791 792 entity_add(cp, ep); 793 client_end_insert(cp); 794 return (REP_PROTOCOL_SUCCESS); 795 } 796 797 /*ARGSUSED*/ 798 static void 799 entity_name(repcache_client_t *cp, const void *in, size_t insz, void *out_arg, 800 size_t *outsz, void *arg) 801 { 802 const struct rep_protocol_entity_name *rpr = in; 803 struct rep_protocol_name_response *out = out_arg; 804 repcache_entity_t *ep; 805 size_t sz = sizeof (out->rpr_name); 806 807 assert(*outsz == sizeof (*out)); 808 809 ep = entity_find(cp, rpr->rpr_entityid); 810 811 if (ep == NULL) { 812 out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID; 813 *outsz = sizeof (out->rpr_response); 814 return; 815 } 816 out->rpr_response = rc_node_name(&ep->re_node, out->rpr_name, 817 sz, rpr->rpr_answertype, &sz); 818 entity_release(ep); 819 820 /* 821 * If we fail, we only return the response code. 822 * If we succeed, we don't return anything after the '\0' in rpr_name. 823 */ 824 if (out->rpr_response != REP_PROTOCOL_SUCCESS) 825 *outsz = sizeof (out->rpr_response); 826 else 827 *outsz = offsetof(struct rep_protocol_name_response, 828 rpr_name[sz + 1]); 829 } 830 831 /*ARGSUSED*/ 832 static void 833 entity_parent_type(repcache_client_t *cp, const void *in, size_t insz, 834 void *out_arg, size_t *outsz, void *arg) 835 { 836 const struct rep_protocol_entity_name *rpr = in; 837 struct rep_protocol_integer_response *out = out_arg; 838 repcache_entity_t *ep; 839 840 assert(*outsz == sizeof (*out)); 841 842 ep = entity_find(cp, rpr->rpr_entityid); 843 844 if (ep == NULL) { 845 out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID; 846 *outsz = sizeof (out->rpr_response); 847 return; 848 } 849 850 out->rpr_response = rc_node_parent_type(&ep->re_node, &out->rpr_value); 851 entity_release(ep); 852 853 if (out->rpr_response != REP_PROTOCOL_SUCCESS) 854 *outsz = sizeof (out->rpr_response); 855 } 856 857 /* 858 * Fails with 859 * _DUPLICATE_ID - the ids are equal 860 * _UNKNOWN_ID - an id does not designate an active register 861 * _INVALID_TYPE - type is invalid 862 * _TYPE_MISMATCH - np doesn't carry children of type type 863 * _DELETED - np has been deleted 864 * _NOT_FOUND - no child with that name/type combo found 865 * _NO_RESOURCES 866 * _BACKEND_ACCESS 867 */ 868 static int 869 entity_get_child(repcache_client_t *cp, 870 struct rep_protocol_entity_get_child *rpr) 871 { 872 repcache_entity_t *parent, *child; 873 int result; 874 875 uint32_t parentid = rpr->rpr_entityid; 876 uint32_t childid = rpr->rpr_childid; 877 878 result = entity_find2(cp, childid, &child, parentid, &parent); 879 if (result != REP_PROTOCOL_SUCCESS) 880 return (result); 881 882 rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0; 883 884 result = rc_node_get_child(&parent->re_node, rpr->rpr_name, 885 child->re_type, &child->re_node); 886 887 entity_release(child); 888 entity_release(parent); 889 890 return (result); 891 } 892 893 /* 894 * Returns _FAIL_DUPLICATE_ID, _FAIL_UNKNOWN_ID, _FAIL_NOT_SET, _FAIL_DELETED, 895 * _FAIL_TYPE_MISMATCH, _FAIL_NOT_FOUND (scope has no parent), or _SUCCESS. 896 * Fails with 897 * _DUPLICATE_ID - the ids are equal 898 * _UNKNOWN_ID - an id does not designate an active register 899 * _NOT_SET - child is not set 900 * _DELETED - child has been deleted 901 * _TYPE_MISMATCH - child's parent does not match that of the parent register 902 * _NOT_FOUND - child has no parent (and is a scope) 903 */ 904 static int 905 entity_get_parent(repcache_client_t *cp, struct rep_protocol_entity_parent *rpr) 906 { 907 repcache_entity_t *child, *parent; 908 int result; 909 910 uint32_t childid = rpr->rpr_entityid; 911 uint32_t outid = rpr->rpr_outid; 912 913 result = entity_find2(cp, childid, &child, outid, &parent); 914 if (result != REP_PROTOCOL_SUCCESS) 915 return (result); 916 917 result = rc_node_get_parent(&child->re_node, parent->re_type, 918 &parent->re_node); 919 920 entity_release(child); 921 entity_release(parent); 922 923 return (result); 924 } 925 926 static int 927 entity_get(repcache_client_t *cp, struct rep_protocol_entity_get *rpr) 928 { 929 repcache_entity_t *ep; 930 int result; 931 932 ep = entity_find(cp, rpr->rpr_entityid); 933 934 if (ep == NULL) 935 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 936 937 switch (rpr->rpr_object) { 938 case RP_ENTITY_GET_INVALIDATE: 939 rc_node_clear(&ep->re_node, 0); 940 result = REP_PROTOCOL_SUCCESS; 941 break; 942 case RP_ENTITY_GET_MOST_LOCAL_SCOPE: 943 result = rc_local_scope(ep->re_type, &ep->re_node); 944 break; 945 default: 946 result = REP_PROTOCOL_FAIL_BAD_REQUEST; 947 break; 948 } 949 950 entity_release(ep); 951 952 return (result); 953 } 954 955 static int 956 entity_update(repcache_client_t *cp, struct rep_protocol_entity_update *rpr) 957 { 958 repcache_entity_t *ep; 959 int result; 960 961 if (rpr->rpr_changeid == INVALID_CHANGEID) 962 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 963 964 ep = entity_find(cp, rpr->rpr_entityid); 965 966 if (ep == NULL) 967 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 968 969 if (ep->re_changeid == rpr->rpr_changeid) { 970 result = REP_PROTOCOL_DONE; 971 } else { 972 result = rc_node_update(&ep->re_node); 973 if (result == REP_PROTOCOL_DONE) 974 ep->re_changeid = rpr->rpr_changeid; 975 } 976 977 entity_release(ep); 978 979 return (result); 980 } 981 982 static int 983 entity_reset(repcache_client_t *cp, struct rep_protocol_entity_reset *rpr) 984 { 985 repcache_entity_t *ep; 986 987 ep = entity_find(cp, rpr->rpr_entityid); 988 if (ep == NULL) 989 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 990 991 rc_node_clear(&ep->re_node, 0); 992 ep->re_txstate = REPCACHE_TX_INIT; 993 994 entity_release(ep); 995 return (REP_PROTOCOL_SUCCESS); 996 } 997 998 /* 999 * Fails with 1000 * _BAD_REQUEST - request has invalid changeid 1001 * rpr_name is invalid 1002 * cannot create children for parent's type of node 1003 * _DUPLICATE_ID - request has duplicate ids 1004 * _UNKNOWN_ID - request has unknown id 1005 * _DELETED - parent has been deleted 1006 * _NOT_SET - parent is reset 1007 * _NOT_APPLICABLE - rpr_childtype is _PROPERTYGRP 1008 * _INVALID_TYPE - parent is corrupt or rpr_childtype is invalid 1009 * _TYPE_MISMATCH - parent cannot have children of type rpr_childtype 1010 * _NO_RESOURCES 1011 * _PERMISSION_DENIED 1012 * _BACKEND_ACCESS 1013 * _BACKEND_READONLY 1014 * _EXISTS - child already exists 1015 */ 1016 static int 1017 entity_create_child(repcache_client_t *cp, 1018 struct rep_protocol_entity_create_child *rpr) 1019 { 1020 repcache_entity_t *parent; 1021 repcache_entity_t *child; 1022 1023 uint32_t parentid = rpr->rpr_entityid; 1024 uint32_t childid = rpr->rpr_childid; 1025 1026 int result; 1027 1028 if (rpr->rpr_changeid == INVALID_CHANGEID) 1029 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 1030 1031 result = entity_find2(cp, parentid, &parent, childid, &child); 1032 if (result != REP_PROTOCOL_SUCCESS) 1033 return (result); 1034 1035 rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0; 1036 1037 if (child->re_changeid == rpr->rpr_changeid) { 1038 result = REP_PROTOCOL_SUCCESS; 1039 } else { 1040 result = rc_node_create_child(&parent->re_node, 1041 rpr->rpr_childtype, rpr->rpr_name, &child->re_node); 1042 if (result == REP_PROTOCOL_SUCCESS) 1043 child->re_changeid = rpr->rpr_changeid; 1044 } 1045 1046 entity_release(parent); 1047 entity_release(child); 1048 1049 return (result); 1050 } 1051 1052 static int 1053 entity_create_pg(repcache_client_t *cp, 1054 struct rep_protocol_entity_create_pg *rpr) 1055 { 1056 repcache_entity_t *parent; 1057 repcache_entity_t *child; 1058 1059 uint32_t parentid = rpr->rpr_entityid; 1060 uint32_t childid = rpr->rpr_childid; 1061 1062 int result; 1063 1064 if (rpr->rpr_changeid == INVALID_CHANGEID) 1065 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 1066 1067 result = entity_find2(cp, parentid, &parent, childid, &child); 1068 if (result != REP_PROTOCOL_SUCCESS) 1069 return (result); 1070 1071 rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0; 1072 rpr->rpr_type[sizeof (rpr->rpr_type) - 1] = 0; 1073 1074 if (child->re_changeid == rpr->rpr_changeid) { 1075 result = REP_PROTOCOL_SUCCESS; 1076 } else { 1077 result = rc_node_create_child_pg(&parent->re_node, 1078 child->re_type, rpr->rpr_name, rpr->rpr_type, 1079 rpr->rpr_flags, &child->re_node); 1080 if (result == REP_PROTOCOL_SUCCESS) 1081 child->re_changeid = rpr->rpr_changeid; 1082 } 1083 1084 entity_release(parent); 1085 entity_release(child); 1086 1087 return (result); 1088 } 1089 1090 static int 1091 entity_delete(repcache_client_t *cp, 1092 struct rep_protocol_entity_delete *rpr) 1093 { 1094 repcache_entity_t *entity; 1095 1096 uint32_t entityid = rpr->rpr_entityid; 1097 1098 int result; 1099 1100 if (rpr->rpr_changeid == INVALID_CHANGEID) 1101 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 1102 1103 entity = entity_find(cp, entityid); 1104 1105 if (entity == NULL) 1106 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 1107 1108 if (entity->re_changeid == rpr->rpr_changeid) { 1109 result = REP_PROTOCOL_SUCCESS; 1110 } else { 1111 result = rc_node_delete(&entity->re_node); 1112 if (result == REP_PROTOCOL_SUCCESS) 1113 entity->re_changeid = rpr->rpr_changeid; 1114 } 1115 1116 entity_release(entity); 1117 1118 return (result); 1119 } 1120 1121 static rep_protocol_responseid_t 1122 entity_teardown(repcache_client_t *cp, struct rep_protocol_entity_teardown *rpr) 1123 { 1124 entity_remove(cp, rpr->rpr_entityid); 1125 1126 return (REP_PROTOCOL_SUCCESS); 1127 } 1128 1129 /* 1130 * Fails with 1131 * _MISORDERED - the iterator exists and is not reset 1132 * _NO_RESOURCES - out of memory 1133 */ 1134 static int 1135 iter_setup(repcache_client_t *cp, struct rep_protocol_iter_request *rpr) 1136 { 1137 repcache_iter_t *iter; 1138 uint32_t sequence; 1139 1140 client_start_insert(cp); 1141 /* 1142 * If the iter already exists, and hasn't been read from, 1143 * we assume the previous call succeeded. 1144 */ 1145 if ((iter = iter_find(cp, rpr->rpr_iterid)) != NULL) { 1146 sequence = iter->ri_sequence; 1147 iter_release(iter); 1148 1149 client_end_insert(cp); 1150 1151 if (sequence != 0) 1152 return (REP_PROTOCOL_FAIL_MISORDERED); 1153 return (REP_PROTOCOL_SUCCESS); 1154 } 1155 1156 iter = iter_alloc(cp); 1157 if (iter == NULL) { 1158 client_end_insert(cp); 1159 return (REP_PROTOCOL_FAIL_NO_RESOURCES); 1160 } 1161 1162 iter->ri_id = rpr->rpr_iterid; 1163 iter->ri_type = REP_PROTOCOL_TYPE_INVALID; 1164 iter->ri_sequence = 0; 1165 iter_add(cp, iter); 1166 1167 client_end_insert(cp); 1168 return (REP_PROTOCOL_SUCCESS); 1169 } 1170 1171 /* 1172 * Fails with 1173 * _UNKNOWN_ID 1174 * _MISORDERED - iterator has already been started 1175 * _NOT_SET 1176 * _DELETED 1177 * _TYPE_MISMATCH - entity cannot have type children 1178 * _BAD_REQUEST - rpr_flags is invalid 1179 * rpr_pattern is invalid 1180 * _NO_RESOURCES 1181 * _INVALID_TYPE 1182 * _BACKEND_ACCESS 1183 */ 1184 static int 1185 iter_start(repcache_client_t *cp, struct rep_protocol_iter_start *rpr) 1186 { 1187 int result; 1188 repcache_iter_t *iter; 1189 repcache_entity_t *ep; 1190 1191 result = iter_find_w_entity(cp, rpr->rpr_iterid, &iter, 1192 rpr->rpr_entity, &ep); 1193 1194 if (result != REP_PROTOCOL_SUCCESS) 1195 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 1196 1197 if (iter->ri_sequence > 1) { 1198 result = REP_PROTOCOL_FAIL_MISORDERED; 1199 goto end; 1200 } 1201 1202 if (iter->ri_sequence == 1) { 1203 result = REP_PROTOCOL_SUCCESS; 1204 goto end; 1205 } 1206 1207 rpr->rpr_pattern[sizeof (rpr->rpr_pattern) - 1] = 0; 1208 1209 result = rc_node_setup_iter(&ep->re_node, &iter->ri_iter, 1210 rpr->rpr_itertype, rpr->rpr_flags, rpr->rpr_pattern); 1211 1212 if (result == REP_PROTOCOL_SUCCESS) 1213 iter->ri_sequence++; 1214 1215 end: 1216 iter_release(iter); 1217 entity_release(ep); 1218 return (result); 1219 } 1220 1221 /* 1222 * Returns 1223 * _UNKNOWN_ID 1224 * _NOT_SET - iter has not been started 1225 * _MISORDERED 1226 * _BAD_REQUEST - iter walks values 1227 * _TYPE_MISMATCH - iter does not walk type entities 1228 * _DELETED - parent was deleted 1229 * _NO_RESOURCES 1230 * _INVALID_TYPE - type is invalid 1231 * _DONE 1232 * _SUCCESS 1233 * 1234 * For composed property group iterators, can also return 1235 * _TYPE_MISMATCH - parent cannot have type children 1236 * _BACKEND_ACCESS 1237 */ 1238 static rep_protocol_responseid_t 1239 iter_read(repcache_client_t *cp, struct rep_protocol_iter_read *rpr) 1240 { 1241 rep_protocol_responseid_t result; 1242 repcache_iter_t *iter; 1243 repcache_entity_t *ep; 1244 uint32_t sequence; 1245 1246 result = iter_find_w_entity(cp, rpr->rpr_iterid, &iter, 1247 rpr->rpr_entityid, &ep); 1248 1249 if (result != REP_PROTOCOL_SUCCESS) 1250 return (result); 1251 1252 sequence = rpr->rpr_sequence; 1253 1254 if (iter->ri_sequence == 0) { 1255 iter_release(iter); 1256 entity_release(ep); 1257 return (REP_PROTOCOL_FAIL_NOT_SET); 1258 } 1259 1260 if (sequence == 1) { 1261 iter_release(iter); 1262 entity_release(ep); 1263 return (REP_PROTOCOL_FAIL_MISORDERED); 1264 } 1265 1266 if (sequence == iter->ri_sequence) { 1267 iter_release(iter); 1268 entity_release(ep); 1269 return (REP_PROTOCOL_SUCCESS); 1270 } 1271 1272 if (sequence == iter->ri_sequence + 1) { 1273 result = rc_iter_next(iter->ri_iter, &ep->re_node, 1274 ep->re_type); 1275 1276 if (result == REP_PROTOCOL_SUCCESS) 1277 iter->ri_sequence++; 1278 1279 iter_release(iter); 1280 entity_release(ep); 1281 1282 return (result); 1283 } 1284 1285 iter_release(iter); 1286 entity_release(ep); 1287 return (REP_PROTOCOL_FAIL_MISORDERED); 1288 } 1289 1290 /*ARGSUSED*/ 1291 static void 1292 iter_read_value(repcache_client_t *cp, const void *in, size_t insz, 1293 void *out_arg, size_t *outsz, void *arg) 1294 { 1295 const struct rep_protocol_iter_read_value *rpr = in; 1296 struct rep_protocol_value_response *out = out_arg; 1297 rep_protocol_responseid_t result; 1298 1299 repcache_iter_t *iter; 1300 uint32_t sequence; 1301 int repeat; 1302 1303 assert(*outsz == sizeof (*out)); 1304 1305 iter = iter_find(cp, rpr->rpr_iterid); 1306 1307 if (iter == NULL) { 1308 result = REP_PROTOCOL_FAIL_UNKNOWN_ID; 1309 goto out; 1310 } 1311 1312 sequence = rpr->rpr_sequence; 1313 1314 if (iter->ri_sequence == 0) { 1315 iter_release(iter); 1316 result = REP_PROTOCOL_FAIL_NOT_SET; 1317 goto out; 1318 } 1319 1320 repeat = (sequence == iter->ri_sequence); 1321 1322 if (sequence == 1 || (!repeat && sequence != iter->ri_sequence + 1)) { 1323 iter_release(iter); 1324 result = REP_PROTOCOL_FAIL_MISORDERED; 1325 goto out; 1326 } 1327 1328 result = rc_iter_next_value(iter->ri_iter, out, outsz, repeat); 1329 1330 if (!repeat && result == REP_PROTOCOL_SUCCESS) 1331 iter->ri_sequence++; 1332 1333 iter_release(iter); 1334 1335 out: 1336 /* 1337 * If we fail, we only return the response code. 1338 * If we succeed, rc_iter_next_value has shortened *outsz 1339 * to only include the value bytes needed. 1340 */ 1341 if (result != REP_PROTOCOL_SUCCESS && result != REP_PROTOCOL_DONE) 1342 *outsz = sizeof (out->rpr_response); 1343 1344 out->rpr_response = result; 1345 } 1346 1347 static int 1348 iter_reset(repcache_client_t *cp, struct rep_protocol_iter_request *rpr) 1349 { 1350 repcache_iter_t *iter = iter_find(cp, rpr->rpr_iterid); 1351 1352 if (iter == NULL) 1353 return (REP_PROTOCOL_FAIL_UNKNOWN_ID); 1354 1355 if (iter->ri_sequence != 0) { 1356 iter->ri_sequence = 0; 1357 rc_iter_destroy(&iter->ri_iter); 1358 } 1359 iter_release(iter); 1360 return (REP_PROTOCOL_SUCCESS); 1361 } 1362 1363 static rep_protocol_responseid_t 1364 iter_teardown(repcache_client_t *cp, struct rep_protocol_iter_request *rpr) 1365 { 1366 iter_remove(cp, rpr->rpr_iterid); 1367 1368 return (REP_PROTOCOL_SUCCESS); 1369 } 1370 1371 static rep_protocol_responseid_t 1372 tx_start(repcache_client_t *cp, struct rep_protocol_transaction_start *rpr) 1373 { 1374 repcache_entity_t *tx; 1375 repcache_entity_t *ep; 1376 rep_protocol_responseid_t result; 1377 1378 uint32_t txid = rpr->rpr_entityid_tx; 1379 uint32_t epid = rpr->rpr_entityid; 1380 1381 result = entity_find2(cp, txid, &tx, epid, &ep); 1382 if (result != REP_PROTOCOL_SUCCESS) 1383 return (result); 1384 1385 if (tx->re_txstate == REPCACHE_TX_SETUP) { 1386 result = REP_PROTOCOL_SUCCESS; 1387 goto end; 1388 } 1389 if (tx->re_txstate != REPCACHE_TX_INIT) { 1390 result = REP_PROTOCOL_FAIL_MISORDERED; 1391 goto end; 1392 } 1393 1394 result = rc_node_setup_tx(&ep->re_node, &tx->re_node); 1395 1396 end: 1397 if (result == REP_PROTOCOL_SUCCESS) 1398 tx->re_txstate = REPCACHE_TX_SETUP; 1399 else 1400 rc_node_clear(&tx->re_node, 0); 1401 1402 entity_release(ep); 1403 entity_release(tx); 1404 return (result); 1405 } 1406 1407 /*ARGSUSED*/ 1408 static void 1409 tx_commit(repcache_client_t *cp, const void *in, size_t insz, 1410 void *out_arg, size_t *outsz, void *arg) 1411 { 1412 struct rep_protocol_response *out = out_arg; 1413 const struct rep_protocol_transaction_commit *rpr = in; 1414 repcache_entity_t *tx; 1415 1416 assert(*outsz == sizeof (*out)); 1417 assert(insz >= REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE); 1418 1419 if (rpr->rpr_size != insz) { 1420 out->rpr_response = REP_PROTOCOL_FAIL_BAD_REQUEST; 1421 return; 1422 } 1423 1424 tx = entity_find(cp, rpr->rpr_entityid); 1425 1426 if (tx == NULL) { 1427 out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID; 1428 return; 1429 } 1430 1431 switch (tx->re_txstate) { 1432 case REPCACHE_TX_INIT: 1433 out->rpr_response = REP_PROTOCOL_FAIL_MISORDERED; 1434 break; 1435 1436 case REPCACHE_TX_SETUP: 1437 out->rpr_response = rc_tx_commit(&tx->re_node, rpr->rpr_cmd, 1438 insz - REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE); 1439 1440 if (out->rpr_response == REP_PROTOCOL_SUCCESS) { 1441 tx->re_txstate = REPCACHE_TX_COMMITTED; 1442 rc_node_clear(&tx->re_node, 0); 1443 } 1444 1445 break; 1446 case REPCACHE_TX_COMMITTED: 1447 out->rpr_response = REP_PROTOCOL_SUCCESS; 1448 break; 1449 default: 1450 assert(0); /* CAN'T HAPPEN */ 1451 break; 1452 } 1453 1454 entity_release(tx); 1455 } 1456 1457 static rep_protocol_responseid_t 1458 next_snaplevel(repcache_client_t *cp, struct rep_protocol_entity_pair *rpr) 1459 { 1460 repcache_entity_t *src; 1461 repcache_entity_t *dest; 1462 1463 uint32_t srcid = rpr->rpr_entity_src; 1464 uint32_t destid = rpr->rpr_entity_dst; 1465 1466 int result; 1467 1468 result = entity_find2(cp, srcid, &src, destid, &dest); 1469 if (result != REP_PROTOCOL_SUCCESS) 1470 return (result); 1471 1472 result = rc_node_next_snaplevel(&src->re_node, &dest->re_node); 1473 1474 entity_release(src); 1475 entity_release(dest); 1476 1477 return (result); 1478 } 1479 1480 static rep_protocol_responseid_t 1481 snapshot_take(repcache_client_t *cp, struct rep_protocol_snapshot_take *rpr) 1482 { 1483 repcache_entity_t *src; 1484 uint32_t srcid = rpr->rpr_entityid_src; 1485 repcache_entity_t *dest; 1486 uint32_t destid = rpr->rpr_entityid_dest; 1487 1488 int result; 1489 1490 result = entity_find2(cp, srcid, &src, destid, &dest); 1491 if (result != REP_PROTOCOL_SUCCESS) 1492 return (result); 1493 1494 if (dest->re_type != REP_PROTOCOL_ENTITY_SNAPSHOT) { 1495 result = REP_PROTOCOL_FAIL_TYPE_MISMATCH; 1496 } else { 1497 rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0; 1498 1499 if (rpr->rpr_flags == REP_SNAPSHOT_NEW) 1500 result = rc_snapshot_take_new(&src->re_node, NULL, 1501 NULL, rpr->rpr_name, &dest->re_node); 1502 else if (rpr->rpr_flags == REP_SNAPSHOT_ATTACH && 1503 rpr->rpr_name[0] == 0) 1504 result = rc_snapshot_take_attach(&src->re_node, 1505 &dest->re_node); 1506 else 1507 result = REP_PROTOCOL_FAIL_BAD_REQUEST; 1508 } 1509 entity_release(src); 1510 entity_release(dest); 1511 1512 return (result); 1513 } 1514 1515 static rep_protocol_responseid_t 1516 snapshot_take_named(repcache_client_t *cp, 1517 struct rep_protocol_snapshot_take_named *rpr) 1518 { 1519 repcache_entity_t *src; 1520 uint32_t srcid = rpr->rpr_entityid_src; 1521 repcache_entity_t *dest; 1522 uint32_t destid = rpr->rpr_entityid_dest; 1523 1524 int result; 1525 1526 result = entity_find2(cp, srcid, &src, destid, &dest); 1527 if (result != REP_PROTOCOL_SUCCESS) 1528 return (result); 1529 1530 if (dest->re_type != REP_PROTOCOL_ENTITY_SNAPSHOT) { 1531 result = REP_PROTOCOL_FAIL_TYPE_MISMATCH; 1532 } else { 1533 rpr->rpr_svcname[sizeof (rpr->rpr_svcname) - 1] = 0; 1534 rpr->rpr_instname[sizeof (rpr->rpr_instname) - 1] = 0; 1535 rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0; 1536 1537 result = rc_snapshot_take_new(&src->re_node, rpr->rpr_svcname, 1538 rpr->rpr_instname, rpr->rpr_name, &dest->re_node); 1539 } 1540 entity_release(src); 1541 entity_release(dest); 1542 1543 return (result); 1544 } 1545 1546 static rep_protocol_responseid_t 1547 snapshot_attach(repcache_client_t *cp, struct rep_protocol_snapshot_attach *rpr) 1548 { 1549 repcache_entity_t *src; 1550 uint32_t srcid = rpr->rpr_entityid_src; 1551 repcache_entity_t *dest; 1552 uint32_t destid = rpr->rpr_entityid_dest; 1553 1554 int result; 1555 1556 result = entity_find2(cp, srcid, &src, destid, &dest); 1557 if (result != REP_PROTOCOL_SUCCESS) 1558 return (result); 1559 1560 result = rc_snapshot_attach(&src->re_node, &dest->re_node); 1561 1562 entity_release(src); 1563 entity_release(dest); 1564 1565 return (result); 1566 } 1567 1568 /*ARGSUSED*/ 1569 static void 1570 property_get_type(repcache_client_t *cp, const void *in, size_t insz, 1571 void *out_arg, size_t *outsz, void *arg) 1572 { 1573 const struct rep_protocol_property_request *rpr = in; 1574 struct rep_protocol_integer_response *out = out_arg; 1575 repcache_entity_t *ep; 1576 rep_protocol_value_type_t t = 0; 1577 1578 assert(*outsz == sizeof (*out)); 1579 1580 ep = entity_find(cp, rpr->rpr_entityid); 1581 1582 if (ep == NULL) { 1583 out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID; 1584 *outsz = sizeof (out->rpr_response); 1585 return; 1586 } 1587 1588 out->rpr_response = rc_node_get_property_type(&ep->re_node, &t); 1589 1590 entity_release(ep); 1591 1592 if (out->rpr_response != REP_PROTOCOL_SUCCESS) 1593 *outsz = sizeof (out->rpr_response); 1594 else 1595 out->rpr_value = t; 1596 } 1597 1598 /* 1599 * Fails with: 1600 * _UNKNOWN_ID - an id does not designate an active register 1601 * _NOT_SET - The property is not set 1602 * _DELETED - The property has been deleted 1603 * _TYPE_MISMATCH - The object is not a property 1604 * _NOT_FOUND - The property has no values. 1605 * 1606 * Succeeds with: 1607 * _SUCCESS - The property has 1 value. 1608 * _TRUNCATED - The property has >1 value. 1609 */ 1610 /*ARGSUSED*/ 1611 static void 1612 property_get_value(repcache_client_t *cp, const void *in, size_t insz, 1613 void *out_arg, size_t *outsz, void *arg) 1614 { 1615 const struct rep_protocol_property_request *rpr = in; 1616 struct rep_protocol_value_response *out = out_arg; 1617 repcache_entity_t *ep; 1618 1619 assert(*outsz == sizeof (*out)); 1620 1621 ep = entity_find(cp, rpr->rpr_entityid); 1622 if (ep == NULL) { 1623 out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID; 1624 *outsz = sizeof (out->rpr_response); 1625 return; 1626 } 1627 1628 out->rpr_response = rc_node_get_property_value(&ep->re_node, out, 1629 outsz); 1630 1631 entity_release(ep); 1632 1633 /* 1634 * If we fail, we only return the response code. 1635 * If we succeed, rc_node_get_property_value has shortened *outsz 1636 * to only include the value bytes needed. 1637 */ 1638 if (out->rpr_response != REP_PROTOCOL_SUCCESS && 1639 out->rpr_response != REP_PROTOCOL_FAIL_TRUNCATED) 1640 *outsz = sizeof (out->rpr_response); 1641 } 1642 1643 static rep_protocol_responseid_t 1644 propertygrp_notify(repcache_client_t *cp, 1645 struct rep_protocol_propertygrp_request *rpr, int *out_fd) 1646 { 1647 int fds[2]; 1648 int ours, theirs; 1649 1650 rep_protocol_responseid_t result; 1651 repcache_entity_t *ep; 1652 1653 if (pipe(fds) < 0) 1654 return (REP_PROTOCOL_FAIL_NO_RESOURCES); 1655 1656 ours = fds[0]; 1657 theirs = fds[1]; 1658 1659 if ((ep = entity_find(cp, rpr->rpr_entityid)) == NULL) { 1660 result = REP_PROTOCOL_FAIL_UNKNOWN_ID; 1661 goto fail; 1662 } 1663 1664 /* 1665 * While the following can race with other threads setting up a 1666 * notification, the worst that can happen is that our fd has 1667 * already been closed before we return. 1668 */ 1669 result = rc_pg_notify_setup(&cp->rc_pg_notify, &ep->re_node, 1670 ours); 1671 1672 entity_release(ep); 1673 1674 if (result != REP_PROTOCOL_SUCCESS) 1675 goto fail; 1676 1677 *out_fd = theirs; 1678 return (REP_PROTOCOL_SUCCESS); 1679 1680 fail: 1681 (void) close(ours); 1682 (void) close(theirs); 1683 1684 return (result); 1685 } 1686 1687 static rep_protocol_responseid_t 1688 client_add_notify(repcache_client_t *cp, 1689 struct rep_protocol_notify_request *rpr) 1690 { 1691 rpr->rpr_pattern[sizeof (rpr->rpr_pattern) - 1] = 0; 1692 1693 switch (rpr->rpr_type) { 1694 case REP_PROTOCOL_NOTIFY_PGNAME: 1695 return (rc_notify_info_add_name(&cp->rc_notify_info, 1696 rpr->rpr_pattern)); 1697 1698 case REP_PROTOCOL_NOTIFY_PGTYPE: 1699 return (rc_notify_info_add_type(&cp->rc_notify_info, 1700 rpr->rpr_pattern)); 1701 1702 default: 1703 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 1704 } 1705 } 1706 1707 /*ARGSUSED*/ 1708 static void 1709 client_wait(repcache_client_t *cp, const void *in, size_t insz, 1710 void *out_arg, size_t *outsz, void *arg) 1711 { 1712 int result; 1713 repcache_entity_t *ep; 1714 const struct rep_protocol_wait_request *rpr = in; 1715 struct rep_protocol_fmri_response *out = out_arg; 1716 1717 assert(*outsz == sizeof (*out)); 1718 1719 (void) pthread_mutex_lock(&cp->rc_lock); 1720 if (cp->rc_notify_thr != 0) { 1721 (void) pthread_mutex_unlock(&cp->rc_lock); 1722 out->rpr_response = REP_PROTOCOL_FAIL_EXISTS; 1723 *outsz = sizeof (out->rpr_response); 1724 return; 1725 } 1726 cp->rc_notify_thr = pthread_self(); 1727 (void) pthread_mutex_unlock(&cp->rc_lock); 1728 1729 result = rc_notify_info_wait(&cp->rc_notify_info, &cp->rc_notify_ptr, 1730 out->rpr_fmri, sizeof (out->rpr_fmri)); 1731 1732 if (result == REP_PROTOCOL_SUCCESS) { 1733 if ((ep = entity_find(cp, rpr->rpr_entityid)) != NULL) { 1734 if (ep->re_type == REP_PROTOCOL_ENTITY_PROPERTYGRP) { 1735 rc_node_ptr_assign(&ep->re_node, 1736 &cp->rc_notify_ptr); 1737 } else { 1738 result = REP_PROTOCOL_FAIL_TYPE_MISMATCH; 1739 } 1740 entity_release(ep); 1741 } else { 1742 result = REP_PROTOCOL_FAIL_UNKNOWN_ID; 1743 } 1744 rc_node_clear(&cp->rc_notify_ptr, 0); 1745 } 1746 1747 (void) pthread_mutex_lock(&cp->rc_lock); 1748 assert(cp->rc_notify_thr == pthread_self()); 1749 cp->rc_notify_thr = 0; 1750 (void) pthread_mutex_unlock(&cp->rc_lock); 1751 1752 out->rpr_response = result; 1753 if (result != REP_PROTOCOL_SUCCESS) 1754 *outsz = sizeof (out->rpr_response); 1755 } 1756 1757 /* 1758 * Can return: 1759 * _PERMISSION_DENIED not enough privileges to do request. 1760 * _BAD_REQUEST name is not valid or reserved 1761 * _TRUNCATED name is too long for current repository path 1762 * _UNKNOWN failed for unknown reason (details written to 1763 * console) 1764 * _BACKEND_READONLY backend is not writable 1765 * _NO_RESOURCES out of memory 1766 * _SUCCESS Backup completed successfully. 1767 */ 1768 static rep_protocol_responseid_t 1769 backup_repository(repcache_client_t *cp, 1770 struct rep_protocol_backup_request *rpr) 1771 { 1772 rep_protocol_responseid_t result; 1773 ucred_t *uc = get_ucred(); 1774 1775 if (!client_is_privileged() && (uc == NULL || ucred_geteuid(uc) != 0)) 1776 return (REP_PROTOCOL_FAIL_PERMISSION_DENIED); 1777 1778 rpr->rpr_name[REP_PROTOCOL_NAME_LEN - 1] = 0; 1779 if (strcmp(rpr->rpr_name, REPOSITORY_BOOT_BACKUP) == 0) 1780 return (REP_PROTOCOL_FAIL_BAD_REQUEST); 1781 1782 (void) pthread_mutex_lock(&cp->rc_lock); 1783 if (rpr->rpr_changeid != cp->rc_changeid) { 1784 result = backend_create_backup(rpr->rpr_name); 1785 if (result == REP_PROTOCOL_SUCCESS) 1786 cp->rc_changeid = rpr->rpr_changeid; 1787 } else { 1788 result = REP_PROTOCOL_SUCCESS; 1789 } 1790 (void) pthread_mutex_unlock(&cp->rc_lock); 1791 1792 return (result); 1793 } 1794 1795 /* 1796 * This function captures the information that will be used for an 1797 * annotation audit event. Specifically, it captures the operation to be 1798 * performed and the name of the file that is being used. These values are 1799 * copied from the rep_protocol_annotation request at rpr to the client 1800 * structure. If both these values are null, the client is turning 1801 * annotation off. 1802 * 1803 * Fails with 1804 * _NO_RESOURCES - unable to allocate memory 1805 */ 1806 static rep_protocol_responseid_t 1807 set_annotation(repcache_client_t *cp, struct rep_protocol_annotation *rpr) 1808 { 1809 au_id_t audit_uid; 1810 const char *file = NULL; 1811 const char *old_ptrs[2]; 1812 const char *operation = NULL; 1813 rep_protocol_responseid_t rc = REP_PROTOCOL_FAIL_NO_RESOURCES; 1814 au_asid_t sessionid; 1815 1816 (void) memset((void *)old_ptrs, 0, sizeof (old_ptrs)); 1817 1818 /* Copy rpr_operation and rpr_file if they are not empty strings. */ 1819 if (rpr->rpr_operation[0] != 0) { 1820 /* 1821 * Make sure that client did not send us an unterminated buffer. 1822 */ 1823 rpr->rpr_operation[sizeof (rpr->rpr_operation) - 1] = 0; 1824 if ((operation = strdup(rpr->rpr_operation)) == NULL) 1825 goto out; 1826 } 1827 if (rpr->rpr_file[0] != 0) { 1828 /* 1829 * Make sure that client did not send us an unterminated buffer. 1830 */ 1831 rpr->rpr_file[sizeof (rpr->rpr_file) - 1] = 0; 1832 if ((file = strdup(rpr->rpr_file)) == NULL) 1833 goto out; 1834 } 1835 1836 (void) pthread_mutex_lock(&cp->rc_annotate_lock); 1837 /* Save addresses of memory to free when not locked */ 1838 old_ptrs[0] = cp->rc_operation; 1839 old_ptrs[1] = cp->rc_file; 1840 1841 /* Save pointers to annotation strings. */ 1842 cp->rc_operation = operation; 1843 cp->rc_file = file; 1844 1845 /* 1846 * Set annotation flag. Annotations should be turned on if either 1847 * operation or file are not NULL. 1848 */ 1849 cp->rc_annotate = (operation != NULL) || (file != NULL); 1850 (void) pthread_mutex_unlock(&cp->rc_annotate_lock); 1851 1852 /* 1853 * operation and file pointers are saved in cp, so don't free them 1854 * during cleanup. 1855 */ 1856 operation = NULL; 1857 file = NULL; 1858 rc = REP_PROTOCOL_SUCCESS; 1859 1860 /* 1861 * Native builds are done to create svc.configd-native. This 1862 * program runs only on the Open Solaris build machines to create 1863 * the seed repository. Until the SMF auditing code is distributed 1864 * to the Open Solaris build machines, adt_get_unique_id() in the 1865 * following code is not a global function in libbsm. Hence the 1866 * following conditional compilation. 1867 */ 1868 #ifndef NATIVE_BUILD 1869 /* 1870 * Set the appropriate audit session id. 1871 */ 1872 if (cp->rc_annotate) { 1873 /* 1874 * We're starting a group of annotated audit events, so 1875 * create and set an audit session ID for this annotation. 1876 */ 1877 adt_get_auid(cp->rc_adt_session, &audit_uid); 1878 sessionid = adt_get_unique_id(audit_uid); 1879 } else { 1880 /* 1881 * Annotation is done so restore our client audit session 1882 * id. 1883 */ 1884 sessionid = cp->rc_adt_sessionid; 1885 } 1886 adt_set_asid(cp->rc_adt_session, sessionid); 1887 #endif /* NATIVE_BUILD */ 1888 1889 out: 1890 if (operation != NULL) 1891 free((void *)operation); 1892 if (file != NULL) 1893 free((void *)file); 1894 free((void *)old_ptrs[0]); 1895 free((void *)old_ptrs[1]); 1896 return (rc); 1897 } 1898 1899 /* 1900 * Determine if an annotation event needs to be generated. If it does 1901 * provide the operation and file name that should be used in the event. 1902 * 1903 * Can return: 1904 * 0 No annotation event needed or buffers are not large 1905 * enough. Either way an event should not be 1906 * generated. 1907 * 1 Generate annotation event. 1908 */ 1909 int 1910 client_annotation_needed(char *operation, size_t oper_sz, 1911 char *file, size_t file_sz) 1912 { 1913 thread_info_t *ti = thread_self(); 1914 repcache_client_t *cp = ti->ti_active_client; 1915 int rc = 0; 1916 1917 (void) pthread_mutex_lock(&cp->rc_annotate_lock); 1918 if (cp->rc_annotate) { 1919 rc = 1; 1920 if (cp->rc_operation == NULL) { 1921 if (oper_sz > 0) 1922 operation[0] = 0; 1923 } else { 1924 if (strlcpy(operation, cp->rc_operation, oper_sz) >= 1925 oper_sz) { 1926 /* Buffer overflow, so do not generate event */ 1927 rc = 0; 1928 } 1929 } 1930 if (cp->rc_file == NULL) { 1931 if (file_sz > 0) 1932 file[0] = 0; 1933 } else if (rc == 1) { 1934 if (strlcpy(file, cp->rc_file, file_sz) >= file_sz) { 1935 /* Buffer overflow, so do not generate event */ 1936 rc = 0; 1937 } 1938 } 1939 } 1940 (void) pthread_mutex_unlock(&cp->rc_annotate_lock); 1941 return (rc); 1942 } 1943 1944 void 1945 client_annotation_finished() 1946 { 1947 thread_info_t *ti = thread_self(); 1948 repcache_client_t *cp = ti->ti_active_client; 1949 1950 (void) pthread_mutex_lock(&cp->rc_annotate_lock); 1951 cp->rc_annotate = 0; 1952 (void) pthread_mutex_unlock(&cp->rc_annotate_lock); 1953 } 1954 1955 static void 1956 start_audit_session(repcache_client_t *cp) 1957 { 1958 ucred_t *cred = NULL; 1959 adt_session_data_t *session; 1960 1961 /* 1962 * A NULL session pointer value can legally be used in all 1963 * subsequent calls to adt_* functions. 1964 */ 1965 cp->rc_adt_session = NULL; 1966 1967 if (!adt_audit_state(AUC_AUDITING)) 1968 return; 1969 1970 if (door_ucred(&cred) != 0) { 1971 switch (errno) { 1972 case EAGAIN: 1973 case ENOMEM: 1974 syslog(LOG_ERR, gettext("start_audit_session(): cannot " 1975 "get ucred. %m\n")); 1976 return; 1977 case EINVAL: 1978 /* 1979 * Door client went away. This is a normal, 1980 * although infrequent event, so there is no need 1981 * to create a syslog message. 1982 */ 1983 return; 1984 case EFAULT: 1985 default: 1986 bad_error("door_ucred", errno); 1987 return; 1988 } 1989 } 1990 if (adt_start_session(&session, NULL, 0) != 0) { 1991 syslog(LOG_ERR, gettext("start_audit_session(): could not " 1992 "start audit session.\n")); 1993 ucred_free(cred); 1994 return; 1995 } 1996 if (adt_set_from_ucred(session, cred, ADT_NEW) != 0) { 1997 syslog(LOG_ERR, gettext("start_audit_session(): cannot set " 1998 "audit session data from ucred\n")); 1999 /* Something went wrong. End the session. */ 2000 (void) adt_end_session(session); 2001 ucred_free(cred); 2002 return; 2003 } 2004 2005 /* All went well. Save the session data and session ID */ 2006 cp->rc_adt_session = session; 2007 adt_get_asid(session, &cp->rc_adt_sessionid); 2008 2009 ucred_free(cred); 2010 } 2011 2012 /* 2013 * Handle switch client request 2014 * 2015 * This routine can return: 2016 * 2017 * _PERMISSION_DENIED not enough privileges to do request. 2018 * _UNKNOWN file operation error (details written to 2019 * the console). 2020 * _SUCCESS switch operation is completed. 2021 * _BACKEND_ACCESS backend access fails. 2022 * _NO_RESOURCES out of memory. 2023 * _BACKEND_READONLY backend is not writable. 2024 */ 2025 static rep_protocol_responseid_t 2026 repository_switch(repcache_client_t *cp, 2027 struct rep_protocol_switch_request *rpr) 2028 { 2029 rep_protocol_responseid_t result; 2030 ucred_t *uc = get_ucred(); 2031 2032 if (!client_is_privileged() && (uc == NULL || 2033 ucred_geteuid(uc) != 0)) { 2034 return (REP_PROTOCOL_FAIL_PERMISSION_DENIED); 2035 } 2036 2037 (void) pthread_mutex_lock(&cp->rc_lock); 2038 if (rpr->rpr_changeid != cp->rc_changeid) { 2039 if ((result = backend_switch(rpr->rpr_flag)) == 2040 REP_PROTOCOL_SUCCESS) 2041 cp->rc_changeid = rpr->rpr_changeid; 2042 } else { 2043 result = REP_PROTOCOL_SUCCESS; 2044 } 2045 (void) pthread_mutex_unlock(&cp->rc_lock); 2046 2047 return (result); 2048 } 2049 2050 typedef rep_protocol_responseid_t protocol_simple_f(repcache_client_t *cp, 2051 const void *rpr); 2052 2053 /*ARGSUSED*/ 2054 static void 2055 simple_handler(repcache_client_t *cp, const void *in, size_t insz, 2056 void *out_arg, size_t *outsz, void *arg) 2057 { 2058 protocol_simple_f *f = (protocol_simple_f *)arg; 2059 rep_protocol_response_t *out = out_arg; 2060 2061 assert(*outsz == sizeof (*out)); 2062 assert(f != NULL); 2063 2064 out->rpr_response = (*f)(cp, in); 2065 } 2066 2067 typedef rep_protocol_responseid_t protocol_simple_fd_f(repcache_client_t *cp, 2068 const void *rpr, int *out_fd); 2069 2070 /*ARGSUSED*/ 2071 static void 2072 simple_fd_handler(repcache_client_t *cp, const void *in, size_t insz, 2073 void *out_arg, size_t *outsz, void *arg, int *out_fd) 2074 { 2075 protocol_simple_fd_f *f = (protocol_simple_fd_f *)arg; 2076 rep_protocol_response_t *out = out_arg; 2077 2078 assert(*outsz == sizeof (*out)); 2079 assert(f != NULL); 2080 2081 out->rpr_response = (*f)(cp, in, out_fd); 2082 } 2083 2084 typedef void protocol_handler_f(repcache_client_t *, const void *in, 2085 size_t insz, void *out, size_t *outsz, void *arg); 2086 2087 typedef void protocol_handler_fdret_f(repcache_client_t *, const void *in, 2088 size_t insz, void *out, size_t *outsz, void *arg, int *fd_out); 2089 2090 #define PROTO(p, f, in) { \ 2091 p, #p, simple_handler, (void *)(&f), NULL, \ 2092 sizeof (in), sizeof (rep_protocol_response_t), 0 \ 2093 } 2094 2095 #define PROTO_FD_OUT(p, f, in) { \ 2096 p, #p, NULL, (void *)(&f), simple_fd_handler, \ 2097 sizeof (in), \ 2098 sizeof (rep_protocol_response_t), \ 2099 PROTO_FLAG_RETFD \ 2100 } 2101 2102 #define PROTO_VARIN(p, f, insz) { \ 2103 p, #p, &(f), NULL, NULL, \ 2104 insz, sizeof (rep_protocol_response_t), \ 2105 PROTO_FLAG_VARINPUT \ 2106 } 2107 2108 #define PROTO_UINT_OUT(p, f, in) { \ 2109 p, #p, &(f), NULL, NULL, \ 2110 sizeof (in), \ 2111 sizeof (struct rep_protocol_integer_response), 0 \ 2112 } 2113 2114 #define PROTO_NAME_OUT(p, f, in) { \ 2115 p, #p, &(f), NULL, NULL, \ 2116 sizeof (in), \ 2117 sizeof (struct rep_protocol_name_response), 0 \ 2118 } 2119 2120 #define PROTO_FMRI_OUT(p, f, in) { \ 2121 p, #p, &(f), NULL, NULL, \ 2122 sizeof (in), \ 2123 sizeof (struct rep_protocol_fmri_response), 0 \ 2124 } 2125 2126 #define PROTO_VALUE_OUT(p, f, in) { \ 2127 p, #p, &(f), NULL, NULL, \ 2128 sizeof (in), \ 2129 sizeof (struct rep_protocol_value_response), 0 \ 2130 } 2131 2132 #define PROTO_PANIC(p) { p, #p, NULL, NULL, NULL, 0, 0, PROTO_FLAG_PANIC } 2133 #define PROTO_END() { 0, NULL, NULL, NULL, NULL, 0, 0, PROTO_FLAG_PANIC } 2134 2135 #define PROTO_FLAG_PANIC 0x00000001 /* should never be called */ 2136 #define PROTO_FLAG_VARINPUT 0x00000004 /* in_size is minimum size */ 2137 #define PROTO_FLAG_RETFD 0x00000008 /* can also return an FD */ 2138 2139 #define PROTO_ALL_FLAGS 0x0000000f /* all flags */ 2140 2141 static struct protocol_entry { 2142 enum rep_protocol_requestid pt_request; 2143 const char *pt_name; 2144 protocol_handler_f *pt_handler; 2145 void *pt_arg; 2146 protocol_handler_fdret_f *pt_fd_handler; 2147 size_t pt_in_size; 2148 size_t pt_out_max; 2149 uint32_t pt_flags; 2150 } protocol_table[] = { 2151 PROTO_PANIC(REP_PROTOCOL_CLOSE), /* special case */ 2152 2153 PROTO(REP_PROTOCOL_ENTITY_SETUP, entity_setup, 2154 struct rep_protocol_entity_setup), 2155 PROTO_NAME_OUT(REP_PROTOCOL_ENTITY_NAME, entity_name, 2156 struct rep_protocol_entity_name), 2157 PROTO_UINT_OUT(REP_PROTOCOL_ENTITY_PARENT_TYPE, entity_parent_type, 2158 struct rep_protocol_entity_parent_type), 2159 PROTO(REP_PROTOCOL_ENTITY_GET_CHILD, entity_get_child, 2160 struct rep_protocol_entity_get_child), 2161 PROTO(REP_PROTOCOL_ENTITY_GET_PARENT, entity_get_parent, 2162 struct rep_protocol_entity_parent), 2163 PROTO(REP_PROTOCOL_ENTITY_GET, entity_get, 2164 struct rep_protocol_entity_get), 2165 PROTO(REP_PROTOCOL_ENTITY_UPDATE, entity_update, 2166 struct rep_protocol_entity_update), 2167 PROTO(REP_PROTOCOL_ENTITY_CREATE_CHILD, entity_create_child, 2168 struct rep_protocol_entity_create_child), 2169 PROTO(REP_PROTOCOL_ENTITY_CREATE_PG, entity_create_pg, 2170 struct rep_protocol_entity_create_pg), 2171 PROTO(REP_PROTOCOL_ENTITY_DELETE, entity_delete, 2172 struct rep_protocol_entity_delete), 2173 PROTO(REP_PROTOCOL_ENTITY_RESET, entity_reset, 2174 struct rep_protocol_entity_reset), 2175 PROTO(REP_PROTOCOL_ENTITY_TEARDOWN, entity_teardown, 2176 struct rep_protocol_entity_teardown), 2177 2178 PROTO(REP_PROTOCOL_ITER_SETUP, iter_setup, 2179 struct rep_protocol_iter_request), 2180 PROTO(REP_PROTOCOL_ITER_START, iter_start, 2181 struct rep_protocol_iter_start), 2182 PROTO(REP_PROTOCOL_ITER_READ, iter_read, 2183 struct rep_protocol_iter_read), 2184 PROTO_VALUE_OUT(REP_PROTOCOL_ITER_READ_VALUE, iter_read_value, 2185 struct rep_protocol_iter_read_value), 2186 PROTO(REP_PROTOCOL_ITER_RESET, iter_reset, 2187 struct rep_protocol_iter_request), 2188 PROTO(REP_PROTOCOL_ITER_TEARDOWN, iter_teardown, 2189 struct rep_protocol_iter_request), 2190 2191 PROTO(REP_PROTOCOL_NEXT_SNAPLEVEL, next_snaplevel, 2192 struct rep_protocol_entity_pair), 2193 2194 PROTO(REP_PROTOCOL_SNAPSHOT_TAKE, snapshot_take, 2195 struct rep_protocol_snapshot_take), 2196 PROTO(REP_PROTOCOL_SNAPSHOT_TAKE_NAMED, snapshot_take_named, 2197 struct rep_protocol_snapshot_take_named), 2198 PROTO(REP_PROTOCOL_SNAPSHOT_ATTACH, snapshot_attach, 2199 struct rep_protocol_snapshot_attach), 2200 2201 PROTO_UINT_OUT(REP_PROTOCOL_PROPERTY_GET_TYPE, property_get_type, 2202 struct rep_protocol_property_request), 2203 PROTO_VALUE_OUT(REP_PROTOCOL_PROPERTY_GET_VALUE, property_get_value, 2204 struct rep_protocol_property_request), 2205 2206 PROTO_FD_OUT(REP_PROTOCOL_PROPERTYGRP_SETUP_WAIT, propertygrp_notify, 2207 struct rep_protocol_propertygrp_request), 2208 PROTO(REP_PROTOCOL_PROPERTYGRP_TX_START, tx_start, 2209 struct rep_protocol_transaction_start), 2210 PROTO_VARIN(REP_PROTOCOL_PROPERTYGRP_TX_COMMIT, tx_commit, 2211 REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE), 2212 2213 PROTO(REP_PROTOCOL_CLIENT_ADD_NOTIFY, client_add_notify, 2214 struct rep_protocol_notify_request), 2215 PROTO_FMRI_OUT(REP_PROTOCOL_CLIENT_WAIT, client_wait, 2216 struct rep_protocol_wait_request), 2217 2218 PROTO(REP_PROTOCOL_BACKUP, backup_repository, 2219 struct rep_protocol_backup_request), 2220 2221 PROTO(REP_PROTOCOL_SET_AUDIT_ANNOTATION, set_annotation, 2222 struct rep_protocol_annotation), 2223 2224 PROTO(REP_PROTOCOL_SWITCH, repository_switch, 2225 struct rep_protocol_switch_request), 2226 2227 PROTO_END() 2228 }; 2229 #undef PROTO 2230 #undef PROTO_FMRI_OUT 2231 #undef PROTO_NAME_OUT 2232 #undef PROTO_UINT_OUT 2233 #undef PROTO_PANIC 2234 #undef PROTO_END 2235 2236 /* 2237 * The number of entries, sans PROTO_END() 2238 */ 2239 #define PROTOCOL_ENTRIES \ 2240 (sizeof (protocol_table) / sizeof (*protocol_table) - 1) 2241 2242 #define PROTOCOL_PREFIX "REP_PROTOCOL_" 2243 2244 int 2245 client_init(void) 2246 { 2247 int i; 2248 struct protocol_entry *e; 2249 2250 if (!client_hash_init()) 2251 return (0); 2252 2253 if (request_log_size > 0) { 2254 request_log = uu_zalloc(request_log_size * 2255 sizeof (request_log_entry_t)); 2256 } 2257 2258 /* 2259 * update the names to not include REP_PROTOCOL_ 2260 */ 2261 for (i = 0; i < PROTOCOL_ENTRIES; i++) { 2262 e = &protocol_table[i]; 2263 assert(strncmp(e->pt_name, PROTOCOL_PREFIX, 2264 strlen(PROTOCOL_PREFIX)) == 0); 2265 e->pt_name += strlen(PROTOCOL_PREFIX); 2266 } 2267 /* 2268 * verify the protocol table is consistent 2269 */ 2270 for (i = 0; i < PROTOCOL_ENTRIES; i++) { 2271 e = &protocol_table[i]; 2272 assert(e->pt_request == (REP_PROTOCOL_BASE + i)); 2273 2274 assert((e->pt_flags & ~PROTO_ALL_FLAGS) == 0); 2275 2276 if (e->pt_flags & PROTO_FLAG_PANIC) 2277 assert(e->pt_in_size == 0 && e->pt_out_max == 0 && 2278 e->pt_handler == NULL); 2279 else 2280 assert(e->pt_in_size != 0 && e->pt_out_max != 0 && 2281 (e->pt_handler != NULL || 2282 e->pt_fd_handler != NULL)); 2283 } 2284 assert((REP_PROTOCOL_BASE + i) == REP_PROTOCOL_MAX_REQUEST); 2285 2286 assert(protocol_table[i].pt_request == 0); 2287 2288 return (1); 2289 } 2290 2291 static void 2292 client_switcher(void *cookie, char *argp, size_t arg_size, door_desc_t *desc_in, 2293 uint_t n_desc) 2294 { 2295 thread_info_t *ti = thread_self(); 2296 2297 repcache_client_t *cp; 2298 uint32_t id = (uint32_t)cookie; 2299 enum rep_protocol_requestid request_code; 2300 2301 rep_protocol_responseid_t result = INVALID_RESULT; 2302 2303 struct protocol_entry *e; 2304 2305 char *retval = NULL; 2306 size_t retsize = 0; 2307 2308 int retfd = -1; 2309 door_desc_t desc; 2310 request_log_entry_t *rlp; 2311 2312 rlp = start_log(id); 2313 2314 if (n_desc != 0) 2315 uu_die("can't happen: %d descriptors @%p (cookie %p)", 2316 n_desc, desc_in, cookie); 2317 2318 if (argp == DOOR_UNREF_DATA) { 2319 client_destroy(id); 2320 goto bad_end; 2321 } 2322 2323 thread_newstate(ti, TI_CLIENT_CALL); 2324 2325 /* 2326 * To simplify returning just a result code, we set up for 2327 * that case here. 2328 */ 2329 retval = (char *)&result; 2330 retsize = sizeof (result); 2331 2332 if (arg_size < sizeof (request_code)) { 2333 result = REP_PROTOCOL_FAIL_BAD_REQUEST; 2334 goto end_unheld; 2335 } 2336 2337 ti->ti_client_request = (void *)argp; 2338 2339 /* LINTED alignment */ 2340 request_code = *(uint32_t *)argp; 2341 2342 if (rlp != NULL) { 2343 rlp->rl_request = request_code; 2344 } 2345 /* 2346 * In order to avoid locking problems on removal, we handle the 2347 * "close" case before doing a lookup. 2348 */ 2349 if (request_code == REP_PROTOCOL_CLOSE) { 2350 client_destroy(id); 2351 result = REP_PROTOCOL_SUCCESS; 2352 goto end_unheld; 2353 } 2354 2355 cp = client_lookup(id); 2356 /* 2357 * cp is held 2358 */ 2359 2360 if (cp == NULL) 2361 goto bad_end; 2362 2363 if (rlp != NULL) 2364 rlp->rl_client = cp; 2365 2366 ti->ti_active_client = cp; 2367 2368 if (request_code < REP_PROTOCOL_BASE || 2369 request_code >= REP_PROTOCOL_BASE + PROTOCOL_ENTRIES) { 2370 result = REP_PROTOCOL_FAIL_BAD_REQUEST; 2371 goto end; 2372 } 2373 2374 e = &protocol_table[request_code - REP_PROTOCOL_BASE]; 2375 2376 assert(!(e->pt_flags & PROTO_FLAG_PANIC)); 2377 2378 if (e->pt_flags & PROTO_FLAG_VARINPUT) { 2379 if (arg_size < e->pt_in_size) { 2380 result = REP_PROTOCOL_FAIL_BAD_REQUEST; 2381 goto end; 2382 } 2383 } else if (arg_size != e->pt_in_size) { 2384 result = REP_PROTOCOL_FAIL_BAD_REQUEST; 2385 goto end; 2386 } 2387 2388 if (retsize != e->pt_out_max) { 2389 retsize = e->pt_out_max; 2390 retval = alloca(retsize); 2391 } 2392 2393 if (e->pt_flags & PROTO_FLAG_RETFD) 2394 e->pt_fd_handler(cp, argp, arg_size, retval, &retsize, 2395 e->pt_arg, &retfd); 2396 else 2397 e->pt_handler(cp, argp, arg_size, retval, &retsize, e->pt_arg); 2398 2399 end: 2400 ti->ti_active_client = NULL; 2401 client_release(cp); 2402 2403 end_unheld: 2404 if (rlp != NULL) { 2405 /* LINTED alignment */ 2406 rlp->rl_response = *(uint32_t *)retval; 2407 end_log(); 2408 rlp = NULL; 2409 } 2410 ti->ti_client_request = NULL; 2411 thread_newstate(ti, TI_DOOR_RETURN); 2412 2413 if (retval == (char *)&result) { 2414 assert(result != INVALID_RESULT && retsize == sizeof (result)); 2415 } else { 2416 /* LINTED alignment */ 2417 result = *(uint32_t *)retval; 2418 } 2419 if (retfd != -1) { 2420 desc.d_attributes = DOOR_DESCRIPTOR | DOOR_RELEASE; 2421 desc.d_data.d_desc.d_descriptor = retfd; 2422 (void) door_return(retval, retsize, &desc, 1); 2423 } else { 2424 (void) door_return(retval, retsize, NULL, 0); 2425 } 2426 bad_end: 2427 if (rlp != NULL) { 2428 rlp->rl_response = -1; 2429 end_log(); 2430 rlp = NULL; 2431 } 2432 (void) door_return(NULL, 0, NULL, 0); 2433 } 2434 2435 int 2436 create_client(pid_t pid, uint32_t debugflags, int privileged, int *out_fd) 2437 { 2438 int fd; 2439 2440 repcache_client_t *cp; 2441 2442 struct door_info info; 2443 2444 int door_flags = DOOR_UNREF | DOOR_REFUSE_DESC; 2445 #ifdef DOOR_NO_CANCEL 2446 door_flags |= DOOR_NO_CANCEL; 2447 #endif 2448 2449 cp = client_alloc(); 2450 if (cp == NULL) 2451 return (REPOSITORY_DOOR_FAIL_NO_RESOURCES); 2452 2453 (void) pthread_mutex_lock(&client_lock); 2454 cp->rc_id = ++client_maxid; 2455 (void) pthread_mutex_unlock(&client_lock); 2456 2457 cp->rc_all_auths = privileged; 2458 cp->rc_pid = pid; 2459 cp->rc_debug = debugflags; 2460 2461 start_audit_session(cp); 2462 2463 cp->rc_doorfd = door_create(client_switcher, (void *)cp->rc_id, 2464 door_flags); 2465 2466 if (cp->rc_doorfd < 0) { 2467 client_free(cp); 2468 return (REPOSITORY_DOOR_FAIL_NO_RESOURCES); 2469 } 2470 #ifdef DOOR_PARAM_DATA_MIN 2471 (void) door_setparam(cp->rc_doorfd, DOOR_PARAM_DATA_MIN, 2472 sizeof (enum rep_protocol_requestid)); 2473 #endif 2474 2475 if ((fd = dup(cp->rc_doorfd)) < 0 || 2476 door_info(cp->rc_doorfd, &info) < 0) { 2477 if (fd >= 0) 2478 (void) close(fd); 2479 (void) door_revoke(cp->rc_doorfd); 2480 cp->rc_doorfd = -1; 2481 client_free(cp); 2482 return (REPOSITORY_DOOR_FAIL_NO_RESOURCES); 2483 } 2484 2485 rc_pg_notify_init(&cp->rc_pg_notify); 2486 rc_notify_info_init(&cp->rc_notify_info); 2487 2488 client_insert(cp); 2489 2490 cp->rc_doorid = info.di_uniquifier; 2491 *out_fd = fd; 2492 2493 return (REPOSITORY_DOOR_SUCCESS); 2494 } 2495