17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
5f2fa366aSjeanm * Common Development and Distribution License (the "License").
6f2fa366aSjeanm * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
215b7f77adStw21770
227c478bd9Sstevel@tonic-gate /*
23a9173115SMarek Pospisil * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
246970e7c5SAndrew Stormont * Copyright 2015 RackTop Systems.
25*44bf619dSJohn Levon * Copyright 2019 Joyent, Inc.
267c478bd9Sstevel@tonic-gate */
277c478bd9Sstevel@tonic-gate
287c478bd9Sstevel@tonic-gate /*
297c478bd9Sstevel@tonic-gate * This is the client layer for svc.configd. All direct protocol interactions
307c478bd9Sstevel@tonic-gate * are handled here.
317c478bd9Sstevel@tonic-gate *
327c478bd9Sstevel@tonic-gate * Essentially, the job of this layer is to turn the idempotent protocol
337c478bd9Sstevel@tonic-gate * into a series of non-idempotent calls into the object layer, while
347c478bd9Sstevel@tonic-gate * also handling the necessary locking.
357c478bd9Sstevel@tonic-gate */
367c478bd9Sstevel@tonic-gate
377c478bd9Sstevel@tonic-gate #include <alloca.h>
387c478bd9Sstevel@tonic-gate #include <assert.h>
395b7f77adStw21770 #include <bsm/adt_event.h>
407c478bd9Sstevel@tonic-gate #include <door.h>
417c478bd9Sstevel@tonic-gate #include <errno.h>
425b7f77adStw21770 #include <libintl.h>
437c478bd9Sstevel@tonic-gate #include <limits.h>
447c478bd9Sstevel@tonic-gate #include <pthread.h>
457c478bd9Sstevel@tonic-gate #include <stdio.h>
467c478bd9Sstevel@tonic-gate #include <stdlib.h>
477c478bd9Sstevel@tonic-gate #include <string.h>
485b7f77adStw21770 #include <syslog.h>
495b7f77adStw21770 #include <ucred.h>
507c478bd9Sstevel@tonic-gate #include <unistd.h>
517c478bd9Sstevel@tonic-gate
527c478bd9Sstevel@tonic-gate #include <libuutil.h>
537c478bd9Sstevel@tonic-gate
547c478bd9Sstevel@tonic-gate #include "configd.h"
557c478bd9Sstevel@tonic-gate #include "repcache_protocol.h"
567c478bd9Sstevel@tonic-gate
577c478bd9Sstevel@tonic-gate #define INVALID_CHANGEID (0)
587c478bd9Sstevel@tonic-gate #define INVALID_DOORID ((door_id_t)-1)
597c478bd9Sstevel@tonic-gate #define INVALID_RESULT ((rep_protocol_responseid_t)INT_MIN)
607c478bd9Sstevel@tonic-gate
617c478bd9Sstevel@tonic-gate /*
627c478bd9Sstevel@tonic-gate * lint doesn't like constant assertions
637c478bd9Sstevel@tonic-gate */
647c478bd9Sstevel@tonic-gate #ifdef lint
657c478bd9Sstevel@tonic-gate #define assert_nolint(x) (void)0
667c478bd9Sstevel@tonic-gate #else
677c478bd9Sstevel@tonic-gate #define assert_nolint(x) assert(x)
687c478bd9Sstevel@tonic-gate #endif
697c478bd9Sstevel@tonic-gate
707c478bd9Sstevel@tonic-gate /*
717c478bd9Sstevel@tonic-gate * Protects client linkage and the freelist
727c478bd9Sstevel@tonic-gate */
737c478bd9Sstevel@tonic-gate #define CLIENT_HASH_SIZE 64
747c478bd9Sstevel@tonic-gate
757c478bd9Sstevel@tonic-gate #pragma align 64(client_hash)
767c478bd9Sstevel@tonic-gate static client_bucket_t client_hash[CLIENT_HASH_SIZE];
777c478bd9Sstevel@tonic-gate
788918dff3Sjwadams static uu_avl_pool_t *entity_pool;
798918dff3Sjwadams static uu_avl_pool_t *iter_pool;
807c478bd9Sstevel@tonic-gate static uu_list_pool_t *client_pool;
817c478bd9Sstevel@tonic-gate
827c478bd9Sstevel@tonic-gate #define CLIENT_HASH(id) (&client_hash[((id) & (CLIENT_HASH_SIZE - 1))])
837c478bd9Sstevel@tonic-gate
847c478bd9Sstevel@tonic-gate uint_t request_log_size = 1024; /* tunable, before we start */
857c478bd9Sstevel@tonic-gate
867c478bd9Sstevel@tonic-gate static pthread_mutex_t request_log_lock = PTHREAD_MUTEX_INITIALIZER;
877c478bd9Sstevel@tonic-gate static uint_t request_log_cur;
887c478bd9Sstevel@tonic-gate request_log_entry_t *request_log;
897c478bd9Sstevel@tonic-gate
907c478bd9Sstevel@tonic-gate static uint32_t client_maxid;
917c478bd9Sstevel@tonic-gate static pthread_mutex_t client_lock; /* protects client_maxid */
927c478bd9Sstevel@tonic-gate
937c478bd9Sstevel@tonic-gate static request_log_entry_t *
get_log(void)947c478bd9Sstevel@tonic-gate get_log(void)
957c478bd9Sstevel@tonic-gate {
967c478bd9Sstevel@tonic-gate thread_info_t *ti = thread_self();
977c478bd9Sstevel@tonic-gate return (&ti->ti_log);
987c478bd9Sstevel@tonic-gate }
997c478bd9Sstevel@tonic-gate
1007c478bd9Sstevel@tonic-gate void
log_enter(request_log_entry_t * rlp)1017c478bd9Sstevel@tonic-gate log_enter(request_log_entry_t *rlp)
1027c478bd9Sstevel@tonic-gate {
1037c478bd9Sstevel@tonic-gate if (rlp->rl_start != 0 && request_log != NULL) {
1047c478bd9Sstevel@tonic-gate request_log_entry_t *logrlp;
1057c478bd9Sstevel@tonic-gate
1067c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&request_log_lock);
1077c478bd9Sstevel@tonic-gate assert(request_log_cur < request_log_size);
1087c478bd9Sstevel@tonic-gate logrlp = &request_log[request_log_cur++];
1097c478bd9Sstevel@tonic-gate if (request_log_cur == request_log_size)
1107c478bd9Sstevel@tonic-gate request_log_cur = 0;
1117c478bd9Sstevel@tonic-gate (void) memcpy(logrlp, rlp, sizeof (*rlp));
1127c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&request_log_lock);
1137c478bd9Sstevel@tonic-gate }
1147c478bd9Sstevel@tonic-gate }
1157c478bd9Sstevel@tonic-gate
1167c478bd9Sstevel@tonic-gate /*
1177c478bd9Sstevel@tonic-gate * Note that the svc.configd dmod will join all of the per-thread log entries
1187c478bd9Sstevel@tonic-gate * with the main log, so that even if the log is disabled, there is some
1197c478bd9Sstevel@tonic-gate * information available.
1207c478bd9Sstevel@tonic-gate */
1217c478bd9Sstevel@tonic-gate static request_log_entry_t *
start_log(uint32_t clientid)1227c478bd9Sstevel@tonic-gate start_log(uint32_t clientid)
1237c478bd9Sstevel@tonic-gate {
1247c478bd9Sstevel@tonic-gate request_log_entry_t *rlp = get_log();
1257c478bd9Sstevel@tonic-gate
1267c478bd9Sstevel@tonic-gate log_enter(rlp);
1277c478bd9Sstevel@tonic-gate
1287c478bd9Sstevel@tonic-gate (void) memset(rlp, 0, sizeof (*rlp));
1297c478bd9Sstevel@tonic-gate rlp->rl_start = gethrtime();
1307c478bd9Sstevel@tonic-gate rlp->rl_tid = pthread_self();
1317c478bd9Sstevel@tonic-gate rlp->rl_clientid = clientid;
1327c478bd9Sstevel@tonic-gate
1337c478bd9Sstevel@tonic-gate return (rlp);
1347c478bd9Sstevel@tonic-gate }
1357c478bd9Sstevel@tonic-gate
1367c478bd9Sstevel@tonic-gate void
end_log(void)1377c478bd9Sstevel@tonic-gate end_log(void)
1387c478bd9Sstevel@tonic-gate {
1397c478bd9Sstevel@tonic-gate request_log_entry_t *rlp = get_log();
1407c478bd9Sstevel@tonic-gate
1417c478bd9Sstevel@tonic-gate rlp->rl_end = gethrtime();
1427c478bd9Sstevel@tonic-gate }
1437c478bd9Sstevel@tonic-gate
1447c478bd9Sstevel@tonic-gate static void
add_log_ptr(request_log_entry_t * rlp,enum rc_ptr_type type,uint32_t id,void * ptr)1457c478bd9Sstevel@tonic-gate add_log_ptr(request_log_entry_t *rlp, enum rc_ptr_type type, uint32_t id,
1467c478bd9Sstevel@tonic-gate void *ptr)
1477c478bd9Sstevel@tonic-gate {
1487c478bd9Sstevel@tonic-gate request_log_ptr_t *rpp;
1497c478bd9Sstevel@tonic-gate
1507c478bd9Sstevel@tonic-gate if (rlp == NULL)
1517c478bd9Sstevel@tonic-gate return;
1527c478bd9Sstevel@tonic-gate
1537c478bd9Sstevel@tonic-gate if (rlp->rl_num_ptrs >= MAX_PTRS)
1547c478bd9Sstevel@tonic-gate return;
1557c478bd9Sstevel@tonic-gate
1567c478bd9Sstevel@tonic-gate rpp = &rlp->rl_ptrs[rlp->rl_num_ptrs++];
1577c478bd9Sstevel@tonic-gate rpp->rlp_type = type;
1587c478bd9Sstevel@tonic-gate rpp->rlp_id = id;
1597c478bd9Sstevel@tonic-gate rpp->rlp_ptr = ptr;
1607c478bd9Sstevel@tonic-gate
1617c478bd9Sstevel@tonic-gate /*
1627c478bd9Sstevel@tonic-gate * For entities, it's useful to have the node pointer at the start
1637c478bd9Sstevel@tonic-gate * of the request.
1647c478bd9Sstevel@tonic-gate */
1657c478bd9Sstevel@tonic-gate if (type == RC_PTR_TYPE_ENTITY && ptr != NULL)
1667c478bd9Sstevel@tonic-gate rpp->rlp_data = ((repcache_entity_t *)ptr)->re_node.rnp_node;
1677c478bd9Sstevel@tonic-gate }
1687c478bd9Sstevel@tonic-gate
1697c478bd9Sstevel@tonic-gate int
client_is_privileged(void)1707c478bd9Sstevel@tonic-gate client_is_privileged(void)
1717c478bd9Sstevel@tonic-gate {
1727c478bd9Sstevel@tonic-gate thread_info_t *ti = thread_self();
1737c478bd9Sstevel@tonic-gate
1747c478bd9Sstevel@tonic-gate ucred_t *uc;
1757c478bd9Sstevel@tonic-gate
1767c478bd9Sstevel@tonic-gate if (ti->ti_active_client != NULL &&
1777c478bd9Sstevel@tonic-gate ti->ti_active_client->rc_all_auths)
1787c478bd9Sstevel@tonic-gate return (1);
1797c478bd9Sstevel@tonic-gate
1807c478bd9Sstevel@tonic-gate if ((uc = get_ucred()) == NULL)
1817c478bd9Sstevel@tonic-gate return (0);
1827c478bd9Sstevel@tonic-gate
1837c478bd9Sstevel@tonic-gate return (ucred_is_privileged(uc));
1847c478bd9Sstevel@tonic-gate }
1857c478bd9Sstevel@tonic-gate
1867c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1877c478bd9Sstevel@tonic-gate static int
client_compare(const void * lc_arg,const void * rc_arg,void * private)1887c478bd9Sstevel@tonic-gate client_compare(const void *lc_arg, const void *rc_arg, void *private)
1897c478bd9Sstevel@tonic-gate {
1907c478bd9Sstevel@tonic-gate uint32_t l_id = ((const repcache_client_t *)lc_arg)->rc_id;
1917c478bd9Sstevel@tonic-gate uint32_t r_id = ((const repcache_client_t *)rc_arg)->rc_id;
1927c478bd9Sstevel@tonic-gate
1937c478bd9Sstevel@tonic-gate if (l_id > r_id)
1947c478bd9Sstevel@tonic-gate return (1);
1957c478bd9Sstevel@tonic-gate if (l_id < r_id)
1967c478bd9Sstevel@tonic-gate return (-1);
1977c478bd9Sstevel@tonic-gate return (0);
1987c478bd9Sstevel@tonic-gate }
1997c478bd9Sstevel@tonic-gate
2007c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2017c478bd9Sstevel@tonic-gate static int
entity_compare(const void * lc_arg,const void * rc_arg,void * private)2027c478bd9Sstevel@tonic-gate entity_compare(const void *lc_arg, const void *rc_arg, void *private)
2037c478bd9Sstevel@tonic-gate {
2047c478bd9Sstevel@tonic-gate uint32_t l_id = ((const repcache_entity_t *)lc_arg)->re_id;
2057c478bd9Sstevel@tonic-gate uint32_t r_id = ((const repcache_entity_t *)rc_arg)->re_id;
2067c478bd9Sstevel@tonic-gate
2077c478bd9Sstevel@tonic-gate if (l_id > r_id)
2087c478bd9Sstevel@tonic-gate return (1);
2097c478bd9Sstevel@tonic-gate if (l_id < r_id)
2107c478bd9Sstevel@tonic-gate return (-1);
2117c478bd9Sstevel@tonic-gate return (0);
2127c478bd9Sstevel@tonic-gate }
2137c478bd9Sstevel@tonic-gate
2147c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2157c478bd9Sstevel@tonic-gate static int
iter_compare(const void * lc_arg,const void * rc_arg,void * private)2167c478bd9Sstevel@tonic-gate iter_compare(const void *lc_arg, const void *rc_arg, void *private)
2177c478bd9Sstevel@tonic-gate {
2187c478bd9Sstevel@tonic-gate uint32_t l_id = ((const repcache_iter_t *)lc_arg)->ri_id;
2197c478bd9Sstevel@tonic-gate uint32_t r_id = ((const repcache_iter_t *)rc_arg)->ri_id;
2207c478bd9Sstevel@tonic-gate
2217c478bd9Sstevel@tonic-gate if (l_id > r_id)
2227c478bd9Sstevel@tonic-gate return (1);
2237c478bd9Sstevel@tonic-gate if (l_id < r_id)
2247c478bd9Sstevel@tonic-gate return (-1);
2257c478bd9Sstevel@tonic-gate return (0);
2267c478bd9Sstevel@tonic-gate }
2277c478bd9Sstevel@tonic-gate
2287c478bd9Sstevel@tonic-gate static int
client_hash_init(void)2297c478bd9Sstevel@tonic-gate client_hash_init(void)
2307c478bd9Sstevel@tonic-gate {
2317c478bd9Sstevel@tonic-gate int x;
2327c478bd9Sstevel@tonic-gate
2337c478bd9Sstevel@tonic-gate assert_nolint(offsetof(repcache_entity_t, re_id) == 0);
2348918dff3Sjwadams entity_pool = uu_avl_pool_create("repcache_entitys",
2357c478bd9Sstevel@tonic-gate sizeof (repcache_entity_t), offsetof(repcache_entity_t, re_link),
2368918dff3Sjwadams entity_compare, UU_AVL_POOL_DEBUG);
2377c478bd9Sstevel@tonic-gate
2387c478bd9Sstevel@tonic-gate assert_nolint(offsetof(repcache_iter_t, ri_id) == 0);
2398918dff3Sjwadams iter_pool = uu_avl_pool_create("repcache_iters",
2407c478bd9Sstevel@tonic-gate sizeof (repcache_iter_t), offsetof(repcache_iter_t, ri_link),
2418918dff3Sjwadams iter_compare, UU_AVL_POOL_DEBUG);
2427c478bd9Sstevel@tonic-gate
2437c478bd9Sstevel@tonic-gate assert_nolint(offsetof(repcache_client_t, rc_id) == 0);
2447c478bd9Sstevel@tonic-gate client_pool = uu_list_pool_create("repcache_clients",
2457c478bd9Sstevel@tonic-gate sizeof (repcache_client_t), offsetof(repcache_client_t, rc_link),
2467c478bd9Sstevel@tonic-gate client_compare, UU_LIST_POOL_DEBUG);
2477c478bd9Sstevel@tonic-gate
2487c478bd9Sstevel@tonic-gate if (entity_pool == NULL || iter_pool == NULL || client_pool == NULL)
2497c478bd9Sstevel@tonic-gate return (0);
2507c478bd9Sstevel@tonic-gate
2517c478bd9Sstevel@tonic-gate for (x = 0; x < CLIENT_HASH_SIZE; x++) {
2527c478bd9Sstevel@tonic-gate uu_list_t *lp = uu_list_create(client_pool, &client_hash[x],
2537c478bd9Sstevel@tonic-gate UU_LIST_SORTED);
2547c478bd9Sstevel@tonic-gate if (lp == NULL)
2557c478bd9Sstevel@tonic-gate return (0);
2567c478bd9Sstevel@tonic-gate
2577c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&client_hash[x].cb_lock, NULL);
2587c478bd9Sstevel@tonic-gate client_hash[x].cb_list = lp;
2597c478bd9Sstevel@tonic-gate }
2607c478bd9Sstevel@tonic-gate
2617c478bd9Sstevel@tonic-gate return (1);
2627c478bd9Sstevel@tonic-gate }
2637c478bd9Sstevel@tonic-gate
2647c478bd9Sstevel@tonic-gate static repcache_client_t *
client_alloc(void)2657c478bd9Sstevel@tonic-gate client_alloc(void)
2667c478bd9Sstevel@tonic-gate {
2677c478bd9Sstevel@tonic-gate repcache_client_t *cp;
2687c478bd9Sstevel@tonic-gate cp = uu_zalloc(sizeof (*cp));
2697c478bd9Sstevel@tonic-gate if (cp == NULL)
2707c478bd9Sstevel@tonic-gate return (NULL);
2717c478bd9Sstevel@tonic-gate
2728918dff3Sjwadams cp->rc_entities = uu_avl_create(entity_pool, cp, 0);
2738918dff3Sjwadams if (cp->rc_entities == NULL)
2747c478bd9Sstevel@tonic-gate goto fail;
2757c478bd9Sstevel@tonic-gate
2768918dff3Sjwadams cp->rc_iters = uu_avl_create(iter_pool, cp, 0);
2778918dff3Sjwadams if (cp->rc_iters == NULL)
2787c478bd9Sstevel@tonic-gate goto fail;
2797c478bd9Sstevel@tonic-gate
2807c478bd9Sstevel@tonic-gate uu_list_node_init(cp, &cp->rc_link, client_pool);
2817c478bd9Sstevel@tonic-gate
2827c478bd9Sstevel@tonic-gate cp->rc_doorfd = -1;
2837c478bd9Sstevel@tonic-gate cp->rc_doorid = INVALID_DOORID;
2847c478bd9Sstevel@tonic-gate
2857c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&cp->rc_lock, NULL);
2865b7f77adStw21770 (void) pthread_mutex_init(&cp->rc_annotate_lock, NULL);
2877c478bd9Sstevel@tonic-gate
2887c478bd9Sstevel@tonic-gate rc_node_ptr_init(&cp->rc_notify_ptr);
2897c478bd9Sstevel@tonic-gate
2907c478bd9Sstevel@tonic-gate return (cp);
2917c478bd9Sstevel@tonic-gate
2927c478bd9Sstevel@tonic-gate fail:
2938918dff3Sjwadams if (cp->rc_iters != NULL)
2948918dff3Sjwadams uu_avl_destroy(cp->rc_iters);
2958918dff3Sjwadams if (cp->rc_entities != NULL)
2968918dff3Sjwadams uu_avl_destroy(cp->rc_entities);
2977c478bd9Sstevel@tonic-gate uu_free(cp);
2987c478bd9Sstevel@tonic-gate return (NULL);
2997c478bd9Sstevel@tonic-gate }
3007c478bd9Sstevel@tonic-gate
3017c478bd9Sstevel@tonic-gate static void
client_free(repcache_client_t * cp)3027c478bd9Sstevel@tonic-gate client_free(repcache_client_t *cp)
3037c478bd9Sstevel@tonic-gate {
3047c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr == 0);
3057c478bd9Sstevel@tonic-gate assert(cp->rc_refcnt == 0);
3067c478bd9Sstevel@tonic-gate assert(cp->rc_doorfd == -1);
3077c478bd9Sstevel@tonic-gate assert(cp->rc_doorid == INVALID_DOORID);
3088918dff3Sjwadams assert(uu_avl_first(cp->rc_entities) == NULL);
3098918dff3Sjwadams assert(uu_avl_first(cp->rc_iters) == NULL);
3108918dff3Sjwadams uu_avl_destroy(cp->rc_entities);
3118918dff3Sjwadams uu_avl_destroy(cp->rc_iters);
3127c478bd9Sstevel@tonic-gate uu_list_node_fini(cp, &cp->rc_link, client_pool);
3137c478bd9Sstevel@tonic-gate (void) pthread_mutex_destroy(&cp->rc_lock);
3145b7f77adStw21770 (void) pthread_mutex_destroy(&cp->rc_annotate_lock);
3155b7f77adStw21770 rc_node_ptr_free_mem(&cp->rc_notify_ptr);
3167c478bd9Sstevel@tonic-gate uu_free(cp);
3177c478bd9Sstevel@tonic-gate }
3187c478bd9Sstevel@tonic-gate
3197c478bd9Sstevel@tonic-gate static void
client_insert(repcache_client_t * cp)3207c478bd9Sstevel@tonic-gate client_insert(repcache_client_t *cp)
3217c478bd9Sstevel@tonic-gate {
3227c478bd9Sstevel@tonic-gate client_bucket_t *bp = CLIENT_HASH(cp->rc_id);
3237c478bd9Sstevel@tonic-gate uu_list_index_t idx;
3247c478bd9Sstevel@tonic-gate
3257c478bd9Sstevel@tonic-gate assert(cp->rc_id > 0);
3267c478bd9Sstevel@tonic-gate
3277c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&bp->cb_lock);
3287c478bd9Sstevel@tonic-gate /*
3297c478bd9Sstevel@tonic-gate * We assume it does not already exist
3307c478bd9Sstevel@tonic-gate */
3317c478bd9Sstevel@tonic-gate (void) uu_list_find(bp->cb_list, cp, NULL, &idx);
3327c478bd9Sstevel@tonic-gate uu_list_insert(bp->cb_list, cp, idx);
3337c478bd9Sstevel@tonic-gate
3347c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&bp->cb_lock);
3357c478bd9Sstevel@tonic-gate }
3367c478bd9Sstevel@tonic-gate
3377c478bd9Sstevel@tonic-gate static repcache_client_t *
client_lookup(uint32_t id)3387c478bd9Sstevel@tonic-gate client_lookup(uint32_t id)
3397c478bd9Sstevel@tonic-gate {
3407c478bd9Sstevel@tonic-gate client_bucket_t *bp = CLIENT_HASH(id);
3417c478bd9Sstevel@tonic-gate repcache_client_t *cp;
3427c478bd9Sstevel@tonic-gate
3437c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&bp->cb_lock);
3447c478bd9Sstevel@tonic-gate
3457c478bd9Sstevel@tonic-gate cp = uu_list_find(bp->cb_list, &id, NULL, NULL);
3467c478bd9Sstevel@tonic-gate
3477c478bd9Sstevel@tonic-gate /*
3487c478bd9Sstevel@tonic-gate * Bump the reference count
3497c478bd9Sstevel@tonic-gate */
3507c478bd9Sstevel@tonic-gate if (cp != NULL) {
3517c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
3527c478bd9Sstevel@tonic-gate assert(!(cp->rc_flags & RC_CLIENT_DEAD));
3537c478bd9Sstevel@tonic-gate cp->rc_refcnt++;
3547c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
3557c478bd9Sstevel@tonic-gate }
3567c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&bp->cb_lock);
3577c478bd9Sstevel@tonic-gate
3587c478bd9Sstevel@tonic-gate return (cp);
3597c478bd9Sstevel@tonic-gate }
3607c478bd9Sstevel@tonic-gate
3617c478bd9Sstevel@tonic-gate static void
client_release(repcache_client_t * cp)3627c478bd9Sstevel@tonic-gate client_release(repcache_client_t *cp)
3637c478bd9Sstevel@tonic-gate {
3647c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
3657c478bd9Sstevel@tonic-gate assert(cp->rc_refcnt > 0);
3667c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr != pthread_self());
3677c478bd9Sstevel@tonic-gate
3687c478bd9Sstevel@tonic-gate --cp->rc_refcnt;
3697c478bd9Sstevel@tonic-gate (void) pthread_cond_broadcast(&cp->rc_cv);
3707c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
3717c478bd9Sstevel@tonic-gate }
3727c478bd9Sstevel@tonic-gate
3737c478bd9Sstevel@tonic-gate /*
3747c478bd9Sstevel@tonic-gate * We only allow one thread to be inserting at a time, to prevent
3757c478bd9Sstevel@tonic-gate * insert/insert races.
3767c478bd9Sstevel@tonic-gate */
3777c478bd9Sstevel@tonic-gate static void
client_start_insert(repcache_client_t * cp)3787c478bd9Sstevel@tonic-gate client_start_insert(repcache_client_t *cp)
3797c478bd9Sstevel@tonic-gate {
3807c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
3817c478bd9Sstevel@tonic-gate assert(cp->rc_refcnt > 0);
3827c478bd9Sstevel@tonic-gate
3837c478bd9Sstevel@tonic-gate while (cp->rc_insert_thr != 0) {
3847c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr != pthread_self());
3857c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&cp->rc_cv, &cp->rc_lock);
3867c478bd9Sstevel@tonic-gate }
3877c478bd9Sstevel@tonic-gate cp->rc_insert_thr = pthread_self();
3887c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
3897c478bd9Sstevel@tonic-gate }
3907c478bd9Sstevel@tonic-gate
3917c478bd9Sstevel@tonic-gate static void
client_end_insert(repcache_client_t * cp)3927c478bd9Sstevel@tonic-gate client_end_insert(repcache_client_t *cp)
3937c478bd9Sstevel@tonic-gate {
3947c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
3957c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr == pthread_self());
3967c478bd9Sstevel@tonic-gate cp->rc_insert_thr = 0;
3977c478bd9Sstevel@tonic-gate (void) pthread_cond_broadcast(&cp->rc_cv);
3987c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
3997c478bd9Sstevel@tonic-gate }
4007c478bd9Sstevel@tonic-gate
4017c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4027c478bd9Sstevel@tonic-gate static repcache_entity_t *
entity_alloc(repcache_client_t * cp)4037c478bd9Sstevel@tonic-gate entity_alloc(repcache_client_t *cp)
4047c478bd9Sstevel@tonic-gate {
4057c478bd9Sstevel@tonic-gate repcache_entity_t *ep = uu_zalloc(sizeof (repcache_entity_t));
4067c478bd9Sstevel@tonic-gate if (ep != NULL) {
4078918dff3Sjwadams uu_avl_node_init(ep, &ep->re_link, entity_pool);
4087c478bd9Sstevel@tonic-gate }
4097c478bd9Sstevel@tonic-gate return (ep);
4107c478bd9Sstevel@tonic-gate }
4117c478bd9Sstevel@tonic-gate
4127c478bd9Sstevel@tonic-gate static void
entity_add(repcache_client_t * cp,repcache_entity_t * ep)4137c478bd9Sstevel@tonic-gate entity_add(repcache_client_t *cp, repcache_entity_t *ep)
4147c478bd9Sstevel@tonic-gate {
4158918dff3Sjwadams uu_avl_index_t idx;
4167c478bd9Sstevel@tonic-gate
4177c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
4187c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr == pthread_self());
4197c478bd9Sstevel@tonic-gate
4208918dff3Sjwadams (void) uu_avl_find(cp->rc_entities, ep, NULL, &idx);
4218918dff3Sjwadams uu_avl_insert(cp->rc_entities, ep, idx);
4227c478bd9Sstevel@tonic-gate
4237c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
4247c478bd9Sstevel@tonic-gate }
4257c478bd9Sstevel@tonic-gate
4267c478bd9Sstevel@tonic-gate static repcache_entity_t *
entity_find(repcache_client_t * cp,uint32_t id)4277c478bd9Sstevel@tonic-gate entity_find(repcache_client_t *cp, uint32_t id)
4287c478bd9Sstevel@tonic-gate {
4297c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
4307c478bd9Sstevel@tonic-gate
4317c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
4328918dff3Sjwadams ep = uu_avl_find(cp->rc_entities, &id, NULL, NULL);
4337c478bd9Sstevel@tonic-gate if (ep != NULL) {
4347c478bd9Sstevel@tonic-gate add_log_ptr(get_log(), RC_PTR_TYPE_ENTITY, id, ep);
4357c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&ep->re_lock);
4367c478bd9Sstevel@tonic-gate }
4377c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
4387c478bd9Sstevel@tonic-gate
4397c478bd9Sstevel@tonic-gate return (ep);
4407c478bd9Sstevel@tonic-gate }
4417c478bd9Sstevel@tonic-gate
4427c478bd9Sstevel@tonic-gate /*
4437c478bd9Sstevel@tonic-gate * Fails with
4447c478bd9Sstevel@tonic-gate * _DUPLICATE_ID - the ids are equal
4457c478bd9Sstevel@tonic-gate * _UNKNOWN_ID - an id does not designate an active register
4467c478bd9Sstevel@tonic-gate */
4477c478bd9Sstevel@tonic-gate static int
entity_find2(repcache_client_t * cp,uint32_t id1,repcache_entity_t ** out1,uint32_t id2,repcache_entity_t ** out2)4487c478bd9Sstevel@tonic-gate entity_find2(repcache_client_t *cp, uint32_t id1, repcache_entity_t **out1,
4497c478bd9Sstevel@tonic-gate uint32_t id2, repcache_entity_t **out2)
4507c478bd9Sstevel@tonic-gate {
4517c478bd9Sstevel@tonic-gate repcache_entity_t *e1, *e2;
4527c478bd9Sstevel@tonic-gate request_log_entry_t *rlp;
4537c478bd9Sstevel@tonic-gate
4547c478bd9Sstevel@tonic-gate if (id1 == id2)
4557c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_DUPLICATE_ID);
4567c478bd9Sstevel@tonic-gate
4577c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
4588918dff3Sjwadams e1 = uu_avl_find(cp->rc_entities, &id1, NULL, NULL);
4598918dff3Sjwadams e2 = uu_avl_find(cp->rc_entities, &id2, NULL, NULL);
4607c478bd9Sstevel@tonic-gate if (e1 == NULL || e2 == NULL) {
4617c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
4627c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
4637c478bd9Sstevel@tonic-gate }
4647c478bd9Sstevel@tonic-gate
4657c478bd9Sstevel@tonic-gate assert(e1 != e2);
4667c478bd9Sstevel@tonic-gate
4677c478bd9Sstevel@tonic-gate /*
4687c478bd9Sstevel@tonic-gate * locks are ordered by id number
4697c478bd9Sstevel@tonic-gate */
4707c478bd9Sstevel@tonic-gate if (id1 < id2) {
4717c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&e1->re_lock);
4727c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&e2->re_lock);
4737c478bd9Sstevel@tonic-gate } else {
4747c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&e2->re_lock);
4757c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&e1->re_lock);
4767c478bd9Sstevel@tonic-gate }
4777c478bd9Sstevel@tonic-gate *out1 = e1;
4787c478bd9Sstevel@tonic-gate *out2 = e2;
4797c478bd9Sstevel@tonic-gate
4807c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
4817c478bd9Sstevel@tonic-gate
4827c478bd9Sstevel@tonic-gate if ((rlp = get_log()) != NULL) {
4837c478bd9Sstevel@tonic-gate add_log_ptr(rlp, RC_PTR_TYPE_ENTITY, id1, e1);
4847c478bd9Sstevel@tonic-gate add_log_ptr(rlp, RC_PTR_TYPE_ENTITY, id2, e2);
4857c478bd9Sstevel@tonic-gate }
4867c478bd9Sstevel@tonic-gate
4877c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
4887c478bd9Sstevel@tonic-gate }
4897c478bd9Sstevel@tonic-gate
4907c478bd9Sstevel@tonic-gate static void
entity_release(repcache_entity_t * ep)4917c478bd9Sstevel@tonic-gate entity_release(repcache_entity_t *ep)
4927c478bd9Sstevel@tonic-gate {
4937c478bd9Sstevel@tonic-gate assert(ep->re_node.rnp_node == NULL ||
4947c478bd9Sstevel@tonic-gate !MUTEX_HELD(&ep->re_node.rnp_node->rn_lock));
4957c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&ep->re_lock);
4967c478bd9Sstevel@tonic-gate }
4977c478bd9Sstevel@tonic-gate
4987c478bd9Sstevel@tonic-gate static void
entity_destroy(repcache_entity_t * entity)4997c478bd9Sstevel@tonic-gate entity_destroy(repcache_entity_t *entity)
5007c478bd9Sstevel@tonic-gate {
5017c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&entity->re_lock);
5027c478bd9Sstevel@tonic-gate rc_node_clear(&entity->re_node, 0);
5037c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&entity->re_lock);
5047c478bd9Sstevel@tonic-gate
5058918dff3Sjwadams uu_avl_node_fini(entity, &entity->re_link, entity_pool);
5067c478bd9Sstevel@tonic-gate (void) pthread_mutex_destroy(&entity->re_lock);
5075b7f77adStw21770 rc_node_ptr_free_mem(&entity->re_node);
5087c478bd9Sstevel@tonic-gate uu_free(entity);
5097c478bd9Sstevel@tonic-gate }
5107c478bd9Sstevel@tonic-gate
5117c478bd9Sstevel@tonic-gate static void
entity_remove(repcache_client_t * cp,uint32_t id)5127c478bd9Sstevel@tonic-gate entity_remove(repcache_client_t *cp, uint32_t id)
5137c478bd9Sstevel@tonic-gate {
5147c478bd9Sstevel@tonic-gate repcache_entity_t *entity;
5157c478bd9Sstevel@tonic-gate
5167c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
5178918dff3Sjwadams entity = uu_avl_find(cp->rc_entities, &id, NULL, NULL);
5186643e1ffSbustos if (entity != NULL) {
5196643e1ffSbustos add_log_ptr(get_log(), RC_PTR_TYPE_ENTITY, id, entity);
5206643e1ffSbustos
5218918dff3Sjwadams uu_avl_remove(cp->rc_entities, entity);
5226643e1ffSbustos }
5237c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
5247c478bd9Sstevel@tonic-gate
5257c478bd9Sstevel@tonic-gate if (entity != NULL)
5267c478bd9Sstevel@tonic-gate entity_destroy(entity);
5277c478bd9Sstevel@tonic-gate }
5287c478bd9Sstevel@tonic-gate
5297c478bd9Sstevel@tonic-gate static void
entity_cleanup(repcache_client_t * cp)5307c478bd9Sstevel@tonic-gate entity_cleanup(repcache_client_t *cp)
5317c478bd9Sstevel@tonic-gate {
5327c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
5337c478bd9Sstevel@tonic-gate void *cookie = NULL;
5347c478bd9Sstevel@tonic-gate
5357c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
5368918dff3Sjwadams while ((ep = uu_avl_teardown(cp->rc_entities, &cookie)) != NULL) {
5377c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
5387c478bd9Sstevel@tonic-gate entity_destroy(ep);
5397c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
5407c478bd9Sstevel@tonic-gate }
5417c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
5427c478bd9Sstevel@tonic-gate }
5437c478bd9Sstevel@tonic-gate
5447c478bd9Sstevel@tonic-gate /*ARGSUSED*/
5457c478bd9Sstevel@tonic-gate static repcache_iter_t *
iter_alloc(repcache_client_t * cp)5467c478bd9Sstevel@tonic-gate iter_alloc(repcache_client_t *cp)
5477c478bd9Sstevel@tonic-gate {
5487c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
5497c478bd9Sstevel@tonic-gate iter = uu_zalloc(sizeof (repcache_iter_t));
5507c478bd9Sstevel@tonic-gate if (iter != NULL)
5518918dff3Sjwadams uu_avl_node_init(iter, &iter->ri_link, iter_pool);
5527c478bd9Sstevel@tonic-gate return (iter);
5537c478bd9Sstevel@tonic-gate }
5547c478bd9Sstevel@tonic-gate
5557c478bd9Sstevel@tonic-gate static void
iter_add(repcache_client_t * cp,repcache_iter_t * iter)5567c478bd9Sstevel@tonic-gate iter_add(repcache_client_t *cp, repcache_iter_t *iter)
5577c478bd9Sstevel@tonic-gate {
5587c478bd9Sstevel@tonic-gate uu_list_index_t idx;
5597c478bd9Sstevel@tonic-gate
5607c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
5617c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr == pthread_self());
5627c478bd9Sstevel@tonic-gate
5638918dff3Sjwadams (void) uu_avl_find(cp->rc_iters, iter, NULL, &idx);
5648918dff3Sjwadams uu_avl_insert(cp->rc_iters, iter, idx);
5657c478bd9Sstevel@tonic-gate
5667c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
5677c478bd9Sstevel@tonic-gate }
5687c478bd9Sstevel@tonic-gate
5697c478bd9Sstevel@tonic-gate static repcache_iter_t *
iter_find(repcache_client_t * cp,uint32_t id)5707c478bd9Sstevel@tonic-gate iter_find(repcache_client_t *cp, uint32_t id)
5717c478bd9Sstevel@tonic-gate {
5727c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
5737c478bd9Sstevel@tonic-gate
5747c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
5757c478bd9Sstevel@tonic-gate
5768918dff3Sjwadams iter = uu_avl_find(cp->rc_iters, &id, NULL, NULL);
5777c478bd9Sstevel@tonic-gate if (iter != NULL) {
5787c478bd9Sstevel@tonic-gate add_log_ptr(get_log(), RC_PTR_TYPE_ITER, id, iter);
5797c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&iter->ri_lock);
5807c478bd9Sstevel@tonic-gate }
5817c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
5827c478bd9Sstevel@tonic-gate
5837c478bd9Sstevel@tonic-gate return (iter);
5847c478bd9Sstevel@tonic-gate }
5857c478bd9Sstevel@tonic-gate
5867c478bd9Sstevel@tonic-gate /*
5877c478bd9Sstevel@tonic-gate * Fails with
5887c478bd9Sstevel@tonic-gate * _UNKNOWN_ID - iter_id or entity_id does not designate an active register
5897c478bd9Sstevel@tonic-gate */
5907c478bd9Sstevel@tonic-gate static int
iter_find_w_entity(repcache_client_t * cp,uint32_t iter_id,repcache_iter_t ** iterp,uint32_t entity_id,repcache_entity_t ** epp)5917c478bd9Sstevel@tonic-gate iter_find_w_entity(repcache_client_t *cp, uint32_t iter_id,
5927c478bd9Sstevel@tonic-gate repcache_iter_t **iterp, uint32_t entity_id, repcache_entity_t **epp)
5937c478bd9Sstevel@tonic-gate {
5947c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
5957c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
5967c478bd9Sstevel@tonic-gate request_log_entry_t *rlp;
5977c478bd9Sstevel@tonic-gate
5987c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
5998918dff3Sjwadams iter = uu_avl_find(cp->rc_iters, &iter_id, NULL, NULL);
6008918dff3Sjwadams ep = uu_avl_find(cp->rc_entities, &entity_id, NULL, NULL);
6017c478bd9Sstevel@tonic-gate
6027c478bd9Sstevel@tonic-gate assert(iter == NULL || !MUTEX_HELD(&iter->ri_lock));
6037c478bd9Sstevel@tonic-gate assert(ep == NULL || !MUTEX_HELD(&ep->re_lock));
6047c478bd9Sstevel@tonic-gate
6057c478bd9Sstevel@tonic-gate if (iter == NULL || ep == NULL) {
6067c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
6077c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
6087c478bd9Sstevel@tonic-gate }
6097c478bd9Sstevel@tonic-gate
6107c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&iter->ri_lock);
6117c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&ep->re_lock);
6127c478bd9Sstevel@tonic-gate
6137c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
6147c478bd9Sstevel@tonic-gate
6157c478bd9Sstevel@tonic-gate *iterp = iter;
6167c478bd9Sstevel@tonic-gate *epp = ep;
6177c478bd9Sstevel@tonic-gate
6187c478bd9Sstevel@tonic-gate if ((rlp = get_log()) != NULL) {
6197c478bd9Sstevel@tonic-gate add_log_ptr(rlp, RC_PTR_TYPE_ENTITY, entity_id, ep);
6207c478bd9Sstevel@tonic-gate add_log_ptr(rlp, RC_PTR_TYPE_ITER, iter_id, iter);
6217c478bd9Sstevel@tonic-gate }
6227c478bd9Sstevel@tonic-gate
6237c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
6247c478bd9Sstevel@tonic-gate }
6257c478bd9Sstevel@tonic-gate
6267c478bd9Sstevel@tonic-gate static void
iter_release(repcache_iter_t * iter)6277c478bd9Sstevel@tonic-gate iter_release(repcache_iter_t *iter)
6287c478bd9Sstevel@tonic-gate {
6297c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&iter->ri_lock);
6307c478bd9Sstevel@tonic-gate }
6317c478bd9Sstevel@tonic-gate
6327c478bd9Sstevel@tonic-gate static void
iter_destroy(repcache_iter_t * iter)6337c478bd9Sstevel@tonic-gate iter_destroy(repcache_iter_t *iter)
6347c478bd9Sstevel@tonic-gate {
6357c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&iter->ri_lock);
6367c478bd9Sstevel@tonic-gate rc_iter_destroy(&iter->ri_iter);
6377c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&iter->ri_lock);
6387c478bd9Sstevel@tonic-gate
6398918dff3Sjwadams uu_avl_node_fini(iter, &iter->ri_link, iter_pool);
6407c478bd9Sstevel@tonic-gate (void) pthread_mutex_destroy(&iter->ri_lock);
6417c478bd9Sstevel@tonic-gate uu_free(iter);
6427c478bd9Sstevel@tonic-gate }
6437c478bd9Sstevel@tonic-gate
6447c478bd9Sstevel@tonic-gate static void
iter_remove(repcache_client_t * cp,uint32_t id)6457c478bd9Sstevel@tonic-gate iter_remove(repcache_client_t *cp, uint32_t id)
6467c478bd9Sstevel@tonic-gate {
6477c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
6487c478bd9Sstevel@tonic-gate
6497c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
6508918dff3Sjwadams iter = uu_avl_find(cp->rc_iters, &id, NULL, NULL);
6517c478bd9Sstevel@tonic-gate if (iter != NULL)
6528918dff3Sjwadams uu_avl_remove(cp->rc_iters, iter);
6537c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
6547c478bd9Sstevel@tonic-gate
6557c478bd9Sstevel@tonic-gate if (iter != NULL)
6567c478bd9Sstevel@tonic-gate iter_destroy(iter);
6577c478bd9Sstevel@tonic-gate }
6587c478bd9Sstevel@tonic-gate
6597c478bd9Sstevel@tonic-gate static void
iter_cleanup(repcache_client_t * cp)6607c478bd9Sstevel@tonic-gate iter_cleanup(repcache_client_t *cp)
6617c478bd9Sstevel@tonic-gate {
6627c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
6637c478bd9Sstevel@tonic-gate void *cookie = NULL;
6647c478bd9Sstevel@tonic-gate
6657c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
6668918dff3Sjwadams while ((iter = uu_avl_teardown(cp->rc_iters, &cookie)) != NULL) {
6677c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
6687c478bd9Sstevel@tonic-gate iter_destroy(iter);
6697c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
6707c478bd9Sstevel@tonic-gate }
6717c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
6727c478bd9Sstevel@tonic-gate }
6737c478bd9Sstevel@tonic-gate
6747c478bd9Sstevel@tonic-gate /*
6757c478bd9Sstevel@tonic-gate * Ensure that the passed client id is no longer usable, wait for any
6767c478bd9Sstevel@tonic-gate * outstanding invocations to complete, then destroy the client
6777c478bd9Sstevel@tonic-gate * structure.
6787c478bd9Sstevel@tonic-gate */
6797c478bd9Sstevel@tonic-gate static void
client_destroy(uint32_t id)6807c478bd9Sstevel@tonic-gate client_destroy(uint32_t id)
6817c478bd9Sstevel@tonic-gate {
6827c478bd9Sstevel@tonic-gate client_bucket_t *bp = CLIENT_HASH(id);
6837c478bd9Sstevel@tonic-gate repcache_client_t *cp;
6847c478bd9Sstevel@tonic-gate
6857c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&bp->cb_lock);
6867c478bd9Sstevel@tonic-gate
6877c478bd9Sstevel@tonic-gate cp = uu_list_find(bp->cb_list, &id, NULL, NULL);
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate if (cp == NULL) {
6907c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&bp->cb_lock);
6917c478bd9Sstevel@tonic-gate return;
6927c478bd9Sstevel@tonic-gate }
6937c478bd9Sstevel@tonic-gate
6947c478bd9Sstevel@tonic-gate uu_list_remove(bp->cb_list, cp);
6957c478bd9Sstevel@tonic-gate
6967c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&bp->cb_lock);
6977c478bd9Sstevel@tonic-gate
6987c478bd9Sstevel@tonic-gate /* kick the waiters out */
6997c478bd9Sstevel@tonic-gate rc_notify_info_fini(&cp->rc_notify_info);
7007c478bd9Sstevel@tonic-gate
7017c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
7027c478bd9Sstevel@tonic-gate assert(!(cp->rc_flags & RC_CLIENT_DEAD));
7037c478bd9Sstevel@tonic-gate cp->rc_flags |= RC_CLIENT_DEAD;
7047c478bd9Sstevel@tonic-gate
7057c478bd9Sstevel@tonic-gate if (cp->rc_doorfd != -1) {
7067c478bd9Sstevel@tonic-gate if (door_revoke(cp->rc_doorfd) < 0)
7077c478bd9Sstevel@tonic-gate perror("door_revoke");
7087c478bd9Sstevel@tonic-gate cp->rc_doorfd = -1;
7097c478bd9Sstevel@tonic-gate cp->rc_doorid = INVALID_DOORID;
7107c478bd9Sstevel@tonic-gate }
7117c478bd9Sstevel@tonic-gate
7127c478bd9Sstevel@tonic-gate while (cp->rc_refcnt > 0)
7137c478bd9Sstevel@tonic-gate (void) pthread_cond_wait(&cp->rc_cv, &cp->rc_lock);
7147c478bd9Sstevel@tonic-gate
7157c478bd9Sstevel@tonic-gate assert(cp->rc_insert_thr == 0 && cp->rc_notify_thr == 0);
7167c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
7177c478bd9Sstevel@tonic-gate
7187c478bd9Sstevel@tonic-gate /*
7197c478bd9Sstevel@tonic-gate * destroy outstanding objects
7207c478bd9Sstevel@tonic-gate */
7217c478bd9Sstevel@tonic-gate entity_cleanup(cp);
7227c478bd9Sstevel@tonic-gate iter_cleanup(cp);
7237c478bd9Sstevel@tonic-gate
7247c478bd9Sstevel@tonic-gate /*
7257c478bd9Sstevel@tonic-gate * clean up notifications
7267c478bd9Sstevel@tonic-gate */
7277c478bd9Sstevel@tonic-gate rc_pg_notify_fini(&cp->rc_pg_notify);
7287c478bd9Sstevel@tonic-gate
7295b7f77adStw21770 /*
7305b7f77adStw21770 * clean up annotations
7315b7f77adStw21770 */
7325b7f77adStw21770 if (cp->rc_operation != NULL)
7335b7f77adStw21770 free((void *)cp->rc_operation);
7345b7f77adStw21770 if (cp->rc_file != NULL)
7355b7f77adStw21770 free((void *)cp->rc_file);
7365b7f77adStw21770
7375b7f77adStw21770 /*
7385b7f77adStw21770 * End audit session.
7395b7f77adStw21770 */
7406970e7c5SAndrew Stormont #ifndef NATIVE_BUILD
7415b7f77adStw21770 (void) adt_end_session(cp->rc_adt_session);
7426970e7c5SAndrew Stormont #endif
7435b7f77adStw21770
7447c478bd9Sstevel@tonic-gate client_free(cp);
7457c478bd9Sstevel@tonic-gate }
7467c478bd9Sstevel@tonic-gate
7477c478bd9Sstevel@tonic-gate /*
7487c478bd9Sstevel@tonic-gate * Fails with
7497c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - the entity is already set up with a different type
7507c478bd9Sstevel@tonic-gate * _NO_RESOURCES - out of memory
7517c478bd9Sstevel@tonic-gate */
7527c478bd9Sstevel@tonic-gate static int
entity_setup(repcache_client_t * cp,struct rep_protocol_entity_setup * rpr)7537c478bd9Sstevel@tonic-gate entity_setup(repcache_client_t *cp, struct rep_protocol_entity_setup *rpr)
7547c478bd9Sstevel@tonic-gate {
7557c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
7567c478bd9Sstevel@tonic-gate uint32_t type;
7577c478bd9Sstevel@tonic-gate
7587c478bd9Sstevel@tonic-gate client_start_insert(cp);
7597c478bd9Sstevel@tonic-gate
7607c478bd9Sstevel@tonic-gate if ((ep = entity_find(cp, rpr->rpr_entityid)) != NULL) {
7617c478bd9Sstevel@tonic-gate type = ep->re_type;
7627c478bd9Sstevel@tonic-gate entity_release(ep);
7637c478bd9Sstevel@tonic-gate
7647c478bd9Sstevel@tonic-gate client_end_insert(cp);
7657c478bd9Sstevel@tonic-gate
7667c478bd9Sstevel@tonic-gate if (type != rpr->rpr_entitytype)
7677c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_TYPE_MISMATCH);
7687c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
7697c478bd9Sstevel@tonic-gate }
7707c478bd9Sstevel@tonic-gate
7717c478bd9Sstevel@tonic-gate switch (type = rpr->rpr_entitytype) {
7727c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SCOPE:
7737c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SERVICE:
7747c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_INSTANCE:
7757c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SNAPSHOT:
7767c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SNAPLEVEL:
7777c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_PROPERTYGRP:
7787c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_PROPERTY:
7797c478bd9Sstevel@tonic-gate break;
7807c478bd9Sstevel@tonic-gate default:
7817c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
7827c478bd9Sstevel@tonic-gate }
7837c478bd9Sstevel@tonic-gate
7847c478bd9Sstevel@tonic-gate ep = entity_alloc(cp);
7857c478bd9Sstevel@tonic-gate if (ep == NULL) {
7867c478bd9Sstevel@tonic-gate client_end_insert(cp);
7877c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_NO_RESOURCES);
7887c478bd9Sstevel@tonic-gate }
7897c478bd9Sstevel@tonic-gate
7907c478bd9Sstevel@tonic-gate ep->re_id = rpr->rpr_entityid;
7917c478bd9Sstevel@tonic-gate ep->re_changeid = INVALID_CHANGEID;
7927c478bd9Sstevel@tonic-gate
7937c478bd9Sstevel@tonic-gate ep->re_type = type;
7947c478bd9Sstevel@tonic-gate rc_node_ptr_init(&ep->re_node);
7957c478bd9Sstevel@tonic-gate
7967c478bd9Sstevel@tonic-gate entity_add(cp, ep);
7977c478bd9Sstevel@tonic-gate client_end_insert(cp);
7987c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
7997c478bd9Sstevel@tonic-gate }
8007c478bd9Sstevel@tonic-gate
8017c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8027c478bd9Sstevel@tonic-gate static void
entity_name(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)8037c478bd9Sstevel@tonic-gate entity_name(repcache_client_t *cp, const void *in, size_t insz, void *out_arg,
8047c478bd9Sstevel@tonic-gate size_t *outsz, void *arg)
8057c478bd9Sstevel@tonic-gate {
8067c478bd9Sstevel@tonic-gate const struct rep_protocol_entity_name *rpr = in;
8077c478bd9Sstevel@tonic-gate struct rep_protocol_name_response *out = out_arg;
8087c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
8097c478bd9Sstevel@tonic-gate size_t sz = sizeof (out->rpr_name);
8107c478bd9Sstevel@tonic-gate
8117c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
8127c478bd9Sstevel@tonic-gate
8137c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
8147c478bd9Sstevel@tonic-gate
8157c478bd9Sstevel@tonic-gate if (ep == NULL) {
8167c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID;
8177c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
8187c478bd9Sstevel@tonic-gate return;
8197c478bd9Sstevel@tonic-gate }
8207c478bd9Sstevel@tonic-gate out->rpr_response = rc_node_name(&ep->re_node, out->rpr_name,
8217c478bd9Sstevel@tonic-gate sz, rpr->rpr_answertype, &sz);
8227c478bd9Sstevel@tonic-gate entity_release(ep);
8237c478bd9Sstevel@tonic-gate
8247c478bd9Sstevel@tonic-gate /*
8257c478bd9Sstevel@tonic-gate * If we fail, we only return the response code.
8267c478bd9Sstevel@tonic-gate * If we succeed, we don't return anything after the '\0' in rpr_name.
8277c478bd9Sstevel@tonic-gate */
8287c478bd9Sstevel@tonic-gate if (out->rpr_response != REP_PROTOCOL_SUCCESS)
8297c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
8307c478bd9Sstevel@tonic-gate else
8317c478bd9Sstevel@tonic-gate *outsz = offsetof(struct rep_protocol_name_response,
8327c478bd9Sstevel@tonic-gate rpr_name[sz + 1]);
8337c478bd9Sstevel@tonic-gate }
8347c478bd9Sstevel@tonic-gate
8357c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8367c478bd9Sstevel@tonic-gate static void
entity_parent_type(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)8377c478bd9Sstevel@tonic-gate entity_parent_type(repcache_client_t *cp, const void *in, size_t insz,
8387c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
8397c478bd9Sstevel@tonic-gate {
8407c478bd9Sstevel@tonic-gate const struct rep_protocol_entity_name *rpr = in;
8417c478bd9Sstevel@tonic-gate struct rep_protocol_integer_response *out = out_arg;
8427c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
8437c478bd9Sstevel@tonic-gate
8447c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
8457c478bd9Sstevel@tonic-gate
8467c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
8477c478bd9Sstevel@tonic-gate
8487c478bd9Sstevel@tonic-gate if (ep == NULL) {
8497c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID;
8507c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
8517c478bd9Sstevel@tonic-gate return;
8527c478bd9Sstevel@tonic-gate }
8537c478bd9Sstevel@tonic-gate
8547c478bd9Sstevel@tonic-gate out->rpr_response = rc_node_parent_type(&ep->re_node, &out->rpr_value);
8557c478bd9Sstevel@tonic-gate entity_release(ep);
8567c478bd9Sstevel@tonic-gate
8577c478bd9Sstevel@tonic-gate if (out->rpr_response != REP_PROTOCOL_SUCCESS)
8587c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
8597c478bd9Sstevel@tonic-gate }
8607c478bd9Sstevel@tonic-gate
8617c478bd9Sstevel@tonic-gate /*
8627c478bd9Sstevel@tonic-gate * Fails with
8637c478bd9Sstevel@tonic-gate * _DUPLICATE_ID - the ids are equal
8647c478bd9Sstevel@tonic-gate * _UNKNOWN_ID - an id does not designate an active register
8657c478bd9Sstevel@tonic-gate * _INVALID_TYPE - type is invalid
8667c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - np doesn't carry children of type type
8677c478bd9Sstevel@tonic-gate * _DELETED - np has been deleted
8687c478bd9Sstevel@tonic-gate * _NOT_FOUND - no child with that name/type combo found
8697c478bd9Sstevel@tonic-gate * _NO_RESOURCES
8707c478bd9Sstevel@tonic-gate * _BACKEND_ACCESS
8717c478bd9Sstevel@tonic-gate */
8727c478bd9Sstevel@tonic-gate static int
entity_get_child(repcache_client_t * cp,struct rep_protocol_entity_get_child * rpr)8737c478bd9Sstevel@tonic-gate entity_get_child(repcache_client_t *cp,
8747c478bd9Sstevel@tonic-gate struct rep_protocol_entity_get_child *rpr)
8757c478bd9Sstevel@tonic-gate {
8767c478bd9Sstevel@tonic-gate repcache_entity_t *parent, *child;
8777c478bd9Sstevel@tonic-gate int result;
8787c478bd9Sstevel@tonic-gate
8797c478bd9Sstevel@tonic-gate uint32_t parentid = rpr->rpr_entityid;
8807c478bd9Sstevel@tonic-gate uint32_t childid = rpr->rpr_childid;
8817c478bd9Sstevel@tonic-gate
8827c478bd9Sstevel@tonic-gate result = entity_find2(cp, childid, &child, parentid, &parent);
8837c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
8847c478bd9Sstevel@tonic-gate return (result);
8857c478bd9Sstevel@tonic-gate
8867c478bd9Sstevel@tonic-gate rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0;
8877c478bd9Sstevel@tonic-gate
8887c478bd9Sstevel@tonic-gate result = rc_node_get_child(&parent->re_node, rpr->rpr_name,
8897c478bd9Sstevel@tonic-gate child->re_type, &child->re_node);
8907c478bd9Sstevel@tonic-gate
8917c478bd9Sstevel@tonic-gate entity_release(child);
8927c478bd9Sstevel@tonic-gate entity_release(parent);
8937c478bd9Sstevel@tonic-gate
8947c478bd9Sstevel@tonic-gate return (result);
8957c478bd9Sstevel@tonic-gate }
8967c478bd9Sstevel@tonic-gate
8977c478bd9Sstevel@tonic-gate /*
8987c478bd9Sstevel@tonic-gate * Returns _FAIL_DUPLICATE_ID, _FAIL_UNKNOWN_ID, _FAIL_NOT_SET, _FAIL_DELETED,
8997c478bd9Sstevel@tonic-gate * _FAIL_TYPE_MISMATCH, _FAIL_NOT_FOUND (scope has no parent), or _SUCCESS.
9007c478bd9Sstevel@tonic-gate * Fails with
9017c478bd9Sstevel@tonic-gate * _DUPLICATE_ID - the ids are equal
9027c478bd9Sstevel@tonic-gate * _UNKNOWN_ID - an id does not designate an active register
9037c478bd9Sstevel@tonic-gate * _NOT_SET - child is not set
9047c478bd9Sstevel@tonic-gate * _DELETED - child has been deleted
9057c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - child's parent does not match that of the parent register
9067c478bd9Sstevel@tonic-gate * _NOT_FOUND - child has no parent (and is a scope)
9077c478bd9Sstevel@tonic-gate */
9087c478bd9Sstevel@tonic-gate static int
entity_get_parent(repcache_client_t * cp,struct rep_protocol_entity_parent * rpr)9097c478bd9Sstevel@tonic-gate entity_get_parent(repcache_client_t *cp, struct rep_protocol_entity_parent *rpr)
9107c478bd9Sstevel@tonic-gate {
9117c478bd9Sstevel@tonic-gate repcache_entity_t *child, *parent;
9127c478bd9Sstevel@tonic-gate int result;
9137c478bd9Sstevel@tonic-gate
9147c478bd9Sstevel@tonic-gate uint32_t childid = rpr->rpr_entityid;
9157c478bd9Sstevel@tonic-gate uint32_t outid = rpr->rpr_outid;
9167c478bd9Sstevel@tonic-gate
9177c478bd9Sstevel@tonic-gate result = entity_find2(cp, childid, &child, outid, &parent);
9187c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
9197c478bd9Sstevel@tonic-gate return (result);
9207c478bd9Sstevel@tonic-gate
9217c478bd9Sstevel@tonic-gate result = rc_node_get_parent(&child->re_node, parent->re_type,
9227c478bd9Sstevel@tonic-gate &parent->re_node);
9237c478bd9Sstevel@tonic-gate
9247c478bd9Sstevel@tonic-gate entity_release(child);
9257c478bd9Sstevel@tonic-gate entity_release(parent);
9267c478bd9Sstevel@tonic-gate
9277c478bd9Sstevel@tonic-gate return (result);
9287c478bd9Sstevel@tonic-gate }
9297c478bd9Sstevel@tonic-gate
9307c478bd9Sstevel@tonic-gate static int
entity_get(repcache_client_t * cp,struct rep_protocol_entity_get * rpr)9317c478bd9Sstevel@tonic-gate entity_get(repcache_client_t *cp, struct rep_protocol_entity_get *rpr)
9327c478bd9Sstevel@tonic-gate {
9337c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
9347c478bd9Sstevel@tonic-gate int result;
9357c478bd9Sstevel@tonic-gate
9367c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
9377c478bd9Sstevel@tonic-gate
9387c478bd9Sstevel@tonic-gate if (ep == NULL)
9397c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
9407c478bd9Sstevel@tonic-gate
9417c478bd9Sstevel@tonic-gate switch (rpr->rpr_object) {
9427c478bd9Sstevel@tonic-gate case RP_ENTITY_GET_INVALIDATE:
9437c478bd9Sstevel@tonic-gate rc_node_clear(&ep->re_node, 0);
9447c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
9457c478bd9Sstevel@tonic-gate break;
9467c478bd9Sstevel@tonic-gate case RP_ENTITY_GET_MOST_LOCAL_SCOPE:
9477c478bd9Sstevel@tonic-gate result = rc_local_scope(ep->re_type, &ep->re_node);
9487c478bd9Sstevel@tonic-gate break;
9497c478bd9Sstevel@tonic-gate default:
9507c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_BAD_REQUEST;
9517c478bd9Sstevel@tonic-gate break;
9527c478bd9Sstevel@tonic-gate }
9537c478bd9Sstevel@tonic-gate
9547c478bd9Sstevel@tonic-gate entity_release(ep);
9557c478bd9Sstevel@tonic-gate
9567c478bd9Sstevel@tonic-gate return (result);
9577c478bd9Sstevel@tonic-gate }
9587c478bd9Sstevel@tonic-gate
9597c478bd9Sstevel@tonic-gate static int
entity_update(repcache_client_t * cp,struct rep_protocol_entity_update * rpr)9607c478bd9Sstevel@tonic-gate entity_update(repcache_client_t *cp, struct rep_protocol_entity_update *rpr)
9617c478bd9Sstevel@tonic-gate {
9627c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
9637c478bd9Sstevel@tonic-gate int result;
9647c478bd9Sstevel@tonic-gate
9657c478bd9Sstevel@tonic-gate if (rpr->rpr_changeid == INVALID_CHANGEID)
9667c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
9677c478bd9Sstevel@tonic-gate
9687c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
9697c478bd9Sstevel@tonic-gate
9707c478bd9Sstevel@tonic-gate if (ep == NULL)
9717c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
9727c478bd9Sstevel@tonic-gate
9737c478bd9Sstevel@tonic-gate if (ep->re_changeid == rpr->rpr_changeid) {
9747c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_DONE;
9757c478bd9Sstevel@tonic-gate } else {
9767c478bd9Sstevel@tonic-gate result = rc_node_update(&ep->re_node);
9777c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_DONE)
9787c478bd9Sstevel@tonic-gate ep->re_changeid = rpr->rpr_changeid;
9797c478bd9Sstevel@tonic-gate }
9807c478bd9Sstevel@tonic-gate
9817c478bd9Sstevel@tonic-gate entity_release(ep);
9827c478bd9Sstevel@tonic-gate
9837c478bd9Sstevel@tonic-gate return (result);
9847c478bd9Sstevel@tonic-gate }
9857c478bd9Sstevel@tonic-gate
9867c478bd9Sstevel@tonic-gate static int
entity_reset(repcache_client_t * cp,struct rep_protocol_entity_reset * rpr)9877c478bd9Sstevel@tonic-gate entity_reset(repcache_client_t *cp, struct rep_protocol_entity_reset *rpr)
9887c478bd9Sstevel@tonic-gate {
9897c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
9907c478bd9Sstevel@tonic-gate
9917c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
9927c478bd9Sstevel@tonic-gate if (ep == NULL)
9937c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
9947c478bd9Sstevel@tonic-gate
9957c478bd9Sstevel@tonic-gate rc_node_clear(&ep->re_node, 0);
9967c478bd9Sstevel@tonic-gate ep->re_txstate = REPCACHE_TX_INIT;
9977c478bd9Sstevel@tonic-gate
9987c478bd9Sstevel@tonic-gate entity_release(ep);
9997c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
10007c478bd9Sstevel@tonic-gate }
10017c478bd9Sstevel@tonic-gate
10027c478bd9Sstevel@tonic-gate /*
10037c478bd9Sstevel@tonic-gate * Fails with
10047c478bd9Sstevel@tonic-gate * _BAD_REQUEST - request has invalid changeid
10057c478bd9Sstevel@tonic-gate * rpr_name is invalid
10067c478bd9Sstevel@tonic-gate * cannot create children for parent's type of node
10077c478bd9Sstevel@tonic-gate * _DUPLICATE_ID - request has duplicate ids
10087c478bd9Sstevel@tonic-gate * _UNKNOWN_ID - request has unknown id
10097c478bd9Sstevel@tonic-gate * _DELETED - parent has been deleted
10107c478bd9Sstevel@tonic-gate * _NOT_SET - parent is reset
10117c478bd9Sstevel@tonic-gate * _NOT_APPLICABLE - rpr_childtype is _PROPERTYGRP
10127c478bd9Sstevel@tonic-gate * _INVALID_TYPE - parent is corrupt or rpr_childtype is invalid
10137c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - parent cannot have children of type rpr_childtype
10147c478bd9Sstevel@tonic-gate * _NO_RESOURCES
10157c478bd9Sstevel@tonic-gate * _PERMISSION_DENIED
10167c478bd9Sstevel@tonic-gate * _BACKEND_ACCESS
10177c478bd9Sstevel@tonic-gate * _BACKEND_READONLY
10187c478bd9Sstevel@tonic-gate * _EXISTS - child already exists
10197c478bd9Sstevel@tonic-gate */
10207c478bd9Sstevel@tonic-gate static int
entity_create_child(repcache_client_t * cp,struct rep_protocol_entity_create_child * rpr)10217c478bd9Sstevel@tonic-gate entity_create_child(repcache_client_t *cp,
10227c478bd9Sstevel@tonic-gate struct rep_protocol_entity_create_child *rpr)
10237c478bd9Sstevel@tonic-gate {
10247c478bd9Sstevel@tonic-gate repcache_entity_t *parent;
10257c478bd9Sstevel@tonic-gate repcache_entity_t *child;
10267c478bd9Sstevel@tonic-gate
10277c478bd9Sstevel@tonic-gate uint32_t parentid = rpr->rpr_entityid;
10287c478bd9Sstevel@tonic-gate uint32_t childid = rpr->rpr_childid;
10297c478bd9Sstevel@tonic-gate
10307c478bd9Sstevel@tonic-gate int result;
10317c478bd9Sstevel@tonic-gate
10327c478bd9Sstevel@tonic-gate if (rpr->rpr_changeid == INVALID_CHANGEID)
10337c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
10347c478bd9Sstevel@tonic-gate
10357c478bd9Sstevel@tonic-gate result = entity_find2(cp, parentid, &parent, childid, &child);
10367c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
10377c478bd9Sstevel@tonic-gate return (result);
10387c478bd9Sstevel@tonic-gate
10397c478bd9Sstevel@tonic-gate rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0;
10407c478bd9Sstevel@tonic-gate
10417c478bd9Sstevel@tonic-gate if (child->re_changeid == rpr->rpr_changeid) {
10427c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
10437c478bd9Sstevel@tonic-gate } else {
10447c478bd9Sstevel@tonic-gate result = rc_node_create_child(&parent->re_node,
10457c478bd9Sstevel@tonic-gate rpr->rpr_childtype, rpr->rpr_name, &child->re_node);
10467c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
10477c478bd9Sstevel@tonic-gate child->re_changeid = rpr->rpr_changeid;
10487c478bd9Sstevel@tonic-gate }
10497c478bd9Sstevel@tonic-gate
10507c478bd9Sstevel@tonic-gate entity_release(parent);
10517c478bd9Sstevel@tonic-gate entity_release(child);
10527c478bd9Sstevel@tonic-gate
10537c478bd9Sstevel@tonic-gate return (result);
10547c478bd9Sstevel@tonic-gate }
10557c478bd9Sstevel@tonic-gate
10567c478bd9Sstevel@tonic-gate static int
entity_create_pg(repcache_client_t * cp,struct rep_protocol_entity_create_pg * rpr)10577c478bd9Sstevel@tonic-gate entity_create_pg(repcache_client_t *cp,
10587c478bd9Sstevel@tonic-gate struct rep_protocol_entity_create_pg *rpr)
10597c478bd9Sstevel@tonic-gate {
10607c478bd9Sstevel@tonic-gate repcache_entity_t *parent;
10617c478bd9Sstevel@tonic-gate repcache_entity_t *child;
10627c478bd9Sstevel@tonic-gate
10637c478bd9Sstevel@tonic-gate uint32_t parentid = rpr->rpr_entityid;
10647c478bd9Sstevel@tonic-gate uint32_t childid = rpr->rpr_childid;
10657c478bd9Sstevel@tonic-gate
10667c478bd9Sstevel@tonic-gate int result;
10677c478bd9Sstevel@tonic-gate
10687c478bd9Sstevel@tonic-gate if (rpr->rpr_changeid == INVALID_CHANGEID)
10697c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
10707c478bd9Sstevel@tonic-gate
10717c478bd9Sstevel@tonic-gate result = entity_find2(cp, parentid, &parent, childid, &child);
10727c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
10737c478bd9Sstevel@tonic-gate return (result);
10747c478bd9Sstevel@tonic-gate
10757c478bd9Sstevel@tonic-gate rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0;
10767c478bd9Sstevel@tonic-gate rpr->rpr_type[sizeof (rpr->rpr_type) - 1] = 0;
10777c478bd9Sstevel@tonic-gate
10787c478bd9Sstevel@tonic-gate if (child->re_changeid == rpr->rpr_changeid) {
10797c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
10807c478bd9Sstevel@tonic-gate } else {
10817c478bd9Sstevel@tonic-gate result = rc_node_create_child_pg(&parent->re_node,
10827c478bd9Sstevel@tonic-gate child->re_type, rpr->rpr_name, rpr->rpr_type,
10837c478bd9Sstevel@tonic-gate rpr->rpr_flags, &child->re_node);
10847c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
10857c478bd9Sstevel@tonic-gate child->re_changeid = rpr->rpr_changeid;
10867c478bd9Sstevel@tonic-gate }
10877c478bd9Sstevel@tonic-gate
10887c478bd9Sstevel@tonic-gate entity_release(parent);
10897c478bd9Sstevel@tonic-gate entity_release(child);
10907c478bd9Sstevel@tonic-gate
10917c478bd9Sstevel@tonic-gate return (result);
10927c478bd9Sstevel@tonic-gate }
10937c478bd9Sstevel@tonic-gate
10947c478bd9Sstevel@tonic-gate static int
entity_delete(repcache_client_t * cp,struct rep_protocol_entity_delete * rpr)10957c478bd9Sstevel@tonic-gate entity_delete(repcache_client_t *cp,
10967c478bd9Sstevel@tonic-gate struct rep_protocol_entity_delete *rpr)
10977c478bd9Sstevel@tonic-gate {
10987c478bd9Sstevel@tonic-gate repcache_entity_t *entity;
10997c478bd9Sstevel@tonic-gate
11007c478bd9Sstevel@tonic-gate uint32_t entityid = rpr->rpr_entityid;
11017c478bd9Sstevel@tonic-gate
11027c478bd9Sstevel@tonic-gate int result;
11037c478bd9Sstevel@tonic-gate
11047c478bd9Sstevel@tonic-gate if (rpr->rpr_changeid == INVALID_CHANGEID)
11057c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
11067c478bd9Sstevel@tonic-gate
11077c478bd9Sstevel@tonic-gate entity = entity_find(cp, entityid);
11087c478bd9Sstevel@tonic-gate
11097c478bd9Sstevel@tonic-gate if (entity == NULL)
11107c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
11117c478bd9Sstevel@tonic-gate
11127c478bd9Sstevel@tonic-gate if (entity->re_changeid == rpr->rpr_changeid) {
11137c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
11147c478bd9Sstevel@tonic-gate } else {
11157c478bd9Sstevel@tonic-gate result = rc_node_delete(&entity->re_node);
11167c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
11177c478bd9Sstevel@tonic-gate entity->re_changeid = rpr->rpr_changeid;
11187c478bd9Sstevel@tonic-gate }
11197c478bd9Sstevel@tonic-gate
11207c478bd9Sstevel@tonic-gate entity_release(entity);
11217c478bd9Sstevel@tonic-gate
11227c478bd9Sstevel@tonic-gate return (result);
11237c478bd9Sstevel@tonic-gate }
11247c478bd9Sstevel@tonic-gate
11257c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
entity_teardown(repcache_client_t * cp,struct rep_protocol_entity_teardown * rpr)11267c478bd9Sstevel@tonic-gate entity_teardown(repcache_client_t *cp, struct rep_protocol_entity_teardown *rpr)
11277c478bd9Sstevel@tonic-gate {
11287c478bd9Sstevel@tonic-gate entity_remove(cp, rpr->rpr_entityid);
11297c478bd9Sstevel@tonic-gate
11307c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
11317c478bd9Sstevel@tonic-gate }
11327c478bd9Sstevel@tonic-gate
11337c478bd9Sstevel@tonic-gate /*
11347c478bd9Sstevel@tonic-gate * Fails with
11357c478bd9Sstevel@tonic-gate * _MISORDERED - the iterator exists and is not reset
11367c478bd9Sstevel@tonic-gate * _NO_RESOURCES - out of memory
11377c478bd9Sstevel@tonic-gate */
11387c478bd9Sstevel@tonic-gate static int
iter_setup(repcache_client_t * cp,struct rep_protocol_iter_request * rpr)11397c478bd9Sstevel@tonic-gate iter_setup(repcache_client_t *cp, struct rep_protocol_iter_request *rpr)
11407c478bd9Sstevel@tonic-gate {
11417c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
11427c478bd9Sstevel@tonic-gate uint32_t sequence;
11437c478bd9Sstevel@tonic-gate
11447c478bd9Sstevel@tonic-gate client_start_insert(cp);
11457c478bd9Sstevel@tonic-gate /*
11467c478bd9Sstevel@tonic-gate * If the iter already exists, and hasn't been read from,
11477c478bd9Sstevel@tonic-gate * we assume the previous call succeeded.
11487c478bd9Sstevel@tonic-gate */
11497c478bd9Sstevel@tonic-gate if ((iter = iter_find(cp, rpr->rpr_iterid)) != NULL) {
11507c478bd9Sstevel@tonic-gate sequence = iter->ri_sequence;
11517c478bd9Sstevel@tonic-gate iter_release(iter);
11527c478bd9Sstevel@tonic-gate
11537c478bd9Sstevel@tonic-gate client_end_insert(cp);
11547c478bd9Sstevel@tonic-gate
11557c478bd9Sstevel@tonic-gate if (sequence != 0)
11567c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_MISORDERED);
11577c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
11587c478bd9Sstevel@tonic-gate }
11597c478bd9Sstevel@tonic-gate
11607c478bd9Sstevel@tonic-gate iter = iter_alloc(cp);
11617c478bd9Sstevel@tonic-gate if (iter == NULL) {
11627c478bd9Sstevel@tonic-gate client_end_insert(cp);
11637c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_NO_RESOURCES);
11647c478bd9Sstevel@tonic-gate }
11657c478bd9Sstevel@tonic-gate
11667c478bd9Sstevel@tonic-gate iter->ri_id = rpr->rpr_iterid;
11677c478bd9Sstevel@tonic-gate iter->ri_type = REP_PROTOCOL_TYPE_INVALID;
11687c478bd9Sstevel@tonic-gate iter->ri_sequence = 0;
11697c478bd9Sstevel@tonic-gate iter_add(cp, iter);
11707c478bd9Sstevel@tonic-gate
11717c478bd9Sstevel@tonic-gate client_end_insert(cp);
11727c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
11737c478bd9Sstevel@tonic-gate }
11747c478bd9Sstevel@tonic-gate
11757c478bd9Sstevel@tonic-gate /*
11767c478bd9Sstevel@tonic-gate * Fails with
11777c478bd9Sstevel@tonic-gate * _UNKNOWN_ID
11787c478bd9Sstevel@tonic-gate * _MISORDERED - iterator has already been started
11797c478bd9Sstevel@tonic-gate * _NOT_SET
11807c478bd9Sstevel@tonic-gate * _DELETED
11817c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - entity cannot have type children
11827c478bd9Sstevel@tonic-gate * _BAD_REQUEST - rpr_flags is invalid
11837c478bd9Sstevel@tonic-gate * rpr_pattern is invalid
11847c478bd9Sstevel@tonic-gate * _NO_RESOURCES
11857c478bd9Sstevel@tonic-gate * _INVALID_TYPE
11867c478bd9Sstevel@tonic-gate * _BACKEND_ACCESS
11877c478bd9Sstevel@tonic-gate */
11887c478bd9Sstevel@tonic-gate static int
iter_start(repcache_client_t * cp,struct rep_protocol_iter_start * rpr)11897c478bd9Sstevel@tonic-gate iter_start(repcache_client_t *cp, struct rep_protocol_iter_start *rpr)
11907c478bd9Sstevel@tonic-gate {
11917c478bd9Sstevel@tonic-gate int result;
11927c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
11937c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
11947c478bd9Sstevel@tonic-gate
11957c478bd9Sstevel@tonic-gate result = iter_find_w_entity(cp, rpr->rpr_iterid, &iter,
11967c478bd9Sstevel@tonic-gate rpr->rpr_entity, &ep);
11977c478bd9Sstevel@tonic-gate
11987c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
11997c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
12007c478bd9Sstevel@tonic-gate
12017c478bd9Sstevel@tonic-gate if (iter->ri_sequence > 1) {
12027c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_MISORDERED;
12037c478bd9Sstevel@tonic-gate goto end;
12047c478bd9Sstevel@tonic-gate }
12057c478bd9Sstevel@tonic-gate
12067c478bd9Sstevel@tonic-gate if (iter->ri_sequence == 1) {
12077c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
12087c478bd9Sstevel@tonic-gate goto end;
12097c478bd9Sstevel@tonic-gate }
12107c478bd9Sstevel@tonic-gate
12117c478bd9Sstevel@tonic-gate rpr->rpr_pattern[sizeof (rpr->rpr_pattern) - 1] = 0;
12127c478bd9Sstevel@tonic-gate
12137c478bd9Sstevel@tonic-gate result = rc_node_setup_iter(&ep->re_node, &iter->ri_iter,
12147c478bd9Sstevel@tonic-gate rpr->rpr_itertype, rpr->rpr_flags, rpr->rpr_pattern);
12157c478bd9Sstevel@tonic-gate
12167c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
12177c478bd9Sstevel@tonic-gate iter->ri_sequence++;
12187c478bd9Sstevel@tonic-gate
12197c478bd9Sstevel@tonic-gate end:
12207c478bd9Sstevel@tonic-gate iter_release(iter);
12217c478bd9Sstevel@tonic-gate entity_release(ep);
12227c478bd9Sstevel@tonic-gate return (result);
12237c478bd9Sstevel@tonic-gate }
12247c478bd9Sstevel@tonic-gate
12257c478bd9Sstevel@tonic-gate /*
12267c478bd9Sstevel@tonic-gate * Returns
12277c478bd9Sstevel@tonic-gate * _UNKNOWN_ID
12287c478bd9Sstevel@tonic-gate * _NOT_SET - iter has not been started
12297c478bd9Sstevel@tonic-gate * _MISORDERED
12307c478bd9Sstevel@tonic-gate * _BAD_REQUEST - iter walks values
12317c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - iter does not walk type entities
12327c478bd9Sstevel@tonic-gate * _DELETED - parent was deleted
12337c478bd9Sstevel@tonic-gate * _NO_RESOURCES
12347c478bd9Sstevel@tonic-gate * _INVALID_TYPE - type is invalid
12357c478bd9Sstevel@tonic-gate * _DONE
12367c478bd9Sstevel@tonic-gate * _SUCCESS
12377c478bd9Sstevel@tonic-gate *
12387c478bd9Sstevel@tonic-gate * For composed property group iterators, can also return
12397c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - parent cannot have type children
12407c478bd9Sstevel@tonic-gate * _BACKEND_ACCESS
12417c478bd9Sstevel@tonic-gate */
12427c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
iter_read(repcache_client_t * cp,struct rep_protocol_iter_read * rpr)12437c478bd9Sstevel@tonic-gate iter_read(repcache_client_t *cp, struct rep_protocol_iter_read *rpr)
12447c478bd9Sstevel@tonic-gate {
12457c478bd9Sstevel@tonic-gate rep_protocol_responseid_t result;
12467c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
12477c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
12487c478bd9Sstevel@tonic-gate uint32_t sequence;
12497c478bd9Sstevel@tonic-gate
12507c478bd9Sstevel@tonic-gate result = iter_find_w_entity(cp, rpr->rpr_iterid, &iter,
12517c478bd9Sstevel@tonic-gate rpr->rpr_entityid, &ep);
12527c478bd9Sstevel@tonic-gate
12537c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
12547c478bd9Sstevel@tonic-gate return (result);
12557c478bd9Sstevel@tonic-gate
12567c478bd9Sstevel@tonic-gate sequence = rpr->rpr_sequence;
12577c478bd9Sstevel@tonic-gate
12587c478bd9Sstevel@tonic-gate if (iter->ri_sequence == 0) {
12597c478bd9Sstevel@tonic-gate iter_release(iter);
12607c478bd9Sstevel@tonic-gate entity_release(ep);
12617c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_NOT_SET);
12627c478bd9Sstevel@tonic-gate }
12637c478bd9Sstevel@tonic-gate
12647c478bd9Sstevel@tonic-gate if (sequence == 1) {
12657c478bd9Sstevel@tonic-gate iter_release(iter);
12667c478bd9Sstevel@tonic-gate entity_release(ep);
12677c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_MISORDERED);
12687c478bd9Sstevel@tonic-gate }
12697c478bd9Sstevel@tonic-gate
12707c478bd9Sstevel@tonic-gate if (sequence == iter->ri_sequence) {
12717c478bd9Sstevel@tonic-gate iter_release(iter);
12727c478bd9Sstevel@tonic-gate entity_release(ep);
12737c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
12747c478bd9Sstevel@tonic-gate }
12757c478bd9Sstevel@tonic-gate
12767c478bd9Sstevel@tonic-gate if (sequence == iter->ri_sequence + 1) {
12777c478bd9Sstevel@tonic-gate result = rc_iter_next(iter->ri_iter, &ep->re_node,
12787c478bd9Sstevel@tonic-gate ep->re_type);
12797c478bd9Sstevel@tonic-gate
12807c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
12817c478bd9Sstevel@tonic-gate iter->ri_sequence++;
12827c478bd9Sstevel@tonic-gate
12837c478bd9Sstevel@tonic-gate iter_release(iter);
12847c478bd9Sstevel@tonic-gate entity_release(ep);
12857c478bd9Sstevel@tonic-gate
12867c478bd9Sstevel@tonic-gate return (result);
12877c478bd9Sstevel@tonic-gate }
12887c478bd9Sstevel@tonic-gate
12897c478bd9Sstevel@tonic-gate iter_release(iter);
12907c478bd9Sstevel@tonic-gate entity_release(ep);
12917c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_MISORDERED);
12927c478bd9Sstevel@tonic-gate }
12937c478bd9Sstevel@tonic-gate
12947c478bd9Sstevel@tonic-gate /*ARGSUSED*/
12957c478bd9Sstevel@tonic-gate static void
iter_read_value(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)12967c478bd9Sstevel@tonic-gate iter_read_value(repcache_client_t *cp, const void *in, size_t insz,
12977c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
12987c478bd9Sstevel@tonic-gate {
12997c478bd9Sstevel@tonic-gate const struct rep_protocol_iter_read_value *rpr = in;
13007c478bd9Sstevel@tonic-gate struct rep_protocol_value_response *out = out_arg;
13017c478bd9Sstevel@tonic-gate rep_protocol_responseid_t result;
13027c478bd9Sstevel@tonic-gate
13037c478bd9Sstevel@tonic-gate repcache_iter_t *iter;
13047c478bd9Sstevel@tonic-gate uint32_t sequence;
13057c478bd9Sstevel@tonic-gate int repeat;
13067c478bd9Sstevel@tonic-gate
13077c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
13087c478bd9Sstevel@tonic-gate
13097c478bd9Sstevel@tonic-gate iter = iter_find(cp, rpr->rpr_iterid);
13107c478bd9Sstevel@tonic-gate
13117c478bd9Sstevel@tonic-gate if (iter == NULL) {
13127c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_UNKNOWN_ID;
13137c478bd9Sstevel@tonic-gate goto out;
13147c478bd9Sstevel@tonic-gate }
13157c478bd9Sstevel@tonic-gate
13167c478bd9Sstevel@tonic-gate sequence = rpr->rpr_sequence;
13177c478bd9Sstevel@tonic-gate
13187c478bd9Sstevel@tonic-gate if (iter->ri_sequence == 0) {
13197c478bd9Sstevel@tonic-gate iter_release(iter);
13207c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_NOT_SET;
13217c478bd9Sstevel@tonic-gate goto out;
13227c478bd9Sstevel@tonic-gate }
13237c478bd9Sstevel@tonic-gate
13247c478bd9Sstevel@tonic-gate repeat = (sequence == iter->ri_sequence);
13257c478bd9Sstevel@tonic-gate
13267c478bd9Sstevel@tonic-gate if (sequence == 1 || (!repeat && sequence != iter->ri_sequence + 1)) {
13277c478bd9Sstevel@tonic-gate iter_release(iter);
13287c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_MISORDERED;
13297c478bd9Sstevel@tonic-gate goto out;
13307c478bd9Sstevel@tonic-gate }
13317c478bd9Sstevel@tonic-gate
13327c478bd9Sstevel@tonic-gate result = rc_iter_next_value(iter->ri_iter, out, outsz, repeat);
13337c478bd9Sstevel@tonic-gate
13347c478bd9Sstevel@tonic-gate if (!repeat && result == REP_PROTOCOL_SUCCESS)
13357c478bd9Sstevel@tonic-gate iter->ri_sequence++;
13367c478bd9Sstevel@tonic-gate
13377c478bd9Sstevel@tonic-gate iter_release(iter);
13387c478bd9Sstevel@tonic-gate
13397c478bd9Sstevel@tonic-gate out:
13407c478bd9Sstevel@tonic-gate /*
13417c478bd9Sstevel@tonic-gate * If we fail, we only return the response code.
13427c478bd9Sstevel@tonic-gate * If we succeed, rc_iter_next_value has shortened *outsz
13437c478bd9Sstevel@tonic-gate * to only include the value bytes needed.
13447c478bd9Sstevel@tonic-gate */
13457c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS && result != REP_PROTOCOL_DONE)
13467c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
13477c478bd9Sstevel@tonic-gate
13487c478bd9Sstevel@tonic-gate out->rpr_response = result;
13497c478bd9Sstevel@tonic-gate }
13507c478bd9Sstevel@tonic-gate
13517c478bd9Sstevel@tonic-gate static int
iter_reset(repcache_client_t * cp,struct rep_protocol_iter_request * rpr)13527c478bd9Sstevel@tonic-gate iter_reset(repcache_client_t *cp, struct rep_protocol_iter_request *rpr)
13537c478bd9Sstevel@tonic-gate {
13547c478bd9Sstevel@tonic-gate repcache_iter_t *iter = iter_find(cp, rpr->rpr_iterid);
13557c478bd9Sstevel@tonic-gate
13567c478bd9Sstevel@tonic-gate if (iter == NULL)
13577c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_UNKNOWN_ID);
13587c478bd9Sstevel@tonic-gate
13597c478bd9Sstevel@tonic-gate if (iter->ri_sequence != 0) {
13607c478bd9Sstevel@tonic-gate iter->ri_sequence = 0;
13617c478bd9Sstevel@tonic-gate rc_iter_destroy(&iter->ri_iter);
13627c478bd9Sstevel@tonic-gate }
13637c478bd9Sstevel@tonic-gate iter_release(iter);
13647c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
13657c478bd9Sstevel@tonic-gate }
13667c478bd9Sstevel@tonic-gate
13677c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
iter_teardown(repcache_client_t * cp,struct rep_protocol_iter_request * rpr)13687c478bd9Sstevel@tonic-gate iter_teardown(repcache_client_t *cp, struct rep_protocol_iter_request *rpr)
13697c478bd9Sstevel@tonic-gate {
13707c478bd9Sstevel@tonic-gate iter_remove(cp, rpr->rpr_iterid);
13717c478bd9Sstevel@tonic-gate
13727c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
13737c478bd9Sstevel@tonic-gate }
13747c478bd9Sstevel@tonic-gate
13757c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
tx_start(repcache_client_t * cp,struct rep_protocol_transaction_start * rpr)13767c478bd9Sstevel@tonic-gate tx_start(repcache_client_t *cp, struct rep_protocol_transaction_start *rpr)
13777c478bd9Sstevel@tonic-gate {
13787c478bd9Sstevel@tonic-gate repcache_entity_t *tx;
13797c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
13807c478bd9Sstevel@tonic-gate rep_protocol_responseid_t result;
13817c478bd9Sstevel@tonic-gate
13827c478bd9Sstevel@tonic-gate uint32_t txid = rpr->rpr_entityid_tx;
13837c478bd9Sstevel@tonic-gate uint32_t epid = rpr->rpr_entityid;
13847c478bd9Sstevel@tonic-gate
13857c478bd9Sstevel@tonic-gate result = entity_find2(cp, txid, &tx, epid, &ep);
13867c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
13877c478bd9Sstevel@tonic-gate return (result);
13887c478bd9Sstevel@tonic-gate
13897c478bd9Sstevel@tonic-gate if (tx->re_txstate == REPCACHE_TX_SETUP) {
13907c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
13917c478bd9Sstevel@tonic-gate goto end;
13927c478bd9Sstevel@tonic-gate }
13937c478bd9Sstevel@tonic-gate if (tx->re_txstate != REPCACHE_TX_INIT) {
13947c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_MISORDERED;
13957c478bd9Sstevel@tonic-gate goto end;
13967c478bd9Sstevel@tonic-gate }
13977c478bd9Sstevel@tonic-gate
13987c478bd9Sstevel@tonic-gate result = rc_node_setup_tx(&ep->re_node, &tx->re_node);
13997c478bd9Sstevel@tonic-gate
14007c478bd9Sstevel@tonic-gate end:
14017c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
14027c478bd9Sstevel@tonic-gate tx->re_txstate = REPCACHE_TX_SETUP;
14037c478bd9Sstevel@tonic-gate else
14047c478bd9Sstevel@tonic-gate rc_node_clear(&tx->re_node, 0);
14057c478bd9Sstevel@tonic-gate
14067c478bd9Sstevel@tonic-gate entity_release(ep);
14077c478bd9Sstevel@tonic-gate entity_release(tx);
14087c478bd9Sstevel@tonic-gate return (result);
14097c478bd9Sstevel@tonic-gate }
14107c478bd9Sstevel@tonic-gate
14117c478bd9Sstevel@tonic-gate /*ARGSUSED*/
14127c478bd9Sstevel@tonic-gate static void
tx_commit(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)14137c478bd9Sstevel@tonic-gate tx_commit(repcache_client_t *cp, const void *in, size_t insz,
14147c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
14157c478bd9Sstevel@tonic-gate {
14167c478bd9Sstevel@tonic-gate struct rep_protocol_response *out = out_arg;
14177c478bd9Sstevel@tonic-gate const struct rep_protocol_transaction_commit *rpr = in;
14187c478bd9Sstevel@tonic-gate repcache_entity_t *tx;
14197c478bd9Sstevel@tonic-gate
14207c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
14217c478bd9Sstevel@tonic-gate assert(insz >= REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE);
14227c478bd9Sstevel@tonic-gate
14237c478bd9Sstevel@tonic-gate if (rpr->rpr_size != insz) {
14247c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_BAD_REQUEST;
14257c478bd9Sstevel@tonic-gate return;
14267c478bd9Sstevel@tonic-gate }
14277c478bd9Sstevel@tonic-gate
14287c478bd9Sstevel@tonic-gate tx = entity_find(cp, rpr->rpr_entityid);
14297c478bd9Sstevel@tonic-gate
14307c478bd9Sstevel@tonic-gate if (tx == NULL) {
14317c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID;
14327c478bd9Sstevel@tonic-gate return;
14337c478bd9Sstevel@tonic-gate }
14347c478bd9Sstevel@tonic-gate
14357c478bd9Sstevel@tonic-gate switch (tx->re_txstate) {
14367c478bd9Sstevel@tonic-gate case REPCACHE_TX_INIT:
14377c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_MISORDERED;
14387c478bd9Sstevel@tonic-gate break;
14397c478bd9Sstevel@tonic-gate
14407c478bd9Sstevel@tonic-gate case REPCACHE_TX_SETUP:
14417c478bd9Sstevel@tonic-gate out->rpr_response = rc_tx_commit(&tx->re_node, rpr->rpr_cmd,
14427c478bd9Sstevel@tonic-gate insz - REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE);
14437c478bd9Sstevel@tonic-gate
14447c478bd9Sstevel@tonic-gate if (out->rpr_response == REP_PROTOCOL_SUCCESS) {
14457c478bd9Sstevel@tonic-gate tx->re_txstate = REPCACHE_TX_COMMITTED;
14467c478bd9Sstevel@tonic-gate rc_node_clear(&tx->re_node, 0);
14477c478bd9Sstevel@tonic-gate }
14487c478bd9Sstevel@tonic-gate
14497c478bd9Sstevel@tonic-gate break;
14507c478bd9Sstevel@tonic-gate case REPCACHE_TX_COMMITTED:
14517c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_SUCCESS;
14527c478bd9Sstevel@tonic-gate break;
14537c478bd9Sstevel@tonic-gate default:
14547c478bd9Sstevel@tonic-gate assert(0); /* CAN'T HAPPEN */
14557c478bd9Sstevel@tonic-gate break;
14567c478bd9Sstevel@tonic-gate }
14577c478bd9Sstevel@tonic-gate
14587c478bd9Sstevel@tonic-gate entity_release(tx);
14597c478bd9Sstevel@tonic-gate }
14607c478bd9Sstevel@tonic-gate
14617c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
next_snaplevel(repcache_client_t * cp,struct rep_protocol_entity_pair * rpr)14627c478bd9Sstevel@tonic-gate next_snaplevel(repcache_client_t *cp, struct rep_protocol_entity_pair *rpr)
14637c478bd9Sstevel@tonic-gate {
14647c478bd9Sstevel@tonic-gate repcache_entity_t *src;
14657c478bd9Sstevel@tonic-gate repcache_entity_t *dest;
14667c478bd9Sstevel@tonic-gate
14677c478bd9Sstevel@tonic-gate uint32_t srcid = rpr->rpr_entity_src;
14687c478bd9Sstevel@tonic-gate uint32_t destid = rpr->rpr_entity_dst;
14697c478bd9Sstevel@tonic-gate
14707c478bd9Sstevel@tonic-gate int result;
14717c478bd9Sstevel@tonic-gate
14727c478bd9Sstevel@tonic-gate result = entity_find2(cp, srcid, &src, destid, &dest);
14737c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
14747c478bd9Sstevel@tonic-gate return (result);
14757c478bd9Sstevel@tonic-gate
14767c478bd9Sstevel@tonic-gate result = rc_node_next_snaplevel(&src->re_node, &dest->re_node);
14777c478bd9Sstevel@tonic-gate
14787c478bd9Sstevel@tonic-gate entity_release(src);
14797c478bd9Sstevel@tonic-gate entity_release(dest);
14807c478bd9Sstevel@tonic-gate
14817c478bd9Sstevel@tonic-gate return (result);
14827c478bd9Sstevel@tonic-gate }
14837c478bd9Sstevel@tonic-gate
14847c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
snapshot_take(repcache_client_t * cp,struct rep_protocol_snapshot_take * rpr)14857c478bd9Sstevel@tonic-gate snapshot_take(repcache_client_t *cp, struct rep_protocol_snapshot_take *rpr)
14867c478bd9Sstevel@tonic-gate {
14877c478bd9Sstevel@tonic-gate repcache_entity_t *src;
14887c478bd9Sstevel@tonic-gate uint32_t srcid = rpr->rpr_entityid_src;
14897c478bd9Sstevel@tonic-gate repcache_entity_t *dest;
14907c478bd9Sstevel@tonic-gate uint32_t destid = rpr->rpr_entityid_dest;
14917c478bd9Sstevel@tonic-gate
14927c478bd9Sstevel@tonic-gate int result;
14937c478bd9Sstevel@tonic-gate
14947c478bd9Sstevel@tonic-gate result = entity_find2(cp, srcid, &src, destid, &dest);
14957c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
14967c478bd9Sstevel@tonic-gate return (result);
14977c478bd9Sstevel@tonic-gate
14987c478bd9Sstevel@tonic-gate if (dest->re_type != REP_PROTOCOL_ENTITY_SNAPSHOT) {
14997c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_TYPE_MISMATCH;
15007c478bd9Sstevel@tonic-gate } else {
15017c478bd9Sstevel@tonic-gate rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0;
15027c478bd9Sstevel@tonic-gate
15037c478bd9Sstevel@tonic-gate if (rpr->rpr_flags == REP_SNAPSHOT_NEW)
15047c478bd9Sstevel@tonic-gate result = rc_snapshot_take_new(&src->re_node, NULL,
15057c478bd9Sstevel@tonic-gate NULL, rpr->rpr_name, &dest->re_node);
15067c478bd9Sstevel@tonic-gate else if (rpr->rpr_flags == REP_SNAPSHOT_ATTACH &&
15077c478bd9Sstevel@tonic-gate rpr->rpr_name[0] == 0)
15087c478bd9Sstevel@tonic-gate result = rc_snapshot_take_attach(&src->re_node,
15097c478bd9Sstevel@tonic-gate &dest->re_node);
15107c478bd9Sstevel@tonic-gate else
15117c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_BAD_REQUEST;
15127c478bd9Sstevel@tonic-gate }
15137c478bd9Sstevel@tonic-gate entity_release(src);
15147c478bd9Sstevel@tonic-gate entity_release(dest);
15157c478bd9Sstevel@tonic-gate
15167c478bd9Sstevel@tonic-gate return (result);
15177c478bd9Sstevel@tonic-gate }
15187c478bd9Sstevel@tonic-gate
15197c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
snapshot_take_named(repcache_client_t * cp,struct rep_protocol_snapshot_take_named * rpr)15207c478bd9Sstevel@tonic-gate snapshot_take_named(repcache_client_t *cp,
15217c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_take_named *rpr)
15227c478bd9Sstevel@tonic-gate {
15237c478bd9Sstevel@tonic-gate repcache_entity_t *src;
15247c478bd9Sstevel@tonic-gate uint32_t srcid = rpr->rpr_entityid_src;
15257c478bd9Sstevel@tonic-gate repcache_entity_t *dest;
15267c478bd9Sstevel@tonic-gate uint32_t destid = rpr->rpr_entityid_dest;
15277c478bd9Sstevel@tonic-gate
15287c478bd9Sstevel@tonic-gate int result;
15297c478bd9Sstevel@tonic-gate
15307c478bd9Sstevel@tonic-gate result = entity_find2(cp, srcid, &src, destid, &dest);
15317c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
15327c478bd9Sstevel@tonic-gate return (result);
15337c478bd9Sstevel@tonic-gate
15347c478bd9Sstevel@tonic-gate if (dest->re_type != REP_PROTOCOL_ENTITY_SNAPSHOT) {
15357c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_TYPE_MISMATCH;
15367c478bd9Sstevel@tonic-gate } else {
15377c478bd9Sstevel@tonic-gate rpr->rpr_svcname[sizeof (rpr->rpr_svcname) - 1] = 0;
15387c478bd9Sstevel@tonic-gate rpr->rpr_instname[sizeof (rpr->rpr_instname) - 1] = 0;
15397c478bd9Sstevel@tonic-gate rpr->rpr_name[sizeof (rpr->rpr_name) - 1] = 0;
15407c478bd9Sstevel@tonic-gate
15417c478bd9Sstevel@tonic-gate result = rc_snapshot_take_new(&src->re_node, rpr->rpr_svcname,
15427c478bd9Sstevel@tonic-gate rpr->rpr_instname, rpr->rpr_name, &dest->re_node);
15437c478bd9Sstevel@tonic-gate }
15447c478bd9Sstevel@tonic-gate entity_release(src);
15457c478bd9Sstevel@tonic-gate entity_release(dest);
15467c478bd9Sstevel@tonic-gate
15477c478bd9Sstevel@tonic-gate return (result);
15487c478bd9Sstevel@tonic-gate }
15497c478bd9Sstevel@tonic-gate
15507c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
snapshot_attach(repcache_client_t * cp,struct rep_protocol_snapshot_attach * rpr)15517c478bd9Sstevel@tonic-gate snapshot_attach(repcache_client_t *cp, struct rep_protocol_snapshot_attach *rpr)
15527c478bd9Sstevel@tonic-gate {
15537c478bd9Sstevel@tonic-gate repcache_entity_t *src;
15547c478bd9Sstevel@tonic-gate uint32_t srcid = rpr->rpr_entityid_src;
15557c478bd9Sstevel@tonic-gate repcache_entity_t *dest;
15567c478bd9Sstevel@tonic-gate uint32_t destid = rpr->rpr_entityid_dest;
15577c478bd9Sstevel@tonic-gate
15587c478bd9Sstevel@tonic-gate int result;
15597c478bd9Sstevel@tonic-gate
15607c478bd9Sstevel@tonic-gate result = entity_find2(cp, srcid, &src, destid, &dest);
15617c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
15627c478bd9Sstevel@tonic-gate return (result);
15637c478bd9Sstevel@tonic-gate
15647c478bd9Sstevel@tonic-gate result = rc_snapshot_attach(&src->re_node, &dest->re_node);
15657c478bd9Sstevel@tonic-gate
15667c478bd9Sstevel@tonic-gate entity_release(src);
15677c478bd9Sstevel@tonic-gate entity_release(dest);
15687c478bd9Sstevel@tonic-gate
15697c478bd9Sstevel@tonic-gate return (result);
15707c478bd9Sstevel@tonic-gate }
15717c478bd9Sstevel@tonic-gate
15727c478bd9Sstevel@tonic-gate /*ARGSUSED*/
15737c478bd9Sstevel@tonic-gate static void
property_get_type(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)15747c478bd9Sstevel@tonic-gate property_get_type(repcache_client_t *cp, const void *in, size_t insz,
15757c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
15767c478bd9Sstevel@tonic-gate {
15777c478bd9Sstevel@tonic-gate const struct rep_protocol_property_request *rpr = in;
15787c478bd9Sstevel@tonic-gate struct rep_protocol_integer_response *out = out_arg;
15797c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
15807c478bd9Sstevel@tonic-gate rep_protocol_value_type_t t = 0;
15817c478bd9Sstevel@tonic-gate
15827c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
15837c478bd9Sstevel@tonic-gate
15847c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
15857c478bd9Sstevel@tonic-gate
15867c478bd9Sstevel@tonic-gate if (ep == NULL) {
15877c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID;
15887c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
15897c478bd9Sstevel@tonic-gate return;
15907c478bd9Sstevel@tonic-gate }
15917c478bd9Sstevel@tonic-gate
15927c478bd9Sstevel@tonic-gate out->rpr_response = rc_node_get_property_type(&ep->re_node, &t);
15937c478bd9Sstevel@tonic-gate
15947c478bd9Sstevel@tonic-gate entity_release(ep);
15957c478bd9Sstevel@tonic-gate
15967c478bd9Sstevel@tonic-gate if (out->rpr_response != REP_PROTOCOL_SUCCESS)
15977c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
15987c478bd9Sstevel@tonic-gate else
15997c478bd9Sstevel@tonic-gate out->rpr_value = t;
16007c478bd9Sstevel@tonic-gate }
16017c478bd9Sstevel@tonic-gate
16027c478bd9Sstevel@tonic-gate /*
16037c478bd9Sstevel@tonic-gate * Fails with:
16047c478bd9Sstevel@tonic-gate * _UNKNOWN_ID - an id does not designate an active register
16057c478bd9Sstevel@tonic-gate * _NOT_SET - The property is not set
16067c478bd9Sstevel@tonic-gate * _DELETED - The property has been deleted
16077c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - The object is not a property
16087c478bd9Sstevel@tonic-gate * _NOT_FOUND - The property has no values.
16097c478bd9Sstevel@tonic-gate *
16107c478bd9Sstevel@tonic-gate * Succeeds with:
16117c478bd9Sstevel@tonic-gate * _SUCCESS - The property has 1 value.
16127c478bd9Sstevel@tonic-gate * _TRUNCATED - The property has >1 value.
16137c478bd9Sstevel@tonic-gate */
16147c478bd9Sstevel@tonic-gate /*ARGSUSED*/
16157c478bd9Sstevel@tonic-gate static void
property_get_value(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)16167c478bd9Sstevel@tonic-gate property_get_value(repcache_client_t *cp, const void *in, size_t insz,
16177c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
16187c478bd9Sstevel@tonic-gate {
16197c478bd9Sstevel@tonic-gate const struct rep_protocol_property_request *rpr = in;
16207c478bd9Sstevel@tonic-gate struct rep_protocol_value_response *out = out_arg;
16217c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
16227c478bd9Sstevel@tonic-gate
16237c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
16247c478bd9Sstevel@tonic-gate
16257c478bd9Sstevel@tonic-gate ep = entity_find(cp, rpr->rpr_entityid);
16267c478bd9Sstevel@tonic-gate if (ep == NULL) {
16277c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_UNKNOWN_ID;
16287c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
16297c478bd9Sstevel@tonic-gate return;
16307c478bd9Sstevel@tonic-gate }
16317c478bd9Sstevel@tonic-gate
16327c478bd9Sstevel@tonic-gate out->rpr_response = rc_node_get_property_value(&ep->re_node, out,
16337c478bd9Sstevel@tonic-gate outsz);
16347c478bd9Sstevel@tonic-gate
16357c478bd9Sstevel@tonic-gate entity_release(ep);
16367c478bd9Sstevel@tonic-gate
16377c478bd9Sstevel@tonic-gate /*
16387c478bd9Sstevel@tonic-gate * If we fail, we only return the response code.
16397c478bd9Sstevel@tonic-gate * If we succeed, rc_node_get_property_value has shortened *outsz
16407c478bd9Sstevel@tonic-gate * to only include the value bytes needed.
16417c478bd9Sstevel@tonic-gate */
16427c478bd9Sstevel@tonic-gate if (out->rpr_response != REP_PROTOCOL_SUCCESS &&
16437c478bd9Sstevel@tonic-gate out->rpr_response != REP_PROTOCOL_FAIL_TRUNCATED)
16447c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
16457c478bd9Sstevel@tonic-gate }
16467c478bd9Sstevel@tonic-gate
16477c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
propertygrp_notify(repcache_client_t * cp,struct rep_protocol_propertygrp_request * rpr,int * out_fd)16487c478bd9Sstevel@tonic-gate propertygrp_notify(repcache_client_t *cp,
16497c478bd9Sstevel@tonic-gate struct rep_protocol_propertygrp_request *rpr, int *out_fd)
16507c478bd9Sstevel@tonic-gate {
16517c478bd9Sstevel@tonic-gate int fds[2];
16527c478bd9Sstevel@tonic-gate int ours, theirs;
16537c478bd9Sstevel@tonic-gate
16547c478bd9Sstevel@tonic-gate rep_protocol_responseid_t result;
16557c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
16567c478bd9Sstevel@tonic-gate
16577c478bd9Sstevel@tonic-gate if (pipe(fds) < 0)
16587c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_NO_RESOURCES);
16597c478bd9Sstevel@tonic-gate
16607c478bd9Sstevel@tonic-gate ours = fds[0];
16617c478bd9Sstevel@tonic-gate theirs = fds[1];
16627c478bd9Sstevel@tonic-gate
16637c478bd9Sstevel@tonic-gate if ((ep = entity_find(cp, rpr->rpr_entityid)) == NULL) {
16647c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_UNKNOWN_ID;
16657c478bd9Sstevel@tonic-gate goto fail;
16667c478bd9Sstevel@tonic-gate }
16677c478bd9Sstevel@tonic-gate
16687c478bd9Sstevel@tonic-gate /*
16697c478bd9Sstevel@tonic-gate * While the following can race with other threads setting up a
16707c478bd9Sstevel@tonic-gate * notification, the worst that can happen is that our fd has
16717c478bd9Sstevel@tonic-gate * already been closed before we return.
16727c478bd9Sstevel@tonic-gate */
16737c478bd9Sstevel@tonic-gate result = rc_pg_notify_setup(&cp->rc_pg_notify, &ep->re_node,
16747c478bd9Sstevel@tonic-gate ours);
16757c478bd9Sstevel@tonic-gate
16767c478bd9Sstevel@tonic-gate entity_release(ep);
16777c478bd9Sstevel@tonic-gate
16787c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
16797c478bd9Sstevel@tonic-gate goto fail;
16807c478bd9Sstevel@tonic-gate
16817c478bd9Sstevel@tonic-gate *out_fd = theirs;
16827c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_SUCCESS);
16837c478bd9Sstevel@tonic-gate
16847c478bd9Sstevel@tonic-gate fail:
16857c478bd9Sstevel@tonic-gate (void) close(ours);
16867c478bd9Sstevel@tonic-gate (void) close(theirs);
16877c478bd9Sstevel@tonic-gate
16887c478bd9Sstevel@tonic-gate return (result);
16897c478bd9Sstevel@tonic-gate }
16907c478bd9Sstevel@tonic-gate
16917c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
client_add_notify(repcache_client_t * cp,struct rep_protocol_notify_request * rpr)16927c478bd9Sstevel@tonic-gate client_add_notify(repcache_client_t *cp,
16937c478bd9Sstevel@tonic-gate struct rep_protocol_notify_request *rpr)
16947c478bd9Sstevel@tonic-gate {
16957c478bd9Sstevel@tonic-gate rpr->rpr_pattern[sizeof (rpr->rpr_pattern) - 1] = 0;
16967c478bd9Sstevel@tonic-gate
16977c478bd9Sstevel@tonic-gate switch (rpr->rpr_type) {
16987c478bd9Sstevel@tonic-gate case REP_PROTOCOL_NOTIFY_PGNAME:
16997c478bd9Sstevel@tonic-gate return (rc_notify_info_add_name(&cp->rc_notify_info,
17007c478bd9Sstevel@tonic-gate rpr->rpr_pattern));
17017c478bd9Sstevel@tonic-gate
17027c478bd9Sstevel@tonic-gate case REP_PROTOCOL_NOTIFY_PGTYPE:
17037c478bd9Sstevel@tonic-gate return (rc_notify_info_add_type(&cp->rc_notify_info,
17047c478bd9Sstevel@tonic-gate rpr->rpr_pattern));
17057c478bd9Sstevel@tonic-gate
17067c478bd9Sstevel@tonic-gate default:
17077c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
17087c478bd9Sstevel@tonic-gate }
17097c478bd9Sstevel@tonic-gate }
17107c478bd9Sstevel@tonic-gate
17117c478bd9Sstevel@tonic-gate /*ARGSUSED*/
17127c478bd9Sstevel@tonic-gate static void
client_wait(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)17137c478bd9Sstevel@tonic-gate client_wait(repcache_client_t *cp, const void *in, size_t insz,
17147c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
17157c478bd9Sstevel@tonic-gate {
17167c478bd9Sstevel@tonic-gate int result;
17177c478bd9Sstevel@tonic-gate repcache_entity_t *ep;
17187c478bd9Sstevel@tonic-gate const struct rep_protocol_wait_request *rpr = in;
17197c478bd9Sstevel@tonic-gate struct rep_protocol_fmri_response *out = out_arg;
17207c478bd9Sstevel@tonic-gate
17217c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
17227c478bd9Sstevel@tonic-gate
17237c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
17247c478bd9Sstevel@tonic-gate if (cp->rc_notify_thr != 0) {
17257c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
17267c478bd9Sstevel@tonic-gate out->rpr_response = REP_PROTOCOL_FAIL_EXISTS;
17277c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
17287c478bd9Sstevel@tonic-gate return;
17297c478bd9Sstevel@tonic-gate }
17307c478bd9Sstevel@tonic-gate cp->rc_notify_thr = pthread_self();
17317c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
17327c478bd9Sstevel@tonic-gate
17337c478bd9Sstevel@tonic-gate result = rc_notify_info_wait(&cp->rc_notify_info, &cp->rc_notify_ptr,
17347c478bd9Sstevel@tonic-gate out->rpr_fmri, sizeof (out->rpr_fmri));
17357c478bd9Sstevel@tonic-gate
17367c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS) {
17377c478bd9Sstevel@tonic-gate if ((ep = entity_find(cp, rpr->rpr_entityid)) != NULL) {
17387c478bd9Sstevel@tonic-gate if (ep->re_type == REP_PROTOCOL_ENTITY_PROPERTYGRP) {
17397c478bd9Sstevel@tonic-gate rc_node_ptr_assign(&ep->re_node,
17407c478bd9Sstevel@tonic-gate &cp->rc_notify_ptr);
17417c478bd9Sstevel@tonic-gate } else {
17427c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_TYPE_MISMATCH;
17437c478bd9Sstevel@tonic-gate }
17447c478bd9Sstevel@tonic-gate entity_release(ep);
17457c478bd9Sstevel@tonic-gate } else {
17467c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_UNKNOWN_ID;
17477c478bd9Sstevel@tonic-gate }
17487c478bd9Sstevel@tonic-gate rc_node_clear(&cp->rc_notify_ptr, 0);
17497c478bd9Sstevel@tonic-gate }
17507c478bd9Sstevel@tonic-gate
17517c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
17527c478bd9Sstevel@tonic-gate assert(cp->rc_notify_thr == pthread_self());
17537c478bd9Sstevel@tonic-gate cp->rc_notify_thr = 0;
17547c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
17557c478bd9Sstevel@tonic-gate
17567c478bd9Sstevel@tonic-gate out->rpr_response = result;
17577c478bd9Sstevel@tonic-gate if (result != REP_PROTOCOL_SUCCESS)
17587c478bd9Sstevel@tonic-gate *outsz = sizeof (out->rpr_response);
17597c478bd9Sstevel@tonic-gate }
17607c478bd9Sstevel@tonic-gate
17617c478bd9Sstevel@tonic-gate /*
17627c478bd9Sstevel@tonic-gate * Can return:
17637c478bd9Sstevel@tonic-gate * _PERMISSION_DENIED not enough privileges to do request.
17647c478bd9Sstevel@tonic-gate * _BAD_REQUEST name is not valid or reserved
17657c478bd9Sstevel@tonic-gate * _TRUNCATED name is too long for current repository path
17667c478bd9Sstevel@tonic-gate * _UNKNOWN failed for unknown reason (details written to
17677c478bd9Sstevel@tonic-gate * console)
17687c478bd9Sstevel@tonic-gate * _BACKEND_READONLY backend is not writable
1769c0889d7aSstevep * _NO_RESOURCES out of memory
17707c478bd9Sstevel@tonic-gate * _SUCCESS Backup completed successfully.
17717c478bd9Sstevel@tonic-gate */
17727c478bd9Sstevel@tonic-gate static rep_protocol_responseid_t
backup_repository(repcache_client_t * cp,struct rep_protocol_backup_request * rpr)17737c478bd9Sstevel@tonic-gate backup_repository(repcache_client_t *cp,
17747c478bd9Sstevel@tonic-gate struct rep_protocol_backup_request *rpr)
17757c478bd9Sstevel@tonic-gate {
17767c478bd9Sstevel@tonic-gate rep_protocol_responseid_t result;
17777c478bd9Sstevel@tonic-gate ucred_t *uc = get_ucred();
17787c478bd9Sstevel@tonic-gate
17797c478bd9Sstevel@tonic-gate if (!client_is_privileged() && (uc == NULL || ucred_geteuid(uc) != 0))
17807c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_PERMISSION_DENIED);
17817c478bd9Sstevel@tonic-gate
17827c478bd9Sstevel@tonic-gate rpr->rpr_name[REP_PROTOCOL_NAME_LEN - 1] = 0;
17837c478bd9Sstevel@tonic-gate if (strcmp(rpr->rpr_name, REPOSITORY_BOOT_BACKUP) == 0)
17847c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_FAIL_BAD_REQUEST);
17857c478bd9Sstevel@tonic-gate
17867c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&cp->rc_lock);
17877c478bd9Sstevel@tonic-gate if (rpr->rpr_changeid != cp->rc_changeid) {
17887c478bd9Sstevel@tonic-gate result = backend_create_backup(rpr->rpr_name);
17897c478bd9Sstevel@tonic-gate if (result == REP_PROTOCOL_SUCCESS)
17907c478bd9Sstevel@tonic-gate cp->rc_changeid = rpr->rpr_changeid;
17917c478bd9Sstevel@tonic-gate } else {
17927c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
17937c478bd9Sstevel@tonic-gate }
17947c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&cp->rc_lock);
17957c478bd9Sstevel@tonic-gate
17967c478bd9Sstevel@tonic-gate return (result);
17977c478bd9Sstevel@tonic-gate }
17987c478bd9Sstevel@tonic-gate
17995b7f77adStw21770 /*
18005b7f77adStw21770 * This function captures the information that will be used for an
18015b7f77adStw21770 * annotation audit event. Specifically, it captures the operation to be
18025b7f77adStw21770 * performed and the name of the file that is being used. These values are
18035b7f77adStw21770 * copied from the rep_protocol_annotation request at rpr to the client
18045b7f77adStw21770 * structure. If both these values are null, the client is turning
18055b7f77adStw21770 * annotation off.
18065b7f77adStw21770 *
18075b7f77adStw21770 * Fails with
18085b7f77adStw21770 * _NO_RESOURCES - unable to allocate memory
18095b7f77adStw21770 */
18105b7f77adStw21770 static rep_protocol_responseid_t
set_annotation(repcache_client_t * cp,struct rep_protocol_annotation * rpr)18115b7f77adStw21770 set_annotation(repcache_client_t *cp, struct rep_protocol_annotation *rpr)
18125b7f77adStw21770 {
18135b7f77adStw21770 au_id_t audit_uid;
18145b7f77adStw21770 const char *file = NULL;
18155b7f77adStw21770 const char *old_ptrs[2];
18165b7f77adStw21770 const char *operation = NULL;
18175b7f77adStw21770 rep_protocol_responseid_t rc = REP_PROTOCOL_FAIL_NO_RESOURCES;
18185b7f77adStw21770 au_asid_t sessionid;
18195b7f77adStw21770
18205b7f77adStw21770 (void) memset((void *)old_ptrs, 0, sizeof (old_ptrs));
18215b7f77adStw21770
18225b7f77adStw21770 /* Copy rpr_operation and rpr_file if they are not empty strings. */
18235b7f77adStw21770 if (rpr->rpr_operation[0] != 0) {
18245b7f77adStw21770 /*
18255b7f77adStw21770 * Make sure that client did not send us an unterminated buffer.
18265b7f77adStw21770 */
18275b7f77adStw21770 rpr->rpr_operation[sizeof (rpr->rpr_operation) - 1] = 0;
18285b7f77adStw21770 if ((operation = strdup(rpr->rpr_operation)) == NULL)
18295b7f77adStw21770 goto out;
18305b7f77adStw21770 }
18315b7f77adStw21770 if (rpr->rpr_file[0] != 0) {
18325b7f77adStw21770 /*
18335b7f77adStw21770 * Make sure that client did not send us an unterminated buffer.
18345b7f77adStw21770 */
18355b7f77adStw21770 rpr->rpr_file[sizeof (rpr->rpr_file) - 1] = 0;
18365b7f77adStw21770 if ((file = strdup(rpr->rpr_file)) == NULL)
18375b7f77adStw21770 goto out;
18385b7f77adStw21770 }
18395b7f77adStw21770
18405b7f77adStw21770 (void) pthread_mutex_lock(&cp->rc_annotate_lock);
18415b7f77adStw21770 /* Save addresses of memory to free when not locked */
18425b7f77adStw21770 old_ptrs[0] = cp->rc_operation;
18435b7f77adStw21770 old_ptrs[1] = cp->rc_file;
18445b7f77adStw21770
18455b7f77adStw21770 /* Save pointers to annotation strings. */
18465b7f77adStw21770 cp->rc_operation = operation;
18475b7f77adStw21770 cp->rc_file = file;
18485b7f77adStw21770
18495b7f77adStw21770 /*
18505b7f77adStw21770 * Set annotation flag. Annotations should be turned on if either
18515b7f77adStw21770 * operation or file are not NULL.
18525b7f77adStw21770 */
18535b7f77adStw21770 cp->rc_annotate = (operation != NULL) || (file != NULL);
18545b7f77adStw21770 (void) pthread_mutex_unlock(&cp->rc_annotate_lock);
18555b7f77adStw21770
18565b7f77adStw21770 /*
18575b7f77adStw21770 * operation and file pointers are saved in cp, so don't free them
18585b7f77adStw21770 * during cleanup.
18595b7f77adStw21770 */
18605b7f77adStw21770 operation = NULL;
18615b7f77adStw21770 file = NULL;
18625b7f77adStw21770 rc = REP_PROTOCOL_SUCCESS;
18635b7f77adStw21770
18645b7f77adStw21770 /*
18655b7f77adStw21770 * Native builds are done to create svc.configd-native. This
18665b7f77adStw21770 * program runs only on the Open Solaris build machines to create
18675b7f77adStw21770 * the seed repository. Until the SMF auditing code is distributed
18685b7f77adStw21770 * to the Open Solaris build machines, adt_get_unique_id() in the
18695b7f77adStw21770 * following code is not a global function in libbsm. Hence the
18705b7f77adStw21770 * following conditional compilation.
18715b7f77adStw21770 */
18725b7f77adStw21770 #ifndef NATIVE_BUILD
18735b7f77adStw21770 /*
18745b7f77adStw21770 * Set the appropriate audit session id.
18755b7f77adStw21770 */
18765b7f77adStw21770 if (cp->rc_annotate) {
18775b7f77adStw21770 /*
18785b7f77adStw21770 * We're starting a group of annotated audit events, so
18795b7f77adStw21770 * create and set an audit session ID for this annotation.
18805b7f77adStw21770 */
18815b7f77adStw21770 adt_get_auid(cp->rc_adt_session, &audit_uid);
18825b7f77adStw21770 sessionid = adt_get_unique_id(audit_uid);
18835b7f77adStw21770 } else {
18845b7f77adStw21770 /*
18855b7f77adStw21770 * Annotation is done so restore our client audit session
18865b7f77adStw21770 * id.
18875b7f77adStw21770 */
18885b7f77adStw21770 sessionid = cp->rc_adt_sessionid;
18895b7f77adStw21770 }
18905b7f77adStw21770 adt_set_asid(cp->rc_adt_session, sessionid);
18915b7f77adStw21770 #endif /* NATIVE_BUILD */
18925b7f77adStw21770
18935b7f77adStw21770 out:
18945b7f77adStw21770 if (operation != NULL)
18955b7f77adStw21770 free((void *)operation);
18965b7f77adStw21770 if (file != NULL)
18975b7f77adStw21770 free((void *)file);
18985b7f77adStw21770 free((void *)old_ptrs[0]);
18995b7f77adStw21770 free((void *)old_ptrs[1]);
19005b7f77adStw21770 return (rc);
19015b7f77adStw21770 }
19025b7f77adStw21770
19035b7f77adStw21770 /*
19045b7f77adStw21770 * Determine if an annotation event needs to be generated. If it does
19055b7f77adStw21770 * provide the operation and file name that should be used in the event.
19065b7f77adStw21770 *
19075b7f77adStw21770 * Can return:
19085b7f77adStw21770 * 0 No annotation event needed or buffers are not large
19095b7f77adStw21770 * enough. Either way an event should not be
19105b7f77adStw21770 * generated.
19115b7f77adStw21770 * 1 Generate annotation event.
19125b7f77adStw21770 */
19135b7f77adStw21770 int
client_annotation_needed(char * operation,size_t oper_sz,char * file,size_t file_sz)19145b7f77adStw21770 client_annotation_needed(char *operation, size_t oper_sz,
19155b7f77adStw21770 char *file, size_t file_sz)
19165b7f77adStw21770 {
19175b7f77adStw21770 thread_info_t *ti = thread_self();
19185b7f77adStw21770 repcache_client_t *cp = ti->ti_active_client;
19195b7f77adStw21770 int rc = 0;
19205b7f77adStw21770
19215b7f77adStw21770 (void) pthread_mutex_lock(&cp->rc_annotate_lock);
19225b7f77adStw21770 if (cp->rc_annotate) {
19235b7f77adStw21770 rc = 1;
19245b7f77adStw21770 if (cp->rc_operation == NULL) {
19255b7f77adStw21770 if (oper_sz > 0)
19265b7f77adStw21770 operation[0] = 0;
19275b7f77adStw21770 } else {
19285b7f77adStw21770 if (strlcpy(operation, cp->rc_operation, oper_sz) >=
19295b7f77adStw21770 oper_sz) {
19305b7f77adStw21770 /* Buffer overflow, so do not generate event */
19315b7f77adStw21770 rc = 0;
19325b7f77adStw21770 }
19335b7f77adStw21770 }
19345b7f77adStw21770 if (cp->rc_file == NULL) {
19355b7f77adStw21770 if (file_sz > 0)
19365b7f77adStw21770 file[0] = 0;
19375b7f77adStw21770 } else if (rc == 1) {
19385b7f77adStw21770 if (strlcpy(file, cp->rc_file, file_sz) >= file_sz) {
19395b7f77adStw21770 /* Buffer overflow, so do not generate event */
19405b7f77adStw21770 rc = 0;
19415b7f77adStw21770 }
19425b7f77adStw21770 }
19435b7f77adStw21770 }
19445b7f77adStw21770 (void) pthread_mutex_unlock(&cp->rc_annotate_lock);
19455b7f77adStw21770 return (rc);
19465b7f77adStw21770 }
19475b7f77adStw21770
19485b7f77adStw21770 void
client_annotation_finished()19495b7f77adStw21770 client_annotation_finished()
19505b7f77adStw21770 {
19515b7f77adStw21770 thread_info_t *ti = thread_self();
19525b7f77adStw21770 repcache_client_t *cp = ti->ti_active_client;
19535b7f77adStw21770
19545b7f77adStw21770 (void) pthread_mutex_lock(&cp->rc_annotate_lock);
19555b7f77adStw21770 cp->rc_annotate = 0;
19565b7f77adStw21770 (void) pthread_mutex_unlock(&cp->rc_annotate_lock);
19575b7f77adStw21770 }
19585b7f77adStw21770
19596970e7c5SAndrew Stormont #ifndef NATIVE_BUILD
19605b7f77adStw21770 static void
start_audit_session(repcache_client_t * cp)19615b7f77adStw21770 start_audit_session(repcache_client_t *cp)
19625b7f77adStw21770 {
19635b7f77adStw21770 ucred_t *cred = NULL;
19645b7f77adStw21770 adt_session_data_t *session;
19655b7f77adStw21770
1966a4dc1477STom Whitten /*
1967a4dc1477STom Whitten * A NULL session pointer value can legally be used in all
1968a4dc1477STom Whitten * subsequent calls to adt_* functions.
1969a4dc1477STom Whitten */
1970a4dc1477STom Whitten cp->rc_adt_session = NULL;
1971a4dc1477STom Whitten
1972a9173115SMarek Pospisil if (!adt_audit_state(AUC_AUDITING))
1973a9173115SMarek Pospisil return;
1974a9173115SMarek Pospisil
1975a4dc1477STom Whitten if (door_ucred(&cred) != 0) {
1976a4dc1477STom Whitten switch (errno) {
1977a4dc1477STom Whitten case EAGAIN:
1978a4dc1477STom Whitten case ENOMEM:
19795b7f77adStw21770 syslog(LOG_ERR, gettext("start_audit_session(): cannot "
19805b7f77adStw21770 "get ucred. %m\n"));
1981a4dc1477STom Whitten return;
1982a4dc1477STom Whitten case EINVAL:
19835b7f77adStw21770 /*
1984a4dc1477STom Whitten * Door client went away. This is a normal,
1985a4dc1477STom Whitten * although infrequent event, so there is no need
1986a4dc1477STom Whitten * to create a syslog message.
19875b7f77adStw21770 */
1988a4dc1477STom Whitten return;
1989a4dc1477STom Whitten case EFAULT:
1990a4dc1477STom Whitten default:
1991a4dc1477STom Whitten bad_error("door_ucred", errno);
1992a4dc1477STom Whitten }
1993a4dc1477STom Whitten }
1994a4dc1477STom Whitten if (adt_start_session(&session, NULL, 0) != 0) {
19955b7f77adStw21770 syslog(LOG_ERR, gettext("start_audit_session(): could not "
19965b7f77adStw21770 "start audit session.\n"));
1997a4dc1477STom Whitten ucred_free(cred);
1998a4dc1477STom Whitten return;
19995b7f77adStw21770 }
2000a4dc1477STom Whitten if (adt_set_from_ucred(session, cred, ADT_NEW) != 0) {
20015b7f77adStw21770 syslog(LOG_ERR, gettext("start_audit_session(): cannot set "
20025b7f77adStw21770 "audit session data from ucred\n"));
2003a4dc1477STom Whitten /* Something went wrong. End the session. */
2004a4dc1477STom Whitten (void) adt_end_session(session);
2005a4dc1477STom Whitten ucred_free(cred);
2006a4dc1477STom Whitten return;
20075b7f77adStw21770 }
2008a4dc1477STom Whitten
20095b7f77adStw21770 /* All went well. Save the session data and session ID */
20105b7f77adStw21770 cp->rc_adt_session = session;
20115b7f77adStw21770 adt_get_asid(session, &cp->rc_adt_sessionid);
20125b7f77adStw21770
20135b7f77adStw21770 ucred_free(cred);
20145b7f77adStw21770 }
20156970e7c5SAndrew Stormont #endif
20167c478bd9Sstevel@tonic-gate
2017c0889d7aSstevep /*
2018c0889d7aSstevep * Handle switch client request
2019c0889d7aSstevep *
2020c0889d7aSstevep * This routine can return:
2021c0889d7aSstevep *
2022c0889d7aSstevep * _PERMISSION_DENIED not enough privileges to do request.
2023c0889d7aSstevep * _UNKNOWN file operation error (details written to
2024c0889d7aSstevep * the console).
2025c0889d7aSstevep * _SUCCESS switch operation is completed.
2026c0889d7aSstevep * _BACKEND_ACCESS backend access fails.
2027c0889d7aSstevep * _NO_RESOURCES out of memory.
2028c0889d7aSstevep * _BACKEND_READONLY backend is not writable.
2029c0889d7aSstevep */
2030c0889d7aSstevep static rep_protocol_responseid_t
repository_switch(repcache_client_t * cp,struct rep_protocol_switch_request * rpr)2031c0889d7aSstevep repository_switch(repcache_client_t *cp,
2032c0889d7aSstevep struct rep_protocol_switch_request *rpr)
2033c0889d7aSstevep {
2034c0889d7aSstevep rep_protocol_responseid_t result;
2035c0889d7aSstevep ucred_t *uc = get_ucred();
2036c0889d7aSstevep
2037c0889d7aSstevep if (!client_is_privileged() && (uc == NULL ||
2038c0889d7aSstevep ucred_geteuid(uc) != 0)) {
2039c0889d7aSstevep return (REP_PROTOCOL_FAIL_PERMISSION_DENIED);
2040c0889d7aSstevep }
2041c0889d7aSstevep
2042c0889d7aSstevep (void) pthread_mutex_lock(&cp->rc_lock);
2043c0889d7aSstevep if (rpr->rpr_changeid != cp->rc_changeid) {
2044c0889d7aSstevep if ((result = backend_switch(rpr->rpr_flag)) ==
2045c0889d7aSstevep REP_PROTOCOL_SUCCESS)
2046c0889d7aSstevep cp->rc_changeid = rpr->rpr_changeid;
2047c0889d7aSstevep } else {
2048c0889d7aSstevep result = REP_PROTOCOL_SUCCESS;
2049c0889d7aSstevep }
2050c0889d7aSstevep (void) pthread_mutex_unlock(&cp->rc_lock);
2051c0889d7aSstevep
2052c0889d7aSstevep return (result);
2053c0889d7aSstevep }
2054c0889d7aSstevep
20557c478bd9Sstevel@tonic-gate typedef rep_protocol_responseid_t protocol_simple_f(repcache_client_t *cp,
20567c478bd9Sstevel@tonic-gate const void *rpr);
20577c478bd9Sstevel@tonic-gate
20587c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20597c478bd9Sstevel@tonic-gate static void
simple_handler(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg)20607c478bd9Sstevel@tonic-gate simple_handler(repcache_client_t *cp, const void *in, size_t insz,
20617c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg)
20627c478bd9Sstevel@tonic-gate {
20637c478bd9Sstevel@tonic-gate protocol_simple_f *f = (protocol_simple_f *)arg;
20647c478bd9Sstevel@tonic-gate rep_protocol_response_t *out = out_arg;
20657c478bd9Sstevel@tonic-gate
20667c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
20677c478bd9Sstevel@tonic-gate assert(f != NULL);
20687c478bd9Sstevel@tonic-gate
20697c478bd9Sstevel@tonic-gate out->rpr_response = (*f)(cp, in);
20707c478bd9Sstevel@tonic-gate }
20717c478bd9Sstevel@tonic-gate
20727c478bd9Sstevel@tonic-gate typedef rep_protocol_responseid_t protocol_simple_fd_f(repcache_client_t *cp,
20737c478bd9Sstevel@tonic-gate const void *rpr, int *out_fd);
20747c478bd9Sstevel@tonic-gate
20757c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20767c478bd9Sstevel@tonic-gate static void
simple_fd_handler(repcache_client_t * cp,const void * in,size_t insz,void * out_arg,size_t * outsz,void * arg,int * out_fd)20777c478bd9Sstevel@tonic-gate simple_fd_handler(repcache_client_t *cp, const void *in, size_t insz,
20787c478bd9Sstevel@tonic-gate void *out_arg, size_t *outsz, void *arg, int *out_fd)
20797c478bd9Sstevel@tonic-gate {
20807c478bd9Sstevel@tonic-gate protocol_simple_fd_f *f = (protocol_simple_fd_f *)arg;
20817c478bd9Sstevel@tonic-gate rep_protocol_response_t *out = out_arg;
20827c478bd9Sstevel@tonic-gate
20837c478bd9Sstevel@tonic-gate assert(*outsz == sizeof (*out));
20847c478bd9Sstevel@tonic-gate assert(f != NULL);
20857c478bd9Sstevel@tonic-gate
20867c478bd9Sstevel@tonic-gate out->rpr_response = (*f)(cp, in, out_fd);
20877c478bd9Sstevel@tonic-gate }
20887c478bd9Sstevel@tonic-gate
20897c478bd9Sstevel@tonic-gate typedef void protocol_handler_f(repcache_client_t *, const void *in,
20907c478bd9Sstevel@tonic-gate size_t insz, void *out, size_t *outsz, void *arg);
20917c478bd9Sstevel@tonic-gate
20927c478bd9Sstevel@tonic-gate typedef void protocol_handler_fdret_f(repcache_client_t *, const void *in,
20937c478bd9Sstevel@tonic-gate size_t insz, void *out, size_t *outsz, void *arg, int *fd_out);
20947c478bd9Sstevel@tonic-gate
20957c478bd9Sstevel@tonic-gate #define PROTO(p, f, in) { \
20967c478bd9Sstevel@tonic-gate p, #p, simple_handler, (void *)(&f), NULL, \
20977c478bd9Sstevel@tonic-gate sizeof (in), sizeof (rep_protocol_response_t), 0 \
20987c478bd9Sstevel@tonic-gate }
20997c478bd9Sstevel@tonic-gate
21007c478bd9Sstevel@tonic-gate #define PROTO_FD_OUT(p, f, in) { \
21017c478bd9Sstevel@tonic-gate p, #p, NULL, (void *)(&f), simple_fd_handler, \
21027c478bd9Sstevel@tonic-gate sizeof (in), \
21037c478bd9Sstevel@tonic-gate sizeof (rep_protocol_response_t), \
21047c478bd9Sstevel@tonic-gate PROTO_FLAG_RETFD \
21057c478bd9Sstevel@tonic-gate }
21067c478bd9Sstevel@tonic-gate
21077c478bd9Sstevel@tonic-gate #define PROTO_VARIN(p, f, insz) { \
21087c478bd9Sstevel@tonic-gate p, #p, &(f), NULL, NULL, \
21097c478bd9Sstevel@tonic-gate insz, sizeof (rep_protocol_response_t), \
21107c478bd9Sstevel@tonic-gate PROTO_FLAG_VARINPUT \
21117c478bd9Sstevel@tonic-gate }
21127c478bd9Sstevel@tonic-gate
21137c478bd9Sstevel@tonic-gate #define PROTO_UINT_OUT(p, f, in) { \
21147c478bd9Sstevel@tonic-gate p, #p, &(f), NULL, NULL, \
21157c478bd9Sstevel@tonic-gate sizeof (in), \
21167c478bd9Sstevel@tonic-gate sizeof (struct rep_protocol_integer_response), 0 \
21177c478bd9Sstevel@tonic-gate }
21187c478bd9Sstevel@tonic-gate
21197c478bd9Sstevel@tonic-gate #define PROTO_NAME_OUT(p, f, in) { \
21207c478bd9Sstevel@tonic-gate p, #p, &(f), NULL, NULL, \
21217c478bd9Sstevel@tonic-gate sizeof (in), \
21227c478bd9Sstevel@tonic-gate sizeof (struct rep_protocol_name_response), 0 \
21237c478bd9Sstevel@tonic-gate }
21247c478bd9Sstevel@tonic-gate
21257c478bd9Sstevel@tonic-gate #define PROTO_FMRI_OUT(p, f, in) { \
21267c478bd9Sstevel@tonic-gate p, #p, &(f), NULL, NULL, \
21277c478bd9Sstevel@tonic-gate sizeof (in), \
21287c478bd9Sstevel@tonic-gate sizeof (struct rep_protocol_fmri_response), 0 \
21297c478bd9Sstevel@tonic-gate }
21307c478bd9Sstevel@tonic-gate
21317c478bd9Sstevel@tonic-gate #define PROTO_VALUE_OUT(p, f, in) { \
21327c478bd9Sstevel@tonic-gate p, #p, &(f), NULL, NULL, \
21337c478bd9Sstevel@tonic-gate sizeof (in), \
21347c478bd9Sstevel@tonic-gate sizeof (struct rep_protocol_value_response), 0 \
21357c478bd9Sstevel@tonic-gate }
21367c478bd9Sstevel@tonic-gate
21377c478bd9Sstevel@tonic-gate #define PROTO_PANIC(p) { p, #p, NULL, NULL, NULL, 0, 0, PROTO_FLAG_PANIC }
21387c478bd9Sstevel@tonic-gate #define PROTO_END() { 0, NULL, NULL, NULL, NULL, 0, 0, PROTO_FLAG_PANIC }
21397c478bd9Sstevel@tonic-gate
21407c478bd9Sstevel@tonic-gate #define PROTO_FLAG_PANIC 0x00000001 /* should never be called */
21417c478bd9Sstevel@tonic-gate #define PROTO_FLAG_VARINPUT 0x00000004 /* in_size is minimum size */
21427c478bd9Sstevel@tonic-gate #define PROTO_FLAG_RETFD 0x00000008 /* can also return an FD */
21437c478bd9Sstevel@tonic-gate
21447c478bd9Sstevel@tonic-gate #define PROTO_ALL_FLAGS 0x0000000f /* all flags */
21457c478bd9Sstevel@tonic-gate
21467c478bd9Sstevel@tonic-gate static struct protocol_entry {
21477c478bd9Sstevel@tonic-gate enum rep_protocol_requestid pt_request;
21487c478bd9Sstevel@tonic-gate const char *pt_name;
21497c478bd9Sstevel@tonic-gate protocol_handler_f *pt_handler;
21507c478bd9Sstevel@tonic-gate void *pt_arg;
21517c478bd9Sstevel@tonic-gate protocol_handler_fdret_f *pt_fd_handler;
21527c478bd9Sstevel@tonic-gate size_t pt_in_size;
21537c478bd9Sstevel@tonic-gate size_t pt_out_max;
21547c478bd9Sstevel@tonic-gate uint32_t pt_flags;
21557c478bd9Sstevel@tonic-gate } protocol_table[] = {
21567c478bd9Sstevel@tonic-gate PROTO_PANIC(REP_PROTOCOL_CLOSE), /* special case */
21577c478bd9Sstevel@tonic-gate
21587c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_SETUP, entity_setup,
21597c478bd9Sstevel@tonic-gate struct rep_protocol_entity_setup),
21607c478bd9Sstevel@tonic-gate PROTO_NAME_OUT(REP_PROTOCOL_ENTITY_NAME, entity_name,
21617c478bd9Sstevel@tonic-gate struct rep_protocol_entity_name),
21627c478bd9Sstevel@tonic-gate PROTO_UINT_OUT(REP_PROTOCOL_ENTITY_PARENT_TYPE, entity_parent_type,
21637c478bd9Sstevel@tonic-gate struct rep_protocol_entity_parent_type),
21647c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_GET_CHILD, entity_get_child,
21657c478bd9Sstevel@tonic-gate struct rep_protocol_entity_get_child),
21667c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_GET_PARENT, entity_get_parent,
21677c478bd9Sstevel@tonic-gate struct rep_protocol_entity_parent),
21687c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_GET, entity_get,
21697c478bd9Sstevel@tonic-gate struct rep_protocol_entity_get),
21707c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_UPDATE, entity_update,
21717c478bd9Sstevel@tonic-gate struct rep_protocol_entity_update),
21727c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_CREATE_CHILD, entity_create_child,
21737c478bd9Sstevel@tonic-gate struct rep_protocol_entity_create_child),
21747c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_CREATE_PG, entity_create_pg,
21757c478bd9Sstevel@tonic-gate struct rep_protocol_entity_create_pg),
21767c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_DELETE, entity_delete,
21777c478bd9Sstevel@tonic-gate struct rep_protocol_entity_delete),
21787c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_RESET, entity_reset,
21797c478bd9Sstevel@tonic-gate struct rep_protocol_entity_reset),
21807c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ENTITY_TEARDOWN, entity_teardown,
21817c478bd9Sstevel@tonic-gate struct rep_protocol_entity_teardown),
21827c478bd9Sstevel@tonic-gate
21837c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ITER_SETUP, iter_setup,
21847c478bd9Sstevel@tonic-gate struct rep_protocol_iter_request),
21857c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ITER_START, iter_start,
21867c478bd9Sstevel@tonic-gate struct rep_protocol_iter_start),
21877c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ITER_READ, iter_read,
21887c478bd9Sstevel@tonic-gate struct rep_protocol_iter_read),
21897c478bd9Sstevel@tonic-gate PROTO_VALUE_OUT(REP_PROTOCOL_ITER_READ_VALUE, iter_read_value,
21907c478bd9Sstevel@tonic-gate struct rep_protocol_iter_read_value),
21917c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ITER_RESET, iter_reset,
21927c478bd9Sstevel@tonic-gate struct rep_protocol_iter_request),
21937c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_ITER_TEARDOWN, iter_teardown,
21947c478bd9Sstevel@tonic-gate struct rep_protocol_iter_request),
21957c478bd9Sstevel@tonic-gate
21967c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_NEXT_SNAPLEVEL, next_snaplevel,
21977c478bd9Sstevel@tonic-gate struct rep_protocol_entity_pair),
21987c478bd9Sstevel@tonic-gate
21997c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_SNAPSHOT_TAKE, snapshot_take,
22007c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_take),
22017c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_SNAPSHOT_TAKE_NAMED, snapshot_take_named,
22027c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_take_named),
22037c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_SNAPSHOT_ATTACH, snapshot_attach,
22047c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_attach),
22057c478bd9Sstevel@tonic-gate
22067c478bd9Sstevel@tonic-gate PROTO_UINT_OUT(REP_PROTOCOL_PROPERTY_GET_TYPE, property_get_type,
22077c478bd9Sstevel@tonic-gate struct rep_protocol_property_request),
22087c478bd9Sstevel@tonic-gate PROTO_VALUE_OUT(REP_PROTOCOL_PROPERTY_GET_VALUE, property_get_value,
22097c478bd9Sstevel@tonic-gate struct rep_protocol_property_request),
22107c478bd9Sstevel@tonic-gate
22117c478bd9Sstevel@tonic-gate PROTO_FD_OUT(REP_PROTOCOL_PROPERTYGRP_SETUP_WAIT, propertygrp_notify,
22127c478bd9Sstevel@tonic-gate struct rep_protocol_propertygrp_request),
22137c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_PROPERTYGRP_TX_START, tx_start,
22147c478bd9Sstevel@tonic-gate struct rep_protocol_transaction_start),
22157c478bd9Sstevel@tonic-gate PROTO_VARIN(REP_PROTOCOL_PROPERTYGRP_TX_COMMIT, tx_commit,
22167c478bd9Sstevel@tonic-gate REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE),
22177c478bd9Sstevel@tonic-gate
22187c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_CLIENT_ADD_NOTIFY, client_add_notify,
22197c478bd9Sstevel@tonic-gate struct rep_protocol_notify_request),
22207c478bd9Sstevel@tonic-gate PROTO_FMRI_OUT(REP_PROTOCOL_CLIENT_WAIT, client_wait,
22217c478bd9Sstevel@tonic-gate struct rep_protocol_wait_request),
22227c478bd9Sstevel@tonic-gate
22237c478bd9Sstevel@tonic-gate PROTO(REP_PROTOCOL_BACKUP, backup_repository,
22247c478bd9Sstevel@tonic-gate struct rep_protocol_backup_request),
22257c478bd9Sstevel@tonic-gate
22265b7f77adStw21770 PROTO(REP_PROTOCOL_SET_AUDIT_ANNOTATION, set_annotation,
22275b7f77adStw21770 struct rep_protocol_annotation),
22285b7f77adStw21770
2229c0889d7aSstevep PROTO(REP_PROTOCOL_SWITCH, repository_switch,
2230c0889d7aSstevep struct rep_protocol_switch_request),
2231c0889d7aSstevep
22327c478bd9Sstevel@tonic-gate PROTO_END()
22337c478bd9Sstevel@tonic-gate };
22347c478bd9Sstevel@tonic-gate #undef PROTO
22357c478bd9Sstevel@tonic-gate #undef PROTO_FMRI_OUT
22367c478bd9Sstevel@tonic-gate #undef PROTO_NAME_OUT
22377c478bd9Sstevel@tonic-gate #undef PROTO_UINT_OUT
22387c478bd9Sstevel@tonic-gate #undef PROTO_PANIC
22397c478bd9Sstevel@tonic-gate #undef PROTO_END
22407c478bd9Sstevel@tonic-gate
22417c478bd9Sstevel@tonic-gate /*
22427c478bd9Sstevel@tonic-gate * The number of entries, sans PROTO_END()
22437c478bd9Sstevel@tonic-gate */
22447c478bd9Sstevel@tonic-gate #define PROTOCOL_ENTRIES \
22457c478bd9Sstevel@tonic-gate (sizeof (protocol_table) / sizeof (*protocol_table) - 1)
22467c478bd9Sstevel@tonic-gate
22477c478bd9Sstevel@tonic-gate #define PROTOCOL_PREFIX "REP_PROTOCOL_"
22487c478bd9Sstevel@tonic-gate
22497c478bd9Sstevel@tonic-gate int
client_init(void)22507c478bd9Sstevel@tonic-gate client_init(void)
22517c478bd9Sstevel@tonic-gate {
22527c478bd9Sstevel@tonic-gate int i;
22537c478bd9Sstevel@tonic-gate struct protocol_entry *e;
22547c478bd9Sstevel@tonic-gate
22557c478bd9Sstevel@tonic-gate if (!client_hash_init())
22567c478bd9Sstevel@tonic-gate return (0);
22577c478bd9Sstevel@tonic-gate
22587c478bd9Sstevel@tonic-gate if (request_log_size > 0) {
22597c478bd9Sstevel@tonic-gate request_log = uu_zalloc(request_log_size *
22607c478bd9Sstevel@tonic-gate sizeof (request_log_entry_t));
22617c478bd9Sstevel@tonic-gate }
22627c478bd9Sstevel@tonic-gate
22637c478bd9Sstevel@tonic-gate /*
22647c478bd9Sstevel@tonic-gate * update the names to not include REP_PROTOCOL_
22657c478bd9Sstevel@tonic-gate */
22667c478bd9Sstevel@tonic-gate for (i = 0; i < PROTOCOL_ENTRIES; i++) {
22677c478bd9Sstevel@tonic-gate e = &protocol_table[i];
22687c478bd9Sstevel@tonic-gate assert(strncmp(e->pt_name, PROTOCOL_PREFIX,
22697c478bd9Sstevel@tonic-gate strlen(PROTOCOL_PREFIX)) == 0);
22707c478bd9Sstevel@tonic-gate e->pt_name += strlen(PROTOCOL_PREFIX);
22717c478bd9Sstevel@tonic-gate }
22727c478bd9Sstevel@tonic-gate /*
22737c478bd9Sstevel@tonic-gate * verify the protocol table is consistent
22747c478bd9Sstevel@tonic-gate */
22757c478bd9Sstevel@tonic-gate for (i = 0; i < PROTOCOL_ENTRIES; i++) {
22767c478bd9Sstevel@tonic-gate e = &protocol_table[i];
22777c478bd9Sstevel@tonic-gate assert(e->pt_request == (REP_PROTOCOL_BASE + i));
22787c478bd9Sstevel@tonic-gate
22797c478bd9Sstevel@tonic-gate assert((e->pt_flags & ~PROTO_ALL_FLAGS) == 0);
22807c478bd9Sstevel@tonic-gate
22817c478bd9Sstevel@tonic-gate if (e->pt_flags & PROTO_FLAG_PANIC)
22827c478bd9Sstevel@tonic-gate assert(e->pt_in_size == 0 && e->pt_out_max == 0 &&
22837c478bd9Sstevel@tonic-gate e->pt_handler == NULL);
22847c478bd9Sstevel@tonic-gate else
22857c478bd9Sstevel@tonic-gate assert(e->pt_in_size != 0 && e->pt_out_max != 0 &&
22867c478bd9Sstevel@tonic-gate (e->pt_handler != NULL ||
22877c478bd9Sstevel@tonic-gate e->pt_fd_handler != NULL));
22887c478bd9Sstevel@tonic-gate }
22897c478bd9Sstevel@tonic-gate assert((REP_PROTOCOL_BASE + i) == REP_PROTOCOL_MAX_REQUEST);
22907c478bd9Sstevel@tonic-gate
22917c478bd9Sstevel@tonic-gate assert(protocol_table[i].pt_request == 0);
22927c478bd9Sstevel@tonic-gate
22937c478bd9Sstevel@tonic-gate return (1);
22947c478bd9Sstevel@tonic-gate }
22957c478bd9Sstevel@tonic-gate
22967c478bd9Sstevel@tonic-gate static void
client_switcher(void * cookie,char * argp,size_t arg_size,door_desc_t * desc_in,uint_t n_desc)22977c478bd9Sstevel@tonic-gate client_switcher(void *cookie, char *argp, size_t arg_size, door_desc_t *desc_in,
22987c478bd9Sstevel@tonic-gate uint_t n_desc)
22997c478bd9Sstevel@tonic-gate {
23007c478bd9Sstevel@tonic-gate thread_info_t *ti = thread_self();
23017c478bd9Sstevel@tonic-gate
23027c478bd9Sstevel@tonic-gate repcache_client_t *cp;
23037c478bd9Sstevel@tonic-gate uint32_t id = (uint32_t)cookie;
23047c478bd9Sstevel@tonic-gate enum rep_protocol_requestid request_code;
23057c478bd9Sstevel@tonic-gate
23067c478bd9Sstevel@tonic-gate rep_protocol_responseid_t result = INVALID_RESULT;
23077c478bd9Sstevel@tonic-gate
23087c478bd9Sstevel@tonic-gate struct protocol_entry *e;
23097c478bd9Sstevel@tonic-gate
23107c478bd9Sstevel@tonic-gate char *retval = NULL;
23117c478bd9Sstevel@tonic-gate size_t retsize = 0;
23127c478bd9Sstevel@tonic-gate
23137c478bd9Sstevel@tonic-gate int retfd = -1;
23147c478bd9Sstevel@tonic-gate door_desc_t desc;
23157c478bd9Sstevel@tonic-gate request_log_entry_t *rlp;
23167c478bd9Sstevel@tonic-gate
23177c478bd9Sstevel@tonic-gate rlp = start_log(id);
23187c478bd9Sstevel@tonic-gate
23197c478bd9Sstevel@tonic-gate if (n_desc != 0)
23207c478bd9Sstevel@tonic-gate uu_die("can't happen: %d descriptors @%p (cookie %p)",
23217c478bd9Sstevel@tonic-gate n_desc, desc_in, cookie);
23227c478bd9Sstevel@tonic-gate
23237c478bd9Sstevel@tonic-gate if (argp == DOOR_UNREF_DATA) {
23247c478bd9Sstevel@tonic-gate client_destroy(id);
23257c478bd9Sstevel@tonic-gate goto bad_end;
23267c478bd9Sstevel@tonic-gate }
23277c478bd9Sstevel@tonic-gate
23287c478bd9Sstevel@tonic-gate thread_newstate(ti, TI_CLIENT_CALL);
23297c478bd9Sstevel@tonic-gate
23307c478bd9Sstevel@tonic-gate /*
23317c478bd9Sstevel@tonic-gate * To simplify returning just a result code, we set up for
23327c478bd9Sstevel@tonic-gate * that case here.
23337c478bd9Sstevel@tonic-gate */
23347c478bd9Sstevel@tonic-gate retval = (char *)&result;
23357c478bd9Sstevel@tonic-gate retsize = sizeof (result);
23367c478bd9Sstevel@tonic-gate
23377c478bd9Sstevel@tonic-gate if (arg_size < sizeof (request_code)) {
23387c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_BAD_REQUEST;
23397c478bd9Sstevel@tonic-gate goto end_unheld;
23407c478bd9Sstevel@tonic-gate }
23417c478bd9Sstevel@tonic-gate
23427c478bd9Sstevel@tonic-gate ti->ti_client_request = (void *)argp;
23437c478bd9Sstevel@tonic-gate
23447c478bd9Sstevel@tonic-gate /* LINTED alignment */
23457c478bd9Sstevel@tonic-gate request_code = *(uint32_t *)argp;
23467c478bd9Sstevel@tonic-gate
23477c478bd9Sstevel@tonic-gate if (rlp != NULL) {
23487c478bd9Sstevel@tonic-gate rlp->rl_request = request_code;
23497c478bd9Sstevel@tonic-gate }
23507c478bd9Sstevel@tonic-gate /*
23517c478bd9Sstevel@tonic-gate * In order to avoid locking problems on removal, we handle the
23527c478bd9Sstevel@tonic-gate * "close" case before doing a lookup.
23537c478bd9Sstevel@tonic-gate */
23547c478bd9Sstevel@tonic-gate if (request_code == REP_PROTOCOL_CLOSE) {
23557c478bd9Sstevel@tonic-gate client_destroy(id);
23567c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_SUCCESS;
23577c478bd9Sstevel@tonic-gate goto end_unheld;
23587c478bd9Sstevel@tonic-gate }
23597c478bd9Sstevel@tonic-gate
23607c478bd9Sstevel@tonic-gate cp = client_lookup(id);
23617c478bd9Sstevel@tonic-gate /*
23627c478bd9Sstevel@tonic-gate * cp is held
23637c478bd9Sstevel@tonic-gate */
23647c478bd9Sstevel@tonic-gate
23657c478bd9Sstevel@tonic-gate if (cp == NULL)
23667c478bd9Sstevel@tonic-gate goto bad_end;
23677c478bd9Sstevel@tonic-gate
23687c478bd9Sstevel@tonic-gate if (rlp != NULL)
23697c478bd9Sstevel@tonic-gate rlp->rl_client = cp;
23707c478bd9Sstevel@tonic-gate
23717c478bd9Sstevel@tonic-gate ti->ti_active_client = cp;
23727c478bd9Sstevel@tonic-gate
23737c478bd9Sstevel@tonic-gate if (request_code < REP_PROTOCOL_BASE ||
23747c478bd9Sstevel@tonic-gate request_code >= REP_PROTOCOL_BASE + PROTOCOL_ENTRIES) {
23757c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_BAD_REQUEST;
23767c478bd9Sstevel@tonic-gate goto end;
23777c478bd9Sstevel@tonic-gate }
23787c478bd9Sstevel@tonic-gate
23797c478bd9Sstevel@tonic-gate e = &protocol_table[request_code - REP_PROTOCOL_BASE];
23807c478bd9Sstevel@tonic-gate
23817c478bd9Sstevel@tonic-gate assert(!(e->pt_flags & PROTO_FLAG_PANIC));
23827c478bd9Sstevel@tonic-gate
23837c478bd9Sstevel@tonic-gate if (e->pt_flags & PROTO_FLAG_VARINPUT) {
23847c478bd9Sstevel@tonic-gate if (arg_size < e->pt_in_size) {
23857c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_BAD_REQUEST;
23867c478bd9Sstevel@tonic-gate goto end;
23877c478bd9Sstevel@tonic-gate }
23887c478bd9Sstevel@tonic-gate } else if (arg_size != e->pt_in_size) {
23897c478bd9Sstevel@tonic-gate result = REP_PROTOCOL_FAIL_BAD_REQUEST;
23907c478bd9Sstevel@tonic-gate goto end;
23917c478bd9Sstevel@tonic-gate }
23927c478bd9Sstevel@tonic-gate
23937c478bd9Sstevel@tonic-gate if (retsize != e->pt_out_max) {
23947c478bd9Sstevel@tonic-gate retsize = e->pt_out_max;
23957c478bd9Sstevel@tonic-gate retval = alloca(retsize);
23967c478bd9Sstevel@tonic-gate }
23977c478bd9Sstevel@tonic-gate
23987c478bd9Sstevel@tonic-gate if (e->pt_flags & PROTO_FLAG_RETFD)
23997c478bd9Sstevel@tonic-gate e->pt_fd_handler(cp, argp, arg_size, retval, &retsize,
24007c478bd9Sstevel@tonic-gate e->pt_arg, &retfd);
24017c478bd9Sstevel@tonic-gate else
24027c478bd9Sstevel@tonic-gate e->pt_handler(cp, argp, arg_size, retval, &retsize, e->pt_arg);
24037c478bd9Sstevel@tonic-gate
24047c478bd9Sstevel@tonic-gate end:
24057c478bd9Sstevel@tonic-gate ti->ti_active_client = NULL;
24067c478bd9Sstevel@tonic-gate client_release(cp);
24077c478bd9Sstevel@tonic-gate
24087c478bd9Sstevel@tonic-gate end_unheld:
24097c478bd9Sstevel@tonic-gate if (rlp != NULL) {
24107c478bd9Sstevel@tonic-gate /* LINTED alignment */
24117c478bd9Sstevel@tonic-gate rlp->rl_response = *(uint32_t *)retval;
24127c478bd9Sstevel@tonic-gate end_log();
24137c478bd9Sstevel@tonic-gate rlp = NULL;
24147c478bd9Sstevel@tonic-gate }
24157c478bd9Sstevel@tonic-gate ti->ti_client_request = NULL;
24167c478bd9Sstevel@tonic-gate thread_newstate(ti, TI_DOOR_RETURN);
24177c478bd9Sstevel@tonic-gate
24187c478bd9Sstevel@tonic-gate if (retval == (char *)&result) {
24197c478bd9Sstevel@tonic-gate assert(result != INVALID_RESULT && retsize == sizeof (result));
24207c478bd9Sstevel@tonic-gate } else {
24217c478bd9Sstevel@tonic-gate /* LINTED alignment */
24227c478bd9Sstevel@tonic-gate result = *(uint32_t *)retval;
24237c478bd9Sstevel@tonic-gate }
24247c478bd9Sstevel@tonic-gate if (retfd != -1) {
24257c478bd9Sstevel@tonic-gate desc.d_attributes = DOOR_DESCRIPTOR | DOOR_RELEASE;
24267c478bd9Sstevel@tonic-gate desc.d_data.d_desc.d_descriptor = retfd;
24277c478bd9Sstevel@tonic-gate (void) door_return(retval, retsize, &desc, 1);
24287c478bd9Sstevel@tonic-gate } else {
24297c478bd9Sstevel@tonic-gate (void) door_return(retval, retsize, NULL, 0);
24307c478bd9Sstevel@tonic-gate }
24317c478bd9Sstevel@tonic-gate bad_end:
24327c478bd9Sstevel@tonic-gate if (rlp != NULL) {
24337c478bd9Sstevel@tonic-gate rlp->rl_response = -1;
24347c478bd9Sstevel@tonic-gate end_log();
24357c478bd9Sstevel@tonic-gate rlp = NULL;
24367c478bd9Sstevel@tonic-gate }
24377c478bd9Sstevel@tonic-gate (void) door_return(NULL, 0, NULL, 0);
24387c478bd9Sstevel@tonic-gate }
24397c478bd9Sstevel@tonic-gate
24407c478bd9Sstevel@tonic-gate int
create_client(pid_t pid,uint32_t debugflags,int privileged,int * out_fd)24417c478bd9Sstevel@tonic-gate create_client(pid_t pid, uint32_t debugflags, int privileged, int *out_fd)
24427c478bd9Sstevel@tonic-gate {
24437c478bd9Sstevel@tonic-gate int fd;
24447c478bd9Sstevel@tonic-gate
24457c478bd9Sstevel@tonic-gate repcache_client_t *cp;
24467c478bd9Sstevel@tonic-gate
24477c478bd9Sstevel@tonic-gate struct door_info info;
24487c478bd9Sstevel@tonic-gate
24497c478bd9Sstevel@tonic-gate int door_flags = DOOR_UNREF | DOOR_REFUSE_DESC;
24507c478bd9Sstevel@tonic-gate #ifdef DOOR_NO_CANCEL
24517c478bd9Sstevel@tonic-gate door_flags |= DOOR_NO_CANCEL;
24527c478bd9Sstevel@tonic-gate #endif
24537c478bd9Sstevel@tonic-gate
24547c478bd9Sstevel@tonic-gate cp = client_alloc();
24557c478bd9Sstevel@tonic-gate if (cp == NULL)
24567c478bd9Sstevel@tonic-gate return (REPOSITORY_DOOR_FAIL_NO_RESOURCES);
24577c478bd9Sstevel@tonic-gate
24587c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&client_lock);
24597c478bd9Sstevel@tonic-gate cp->rc_id = ++client_maxid;
24607c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&client_lock);
24617c478bd9Sstevel@tonic-gate
24627c478bd9Sstevel@tonic-gate cp->rc_all_auths = privileged;
24637c478bd9Sstevel@tonic-gate cp->rc_pid = pid;
24647c478bd9Sstevel@tonic-gate cp->rc_debug = debugflags;
24657c478bd9Sstevel@tonic-gate
24666970e7c5SAndrew Stormont #ifndef NATIVE_BUILD
24675b7f77adStw21770 start_audit_session(cp);
24686970e7c5SAndrew Stormont #endif
24695b7f77adStw21770
24707c478bd9Sstevel@tonic-gate cp->rc_doorfd = door_create(client_switcher, (void *)cp->rc_id,
24717c478bd9Sstevel@tonic-gate door_flags);
24727c478bd9Sstevel@tonic-gate
24737c478bd9Sstevel@tonic-gate if (cp->rc_doorfd < 0) {
24747c478bd9Sstevel@tonic-gate client_free(cp);
24757c478bd9Sstevel@tonic-gate return (REPOSITORY_DOOR_FAIL_NO_RESOURCES);
24767c478bd9Sstevel@tonic-gate }
24777c478bd9Sstevel@tonic-gate #ifdef DOOR_PARAM_DATA_MIN
24787c478bd9Sstevel@tonic-gate (void) door_setparam(cp->rc_doorfd, DOOR_PARAM_DATA_MIN,
24797c478bd9Sstevel@tonic-gate sizeof (enum rep_protocol_requestid));
24807c478bd9Sstevel@tonic-gate #endif
24817c478bd9Sstevel@tonic-gate
24827c478bd9Sstevel@tonic-gate if ((fd = dup(cp->rc_doorfd)) < 0 ||
24837c478bd9Sstevel@tonic-gate door_info(cp->rc_doorfd, &info) < 0) {
24847c478bd9Sstevel@tonic-gate if (fd >= 0)
24857c478bd9Sstevel@tonic-gate (void) close(fd);
24867c478bd9Sstevel@tonic-gate (void) door_revoke(cp->rc_doorfd);
24877c478bd9Sstevel@tonic-gate cp->rc_doorfd = -1;
24887c478bd9Sstevel@tonic-gate client_free(cp);
24897c478bd9Sstevel@tonic-gate return (REPOSITORY_DOOR_FAIL_NO_RESOURCES);
24907c478bd9Sstevel@tonic-gate }
24917c478bd9Sstevel@tonic-gate
24927c478bd9Sstevel@tonic-gate rc_pg_notify_init(&cp->rc_pg_notify);
24937c478bd9Sstevel@tonic-gate rc_notify_info_init(&cp->rc_notify_info);
24947c478bd9Sstevel@tonic-gate
24957c478bd9Sstevel@tonic-gate client_insert(cp);
24967c478bd9Sstevel@tonic-gate
24977c478bd9Sstevel@tonic-gate cp->rc_doorid = info.di_uniquifier;
24987c478bd9Sstevel@tonic-gate *out_fd = fd;
24997c478bd9Sstevel@tonic-gate
25007c478bd9Sstevel@tonic-gate return (REPOSITORY_DOOR_SUCCESS);
25017c478bd9Sstevel@tonic-gate }
2502