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 5103b2b15Sgww * Common Development and Distribution License (the "License"). 6103b2b15Sgww * 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 */ 21a574db85Sraf 227c478bd9Sstevel@tonic-gate /* 23b56bf881SAntonello Cruz * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 246c7c876cSJerry Jelinek * Copyright 2013, Joyent, Inc. All rights reserved. 254f5c6fa5SAndrew Stormont * Copyright 2016 RackTop Systems. 2648bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved. 27*ad3ad82aSAndy Fiddaman * Copyright 2017 OmniOS Community Edition (OmniOSce) Association. 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate /* 317c478bd9Sstevel@tonic-gate * This is the main implementation file for the low-level repository 327c478bd9Sstevel@tonic-gate * interface. 337c478bd9Sstevel@tonic-gate */ 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate #include "lowlevel_impl.h" 367c478bd9Sstevel@tonic-gate 377c478bd9Sstevel@tonic-gate #include "repcache_protocol.h" 387c478bd9Sstevel@tonic-gate #include "scf_type.h" 397c478bd9Sstevel@tonic-gate 407c478bd9Sstevel@tonic-gate #include <assert.h> 417c478bd9Sstevel@tonic-gate #include <alloca.h> 427c478bd9Sstevel@tonic-gate #include <door.h> 437c478bd9Sstevel@tonic-gate #include <errno.h> 447c478bd9Sstevel@tonic-gate #include <fcntl.h> 457c478bd9Sstevel@tonic-gate #include <fnmatch.h> 467c478bd9Sstevel@tonic-gate #include <libuutil.h> 477c478bd9Sstevel@tonic-gate #include <poll.h> 487c478bd9Sstevel@tonic-gate #include <pthread.h> 4953f3aea0SRoger A. Faulkner #include <synch.h> 507c478bd9Sstevel@tonic-gate #include <stddef.h> 517c478bd9Sstevel@tonic-gate #include <stdio.h> 527c478bd9Sstevel@tonic-gate #include <stdlib.h> 537c478bd9Sstevel@tonic-gate #include <string.h> 547c478bd9Sstevel@tonic-gate #include <sys/mman.h> 557c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 56048b0279SBryan Cantrill #include <libzonecfg.h> 577c478bd9Sstevel@tonic-gate #include <unistd.h> 58048b0279SBryan Cantrill #include <dlfcn.h> 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate #define ENV_SCF_DEBUG "LIBSCF_DEBUG" 617c478bd9Sstevel@tonic-gate #define ENV_SCF_DOORPATH "LIBSCF_DOORPATH" 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate static uint32_t default_debug = 0; 647c478bd9Sstevel@tonic-gate static const char *default_door_path = REPOSITORY_DOOR_NAME; 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate #define CALL_FAILED -1 677c478bd9Sstevel@tonic-gate #define RESULT_TOO_BIG -2 687c478bd9Sstevel@tonic-gate #define NOT_BOUND -3 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate static pthread_mutex_t lowlevel_init_lock; 717c478bd9Sstevel@tonic-gate static int32_t lowlevel_inited; 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate static uu_list_pool_t *tran_entry_pool; 747c478bd9Sstevel@tonic-gate static uu_list_pool_t *datael_pool; 757c478bd9Sstevel@tonic-gate static uu_list_pool_t *iter_pool; 767c478bd9Sstevel@tonic-gate 771f6eb021SLiane Praza /* 781f6eb021SLiane Praza * base32[] index32[] are used in base32 encoding and decoding. 791f6eb021SLiane Praza */ 801f6eb021SLiane Praza static char base32[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; 811f6eb021SLiane Praza static char index32[128] = { 821f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 0-7 */ 831f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 8-15 */ 841f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 16-23 */ 851f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 24-31 */ 861f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 32-39 */ 871f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 40-47 */ 881f6eb021SLiane Praza -1, -1, 26, 27, 28, 29, 30, 31, /* 48-55 */ 891f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 56-63 */ 901f6eb021SLiane Praza -1, 0, 1, 2, 3, 4, 5, 6, /* 64-71 */ 911f6eb021SLiane Praza 7, 8, 9, 10, 11, 12, 13, 14, /* 72-79 */ 921f6eb021SLiane Praza 15, 16, 17, 18, 19, 20, 21, 22, /* 80-87 */ 931f6eb021SLiane Praza 23, 24, 25, -1, -1, -1, -1, -1, /* 88-95 */ 941f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 96-103 */ 951f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 104-111 */ 961f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1, /* 112-119 */ 971f6eb021SLiane Praza -1, -1, -1, -1, -1, -1, -1, -1 /* 120-127 */ 981f6eb021SLiane Praza }; 991f6eb021SLiane Praza 1001f6eb021SLiane Praza #define DECODE32_GS (8) /* scf_decode32 group size */ 1011f6eb021SLiane Praza 1027c478bd9Sstevel@tonic-gate #ifdef lint 1037c478bd9Sstevel@tonic-gate #define assert_nolint(x) (void)0 1047c478bd9Sstevel@tonic-gate #else 1057c478bd9Sstevel@tonic-gate #define assert_nolint(x) assert(x) 1067c478bd9Sstevel@tonic-gate #endif 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate static void scf_iter_reset_locked(scf_iter_t *iter); 1097c478bd9Sstevel@tonic-gate static void scf_value_reset_locked(scf_value_t *val, int and_destroy); 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate #define TYPE_VALUE (-100) 1127c478bd9Sstevel@tonic-gate 1137c478bd9Sstevel@tonic-gate /* 1147c478bd9Sstevel@tonic-gate * Hold and release subhandles. We only allow one thread access to the 11548bbca81SDaniel Hoffman * subhandles at a time, and it can use any subset, grabbing and releasing 1167c478bd9Sstevel@tonic-gate * them in any order. The only restrictions are that you cannot hold an 1177c478bd9Sstevel@tonic-gate * already-held subhandle, and all subhandles must be released before 1187c478bd9Sstevel@tonic-gate * returning to the original caller. 1197c478bd9Sstevel@tonic-gate */ 1207c478bd9Sstevel@tonic-gate static void 1217c478bd9Sstevel@tonic-gate handle_hold_subhandles(scf_handle_t *h, int mask) 1227c478bd9Sstevel@tonic-gate { 1237c478bd9Sstevel@tonic-gate assert(mask != 0 && (mask & ~RH_HOLD_ALL) == 0); 1247c478bd9Sstevel@tonic-gate 1257c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 126a574db85Sraf while (h->rh_hold_flags != 0 && h->rh_holder != pthread_self()) { 127a574db85Sraf int cancel_state; 128a574db85Sraf 129a574db85Sraf (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 130a574db85Sraf &cancel_state); 131a574db85Sraf (void) pthread_cond_wait(&h->rh_cv, &h->rh_lock); 132a574db85Sraf (void) pthread_setcancelstate(cancel_state, NULL); 133a574db85Sraf } 1347c478bd9Sstevel@tonic-gate if (h->rh_hold_flags == 0) 1357c478bd9Sstevel@tonic-gate h->rh_holder = pthread_self(); 1367c478bd9Sstevel@tonic-gate assert(!(h->rh_hold_flags & mask)); 1377c478bd9Sstevel@tonic-gate h->rh_hold_flags |= mask; 1387c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 1397c478bd9Sstevel@tonic-gate } 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate static void 1427c478bd9Sstevel@tonic-gate handle_rele_subhandles(scf_handle_t *h, int mask) 1437c478bd9Sstevel@tonic-gate { 1447c478bd9Sstevel@tonic-gate assert(mask != 0 && (mask & ~RH_HOLD_ALL) == 0); 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 1477c478bd9Sstevel@tonic-gate assert(h->rh_holder == pthread_self()); 1487c478bd9Sstevel@tonic-gate assert((h->rh_hold_flags & mask)); 1497c478bd9Sstevel@tonic-gate 1507c478bd9Sstevel@tonic-gate h->rh_hold_flags &= ~mask; 1517c478bd9Sstevel@tonic-gate if (h->rh_hold_flags == 0) 1527c478bd9Sstevel@tonic-gate (void) pthread_cond_signal(&h->rh_cv); 1537c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 1547c478bd9Sstevel@tonic-gate } 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate #define HOLD_HANDLE(h, flag, field) \ 1577c478bd9Sstevel@tonic-gate (handle_hold_subhandles((h), (flag)), (h)->field) 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate #define RELE_HANDLE(h, flag) \ 1607c478bd9Sstevel@tonic-gate (handle_rele_subhandles((h), (flag))) 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate /* 1637c478bd9Sstevel@tonic-gate * convenience macros, for functions that only need a one or two handles at 1647c478bd9Sstevel@tonic-gate * any given time 1657c478bd9Sstevel@tonic-gate */ 1667c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_ITER(h) HOLD_HANDLE((h), RH_HOLD_ITER, rh_iter) 1677c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_SCOPE(h) HOLD_HANDLE((h), RH_HOLD_SCOPE, rh_scope) 1687c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_SERVICE(h) HOLD_HANDLE((h), RH_HOLD_SERVICE, rh_service) 1697c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_INSTANCE(h) HOLD_HANDLE((h), RH_HOLD_INSTANCE, rh_instance) 1707c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_SNAPSHOT(h) HOLD_HANDLE((h), RH_HOLD_SNAPSHOT, rh_snapshot) 1717c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_SNAPLVL(h) HOLD_HANDLE((h), RH_HOLD_SNAPLVL, rh_snaplvl) 1727c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_PG(h) HOLD_HANDLE((h), RH_HOLD_PG, rh_pg) 1737c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_PROPERTY(h) HOLD_HANDLE((h), RH_HOLD_PROPERTY, rh_property) 1747c478bd9Sstevel@tonic-gate #define HANDLE_HOLD_VALUE(h) HOLD_HANDLE((h), RH_HOLD_VALUE, rh_value) 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate #define HANDLE_RELE_ITER(h) RELE_HANDLE((h), RH_HOLD_ITER) 1777c478bd9Sstevel@tonic-gate #define HANDLE_RELE_SCOPE(h) RELE_HANDLE((h), RH_HOLD_SCOPE) 1787c478bd9Sstevel@tonic-gate #define HANDLE_RELE_SERVICE(h) RELE_HANDLE((h), RH_HOLD_SERVICE) 1797c478bd9Sstevel@tonic-gate #define HANDLE_RELE_INSTANCE(h) RELE_HANDLE((h), RH_HOLD_INSTANCE) 1807c478bd9Sstevel@tonic-gate #define HANDLE_RELE_SNAPSHOT(h) RELE_HANDLE((h), RH_HOLD_SNAPSHOT) 1817c478bd9Sstevel@tonic-gate #define HANDLE_RELE_SNAPLVL(h) RELE_HANDLE((h), RH_HOLD_SNAPLVL) 1827c478bd9Sstevel@tonic-gate #define HANDLE_RELE_PG(h) RELE_HANDLE((h), RH_HOLD_PG) 1837c478bd9Sstevel@tonic-gate #define HANDLE_RELE_PROPERTY(h) RELE_HANDLE((h), RH_HOLD_PROPERTY) 1847c478bd9Sstevel@tonic-gate #define HANDLE_RELE_VALUE(h) RELE_HANDLE((h), RH_HOLD_VALUE) 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1877c478bd9Sstevel@tonic-gate static int 1887c478bd9Sstevel@tonic-gate transaction_entry_compare(const void *l_arg, const void *r_arg, void *private) 1897c478bd9Sstevel@tonic-gate { 1907c478bd9Sstevel@tonic-gate const char *l_prop = 1917c478bd9Sstevel@tonic-gate ((scf_transaction_entry_t *)l_arg)->entry_property; 1927c478bd9Sstevel@tonic-gate const char *r_prop = 1937c478bd9Sstevel@tonic-gate ((scf_transaction_entry_t *)r_arg)->entry_property; 1947c478bd9Sstevel@tonic-gate 1957c478bd9Sstevel@tonic-gate int ret; 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate ret = strcmp(l_prop, r_prop); 1987c478bd9Sstevel@tonic-gate if (ret > 0) 1997c478bd9Sstevel@tonic-gate return (1); 2008918dff3Sjwadams if (ret < 0) 2018918dff3Sjwadams return (-1); 2028918dff3Sjwadams return (0); 2038918dff3Sjwadams } 2048918dff3Sjwadams 2058918dff3Sjwadams static int 2068918dff3Sjwadams datael_compare(const void *l_arg, const void *r_arg, void *private) 2078918dff3Sjwadams { 2088918dff3Sjwadams uint32_t l_id = ((scf_datael_t *)l_arg)->rd_entity; 2098918dff3Sjwadams uint32_t r_id = (r_arg != NULL) ? ((scf_datael_t *)r_arg)->rd_entity : 2108918dff3Sjwadams *(uint32_t *)private; 2118918dff3Sjwadams 2128918dff3Sjwadams if (l_id > r_id) 2138918dff3Sjwadams return (1); 2148918dff3Sjwadams if (l_id < r_id) 2158918dff3Sjwadams return (-1); 2168918dff3Sjwadams return (0); 2178918dff3Sjwadams } 2188918dff3Sjwadams 2198918dff3Sjwadams static int 2208918dff3Sjwadams iter_compare(const void *l_arg, const void *r_arg, void *private) 2218918dff3Sjwadams { 2228918dff3Sjwadams uint32_t l_id = ((scf_iter_t *)l_arg)->iter_id; 2238918dff3Sjwadams uint32_t r_id = (r_arg != NULL) ? ((scf_iter_t *)r_arg)->iter_id : 2248918dff3Sjwadams *(uint32_t *)private; 2258918dff3Sjwadams 2268918dff3Sjwadams if (l_id > r_id) 2278918dff3Sjwadams return (1); 2288918dff3Sjwadams if (l_id < r_id) 2297c478bd9Sstevel@tonic-gate return (-1); 2307c478bd9Sstevel@tonic-gate return (0); 2317c478bd9Sstevel@tonic-gate } 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate static int 2347c478bd9Sstevel@tonic-gate lowlevel_init(void) 2357c478bd9Sstevel@tonic-gate { 2367c478bd9Sstevel@tonic-gate const char *debug; 2377c478bd9Sstevel@tonic-gate const char *door_path; 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&lowlevel_init_lock); 2407c478bd9Sstevel@tonic-gate if (lowlevel_inited == 0) { 2417c478bd9Sstevel@tonic-gate if (!issetugid() && 2427c478bd9Sstevel@tonic-gate (debug = getenv(ENV_SCF_DEBUG)) != NULL && debug[0] != 0 && 2437c478bd9Sstevel@tonic-gate uu_strtoint(debug, &default_debug, sizeof (default_debug), 2447c478bd9Sstevel@tonic-gate 0, 0, 0) == -1) { 2457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "LIBSCF: $%s (%s): %s", 2467c478bd9Sstevel@tonic-gate ENV_SCF_DEBUG, debug, 2477c478bd9Sstevel@tonic-gate uu_strerror(uu_error())); 2487c478bd9Sstevel@tonic-gate } 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate if (!issetugid() && 2517c478bd9Sstevel@tonic-gate (door_path = getenv(ENV_SCF_DOORPATH)) != NULL && 2527c478bd9Sstevel@tonic-gate door_path[0] != 0) { 2537c478bd9Sstevel@tonic-gate default_door_path = strdup(door_path); 2547c478bd9Sstevel@tonic-gate if (default_door_path == NULL) 2557c478bd9Sstevel@tonic-gate default_door_path = door_path; 2567c478bd9Sstevel@tonic-gate } 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate datael_pool = uu_list_pool_create("SUNW,libscf_datael", 2597c478bd9Sstevel@tonic-gate sizeof (scf_datael_t), offsetof(scf_datael_t, rd_node), 2608918dff3Sjwadams datael_compare, UU_LIST_POOL_DEBUG); 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate iter_pool = uu_list_pool_create("SUNW,libscf_iter", 2637c478bd9Sstevel@tonic-gate sizeof (scf_iter_t), offsetof(scf_iter_t, iter_node), 2648918dff3Sjwadams iter_compare, UU_LIST_POOL_DEBUG); 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate assert_nolint(offsetof(scf_transaction_entry_t, 2677c478bd9Sstevel@tonic-gate entry_property) == 0); 2687c478bd9Sstevel@tonic-gate tran_entry_pool = uu_list_pool_create( 2697c478bd9Sstevel@tonic-gate "SUNW,libscf_transaction_entity", 2707c478bd9Sstevel@tonic-gate sizeof (scf_transaction_entry_t), 2717c478bd9Sstevel@tonic-gate offsetof(scf_transaction_entry_t, entry_link), 2727c478bd9Sstevel@tonic-gate transaction_entry_compare, UU_LIST_POOL_DEBUG); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate if (datael_pool == NULL || iter_pool == NULL || 2757c478bd9Sstevel@tonic-gate tran_entry_pool == NULL) { 2767c478bd9Sstevel@tonic-gate lowlevel_inited = -1; 2777c478bd9Sstevel@tonic-gate goto end; 2787c478bd9Sstevel@tonic-gate } 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate if (!scf_setup_error()) { 2817c478bd9Sstevel@tonic-gate lowlevel_inited = -1; 2827c478bd9Sstevel@tonic-gate goto end; 2837c478bd9Sstevel@tonic-gate } 2847c478bd9Sstevel@tonic-gate lowlevel_inited = 1; 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate end: 2877c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&lowlevel_init_lock); 2887c478bd9Sstevel@tonic-gate if (lowlevel_inited > 0) 2897c478bd9Sstevel@tonic-gate return (1); 2907c478bd9Sstevel@tonic-gate return (0); 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate static const struct { 2947c478bd9Sstevel@tonic-gate scf_type_t ti_type; 2957c478bd9Sstevel@tonic-gate rep_protocol_value_type_t ti_proto_type; 2967c478bd9Sstevel@tonic-gate const char *ti_name; 2977c478bd9Sstevel@tonic-gate } scf_type_info[] = { 2984f5c6fa5SAndrew Stormont {SCF_TYPE_BOOLEAN, REP_PROTOCOL_TYPE_BOOLEAN, 2994f5c6fa5SAndrew Stormont SCF_TYPE_STRING_BOOLEAN}, 3004f5c6fa5SAndrew Stormont {SCF_TYPE_COUNT, REP_PROTOCOL_TYPE_COUNT, 3014f5c6fa5SAndrew Stormont SCF_TYPE_STRING_COUNT}, 3024f5c6fa5SAndrew Stormont {SCF_TYPE_INTEGER, REP_PROTOCOL_TYPE_INTEGER, 3034f5c6fa5SAndrew Stormont SCF_TYPE_STRING_INTEGER}, 3044f5c6fa5SAndrew Stormont {SCF_TYPE_TIME, REP_PROTOCOL_TYPE_TIME, 3054f5c6fa5SAndrew Stormont SCF_TYPE_STRING_TIME}, 3064f5c6fa5SAndrew Stormont {SCF_TYPE_ASTRING, REP_PROTOCOL_TYPE_STRING, 3074f5c6fa5SAndrew Stormont SCF_TYPE_STRING_ASTRING}, 3084f5c6fa5SAndrew Stormont {SCF_TYPE_OPAQUE, REP_PROTOCOL_TYPE_OPAQUE, 3094f5c6fa5SAndrew Stormont SCF_TYPE_STRING_OPAQUE}, 3104f5c6fa5SAndrew Stormont {SCF_TYPE_USTRING, REP_PROTOCOL_SUBTYPE_USTRING, 3114f5c6fa5SAndrew Stormont SCF_TYPE_STRING_USTRING}, 3124f5c6fa5SAndrew Stormont {SCF_TYPE_URI, REP_PROTOCOL_SUBTYPE_URI, 3134f5c6fa5SAndrew Stormont SCF_TYPE_STRING_URI}, 3144f5c6fa5SAndrew Stormont {SCF_TYPE_FMRI, REP_PROTOCOL_SUBTYPE_FMRI, 3154f5c6fa5SAndrew Stormont SCF_TYPE_STRING_FMRI}, 3164f5c6fa5SAndrew Stormont {SCF_TYPE_HOST, REP_PROTOCOL_SUBTYPE_HOST, 3174f5c6fa5SAndrew Stormont SCF_TYPE_STRING_HOST}, 3184f5c6fa5SAndrew Stormont {SCF_TYPE_HOSTNAME, REP_PROTOCOL_SUBTYPE_HOSTNAME, 3194f5c6fa5SAndrew Stormont SCF_TYPE_STRING_HOSTNAME}, 3204f5c6fa5SAndrew Stormont {SCF_TYPE_NET_ADDR, REP_PROTOCOL_SUBTYPE_NETADDR, 3214f5c6fa5SAndrew Stormont SCF_TYPE_STRING_NET_ADDR}, 3227c478bd9Sstevel@tonic-gate {SCF_TYPE_NET_ADDR_V4, REP_PROTOCOL_SUBTYPE_NETADDR_V4, 3234f5c6fa5SAndrew Stormont SCF_TYPE_STRING_NET_ADDR_V4}, 3247c478bd9Sstevel@tonic-gate {SCF_TYPE_NET_ADDR_V6, REP_PROTOCOL_SUBTYPE_NETADDR_V6, 3254f5c6fa5SAndrew Stormont SCF_TYPE_STRING_NET_ADDR_V6} 3267c478bd9Sstevel@tonic-gate }; 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate #define SCF_TYPE_INFO_COUNT (sizeof (scf_type_info) / sizeof (*scf_type_info)) 3297c478bd9Sstevel@tonic-gate static rep_protocol_value_type_t 3307c478bd9Sstevel@tonic-gate scf_type_to_protocol_type(scf_type_t t) 3317c478bd9Sstevel@tonic-gate { 3327c478bd9Sstevel@tonic-gate int i; 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate for (i = 0; i < SCF_TYPE_INFO_COUNT; i++) 3357c478bd9Sstevel@tonic-gate if (scf_type_info[i].ti_type == t) 3367c478bd9Sstevel@tonic-gate return (scf_type_info[i].ti_proto_type); 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_TYPE_INVALID); 3397c478bd9Sstevel@tonic-gate } 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate static scf_type_t 3427c478bd9Sstevel@tonic-gate scf_protocol_type_to_type(rep_protocol_value_type_t t) 3437c478bd9Sstevel@tonic-gate { 3447c478bd9Sstevel@tonic-gate int i; 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate for (i = 0; i < SCF_TYPE_INFO_COUNT; i++) 3477c478bd9Sstevel@tonic-gate if (scf_type_info[i].ti_proto_type == t) 3487c478bd9Sstevel@tonic-gate return (scf_type_info[i].ti_type); 3497c478bd9Sstevel@tonic-gate 3507c478bd9Sstevel@tonic-gate return (SCF_TYPE_INVALID); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate 3537c478bd9Sstevel@tonic-gate const char * 3547c478bd9Sstevel@tonic-gate scf_type_to_string(scf_type_t ty) 3557c478bd9Sstevel@tonic-gate { 3567c478bd9Sstevel@tonic-gate int i; 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate for (i = 0; i < SCF_TYPE_INFO_COUNT; i++) 3597c478bd9Sstevel@tonic-gate if (scf_type_info[i].ti_type == ty) 3607c478bd9Sstevel@tonic-gate return (scf_type_info[i].ti_name); 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate return ("unknown"); 3637c478bd9Sstevel@tonic-gate } 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate scf_type_t 3667c478bd9Sstevel@tonic-gate scf_string_to_type(const char *name) 3677c478bd9Sstevel@tonic-gate { 3687c478bd9Sstevel@tonic-gate int i; 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate for (i = 0; i < sizeof (scf_type_info) / sizeof (*scf_type_info); i++) 3717c478bd9Sstevel@tonic-gate if (strcmp(scf_type_info[i].ti_name, name) == 0) 3727c478bd9Sstevel@tonic-gate return (scf_type_info[i].ti_type); 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate return (SCF_TYPE_INVALID); 3757c478bd9Sstevel@tonic-gate } 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate int 3787c478bd9Sstevel@tonic-gate scf_type_base_type(scf_type_t type, scf_type_t *out) 3797c478bd9Sstevel@tonic-gate { 3807c478bd9Sstevel@tonic-gate rep_protocol_value_type_t t = scf_type_to_protocol_type(type); 3817c478bd9Sstevel@tonic-gate if (t == REP_PROTOCOL_TYPE_INVALID) 3827c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate *out = scf_protocol_type_to_type(scf_proto_underlying_type(t)); 3857c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 3867c478bd9Sstevel@tonic-gate } 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate /* 3897c478bd9Sstevel@tonic-gate * Convert a protocol error code into an SCF_ERROR_* code. 3907c478bd9Sstevel@tonic-gate */ 3917c478bd9Sstevel@tonic-gate static scf_error_t 3927c478bd9Sstevel@tonic-gate proto_error(rep_protocol_responseid_t e) 3937c478bd9Sstevel@tonic-gate { 3947c478bd9Sstevel@tonic-gate switch (e) { 3957c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_MISORDERED: 3967c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_UNKNOWN_ID: 3977c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_INVALID_TYPE: 3987c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_TRUNCATED: 3997c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_TYPE_MISMATCH: 4007c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_NOT_APPLICABLE: 4017c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_UNKNOWN: 4027c478bd9Sstevel@tonic-gate return (SCF_ERROR_INTERNAL); 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_BAD_TX: 4057c478bd9Sstevel@tonic-gate return (SCF_ERROR_INVALID_ARGUMENT); 4067c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_BAD_REQUEST: 4077c478bd9Sstevel@tonic-gate return (SCF_ERROR_INVALID_ARGUMENT); 4087c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_NO_RESOURCES: 4097c478bd9Sstevel@tonic-gate return (SCF_ERROR_NO_RESOURCES); 4107c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_NOT_FOUND: 4117c478bd9Sstevel@tonic-gate return (SCF_ERROR_NOT_FOUND); 4127c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_DELETED: 4137c478bd9Sstevel@tonic-gate return (SCF_ERROR_DELETED); 4147c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_NOT_SET: 4157c478bd9Sstevel@tonic-gate return (SCF_ERROR_NOT_SET); 4167c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_EXISTS: 4177c478bd9Sstevel@tonic-gate return (SCF_ERROR_EXISTS); 4187c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_DUPLICATE_ID: 4197c478bd9Sstevel@tonic-gate return (SCF_ERROR_EXISTS); 4207c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_PERMISSION_DENIED: 4217c478bd9Sstevel@tonic-gate return (SCF_ERROR_PERMISSION_DENIED); 4227c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_BACKEND_ACCESS: 4237c478bd9Sstevel@tonic-gate return (SCF_ERROR_BACKEND_ACCESS); 4247c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_BACKEND_READONLY: 4257c478bd9Sstevel@tonic-gate return (SCF_ERROR_BACKEND_READONLY); 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate case REP_PROTOCOL_SUCCESS: 4287c478bd9Sstevel@tonic-gate case REP_PROTOCOL_DONE: 4297c478bd9Sstevel@tonic-gate case REP_PROTOCOL_FAIL_NOT_LATEST: /* TX code should handle this */ 4307c478bd9Sstevel@tonic-gate default: 4317c478bd9Sstevel@tonic-gate #ifndef NDEBUG 4327c478bd9Sstevel@tonic-gate uu_warn("%s:%d: Bad error code %d passed to proto_error().\n", 4337c478bd9Sstevel@tonic-gate __FILE__, __LINE__, e); 4347c478bd9Sstevel@tonic-gate #endif 4357c478bd9Sstevel@tonic-gate abort(); 4367c478bd9Sstevel@tonic-gate /*NOTREACHED*/ 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate } 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate ssize_t 4417c478bd9Sstevel@tonic-gate scf_limit(uint32_t limit) 4427c478bd9Sstevel@tonic-gate { 4437c478bd9Sstevel@tonic-gate switch (limit) { 4447c478bd9Sstevel@tonic-gate case SCF_LIMIT_MAX_NAME_LENGTH: 4457c478bd9Sstevel@tonic-gate case SCF_LIMIT_MAX_PG_TYPE_LENGTH: 4467c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_NAME_LEN - 1); 4477c478bd9Sstevel@tonic-gate case SCF_LIMIT_MAX_VALUE_LENGTH: 4487c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_VALUE_LEN - 1); 4497c478bd9Sstevel@tonic-gate case SCF_LIMIT_MAX_FMRI_LENGTH: 4507c478bd9Sstevel@tonic-gate return (SCF_FMRI_PREFIX_MAX_LEN + 4517c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SCOPE_PREFIX) - 1 + 4527c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1 + 4537c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SERVICE_PREFIX) - 1 + 4547c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1 + 4557c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1 + 4567c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1 + 4577c478bd9Sstevel@tonic-gate 5 * (REP_PROTOCOL_NAME_LEN - 1)); 4587c478bd9Sstevel@tonic-gate default: 4597c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate } 4627c478bd9Sstevel@tonic-gate 4637c478bd9Sstevel@tonic-gate static size_t 4647c478bd9Sstevel@tonic-gate scf_opaque_decode(char *out_arg, const char *in, size_t max_out) 4657c478bd9Sstevel@tonic-gate { 4667c478bd9Sstevel@tonic-gate char a, b; 4677c478bd9Sstevel@tonic-gate char *out = out_arg; 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate while (max_out > 0 && (a = in[0]) != 0 && (b = in[1]) != 0) { 4707c478bd9Sstevel@tonic-gate in += 2; 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate if (a >= '0' && a <= '9') 4737c478bd9Sstevel@tonic-gate a -= '0'; 4747c478bd9Sstevel@tonic-gate else if (a >= 'a' && a <= 'f') 4757c478bd9Sstevel@tonic-gate a = a - 'a' + 10; 4767c478bd9Sstevel@tonic-gate else if (a >= 'A' && a <= 'F') 4777c478bd9Sstevel@tonic-gate a = a - 'A' + 10; 4787c478bd9Sstevel@tonic-gate else 4797c478bd9Sstevel@tonic-gate break; 4807c478bd9Sstevel@tonic-gate 4817c478bd9Sstevel@tonic-gate if (b >= '0' && b <= '9') 4827c478bd9Sstevel@tonic-gate b -= '0'; 4837c478bd9Sstevel@tonic-gate else if (b >= 'a' && b <= 'f') 4847c478bd9Sstevel@tonic-gate b = b - 'a' + 10; 4857c478bd9Sstevel@tonic-gate else if (b >= 'A' && b <= 'F') 4867c478bd9Sstevel@tonic-gate b = b - 'A' + 10; 4877c478bd9Sstevel@tonic-gate else 4887c478bd9Sstevel@tonic-gate break; 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate *out++ = (a << 4) | b; 4917c478bd9Sstevel@tonic-gate max_out--; 4927c478bd9Sstevel@tonic-gate } 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate return (out - out_arg); 4957c478bd9Sstevel@tonic-gate } 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate static size_t 4987c478bd9Sstevel@tonic-gate scf_opaque_encode(char *out_arg, const char *in_arg, size_t in_sz) 4997c478bd9Sstevel@tonic-gate { 5007c478bd9Sstevel@tonic-gate uint8_t *in = (uint8_t *)in_arg; 5017c478bd9Sstevel@tonic-gate uint8_t *end = in + in_sz; 5027c478bd9Sstevel@tonic-gate char *out = out_arg; 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate if (out == NULL) 5057c478bd9Sstevel@tonic-gate return (2 * in_sz); 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate while (in < end) { 5087c478bd9Sstevel@tonic-gate uint8_t c = *in++; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate uint8_t a = (c & 0xf0) >> 4; 5117c478bd9Sstevel@tonic-gate uint8_t b = (c & 0x0f); 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate if (a <= 9) 5147c478bd9Sstevel@tonic-gate *out++ = a + '0'; 5157c478bd9Sstevel@tonic-gate else 5167c478bd9Sstevel@tonic-gate *out++ = a + 'a' - 10; 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate if (b <= 9) 5197c478bd9Sstevel@tonic-gate *out++ = b + '0'; 5207c478bd9Sstevel@tonic-gate else 5217c478bd9Sstevel@tonic-gate *out++ = b + 'a' - 10; 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate *out = 0; 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate return (out - out_arg); 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate static void 5307c478bd9Sstevel@tonic-gate handle_do_close(scf_handle_t *h) 5317c478bd9Sstevel@tonic-gate { 5327c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 5337c478bd9Sstevel@tonic-gate assert(h->rh_doorfd != -1); 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate /* 5367c478bd9Sstevel@tonic-gate * if there are any active FD users, we just move the FD over 5377c478bd9Sstevel@tonic-gate * to rh_doorfd_old -- they'll close it when they finish. 5387c478bd9Sstevel@tonic-gate */ 5397c478bd9Sstevel@tonic-gate if (h->rh_fd_users > 0) { 5407c478bd9Sstevel@tonic-gate h->rh_doorfd_old = h->rh_doorfd; 5417c478bd9Sstevel@tonic-gate h->rh_doorfd = -1; 5427c478bd9Sstevel@tonic-gate } else { 5437c478bd9Sstevel@tonic-gate assert(h->rh_doorfd_old == -1); 5447c478bd9Sstevel@tonic-gate (void) close(h->rh_doorfd); 5457c478bd9Sstevel@tonic-gate h->rh_doorfd = -1; 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate /* 5507c478bd9Sstevel@tonic-gate * Check if a handle is currently bound. fork()ing implicitly unbinds 5517c478bd9Sstevel@tonic-gate * the handle in the child. 5527c478bd9Sstevel@tonic-gate */ 5537c478bd9Sstevel@tonic-gate static int 5547c478bd9Sstevel@tonic-gate handle_is_bound(scf_handle_t *h) 5557c478bd9Sstevel@tonic-gate { 5567c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate if (h->rh_doorfd == -1) 5597c478bd9Sstevel@tonic-gate return (0); 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate if (getpid() == h->rh_doorpid) 5627c478bd9Sstevel@tonic-gate return (1); 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* forked since our last bind -- initiate handle close */ 5657c478bd9Sstevel@tonic-gate handle_do_close(h); 5667c478bd9Sstevel@tonic-gate return (0); 5677c478bd9Sstevel@tonic-gate } 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate static int 5708918dff3Sjwadams handle_has_server_locked(scf_handle_t *h) 5717c478bd9Sstevel@tonic-gate { 5727c478bd9Sstevel@tonic-gate door_info_t i; 5738918dff3Sjwadams assert(MUTEX_HELD(&h->rh_lock)); 5748918dff3Sjwadams 5758918dff3Sjwadams return (handle_is_bound(h) && door_info(h->rh_doorfd, &i) != -1 && 5768918dff3Sjwadams i.di_target != -1); 5778918dff3Sjwadams } 5788918dff3Sjwadams 5798918dff3Sjwadams static int 5808918dff3Sjwadams handle_has_server(scf_handle_t *h) 5818918dff3Sjwadams { 5827c478bd9Sstevel@tonic-gate int ret; 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 5858918dff3Sjwadams ret = handle_has_server_locked(h); 5867c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 5877c478bd9Sstevel@tonic-gate 5887c478bd9Sstevel@tonic-gate return (ret); 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate /* 5927c478bd9Sstevel@tonic-gate * This makes a door request on the client door associated with handle h. 5937c478bd9Sstevel@tonic-gate * It will automatically retry calls which fail on EINTR. If h is not bound, 5947c478bd9Sstevel@tonic-gate * returns NOT_BOUND. If the door call fails or the server response is too 5957c478bd9Sstevel@tonic-gate * small, returns CALL_FAILED. If the server response is too big, truncates the 5967c478bd9Sstevel@tonic-gate * response and returns RESULT_TOO_BIG. Otherwise, the size of the result is 5977c478bd9Sstevel@tonic-gate * returned. 5987c478bd9Sstevel@tonic-gate */ 5997c478bd9Sstevel@tonic-gate static ssize_t 6007c478bd9Sstevel@tonic-gate make_door_call(scf_handle_t *h, const void *req, size_t req_sz, 6017c478bd9Sstevel@tonic-gate void *res, size_t res_sz) 6027c478bd9Sstevel@tonic-gate { 6037c478bd9Sstevel@tonic-gate door_arg_t arg; 6047c478bd9Sstevel@tonic-gate int r; 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate if (!handle_is_bound(h)) { 6097c478bd9Sstevel@tonic-gate return (NOT_BOUND); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate arg.data_ptr = (void *)req; 6137c478bd9Sstevel@tonic-gate arg.data_size = req_sz; 6147c478bd9Sstevel@tonic-gate arg.desc_ptr = NULL; 6157c478bd9Sstevel@tonic-gate arg.desc_num = 0; 6167c478bd9Sstevel@tonic-gate arg.rbuf = res; 6177c478bd9Sstevel@tonic-gate arg.rsize = res_sz; 6187c478bd9Sstevel@tonic-gate 6197c478bd9Sstevel@tonic-gate while ((r = door_call(h->rh_doorfd, &arg)) < 0) { 6207c478bd9Sstevel@tonic-gate if (errno != EINTR) 6217c478bd9Sstevel@tonic-gate break; 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate if (r < 0) { 6257c478bd9Sstevel@tonic-gate return (CALL_FAILED); 6267c478bd9Sstevel@tonic-gate } 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate if (arg.desc_num > 0) { 6297c478bd9Sstevel@tonic-gate while (arg.desc_num > 0) { 6307c478bd9Sstevel@tonic-gate if (arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) { 6317c478bd9Sstevel@tonic-gate int cfd = arg.desc_ptr->d_data.d_desc.d_id; 6327c478bd9Sstevel@tonic-gate (void) close(cfd); 6337c478bd9Sstevel@tonic-gate } 6347c478bd9Sstevel@tonic-gate arg.desc_ptr++; 6357c478bd9Sstevel@tonic-gate arg.desc_num--; 6367c478bd9Sstevel@tonic-gate } 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate if (arg.data_ptr != res && arg.data_size > 0) 6397c478bd9Sstevel@tonic-gate (void) memmove(res, arg.data_ptr, MIN(arg.data_size, res_sz)); 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate if (arg.rbuf != res) 6427c478bd9Sstevel@tonic-gate (void) munmap(arg.rbuf, arg.rsize); 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate if (arg.data_size > res_sz) 6457c478bd9Sstevel@tonic-gate return (RESULT_TOO_BIG); 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate if (arg.data_size < sizeof (uint32_t)) 6487c478bd9Sstevel@tonic-gate return (CALL_FAILED); 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate return (arg.data_size); 6517c478bd9Sstevel@tonic-gate } 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate /* 6547c478bd9Sstevel@tonic-gate * Should only be used when r < 0. 6557c478bd9Sstevel@tonic-gate */ 6567c478bd9Sstevel@tonic-gate #define DOOR_ERRORS_BLOCK(r) { \ 6577c478bd9Sstevel@tonic-gate switch (r) { \ 6587c478bd9Sstevel@tonic-gate case NOT_BOUND: \ 6597c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_BOUND)); \ 6607c478bd9Sstevel@tonic-gate \ 6617c478bd9Sstevel@tonic-gate case CALL_FAILED: \ 6627c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN)); \ 6637c478bd9Sstevel@tonic-gate \ 6647c478bd9Sstevel@tonic-gate case RESULT_TOO_BIG: \ 6657c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); \ 6667c478bd9Sstevel@tonic-gate \ 6677c478bd9Sstevel@tonic-gate default: \ 6687c478bd9Sstevel@tonic-gate assert(r == NOT_BOUND || r == CALL_FAILED || \ 6697c478bd9Sstevel@tonic-gate r == RESULT_TOO_BIG); \ 6707c478bd9Sstevel@tonic-gate abort(); \ 6717c478bd9Sstevel@tonic-gate } \ 6727c478bd9Sstevel@tonic-gate } 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate /* 6757c478bd9Sstevel@tonic-gate * Like make_door_call(), but takes an fd instead of a handle, and expects 6767c478bd9Sstevel@tonic-gate * a single file descriptor, returned via res_fd. 6777c478bd9Sstevel@tonic-gate * 6787c478bd9Sstevel@tonic-gate * If no file descriptor is returned, *res_fd == -1. 6797c478bd9Sstevel@tonic-gate */ 6807c478bd9Sstevel@tonic-gate static int 6817c478bd9Sstevel@tonic-gate make_door_call_retfd(int fd, const void *req, size_t req_sz, void *res, 6827c478bd9Sstevel@tonic-gate size_t res_sz, int *res_fd) 6837c478bd9Sstevel@tonic-gate { 6847c478bd9Sstevel@tonic-gate door_arg_t arg; 6857c478bd9Sstevel@tonic-gate int r; 6867c478bd9Sstevel@tonic-gate char rbuf[256]; 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate *res_fd = -1; 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate if (fd == -1) 6917c478bd9Sstevel@tonic-gate return (NOT_BOUND); 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate arg.data_ptr = (void *)req; 6947c478bd9Sstevel@tonic-gate arg.data_size = req_sz; 6957c478bd9Sstevel@tonic-gate arg.desc_ptr = NULL; 6967c478bd9Sstevel@tonic-gate arg.desc_num = 0; 6977c478bd9Sstevel@tonic-gate arg.rbuf = rbuf; 6987c478bd9Sstevel@tonic-gate arg.rsize = sizeof (rbuf); 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate while ((r = door_call(fd, &arg)) < 0) { 7017c478bd9Sstevel@tonic-gate if (errno != EINTR) 7027c478bd9Sstevel@tonic-gate break; 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate if (r < 0) 7067c478bd9Sstevel@tonic-gate return (CALL_FAILED); 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate if (arg.desc_num > 1) { 7097c478bd9Sstevel@tonic-gate while (arg.desc_num > 0) { 7107c478bd9Sstevel@tonic-gate if (arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) { 7117c478bd9Sstevel@tonic-gate int cfd = 7127c478bd9Sstevel@tonic-gate arg.desc_ptr->d_data.d_desc.d_descriptor; 7137c478bd9Sstevel@tonic-gate (void) close(cfd); 7147c478bd9Sstevel@tonic-gate } 7157c478bd9Sstevel@tonic-gate arg.desc_ptr++; 7167c478bd9Sstevel@tonic-gate arg.desc_num--; 7177c478bd9Sstevel@tonic-gate } 7187c478bd9Sstevel@tonic-gate } 7197c478bd9Sstevel@tonic-gate if (arg.desc_num == 1 && arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) 7207c478bd9Sstevel@tonic-gate *res_fd = arg.desc_ptr->d_data.d_desc.d_descriptor; 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate if (arg.data_size > 0) 7237c478bd9Sstevel@tonic-gate (void) memmove(res, arg.data_ptr, MIN(arg.data_size, res_sz)); 7247c478bd9Sstevel@tonic-gate 7257c478bd9Sstevel@tonic-gate if (arg.rbuf != rbuf) 7267c478bd9Sstevel@tonic-gate (void) munmap(arg.rbuf, arg.rsize); 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate if (arg.data_size > res_sz) 7297c478bd9Sstevel@tonic-gate return (RESULT_TOO_BIG); 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate if (arg.data_size < sizeof (uint32_t)) 7327c478bd9Sstevel@tonic-gate return (CALL_FAILED); 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate return (arg.data_size); 7357c478bd9Sstevel@tonic-gate } 7367c478bd9Sstevel@tonic-gate 7377c478bd9Sstevel@tonic-gate /* 7387c478bd9Sstevel@tonic-gate * Fails with 7397c478bd9Sstevel@tonic-gate * _VERSION_MISMATCH 7407c478bd9Sstevel@tonic-gate * _NO_MEMORY 7417c478bd9Sstevel@tonic-gate */ 7427c478bd9Sstevel@tonic-gate scf_handle_t * 7437c478bd9Sstevel@tonic-gate scf_handle_create(scf_version_t v) 7447c478bd9Sstevel@tonic-gate { 7457c478bd9Sstevel@tonic-gate scf_handle_t *ret; 7467c478bd9Sstevel@tonic-gate int failed; 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate /* 7497c478bd9Sstevel@tonic-gate * This will need to be revisited when we bump SCF_VERSION 7507c478bd9Sstevel@tonic-gate */ 7517c478bd9Sstevel@tonic-gate if (v != SCF_VERSION) { 7527c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_VERSION_MISMATCH); 7537c478bd9Sstevel@tonic-gate return (NULL); 7547c478bd9Sstevel@tonic-gate } 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate if (!lowlevel_init()) { 7577c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 7587c478bd9Sstevel@tonic-gate return (NULL); 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate 7617c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 7627c478bd9Sstevel@tonic-gate if (ret == NULL) { 7637c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 7647c478bd9Sstevel@tonic-gate return (NULL); 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate ret->rh_dataels = uu_list_create(datael_pool, ret, 0); 7687c478bd9Sstevel@tonic-gate ret->rh_iters = uu_list_create(iter_pool, ret, 0); 7697c478bd9Sstevel@tonic-gate if (ret->rh_dataels == NULL || ret->rh_iters == NULL) { 7707c478bd9Sstevel@tonic-gate if (ret->rh_dataels != NULL) 7717c478bd9Sstevel@tonic-gate uu_list_destroy(ret->rh_dataels); 7727c478bd9Sstevel@tonic-gate if (ret->rh_iters != NULL) 7737c478bd9Sstevel@tonic-gate uu_list_destroy(ret->rh_iters); 7747c478bd9Sstevel@tonic-gate uu_free(ret); 7757c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 7767c478bd9Sstevel@tonic-gate return (NULL); 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate ret->rh_doorfd = -1; 7807c478bd9Sstevel@tonic-gate ret->rh_doorfd_old = -1; 7817c478bd9Sstevel@tonic-gate (void) pthread_mutex_init(&ret->rh_lock, NULL); 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate handle_hold_subhandles(ret, RH_HOLD_ALL); 7847c478bd9Sstevel@tonic-gate 7857c478bd9Sstevel@tonic-gate failed = ((ret->rh_iter = scf_iter_create(ret)) == NULL || 7867c478bd9Sstevel@tonic-gate (ret->rh_scope = scf_scope_create(ret)) == NULL || 7877c478bd9Sstevel@tonic-gate (ret->rh_service = scf_service_create(ret)) == NULL || 7887c478bd9Sstevel@tonic-gate (ret->rh_instance = scf_instance_create(ret)) == NULL || 7897c478bd9Sstevel@tonic-gate (ret->rh_snapshot = scf_snapshot_create(ret)) == NULL || 7907c478bd9Sstevel@tonic-gate (ret->rh_snaplvl = scf_snaplevel_create(ret)) == NULL || 7917c478bd9Sstevel@tonic-gate (ret->rh_pg = scf_pg_create(ret)) == NULL || 7927c478bd9Sstevel@tonic-gate (ret->rh_property = scf_property_create(ret)) == NULL || 7937c478bd9Sstevel@tonic-gate (ret->rh_value = scf_value_create(ret)) == NULL); 7947c478bd9Sstevel@tonic-gate 7957c478bd9Sstevel@tonic-gate /* 7967c478bd9Sstevel@tonic-gate * these subhandles count as internal references, not external ones. 7977c478bd9Sstevel@tonic-gate */ 7987c478bd9Sstevel@tonic-gate ret->rh_intrefs = ret->rh_extrefs; 7997c478bd9Sstevel@tonic-gate ret->rh_extrefs = 0; 8007c478bd9Sstevel@tonic-gate handle_rele_subhandles(ret, RH_HOLD_ALL); 8017c478bd9Sstevel@tonic-gate 8027c478bd9Sstevel@tonic-gate if (failed) { 8037c478bd9Sstevel@tonic-gate scf_handle_destroy(ret); 8047c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 8057c478bd9Sstevel@tonic-gate return (NULL); 8067c478bd9Sstevel@tonic-gate } 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate scf_value_set_count(ret->rh_value, default_debug); 8097c478bd9Sstevel@tonic-gate (void) scf_handle_decorate(ret, "debug", ret->rh_value); 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate return (ret); 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate 814f6e214c7SGavin Maltby /* 815f6e214c7SGavin Maltby * Fails with 816f6e214c7SGavin Maltby * _NO_MEMORY 817f6e214c7SGavin Maltby * _NO_SERVER - server door could not be open()ed 818f6e214c7SGavin Maltby * door call failed 819f6e214c7SGavin Maltby * door_info() failed 820f6e214c7SGavin Maltby * _VERSION_MISMATCH - server returned bad file descriptor 821f6e214c7SGavin Maltby * server claimed bad request 822f6e214c7SGavin Maltby * server reported version mismatch 823f6e214c7SGavin Maltby * server refused with unknown reason 824f6e214c7SGavin Maltby * _INVALID_ARGUMENT 825f6e214c7SGavin Maltby * _NO_RESOURCES - server is out of memory 826f6e214c7SGavin Maltby * _PERMISSION_DENIED 827f6e214c7SGavin Maltby * _INTERNAL - could not set up entities or iters 828f6e214c7SGavin Maltby * server response too big 829f6e214c7SGavin Maltby */ 830f6e214c7SGavin Maltby scf_handle_t * 831f6e214c7SGavin Maltby _scf_handle_create_and_bind(scf_version_t ver) 832f6e214c7SGavin Maltby { 833f6e214c7SGavin Maltby scf_handle_t *h; 834f6e214c7SGavin Maltby 835f6e214c7SGavin Maltby h = scf_handle_create(ver); 836f6e214c7SGavin Maltby if (h == NULL) 837f6e214c7SGavin Maltby return (NULL); 838f6e214c7SGavin Maltby 839f6e214c7SGavin Maltby if (scf_handle_bind(h) == -1) { 840f6e214c7SGavin Maltby scf_handle_destroy(h); 841f6e214c7SGavin Maltby return (NULL); 842f6e214c7SGavin Maltby } 843f6e214c7SGavin Maltby return (h); 844f6e214c7SGavin Maltby } 845f6e214c7SGavin Maltby 8467c478bd9Sstevel@tonic-gate int 8477c478bd9Sstevel@tonic-gate scf_handle_decorate(scf_handle_t *handle, const char *name, scf_value_t *v) 8487c478bd9Sstevel@tonic-gate { 8497c478bd9Sstevel@tonic-gate if (v != SCF_DECORATE_CLEAR && handle != v->value_handle) 8507c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 8537c478bd9Sstevel@tonic-gate if (handle_is_bound(handle)) { 8547c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 8557c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_IN_USE)); 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 8587c478bd9Sstevel@tonic-gate 8597c478bd9Sstevel@tonic-gate if (strcmp(name, "debug") == 0) { 8607c478bd9Sstevel@tonic-gate if (v == SCF_DECORATE_CLEAR) { 8617c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 8627c478bd9Sstevel@tonic-gate handle->rh_debug = 0; 8637c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 8647c478bd9Sstevel@tonic-gate } else { 8657c478bd9Sstevel@tonic-gate uint64_t val; 8667c478bd9Sstevel@tonic-gate if (scf_value_get_count(v, &val) < 0) 8677c478bd9Sstevel@tonic-gate return (-1); /* error already set */ 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 8707c478bd9Sstevel@tonic-gate handle->rh_debug = (uid_t)val; 8717c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 8727c478bd9Sstevel@tonic-gate } 8737c478bd9Sstevel@tonic-gate return (0); 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate if (strcmp(name, "door_path") == 0) { 8767c478bd9Sstevel@tonic-gate char name[sizeof (handle->rh_doorpath)]; 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate if (v == SCF_DECORATE_CLEAR) { 8797c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 8807c478bd9Sstevel@tonic-gate handle->rh_doorpath[0] = 0; 8817c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 8827c478bd9Sstevel@tonic-gate } else { 8837c478bd9Sstevel@tonic-gate ssize_t len; 8847c478bd9Sstevel@tonic-gate 8857c478bd9Sstevel@tonic-gate if ((len = scf_value_get_astring(v, name, 8867c478bd9Sstevel@tonic-gate sizeof (name))) < 0) { 8877c478bd9Sstevel@tonic-gate return (-1); /* error already set */ 8887c478bd9Sstevel@tonic-gate } 8897c478bd9Sstevel@tonic-gate if (len == 0 || len >= sizeof (name)) { 8907c478bd9Sstevel@tonic-gate return (scf_set_error( 8917c478bd9Sstevel@tonic-gate SCF_ERROR_INVALID_ARGUMENT)); 8927c478bd9Sstevel@tonic-gate } 8937c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 8947c478bd9Sstevel@tonic-gate (void) strlcpy(handle->rh_doorpath, name, 8957c478bd9Sstevel@tonic-gate sizeof (handle->rh_doorpath)); 8967c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate return (0); 8997c478bd9Sstevel@tonic-gate } 900048b0279SBryan Cantrill 901048b0279SBryan Cantrill if (strcmp(name, "zone") == 0) { 902048b0279SBryan Cantrill char zone[MAXPATHLEN], root[MAXPATHLEN], door[MAXPATHLEN]; 903048b0279SBryan Cantrill static int (*zone_get_rootpath)(char *, char *, size_t); 904048b0279SBryan Cantrill ssize_t len; 905048b0279SBryan Cantrill 906048b0279SBryan Cantrill /* 907048b0279SBryan Cantrill * In order to be able to set the zone on a handle, we want 908048b0279SBryan Cantrill * to determine the zone's path, which requires us to call into 909048b0279SBryan Cantrill * libzonecfg -- but libzonecfg.so links against libscf.so so 910048b0279SBryan Cantrill * we must not explicitly link to it. To circumvent the 911048b0279SBryan Cantrill * circular dependency, we will pull it in here via dlopen(). 912048b0279SBryan Cantrill */ 913048b0279SBryan Cantrill if (zone_get_rootpath == NULL) { 914048b0279SBryan Cantrill void *dl = dlopen("libzonecfg.so.1", RTLD_LAZY), *sym; 915048b0279SBryan Cantrill 916048b0279SBryan Cantrill if (dl == NULL) 917048b0279SBryan Cantrill return (scf_set_error(SCF_ERROR_NOT_FOUND)); 918048b0279SBryan Cantrill 919048b0279SBryan Cantrill if ((sym = dlsym(dl, "zone_get_rootpath")) == NULL) { 920048b0279SBryan Cantrill (void) dlclose(dl); 921048b0279SBryan Cantrill return (scf_set_error(SCF_ERROR_INTERNAL)); 922048b0279SBryan Cantrill } 923048b0279SBryan Cantrill 924048b0279SBryan Cantrill zone_get_rootpath = (int(*)(char *, char *, size_t))sym; 925048b0279SBryan Cantrill } 926048b0279SBryan Cantrill 927048b0279SBryan Cantrill if (v == SCF_DECORATE_CLEAR) { 928048b0279SBryan Cantrill (void) pthread_mutex_lock(&handle->rh_lock); 929048b0279SBryan Cantrill handle->rh_doorpath[0] = 0; 930048b0279SBryan Cantrill (void) pthread_mutex_unlock(&handle->rh_lock); 931048b0279SBryan Cantrill 932048b0279SBryan Cantrill return (0); 933048b0279SBryan Cantrill } 934048b0279SBryan Cantrill 935048b0279SBryan Cantrill if ((len = scf_value_get_astring(v, zone, sizeof (zone))) < 0) 936048b0279SBryan Cantrill return (-1); 937048b0279SBryan Cantrill 938048b0279SBryan Cantrill if (len == 0 || len >= sizeof (zone)) 939048b0279SBryan Cantrill return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 940048b0279SBryan Cantrill 941048b0279SBryan Cantrill if (zone_get_rootpath(zone, root, sizeof (root)) != Z_OK) { 942048b0279SBryan Cantrill if (strcmp(zone, GLOBAL_ZONENAME) == 0) { 943048b0279SBryan Cantrill root[0] = '\0'; 944048b0279SBryan Cantrill } else { 945048b0279SBryan Cantrill return (scf_set_error(SCF_ERROR_NOT_FOUND)); 946048b0279SBryan Cantrill } 947048b0279SBryan Cantrill } 948048b0279SBryan Cantrill 949048b0279SBryan Cantrill if (snprintf(door, sizeof (door), "%s/%s", root, 950048b0279SBryan Cantrill default_door_path) >= sizeof (door)) 951048b0279SBryan Cantrill return (scf_set_error(SCF_ERROR_INTERNAL)); 952048b0279SBryan Cantrill 953048b0279SBryan Cantrill (void) pthread_mutex_lock(&handle->rh_lock); 954048b0279SBryan Cantrill (void) strlcpy(handle->rh_doorpath, door, 955048b0279SBryan Cantrill sizeof (handle->rh_doorpath)); 956048b0279SBryan Cantrill (void) pthread_mutex_unlock(&handle->rh_lock); 957048b0279SBryan Cantrill 958048b0279SBryan Cantrill return (0); 959048b0279SBryan Cantrill } 960048b0279SBryan Cantrill 9617c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 9627c478bd9Sstevel@tonic-gate } 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate /* 9657c478bd9Sstevel@tonic-gate * fails with INVALID_ARGUMENT and HANDLE_MISMATCH. 9667c478bd9Sstevel@tonic-gate */ 9677c478bd9Sstevel@tonic-gate int 9687c478bd9Sstevel@tonic-gate _scf_handle_decorations(scf_handle_t *handle, scf_decoration_func *f, 9697c478bd9Sstevel@tonic-gate scf_value_t *v, void *data) 9707c478bd9Sstevel@tonic-gate { 9717c478bd9Sstevel@tonic-gate scf_decoration_info_t i; 9727c478bd9Sstevel@tonic-gate char name[sizeof (handle->rh_doorpath)]; 9737c478bd9Sstevel@tonic-gate uint64_t debug; 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate if (f == NULL || v == NULL) 9767c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 9777c478bd9Sstevel@tonic-gate 9787c478bd9Sstevel@tonic-gate if (v->value_handle != handle) 9797c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate i.sdi_name = (const char *)"debug"; 9827c478bd9Sstevel@tonic-gate i.sdi_type = SCF_TYPE_COUNT; 9837c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 9847c478bd9Sstevel@tonic-gate debug = handle->rh_debug; 9857c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 9867c478bd9Sstevel@tonic-gate if (debug != 0) { 9877c478bd9Sstevel@tonic-gate scf_value_set_count(v, debug); 9887c478bd9Sstevel@tonic-gate i.sdi_value = v; 9897c478bd9Sstevel@tonic-gate } else { 9907c478bd9Sstevel@tonic-gate i.sdi_value = SCF_DECORATE_CLEAR; 9917c478bd9Sstevel@tonic-gate } 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate if ((*f)(&i, data) == 0) 9947c478bd9Sstevel@tonic-gate return (0); 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate i.sdi_name = (const char *)"door_path"; 9977c478bd9Sstevel@tonic-gate i.sdi_type = SCF_TYPE_ASTRING; 9987c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 9997c478bd9Sstevel@tonic-gate (void) strlcpy(name, handle->rh_doorpath, sizeof (name)); 10007c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 10017c478bd9Sstevel@tonic-gate if (name[0] != 0) { 10027c478bd9Sstevel@tonic-gate (void) scf_value_set_astring(v, name); 10037c478bd9Sstevel@tonic-gate i.sdi_value = v; 10047c478bd9Sstevel@tonic-gate } else { 10057c478bd9Sstevel@tonic-gate i.sdi_value = SCF_DECORATE_CLEAR; 10067c478bd9Sstevel@tonic-gate } 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate if ((*f)(&i, data) == 0) 10097c478bd9Sstevel@tonic-gate return (0); 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate return (1); 10127c478bd9Sstevel@tonic-gate } 10137c478bd9Sstevel@tonic-gate 10147c478bd9Sstevel@tonic-gate /* 10157c478bd9Sstevel@tonic-gate * Fails if handle is not bound. 10167c478bd9Sstevel@tonic-gate */ 10177c478bd9Sstevel@tonic-gate static int 10187c478bd9Sstevel@tonic-gate handle_unbind_unlocked(scf_handle_t *handle) 10197c478bd9Sstevel@tonic-gate { 10207c478bd9Sstevel@tonic-gate rep_protocol_request_t request; 10217c478bd9Sstevel@tonic-gate rep_protocol_response_t response; 10227c478bd9Sstevel@tonic-gate 10237c478bd9Sstevel@tonic-gate if (!handle_is_bound(handle)) 10247c478bd9Sstevel@tonic-gate return (-1); 10257c478bd9Sstevel@tonic-gate 10267c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_CLOSE; 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate (void) make_door_call(handle, &request, sizeof (request), 10297c478bd9Sstevel@tonic-gate &response, sizeof (response)); 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate handle_do_close(handle); 10327c478bd9Sstevel@tonic-gate 10337c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 10347c478bd9Sstevel@tonic-gate } 10357c478bd9Sstevel@tonic-gate 10367c478bd9Sstevel@tonic-gate /* 10377c478bd9Sstevel@tonic-gate * Fails with 10387c478bd9Sstevel@tonic-gate * _HANDLE_DESTROYED - dp's handle has been destroyed 10397c478bd9Sstevel@tonic-gate * _INTERNAL - server response too big 10407c478bd9Sstevel@tonic-gate * entity already set up with different type 10417c478bd9Sstevel@tonic-gate * _NO_RESOURCES - server out of memory 10427c478bd9Sstevel@tonic-gate */ 10437c478bd9Sstevel@tonic-gate static int 10447c478bd9Sstevel@tonic-gate datael_attach(scf_datael_t *dp) 10457c478bd9Sstevel@tonic-gate { 10467c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate struct rep_protocol_entity_setup request; 10497c478bd9Sstevel@tonic-gate rep_protocol_response_t response; 10507c478bd9Sstevel@tonic-gate ssize_t r; 10517c478bd9Sstevel@tonic-gate 10527c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 10537c478bd9Sstevel@tonic-gate 10547c478bd9Sstevel@tonic-gate dp->rd_reset = 0; /* setup implicitly resets */ 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate if (h->rh_flags & HANDLE_DEAD) 10577c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED)); 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate if (!handle_is_bound(h)) 10607c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); /* nothing to do */ 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_SETUP; 10637c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 10647c478bd9Sstevel@tonic-gate request.rpr_entitytype = dp->rd_type; 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 10677c478bd9Sstevel@tonic-gate &response, sizeof (response)); 10687c478bd9Sstevel@tonic-gate 10697c478bd9Sstevel@tonic-gate if (r == NOT_BOUND || r == CALL_FAILED) 10707c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 10717c478bd9Sstevel@tonic-gate if (r == RESULT_TOO_BIG) 10727c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 10757c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate /* 10817c478bd9Sstevel@tonic-gate * Fails with 10827c478bd9Sstevel@tonic-gate * _HANDLE_DESTROYED - iter's handle has been destroyed 10837c478bd9Sstevel@tonic-gate * _INTERNAL - server response too big 10847c478bd9Sstevel@tonic-gate * iter already existed 10857c478bd9Sstevel@tonic-gate * _NO_RESOURCES 10867c478bd9Sstevel@tonic-gate */ 10877c478bd9Sstevel@tonic-gate static int 10887c478bd9Sstevel@tonic-gate iter_attach(scf_iter_t *iter) 10897c478bd9Sstevel@tonic-gate { 10907c478bd9Sstevel@tonic-gate scf_handle_t *h = iter->iter_handle; 10917c478bd9Sstevel@tonic-gate struct rep_protocol_iter_request request; 10927c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 10937c478bd9Sstevel@tonic-gate int r; 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate if (h->rh_flags & HANDLE_DEAD) 10987c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED)); 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate if (!handle_is_bound(h)) 11017c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); /* nothing to do */ 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_SETUP; 11047c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 11057c478bd9Sstevel@tonic-gate 11067c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 11077c478bd9Sstevel@tonic-gate &response, sizeof (response)); 11087c478bd9Sstevel@tonic-gate 11097c478bd9Sstevel@tonic-gate if (r == NOT_BOUND || r == CALL_FAILED) 11107c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 11117c478bd9Sstevel@tonic-gate if (r == RESULT_TOO_BIG) 11127c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 11157c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 11187c478bd9Sstevel@tonic-gate } 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate /* 11217c478bd9Sstevel@tonic-gate * Fails with 11227c478bd9Sstevel@tonic-gate * _IN_USE - handle already bound 11237c478bd9Sstevel@tonic-gate * _NO_SERVER - server door could not be open()ed 11247c478bd9Sstevel@tonic-gate * door call failed 11257c478bd9Sstevel@tonic-gate * door_info() failed 11267c478bd9Sstevel@tonic-gate * _VERSION_MISMATCH - server returned bad file descriptor 11277c478bd9Sstevel@tonic-gate * server claimed bad request 11287c478bd9Sstevel@tonic-gate * server reported version mismatch 11297c478bd9Sstevel@tonic-gate * server refused with unknown reason 11307c478bd9Sstevel@tonic-gate * _INVALID_ARGUMENT 11317c478bd9Sstevel@tonic-gate * _NO_RESOURCES - server is out of memory 11327c478bd9Sstevel@tonic-gate * _PERMISSION_DENIED 11337c478bd9Sstevel@tonic-gate * _INTERNAL - could not set up entities or iters 11347c478bd9Sstevel@tonic-gate * server response too big 11357c478bd9Sstevel@tonic-gate * 11367c478bd9Sstevel@tonic-gate * perhaps this should try multiple times. 11377c478bd9Sstevel@tonic-gate */ 11387c478bd9Sstevel@tonic-gate int 11397c478bd9Sstevel@tonic-gate scf_handle_bind(scf_handle_t *handle) 11407c478bd9Sstevel@tonic-gate { 11417c478bd9Sstevel@tonic-gate scf_datael_t *el; 11427c478bd9Sstevel@tonic-gate scf_iter_t *iter; 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate pid_t pid; 11457c478bd9Sstevel@tonic-gate int fd; 11467c478bd9Sstevel@tonic-gate int res; 11477c478bd9Sstevel@tonic-gate door_info_t info; 11487c478bd9Sstevel@tonic-gate repository_door_request_t request; 11497c478bd9Sstevel@tonic-gate repository_door_response_t response; 11507c478bd9Sstevel@tonic-gate const char *door_name = default_door_path; 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 11537c478bd9Sstevel@tonic-gate if (handle_is_bound(handle)) { 11547c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 11557c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_IN_USE)); 11567c478bd9Sstevel@tonic-gate } 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate /* wait until any active fd users have cleared out */ 1159a574db85Sraf while (handle->rh_fd_users > 0) { 1160a574db85Sraf int cancel_state; 1161a574db85Sraf 1162a574db85Sraf (void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 1163a574db85Sraf &cancel_state); 1164a574db85Sraf (void) pthread_cond_wait(&handle->rh_cv, &handle->rh_lock); 1165a574db85Sraf (void) pthread_setcancelstate(cancel_state, NULL); 1166a574db85Sraf } 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate /* check again, since we had to drop the lock */ 11697c478bd9Sstevel@tonic-gate if (handle_is_bound(handle)) { 11707c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 11717c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_IN_USE)); 11727c478bd9Sstevel@tonic-gate } 11737c478bd9Sstevel@tonic-gate 11747c478bd9Sstevel@tonic-gate assert(handle->rh_doorfd == -1 && handle->rh_doorfd_old == -1); 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate if (handle->rh_doorpath[0] != 0) 11777c478bd9Sstevel@tonic-gate door_name = handle->rh_doorpath; 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate fd = open(door_name, O_RDONLY, 0); 11807c478bd9Sstevel@tonic-gate if (fd == -1) { 11817c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 11827c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NO_SERVER)); 11837c478bd9Sstevel@tonic-gate } 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate request.rdr_version = REPOSITORY_DOOR_VERSION; 11867c478bd9Sstevel@tonic-gate request.rdr_request = REPOSITORY_DOOR_REQUEST_CONNECT; 11877c478bd9Sstevel@tonic-gate request.rdr_flags = handle->rh_flags; 11887c478bd9Sstevel@tonic-gate request.rdr_debug = handle->rh_debug; 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate pid = getpid(); 11917c478bd9Sstevel@tonic-gate 11927c478bd9Sstevel@tonic-gate res = make_door_call_retfd(fd, &request, sizeof (request), 11937c478bd9Sstevel@tonic-gate &response, sizeof (response), &handle->rh_doorfd); 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate (void) close(fd); 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate if (res < 0) { 11987c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate assert(res != NOT_BOUND); 12017c478bd9Sstevel@tonic-gate if (res == CALL_FAILED) 12027c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NO_SERVER)); 12037c478bd9Sstevel@tonic-gate assert(res == RESULT_TOO_BIG); 12047c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 12057c478bd9Sstevel@tonic-gate } 12067c478bd9Sstevel@tonic-gate 12077c478bd9Sstevel@tonic-gate if (handle->rh_doorfd < 0) { 12087c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate switch (response.rdr_status) { 12117c478bd9Sstevel@tonic-gate case REPOSITORY_DOOR_SUCCESS: 12127c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_VERSION_MISMATCH)); 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate case REPOSITORY_DOOR_FAIL_BAD_REQUEST: 12157c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_VERSION_MISMATCH)); 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate case REPOSITORY_DOOR_FAIL_VERSION_MISMATCH: 12187c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_VERSION_MISMATCH)); 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate case REPOSITORY_DOOR_FAIL_BAD_FLAG: 12217c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate case REPOSITORY_DOOR_FAIL_NO_RESOURCES: 12247c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NO_RESOURCES)); 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate case REPOSITORY_DOOR_FAIL_PERMISSION_DENIED: 12277c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_PERMISSION_DENIED)); 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate default: 12307c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_VERSION_MISMATCH)); 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate 12347c478bd9Sstevel@tonic-gate (void) fcntl(handle->rh_doorfd, F_SETFD, FD_CLOEXEC); 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate if (door_info(handle->rh_doorfd, &info) < 0) { 12377c478bd9Sstevel@tonic-gate (void) close(handle->rh_doorfd); 12387c478bd9Sstevel@tonic-gate handle->rh_doorfd = -1; 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 12417c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NO_SERVER)); 12427c478bd9Sstevel@tonic-gate } 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate handle->rh_doorpid = pid; 12457c478bd9Sstevel@tonic-gate handle->rh_doorid = info.di_uniquifier; 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate /* 12487c478bd9Sstevel@tonic-gate * Now, re-attach everything 12497c478bd9Sstevel@tonic-gate */ 12507c478bd9Sstevel@tonic-gate for (el = uu_list_first(handle->rh_dataels); el != NULL; 12517c478bd9Sstevel@tonic-gate el = uu_list_next(handle->rh_dataels, el)) { 12527c478bd9Sstevel@tonic-gate if (datael_attach(el) == -1) { 12537c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_HANDLE_DESTROYED); 12547c478bd9Sstevel@tonic-gate (void) handle_unbind_unlocked(handle); 12557c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 12567c478bd9Sstevel@tonic-gate return (-1); 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate for (iter = uu_list_first(handle->rh_iters); iter != NULL; 12617c478bd9Sstevel@tonic-gate iter = uu_list_next(handle->rh_iters, iter)) { 12627c478bd9Sstevel@tonic-gate if (iter_attach(iter) == -1) { 12637c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_HANDLE_DESTROYED); 12647c478bd9Sstevel@tonic-gate (void) handle_unbind_unlocked(handle); 12657c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 12667c478bd9Sstevel@tonic-gate return (-1); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate } 12697c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 12707c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 12717c478bd9Sstevel@tonic-gate } 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate int 12747c478bd9Sstevel@tonic-gate scf_handle_unbind(scf_handle_t *handle) 12757c478bd9Sstevel@tonic-gate { 12767c478bd9Sstevel@tonic-gate int ret; 12777c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 12787c478bd9Sstevel@tonic-gate ret = handle_unbind_unlocked(handle); 12797c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 12807c478bd9Sstevel@tonic-gate return (ret == SCF_SUCCESS ? ret : scf_set_error(SCF_ERROR_NOT_BOUND)); 12817c478bd9Sstevel@tonic-gate } 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate static scf_handle_t * 12847c478bd9Sstevel@tonic-gate handle_get(scf_handle_t *h) 12857c478bd9Sstevel@tonic-gate { 12867c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 12877c478bd9Sstevel@tonic-gate if (h->rh_flags & HANDLE_DEAD) { 12887c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 12897c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED); 12907c478bd9Sstevel@tonic-gate return (NULL); 12917c478bd9Sstevel@tonic-gate } 12927c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 12937c478bd9Sstevel@tonic-gate return (h); 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate /* 12977c478bd9Sstevel@tonic-gate * Called when an object is removed from the handle. On the last remove, 12987c478bd9Sstevel@tonic-gate * cleans up and frees the handle. 12997c478bd9Sstevel@tonic-gate */ 13007c478bd9Sstevel@tonic-gate static void 13017c478bd9Sstevel@tonic-gate handle_unrefed(scf_handle_t *handle) 13027c478bd9Sstevel@tonic-gate { 13037c478bd9Sstevel@tonic-gate scf_iter_t *iter; 13047c478bd9Sstevel@tonic-gate scf_value_t *v; 13057c478bd9Sstevel@tonic-gate scf_scope_t *sc; 13067c478bd9Sstevel@tonic-gate scf_service_t *svc; 13077c478bd9Sstevel@tonic-gate scf_instance_t *inst; 13087c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 13097c478bd9Sstevel@tonic-gate scf_snaplevel_t *snaplvl; 13107c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg; 13117c478bd9Sstevel@tonic-gate scf_property_t *prop; 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&handle->rh_lock)); 13147c478bd9Sstevel@tonic-gate 13157c478bd9Sstevel@tonic-gate /* 13167c478bd9Sstevel@tonic-gate * Don't do anything if the handle has not yet been destroyed, there 13177c478bd9Sstevel@tonic-gate * are still external references, or we're already doing unrefed 13187c478bd9Sstevel@tonic-gate * handling. 13197c478bd9Sstevel@tonic-gate */ 13207c478bd9Sstevel@tonic-gate if (!(handle->rh_flags & HANDLE_DEAD) || 13217c478bd9Sstevel@tonic-gate handle->rh_extrefs > 0 || 13227c478bd9Sstevel@tonic-gate handle->rh_fd_users > 0 || 13237c478bd9Sstevel@tonic-gate (handle->rh_flags & HANDLE_UNREFED)) { 13247c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 13257c478bd9Sstevel@tonic-gate return; 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate handle->rh_flags |= HANDLE_UNREFED; 13297c478bd9Sstevel@tonic-gate 13307c478bd9Sstevel@tonic-gate /* 13317c478bd9Sstevel@tonic-gate * Now that we know that there are no external references, and the 13327c478bd9Sstevel@tonic-gate * HANDLE_DEAD flag keeps new ones from appearing, we can clean up 13337c478bd9Sstevel@tonic-gate * our subhandles and destroy the handle completely. 13347c478bd9Sstevel@tonic-gate */ 13357c478bd9Sstevel@tonic-gate assert(handle->rh_intrefs >= 0); 13367c478bd9Sstevel@tonic-gate handle->rh_extrefs = handle->rh_intrefs; 13377c478bd9Sstevel@tonic-gate handle->rh_intrefs = 0; 13387c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate handle_hold_subhandles(handle, RH_HOLD_ALL); 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate iter = handle->rh_iter; 13437c478bd9Sstevel@tonic-gate sc = handle->rh_scope; 13447c478bd9Sstevel@tonic-gate svc = handle->rh_service; 13457c478bd9Sstevel@tonic-gate inst = handle->rh_instance; 13467c478bd9Sstevel@tonic-gate snap = handle->rh_snapshot; 13477c478bd9Sstevel@tonic-gate snaplvl = handle->rh_snaplvl; 13487c478bd9Sstevel@tonic-gate pg = handle->rh_pg; 13497c478bd9Sstevel@tonic-gate prop = handle->rh_property; 13507c478bd9Sstevel@tonic-gate v = handle->rh_value; 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate handle->rh_iter = NULL; 13537c478bd9Sstevel@tonic-gate handle->rh_scope = NULL; 13547c478bd9Sstevel@tonic-gate handle->rh_service = NULL; 13557c478bd9Sstevel@tonic-gate handle->rh_instance = NULL; 13567c478bd9Sstevel@tonic-gate handle->rh_snapshot = NULL; 13577c478bd9Sstevel@tonic-gate handle->rh_snaplvl = NULL; 13587c478bd9Sstevel@tonic-gate handle->rh_pg = NULL; 13597c478bd9Sstevel@tonic-gate handle->rh_property = NULL; 13607c478bd9Sstevel@tonic-gate handle->rh_value = NULL; 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate if (iter != NULL) 13637c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 13647c478bd9Sstevel@tonic-gate if (sc != NULL) 13657c478bd9Sstevel@tonic-gate scf_scope_destroy(sc); 13667c478bd9Sstevel@tonic-gate if (svc != NULL) 13677c478bd9Sstevel@tonic-gate scf_service_destroy(svc); 13687c478bd9Sstevel@tonic-gate if (inst != NULL) 13697c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 13707c478bd9Sstevel@tonic-gate if (snap != NULL) 13717c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 13727c478bd9Sstevel@tonic-gate if (snaplvl != NULL) 13737c478bd9Sstevel@tonic-gate scf_snaplevel_destroy(snaplvl); 13747c478bd9Sstevel@tonic-gate if (pg != NULL) 13757c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 13767c478bd9Sstevel@tonic-gate if (prop != NULL) 13777c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 13787c478bd9Sstevel@tonic-gate if (v != NULL) 13797c478bd9Sstevel@tonic-gate scf_value_destroy(v); 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate /* there should be no outstanding children at this point */ 13847c478bd9Sstevel@tonic-gate assert(handle->rh_extrefs == 0); 13857c478bd9Sstevel@tonic-gate assert(handle->rh_intrefs == 0); 13867c478bd9Sstevel@tonic-gate assert(handle->rh_values == 0); 13877c478bd9Sstevel@tonic-gate assert(handle->rh_entries == 0); 13887c478bd9Sstevel@tonic-gate assert(uu_list_numnodes(handle->rh_dataels) == 0); 13897c478bd9Sstevel@tonic-gate assert(uu_list_numnodes(handle->rh_iters) == 0); 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate uu_list_destroy(handle->rh_dataels); 13927c478bd9Sstevel@tonic-gate uu_list_destroy(handle->rh_iters); 13937c478bd9Sstevel@tonic-gate handle->rh_dataels = NULL; 13947c478bd9Sstevel@tonic-gate handle->rh_iters = NULL; 13957c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate (void) pthread_mutex_destroy(&handle->rh_lock); 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate uu_free(handle); 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate 14027c478bd9Sstevel@tonic-gate void 14037c478bd9Sstevel@tonic-gate scf_handle_destroy(scf_handle_t *handle) 14047c478bd9Sstevel@tonic-gate { 14057c478bd9Sstevel@tonic-gate if (handle == NULL) 14067c478bd9Sstevel@tonic-gate return; 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 14097c478bd9Sstevel@tonic-gate if (handle->rh_flags & HANDLE_DEAD) { 14107c478bd9Sstevel@tonic-gate /* 14117c478bd9Sstevel@tonic-gate * This is an error (you are not allowed to reference the 14127c478bd9Sstevel@tonic-gate * handle after it is destroyed), but we can't report it. 14137c478bd9Sstevel@tonic-gate */ 14147c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&handle->rh_lock); 14157c478bd9Sstevel@tonic-gate return; 14167c478bd9Sstevel@tonic-gate } 14177c478bd9Sstevel@tonic-gate handle->rh_flags |= HANDLE_DEAD; 14187c478bd9Sstevel@tonic-gate (void) handle_unbind_unlocked(handle); 14197c478bd9Sstevel@tonic-gate handle_unrefed(handle); 14207c478bd9Sstevel@tonic-gate } 14217c478bd9Sstevel@tonic-gate 14227c478bd9Sstevel@tonic-gate ssize_t 14237c478bd9Sstevel@tonic-gate scf_myname(scf_handle_t *h, char *out, size_t len) 14247c478bd9Sstevel@tonic-gate { 14257c478bd9Sstevel@tonic-gate char *cp; 14267c478bd9Sstevel@tonic-gate 14277c478bd9Sstevel@tonic-gate if (!handle_has_server(h)) 14287c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN)); 14297c478bd9Sstevel@tonic-gate 14307c478bd9Sstevel@tonic-gate cp = getenv("SMF_FMRI"); 14317c478bd9Sstevel@tonic-gate if (cp == NULL) 14327c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate return (strlcpy(out, cp, len)); 14357c478bd9Sstevel@tonic-gate } 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate static uint32_t 14388918dff3Sjwadams handle_alloc_entityid(scf_handle_t *h) 14397c478bd9Sstevel@tonic-gate { 14408918dff3Sjwadams uint32_t nextid; 14418918dff3Sjwadams 14428918dff3Sjwadams assert(MUTEX_HELD(&h->rh_lock)); 14438918dff3Sjwadams 14448918dff3Sjwadams if (uu_list_numnodes(h->rh_dataels) == UINT32_MAX) 14458918dff3Sjwadams return (0); /* no ids available */ 14468918dff3Sjwadams 14478918dff3Sjwadams /* 14488918dff3Sjwadams * The following loop assumes that there are not a huge number of 14498918dff3Sjwadams * outstanding entities when we've wrapped. If that ends up not 14508918dff3Sjwadams * being the case, the O(N^2) nature of this search will hurt a lot, 14518918dff3Sjwadams * and the data structure should be switched to an AVL tree. 14528918dff3Sjwadams */ 14538918dff3Sjwadams nextid = h->rh_nextentity + 1; 14548918dff3Sjwadams for (;;) { 14558918dff3Sjwadams scf_datael_t *cur; 14568918dff3Sjwadams 14578918dff3Sjwadams if (nextid == 0) { 14588918dff3Sjwadams nextid++; 14598918dff3Sjwadams h->rh_flags |= HANDLE_WRAPPED_ENTITY; 14608918dff3Sjwadams } 14618918dff3Sjwadams if (!(h->rh_flags & HANDLE_WRAPPED_ENTITY)) 14628918dff3Sjwadams break; 14638918dff3Sjwadams 14648918dff3Sjwadams cur = uu_list_find(h->rh_dataels, NULL, &nextid, NULL); 14658918dff3Sjwadams if (cur == NULL) 14668918dff3Sjwadams break; /* not in use */ 14678918dff3Sjwadams 14688918dff3Sjwadams if (nextid == h->rh_nextentity) 14698918dff3Sjwadams return (0); /* wrapped around; no ids available */ 14708918dff3Sjwadams nextid++; 14718918dff3Sjwadams } 14728918dff3Sjwadams 14738918dff3Sjwadams h->rh_nextentity = nextid; 14748918dff3Sjwadams return (nextid); 14757c478bd9Sstevel@tonic-gate } 14767c478bd9Sstevel@tonic-gate 14777c478bd9Sstevel@tonic-gate static uint32_t 14788918dff3Sjwadams handle_alloc_iterid(scf_handle_t *h) 14797c478bd9Sstevel@tonic-gate { 14808918dff3Sjwadams uint32_t nextid; 14818918dff3Sjwadams 14828918dff3Sjwadams assert(MUTEX_HELD(&h->rh_lock)); 14838918dff3Sjwadams 14848918dff3Sjwadams if (uu_list_numnodes(h->rh_iters) == UINT32_MAX) 14858918dff3Sjwadams return (0); /* no ids available */ 14868918dff3Sjwadams 14878918dff3Sjwadams /* see the comment in handle_alloc_entityid */ 14888918dff3Sjwadams nextid = h->rh_nextiter + 1; 14898918dff3Sjwadams for (;;) { 14908918dff3Sjwadams scf_iter_t *cur; 14918918dff3Sjwadams 14928918dff3Sjwadams if (nextid == 0) { 14938918dff3Sjwadams nextid++; 14948918dff3Sjwadams h->rh_flags |= HANDLE_WRAPPED_ITER; 14958918dff3Sjwadams } 14968918dff3Sjwadams if (!(h->rh_flags & HANDLE_WRAPPED_ITER)) 14978918dff3Sjwadams break; /* not yet wrapped */ 14988918dff3Sjwadams 14998918dff3Sjwadams cur = uu_list_find(h->rh_iters, NULL, &nextid, NULL); 15008918dff3Sjwadams if (cur == NULL) 15018918dff3Sjwadams break; /* not in use */ 15028918dff3Sjwadams 15038918dff3Sjwadams if (nextid == h->rh_nextiter) 15048918dff3Sjwadams return (0); /* wrapped around; no ids available */ 15058918dff3Sjwadams nextid++; 15068918dff3Sjwadams } 15078918dff3Sjwadams 15088918dff3Sjwadams h->rh_nextiter = nextid; 15098918dff3Sjwadams return (nextid); 15107c478bd9Sstevel@tonic-gate } 15117c478bd9Sstevel@tonic-gate 15127c478bd9Sstevel@tonic-gate static uint32_t 15138918dff3Sjwadams handle_next_changeid(scf_handle_t *handle) 15147c478bd9Sstevel@tonic-gate { 15158918dff3Sjwadams uint32_t nextid; 15168918dff3Sjwadams 15177c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&handle->rh_lock)); 15188918dff3Sjwadams 15198918dff3Sjwadams nextid = ++handle->rh_nextchangeid; 15208918dff3Sjwadams if (nextid == 0) 15218918dff3Sjwadams nextid = ++handle->rh_nextchangeid; 15228918dff3Sjwadams return (nextid); 15237c478bd9Sstevel@tonic-gate } 15247c478bd9Sstevel@tonic-gate 15257c478bd9Sstevel@tonic-gate /* 15267c478bd9Sstevel@tonic-gate * Fails with 15277c478bd9Sstevel@tonic-gate * _INVALID_ARGUMENT - h is NULL 15287c478bd9Sstevel@tonic-gate * _HANDLE_DESTROYED 15297c478bd9Sstevel@tonic-gate * _INTERNAL - server response too big 15307c478bd9Sstevel@tonic-gate * entity already set up with different type 15317c478bd9Sstevel@tonic-gate * _NO_RESOURCES 15327c478bd9Sstevel@tonic-gate */ 15337c478bd9Sstevel@tonic-gate static int 15347c478bd9Sstevel@tonic-gate datael_init(scf_datael_t *dp, scf_handle_t *h, uint32_t type) 15357c478bd9Sstevel@tonic-gate { 15367c478bd9Sstevel@tonic-gate int ret; 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate if (h == NULL) 15397c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate uu_list_node_init(dp, &dp->rd_node, datael_pool); 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate dp->rd_handle = h; 15447c478bd9Sstevel@tonic-gate dp->rd_type = type; 15457c478bd9Sstevel@tonic-gate dp->rd_reset = 0; 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 15487c478bd9Sstevel@tonic-gate if (h->rh_flags & HANDLE_DEAD) { 15497c478bd9Sstevel@tonic-gate /* 15507c478bd9Sstevel@tonic-gate * we're in undefined territory (the user cannot use a handle 15517c478bd9Sstevel@tonic-gate * directly after it has been destroyed), but we don't want 15527c478bd9Sstevel@tonic-gate * to allow any new references to happen, so we fail here. 15537c478bd9Sstevel@tonic-gate */ 15547c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 15557c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED)); 15567c478bd9Sstevel@tonic-gate } 15577c478bd9Sstevel@tonic-gate dp->rd_entity = handle_alloc_entityid(h); 15588918dff3Sjwadams if (dp->rd_entity == 0) { 15598918dff3Sjwadams (void) pthread_mutex_unlock(&h->rh_lock); 15608918dff3Sjwadams uu_list_node_fini(dp, &dp->rd_node, datael_pool); 15618918dff3Sjwadams return (scf_set_error(SCF_ERROR_NO_MEMORY)); 15628918dff3Sjwadams } 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate ret = datael_attach(dp); 15657c478bd9Sstevel@tonic-gate if (ret == 0) { 15667c478bd9Sstevel@tonic-gate (void) uu_list_insert_before(h->rh_dataels, NULL, dp); 15677c478bd9Sstevel@tonic-gate h->rh_extrefs++; 15687c478bd9Sstevel@tonic-gate } else { 15697c478bd9Sstevel@tonic-gate uu_list_node_fini(dp, &dp->rd_node, datael_pool); 15707c478bd9Sstevel@tonic-gate } 15717c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 15727c478bd9Sstevel@tonic-gate 15737c478bd9Sstevel@tonic-gate return (ret); 15747c478bd9Sstevel@tonic-gate } 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate static void 15777c478bd9Sstevel@tonic-gate datael_destroy(scf_datael_t *dp) 15787c478bd9Sstevel@tonic-gate { 15797c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate struct rep_protocol_entity_teardown request; 15827c478bd9Sstevel@tonic-gate rep_protocol_response_t response; 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 15857c478bd9Sstevel@tonic-gate uu_list_remove(h->rh_dataels, dp); 15867c478bd9Sstevel@tonic-gate --h->rh_extrefs; 15877c478bd9Sstevel@tonic-gate 15887c478bd9Sstevel@tonic-gate if (handle_is_bound(h)) { 15897c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_TEARDOWN; 15907c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 15917c478bd9Sstevel@tonic-gate 15927c478bd9Sstevel@tonic-gate (void) make_door_call(h, &request, sizeof (request), 15937c478bd9Sstevel@tonic-gate &response, sizeof (response)); 15947c478bd9Sstevel@tonic-gate } 15957c478bd9Sstevel@tonic-gate handle_unrefed(h); /* drops h->rh_lock */ 15967c478bd9Sstevel@tonic-gate 15977c478bd9Sstevel@tonic-gate dp->rd_handle = NULL; 15987c478bd9Sstevel@tonic-gate } 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate static scf_handle_t * 16017c478bd9Sstevel@tonic-gate datael_handle(const scf_datael_t *dp) 16027c478bd9Sstevel@tonic-gate { 16037c478bd9Sstevel@tonic-gate return (handle_get(dp->rd_handle)); 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate /* 16077c478bd9Sstevel@tonic-gate * We delay ENTITY_RESETs until right before the entity is used. By doing 16087c478bd9Sstevel@tonic-gate * them lazily, we remove quite a few unnecessary calls. 16097c478bd9Sstevel@tonic-gate */ 16107c478bd9Sstevel@tonic-gate static void 16117c478bd9Sstevel@tonic-gate datael_do_reset_locked(scf_datael_t *dp) 16127c478bd9Sstevel@tonic-gate { 16137c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate struct rep_protocol_entity_reset request; 16167c478bd9Sstevel@tonic-gate rep_protocol_response_t response; 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 16197c478bd9Sstevel@tonic-gate 16207c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_RESET; 16217c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 16227c478bd9Sstevel@tonic-gate 16237c478bd9Sstevel@tonic-gate (void) make_door_call(h, &request, sizeof (request), 16247c478bd9Sstevel@tonic-gate &response, sizeof (response)); 16257c478bd9Sstevel@tonic-gate 16267c478bd9Sstevel@tonic-gate dp->rd_reset = 0; 16277c478bd9Sstevel@tonic-gate } 16287c478bd9Sstevel@tonic-gate 16297c478bd9Sstevel@tonic-gate static void 16307c478bd9Sstevel@tonic-gate datael_reset_locked(scf_datael_t *dp) 16317c478bd9Sstevel@tonic-gate { 16327c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&dp->rd_handle->rh_lock)); 16337c478bd9Sstevel@tonic-gate dp->rd_reset = 1; 16347c478bd9Sstevel@tonic-gate } 16357c478bd9Sstevel@tonic-gate 16367c478bd9Sstevel@tonic-gate static void 16377c478bd9Sstevel@tonic-gate datael_reset(scf_datael_t *dp) 16387c478bd9Sstevel@tonic-gate { 16397c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 16407c478bd9Sstevel@tonic-gate 16417c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 16427c478bd9Sstevel@tonic-gate dp->rd_reset = 1; 16437c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 16447c478bd9Sstevel@tonic-gate } 16457c478bd9Sstevel@tonic-gate 16467c478bd9Sstevel@tonic-gate static void 16477c478bd9Sstevel@tonic-gate datael_finish_reset(const scf_datael_t *dp_arg) 16487c478bd9Sstevel@tonic-gate { 16497c478bd9Sstevel@tonic-gate scf_datael_t *dp = (scf_datael_t *)dp_arg; 16507c478bd9Sstevel@tonic-gate 16517c478bd9Sstevel@tonic-gate if (dp->rd_reset) 16527c478bd9Sstevel@tonic-gate datael_do_reset_locked(dp); 16537c478bd9Sstevel@tonic-gate } 16547c478bd9Sstevel@tonic-gate 16557c478bd9Sstevel@tonic-gate /* 16567c478bd9Sstevel@tonic-gate * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too 16577c478bd9Sstevel@tonic-gate * big, bad entity id, request not applicable to entity, name too long for 16587c478bd9Sstevel@tonic-gate * buffer), _NOT_SET, _DELETED, or _CONSTRAINT_VIOLATED (snaplevel is not of an 16597c478bd9Sstevel@tonic-gate * instance). 16607c478bd9Sstevel@tonic-gate */ 16617c478bd9Sstevel@tonic-gate static ssize_t 16627c478bd9Sstevel@tonic-gate datael_get_name(const scf_datael_t *dp, char *buf, size_t size, uint32_t type) 16637c478bd9Sstevel@tonic-gate { 16647c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate struct rep_protocol_entity_name request; 16677c478bd9Sstevel@tonic-gate struct rep_protocol_name_response response; 16687c478bd9Sstevel@tonic-gate ssize_t r; 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 16717c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_NAME; 16727c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 16737c478bd9Sstevel@tonic-gate request.rpr_answertype = type; 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 16767c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 16777c478bd9Sstevel@tonic-gate &response, sizeof (response)); 16787c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 16797c478bd9Sstevel@tonic-gate 16807c478bd9Sstevel@tonic-gate if (r < 0) 16817c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 16847c478bd9Sstevel@tonic-gate assert(response.rpr_response != REP_PROTOCOL_FAIL_BAD_REQUEST); 16857c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_FOUND) 16867c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED)); 16877c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 16887c478bd9Sstevel@tonic-gate } 16897c478bd9Sstevel@tonic-gate return (strlcpy(buf, response.rpr_name, size)); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate /* 16937c478bd9Sstevel@tonic-gate * Fails with _HANDLE_MISMATCH, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL 16947c478bd9Sstevel@tonic-gate * (server response too big, bad element id), _EXISTS (elements have same id), 16957c478bd9Sstevel@tonic-gate * _NOT_SET, _DELETED, _CONSTRAINT_VIOLATED, _NOT_FOUND (scope has no parent), 16967c478bd9Sstevel@tonic-gate * or _SUCCESS. 16977c478bd9Sstevel@tonic-gate */ 16987c478bd9Sstevel@tonic-gate static int 16997c478bd9Sstevel@tonic-gate datael_get_parent(const scf_datael_t *dp, scf_datael_t *pp) 17007c478bd9Sstevel@tonic-gate { 17017c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 17027c478bd9Sstevel@tonic-gate 17037c478bd9Sstevel@tonic-gate struct rep_protocol_entity_parent request; 17047c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate ssize_t r; 17077c478bd9Sstevel@tonic-gate 17087c478bd9Sstevel@tonic-gate if (h != pp->rd_handle) 17097c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 17127c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_GET_PARENT; 17137c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 17147c478bd9Sstevel@tonic-gate request.rpr_outid = pp->rd_entity; 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 17177c478bd9Sstevel@tonic-gate datael_finish_reset(pp); 17187c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 17197c478bd9Sstevel@tonic-gate &response, sizeof (response)); 17207c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate if (r < 0) 17237c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 17247c478bd9Sstevel@tonic-gate 17257c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 17267c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_FAIL_TYPE_MISMATCH) 17277c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED)); 17287c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 17297c478bd9Sstevel@tonic-gate } 17307c478bd9Sstevel@tonic-gate 17317c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 17327c478bd9Sstevel@tonic-gate } 17337c478bd9Sstevel@tonic-gate 17347c478bd9Sstevel@tonic-gate /* 17357c478bd9Sstevel@tonic-gate * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type, 17367c478bd9Sstevel@tonic-gate * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response 17377c478bd9Sstevel@tonic-gate * too big, bad id, iter already exists, element cannot have children of type, 17387c478bd9Sstevel@tonic-gate * type is invalid, iter was reset, sequence was bad, iter walks values, iter 17397c478bd9Sstevel@tonic-gate * does not walk type entities), _NOT_SET, _DELETED, _NO_RESOURCES, 174076cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 17417c478bd9Sstevel@tonic-gate */ 17427c478bd9Sstevel@tonic-gate static int 17437c478bd9Sstevel@tonic-gate datael_get_child_composed_locked(const scf_datael_t *dp, const char *name, 17447c478bd9Sstevel@tonic-gate uint32_t type, scf_datael_t *out, scf_iter_t *iter) 17457c478bd9Sstevel@tonic-gate { 17467c478bd9Sstevel@tonic-gate struct rep_protocol_iter_start request; 17477c478bd9Sstevel@tonic-gate struct rep_protocol_iter_read read_request; 17487c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 17497c478bd9Sstevel@tonic-gate 17507c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 17517c478bd9Sstevel@tonic-gate ssize_t r; 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate if (h != out->rd_handle) 17547c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate if (out->rd_type != type) 17577c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 17587c478bd9Sstevel@tonic-gate 17597c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 17607c478bd9Sstevel@tonic-gate assert(iter != NULL); 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate scf_iter_reset_locked(iter); 17637c478bd9Sstevel@tonic-gate iter->iter_type = type; 17647c478bd9Sstevel@tonic-gate 17657c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_START; 17667c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 17677c478bd9Sstevel@tonic-gate request.rpr_entity = dp->rd_entity; 17687c478bd9Sstevel@tonic-gate request.rpr_itertype = type; 17697c478bd9Sstevel@tonic-gate request.rpr_flags = RP_ITER_START_EXACT | RP_ITER_START_COMPOSED; 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate if (name == NULL || strlcpy(request.rpr_pattern, name, 17727c478bd9Sstevel@tonic-gate sizeof (request.rpr_pattern)) >= sizeof (request.rpr_pattern)) { 17737c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 17747c478bd9Sstevel@tonic-gate } 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 17777c478bd9Sstevel@tonic-gate datael_finish_reset(out); 17787c478bd9Sstevel@tonic-gate 17797c478bd9Sstevel@tonic-gate /* 17807c478bd9Sstevel@tonic-gate * We hold the handle lock across both door calls, so that they 17817c478bd9Sstevel@tonic-gate * appear atomic. 17827c478bd9Sstevel@tonic-gate */ 17837c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 17847c478bd9Sstevel@tonic-gate &response, sizeof (response)); 17857c478bd9Sstevel@tonic-gate 17867c478bd9Sstevel@tonic-gate if (r < 0) 17877c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 17907c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 17917c478bd9Sstevel@tonic-gate 17927c478bd9Sstevel@tonic-gate iter->iter_sequence++; 17937c478bd9Sstevel@tonic-gate 17947c478bd9Sstevel@tonic-gate read_request.rpr_request = REP_PROTOCOL_ITER_READ; 17957c478bd9Sstevel@tonic-gate read_request.rpr_iterid = iter->iter_id; 17967c478bd9Sstevel@tonic-gate read_request.rpr_sequence = iter->iter_sequence; 17977c478bd9Sstevel@tonic-gate read_request.rpr_entityid = out->rd_entity; 17987c478bd9Sstevel@tonic-gate 17997c478bd9Sstevel@tonic-gate r = make_door_call(h, &read_request, sizeof (read_request), 18007c478bd9Sstevel@tonic-gate &response, sizeof (response)); 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate scf_iter_reset_locked(iter); 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate if (r < 0) 18057c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 18067c478bd9Sstevel@tonic-gate 18077c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_DONE) { 18087c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_FOUND)); 18097c478bd9Sstevel@tonic-gate } 18107c478bd9Sstevel@tonic-gate 18117c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 18127c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_SET || 18137c478bd9Sstevel@tonic-gate response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST) 18147c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 18157c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate return (0); 18197c478bd9Sstevel@tonic-gate } 18207c478bd9Sstevel@tonic-gate 18217c478bd9Sstevel@tonic-gate /* 18227c478bd9Sstevel@tonic-gate * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type, 18237c478bd9Sstevel@tonic-gate * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response 18247c478bd9Sstevel@tonic-gate * too big, bad id, element cannot have children of type, type is invalid), 18257c478bd9Sstevel@tonic-gate * _NOT_SET, _DELETED, _NO_RESOURCES, _BACKEND_ACCESS. 18267c478bd9Sstevel@tonic-gate */ 18277c478bd9Sstevel@tonic-gate static int 18287c478bd9Sstevel@tonic-gate datael_get_child_locked(const scf_datael_t *dp, const char *name, 18297c478bd9Sstevel@tonic-gate uint32_t type, scf_datael_t *out) 18307c478bd9Sstevel@tonic-gate { 18317c478bd9Sstevel@tonic-gate struct rep_protocol_entity_get_child request; 18327c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 18357c478bd9Sstevel@tonic-gate ssize_t r; 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate if (h != out->rd_handle) 18387c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate if (out->rd_type != type) 18417c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_GET_CHILD; 18467c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 18477c478bd9Sstevel@tonic-gate request.rpr_childid = out->rd_entity; 18487c478bd9Sstevel@tonic-gate 18497c478bd9Sstevel@tonic-gate if (name == NULL || strlcpy(request.rpr_name, name, 18507c478bd9Sstevel@tonic-gate sizeof (request.rpr_name)) >= sizeof (request.rpr_name)) { 18517c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 18527c478bd9Sstevel@tonic-gate } 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 18557c478bd9Sstevel@tonic-gate datael_finish_reset(out); 18567c478bd9Sstevel@tonic-gate 18577c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 18587c478bd9Sstevel@tonic-gate &response, sizeof (response)); 18597c478bd9Sstevel@tonic-gate 18607c478bd9Sstevel@tonic-gate if (r < 0) 18617c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 18647c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 18657c478bd9Sstevel@tonic-gate return (0); 18667c478bd9Sstevel@tonic-gate } 18677c478bd9Sstevel@tonic-gate 186876cf44abSjeanm /* 186976cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type, 187076cf44abSjeanm * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response 187176cf44abSjeanm * too big, bad id, iter already exists, element cannot have children of type, 187276cf44abSjeanm * type is invalid, iter was reset, sequence was bad, iter walks values, iter 187376cf44abSjeanm * does not walk type entities), _NOT_SET, _DELETED, _NO_RESOURCES, 187476cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 187576cf44abSjeanm */ 18767c478bd9Sstevel@tonic-gate static int 18777c478bd9Sstevel@tonic-gate datael_get_child(const scf_datael_t *dp, const char *name, uint32_t type, 18787c478bd9Sstevel@tonic-gate scf_datael_t *out, boolean_t composed) 18797c478bd9Sstevel@tonic-gate { 18807c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 18817c478bd9Sstevel@tonic-gate uint32_t held = 0; 18827c478bd9Sstevel@tonic-gate int ret; 18837c478bd9Sstevel@tonic-gate 18847c478bd9Sstevel@tonic-gate scf_iter_t *iter = NULL; 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate if (composed) 18877c478bd9Sstevel@tonic-gate iter = HANDLE_HOLD_ITER(h); 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate if (out == NULL) { 18907c478bd9Sstevel@tonic-gate switch (type) { 18917c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SERVICE: 18927c478bd9Sstevel@tonic-gate out = &HANDLE_HOLD_SERVICE(h)->rd_d; 18937c478bd9Sstevel@tonic-gate held = RH_HOLD_SERVICE; 18947c478bd9Sstevel@tonic-gate break; 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_INSTANCE: 18977c478bd9Sstevel@tonic-gate out = &HANDLE_HOLD_INSTANCE(h)->rd_d; 18987c478bd9Sstevel@tonic-gate held = RH_HOLD_INSTANCE; 18997c478bd9Sstevel@tonic-gate break; 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SNAPSHOT: 19027c478bd9Sstevel@tonic-gate out = &HANDLE_HOLD_SNAPSHOT(h)->rd_d; 19037c478bd9Sstevel@tonic-gate held = RH_HOLD_SNAPSHOT; 19047c478bd9Sstevel@tonic-gate break; 19057c478bd9Sstevel@tonic-gate 19067c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SNAPLEVEL: 19077c478bd9Sstevel@tonic-gate out = &HANDLE_HOLD_SNAPLVL(h)->rd_d; 19087c478bd9Sstevel@tonic-gate held = RH_HOLD_SNAPLVL; 19097c478bd9Sstevel@tonic-gate break; 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_PROPERTYGRP: 19127c478bd9Sstevel@tonic-gate out = &HANDLE_HOLD_PG(h)->rd_d; 19137c478bd9Sstevel@tonic-gate held = RH_HOLD_PG; 19147c478bd9Sstevel@tonic-gate break; 19157c478bd9Sstevel@tonic-gate 19167c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_PROPERTY: 19177c478bd9Sstevel@tonic-gate out = &HANDLE_HOLD_PROPERTY(h)->rd_d; 19187c478bd9Sstevel@tonic-gate held = RH_HOLD_PROPERTY; 19197c478bd9Sstevel@tonic-gate break; 19207c478bd9Sstevel@tonic-gate 19217c478bd9Sstevel@tonic-gate default: 19227c478bd9Sstevel@tonic-gate assert(0); 19237c478bd9Sstevel@tonic-gate abort(); 19247c478bd9Sstevel@tonic-gate } 19257c478bd9Sstevel@tonic-gate } 19267c478bd9Sstevel@tonic-gate 19277c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 19287c478bd9Sstevel@tonic-gate if (composed) 19297c478bd9Sstevel@tonic-gate ret = datael_get_child_composed_locked(dp, name, type, out, 19307c478bd9Sstevel@tonic-gate iter); 19317c478bd9Sstevel@tonic-gate else 19327c478bd9Sstevel@tonic-gate ret = datael_get_child_locked(dp, name, type, out); 19337c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate if (composed) 19367c478bd9Sstevel@tonic-gate HANDLE_RELE_ITER(h); 19377c478bd9Sstevel@tonic-gate 19387c478bd9Sstevel@tonic-gate if (held) 19397c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, held); 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate return (ret); 19427c478bd9Sstevel@tonic-gate } 19437c478bd9Sstevel@tonic-gate 19447c478bd9Sstevel@tonic-gate /* 19457c478bd9Sstevel@tonic-gate * Fails with 19467c478bd9Sstevel@tonic-gate * _HANDLE_MISMATCH 19477c478bd9Sstevel@tonic-gate * _INVALID_ARGUMENT - name is too long 19487c478bd9Sstevel@tonic-gate * invalid changeid 19497c478bd9Sstevel@tonic-gate * name is invalid 19507c478bd9Sstevel@tonic-gate * cannot create children for dp's type of node 19517c478bd9Sstevel@tonic-gate * _NOT_BOUND - handle is not bound 19527c478bd9Sstevel@tonic-gate * _CONNECTION_BROKEN - server is not reachable 19537c478bd9Sstevel@tonic-gate * _INTERNAL - server response too big 19547c478bd9Sstevel@tonic-gate * dp or cp has unknown id 19557c478bd9Sstevel@tonic-gate * type is _PROPERTYGRP 19567c478bd9Sstevel@tonic-gate * type is invalid 19577c478bd9Sstevel@tonic-gate * dp cannot have children of type type 19587c478bd9Sstevel@tonic-gate * database is corrupt 19597c478bd9Sstevel@tonic-gate * _EXISTS - dp & cp have the same id 19607c478bd9Sstevel@tonic-gate * _EXISTS - child already exists 19617c478bd9Sstevel@tonic-gate * _DELETED - dp has been deleted 19627c478bd9Sstevel@tonic-gate * _NOT_SET - dp is reset 19637c478bd9Sstevel@tonic-gate * _NO_RESOURCES 19647c478bd9Sstevel@tonic-gate * _PERMISSION_DENIED 19657c478bd9Sstevel@tonic-gate * _BACKEND_ACCESS 19667c478bd9Sstevel@tonic-gate * _BACKEND_READONLY 19677c478bd9Sstevel@tonic-gate */ 19687c478bd9Sstevel@tonic-gate static int 19697c478bd9Sstevel@tonic-gate datael_add_child(const scf_datael_t *dp, const char *name, uint32_t type, 19707c478bd9Sstevel@tonic-gate scf_datael_t *cp) 19717c478bd9Sstevel@tonic-gate { 19727c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 19737c478bd9Sstevel@tonic-gate 19747c478bd9Sstevel@tonic-gate struct rep_protocol_entity_create_child request; 19757c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 19767c478bd9Sstevel@tonic-gate ssize_t r; 19777c478bd9Sstevel@tonic-gate uint32_t held = 0; 19787c478bd9Sstevel@tonic-gate 19797c478bd9Sstevel@tonic-gate if (cp == NULL) { 19807c478bd9Sstevel@tonic-gate switch (type) { 19817c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SCOPE: 19827c478bd9Sstevel@tonic-gate cp = &HANDLE_HOLD_SCOPE(h)->rd_d; 19837c478bd9Sstevel@tonic-gate held = RH_HOLD_SCOPE; 19847c478bd9Sstevel@tonic-gate break; 19857c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SERVICE: 19867c478bd9Sstevel@tonic-gate cp = &HANDLE_HOLD_SERVICE(h)->rd_d; 19877c478bd9Sstevel@tonic-gate held = RH_HOLD_SERVICE; 19887c478bd9Sstevel@tonic-gate break; 19897c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_INSTANCE: 19907c478bd9Sstevel@tonic-gate cp = &HANDLE_HOLD_INSTANCE(h)->rd_d; 19917c478bd9Sstevel@tonic-gate held = RH_HOLD_INSTANCE; 19927c478bd9Sstevel@tonic-gate break; 19937c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SNAPSHOT: 19947c478bd9Sstevel@tonic-gate default: 19957c478bd9Sstevel@tonic-gate assert(0); 19967c478bd9Sstevel@tonic-gate abort(); 19977c478bd9Sstevel@tonic-gate } 19987c478bd9Sstevel@tonic-gate assert(h == cp->rd_handle); 19997c478bd9Sstevel@tonic-gate 20007c478bd9Sstevel@tonic-gate } else if (h != cp->rd_handle) { 20017c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 20027c478bd9Sstevel@tonic-gate } 20037c478bd9Sstevel@tonic-gate 20047c478bd9Sstevel@tonic-gate if (strlcpy(request.rpr_name, name, sizeof (request.rpr_name)) >= 20057c478bd9Sstevel@tonic-gate sizeof (request.rpr_name)) { 20067c478bd9Sstevel@tonic-gate r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 20077c478bd9Sstevel@tonic-gate goto err; 20087c478bd9Sstevel@tonic-gate } 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 20117c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_CREATE_CHILD; 20127c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 20137c478bd9Sstevel@tonic-gate request.rpr_childtype = type; 20147c478bd9Sstevel@tonic-gate request.rpr_childid = cp->rd_entity; 20157c478bd9Sstevel@tonic-gate 20167c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 20178918dff3Sjwadams request.rpr_changeid = handle_next_changeid(h); 20187c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 20197c478bd9Sstevel@tonic-gate &response, sizeof (response)); 20207c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 20217c478bd9Sstevel@tonic-gate 20227c478bd9Sstevel@tonic-gate if (held) 20237c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, held); 20247c478bd9Sstevel@tonic-gate 20257c478bd9Sstevel@tonic-gate if (r < 0) 20267c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 20277c478bd9Sstevel@tonic-gate 20287c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 20297c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 20307c478bd9Sstevel@tonic-gate 20317c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate err: 20347c478bd9Sstevel@tonic-gate if (held) 20357c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, held); 20367c478bd9Sstevel@tonic-gate return (r); 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate static int 20407c478bd9Sstevel@tonic-gate datael_add_pg(const scf_datael_t *dp, const char *name, const char *type, 20417c478bd9Sstevel@tonic-gate uint32_t flags, scf_datael_t *cp) 20427c478bd9Sstevel@tonic-gate { 20437c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 20447c478bd9Sstevel@tonic-gate 20457c478bd9Sstevel@tonic-gate struct rep_protocol_entity_create_pg request; 20467c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 20477c478bd9Sstevel@tonic-gate ssize_t r; 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate int holding_els = 0; 20507c478bd9Sstevel@tonic-gate 20517c478bd9Sstevel@tonic-gate if (cp == NULL) { 20527c478bd9Sstevel@tonic-gate holding_els = 1; 20537c478bd9Sstevel@tonic-gate cp = &HANDLE_HOLD_PG(h)->rd_d; 20547c478bd9Sstevel@tonic-gate assert(h == cp->rd_handle); 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate } else if (h != cp->rd_handle) { 20577c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 20587c478bd9Sstevel@tonic-gate } 20597c478bd9Sstevel@tonic-gate 20607c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_CREATE_PG; 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate if (name == NULL || strlcpy(request.rpr_name, name, 20637c478bd9Sstevel@tonic-gate sizeof (request.rpr_name)) > sizeof (request.rpr_name)) { 20647c478bd9Sstevel@tonic-gate r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 20657c478bd9Sstevel@tonic-gate goto err; 20667c478bd9Sstevel@tonic-gate } 20677c478bd9Sstevel@tonic-gate 20687c478bd9Sstevel@tonic-gate if (type == NULL || strlcpy(request.rpr_type, type, 20697c478bd9Sstevel@tonic-gate sizeof (request.rpr_type)) > sizeof (request.rpr_type)) { 20707c478bd9Sstevel@tonic-gate r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 20717c478bd9Sstevel@tonic-gate goto err; 20727c478bd9Sstevel@tonic-gate } 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 20757c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 20767c478bd9Sstevel@tonic-gate request.rpr_childid = cp->rd_entity; 20777c478bd9Sstevel@tonic-gate request.rpr_flags = flags; 20787c478bd9Sstevel@tonic-gate 20797c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 20807c478bd9Sstevel@tonic-gate datael_finish_reset(cp); 20818918dff3Sjwadams request.rpr_changeid = handle_next_changeid(h); 20827c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 20837c478bd9Sstevel@tonic-gate &response, sizeof (response)); 20847c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate if (holding_els) 20877c478bd9Sstevel@tonic-gate HANDLE_RELE_PG(h); 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate if (r < 0) 20907c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 20937c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 20947c478bd9Sstevel@tonic-gate 20957c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate err: 20987c478bd9Sstevel@tonic-gate if (holding_els) 20997c478bd9Sstevel@tonic-gate HANDLE_RELE_PG(h); 21007c478bd9Sstevel@tonic-gate return (r); 21017c478bd9Sstevel@tonic-gate } 21027c478bd9Sstevel@tonic-gate 21037c478bd9Sstevel@tonic-gate static int 21047c478bd9Sstevel@tonic-gate datael_delete(const scf_datael_t *dp) 21057c478bd9Sstevel@tonic-gate { 21067c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 21077c478bd9Sstevel@tonic-gate 21087c478bd9Sstevel@tonic-gate struct rep_protocol_entity_delete request; 21097c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 21107c478bd9Sstevel@tonic-gate ssize_t r; 21117c478bd9Sstevel@tonic-gate 21127c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 21137c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_DELETE; 21147c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 21157c478bd9Sstevel@tonic-gate 21167c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 21178918dff3Sjwadams request.rpr_changeid = handle_next_changeid(h); 21187c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 21197c478bd9Sstevel@tonic-gate &response, sizeof (response)); 21207c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 21217c478bd9Sstevel@tonic-gate 21227c478bd9Sstevel@tonic-gate if (r < 0) 21237c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 21247c478bd9Sstevel@tonic-gate 21257c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 21267c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate /* 21327c478bd9Sstevel@tonic-gate * Fails with 21337c478bd9Sstevel@tonic-gate * _INVALID_ARGUMENT - h is NULL 21347c478bd9Sstevel@tonic-gate * _NO_MEMORY 21357c478bd9Sstevel@tonic-gate * _HANDLE_DESTROYED - h has been destroyed 21367c478bd9Sstevel@tonic-gate * _INTERNAL - server response too big 21377c478bd9Sstevel@tonic-gate * iter already exists 21387c478bd9Sstevel@tonic-gate * _NO_RESOURCES 21397c478bd9Sstevel@tonic-gate */ 21407c478bd9Sstevel@tonic-gate scf_iter_t * 21417c478bd9Sstevel@tonic-gate scf_iter_create(scf_handle_t *h) 21427c478bd9Sstevel@tonic-gate { 21437c478bd9Sstevel@tonic-gate scf_iter_t *iter; 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate if (h == NULL) { 21467c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 21477c478bd9Sstevel@tonic-gate return (NULL); 21487c478bd9Sstevel@tonic-gate } 21497c478bd9Sstevel@tonic-gate 21507c478bd9Sstevel@tonic-gate iter = uu_zalloc(sizeof (*iter)); 21517c478bd9Sstevel@tonic-gate if (iter == NULL) { 21527c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 21537c478bd9Sstevel@tonic-gate return (NULL); 21547c478bd9Sstevel@tonic-gate } 21557c478bd9Sstevel@tonic-gate 21567c478bd9Sstevel@tonic-gate uu_list_node_init(iter, &iter->iter_node, iter_pool); 21577c478bd9Sstevel@tonic-gate iter->iter_handle = h; 21587c478bd9Sstevel@tonic-gate iter->iter_sequence = 1; 21597c478bd9Sstevel@tonic-gate iter->iter_type = REP_PROTOCOL_ENTITY_NONE; 21607c478bd9Sstevel@tonic-gate 21617c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 21627c478bd9Sstevel@tonic-gate iter->iter_id = handle_alloc_iterid(h); 21638918dff3Sjwadams if (iter->iter_id == 0) { 21648918dff3Sjwadams (void) pthread_mutex_unlock(&h->rh_lock); 21658918dff3Sjwadams uu_list_node_fini(iter, &iter->iter_node, iter_pool); 21668918dff3Sjwadams (void) scf_set_error(SCF_ERROR_NO_MEMORY); 21671f6eb021SLiane Praza uu_free(iter); 21688918dff3Sjwadams return (NULL); 21698918dff3Sjwadams } 21707c478bd9Sstevel@tonic-gate if (iter_attach(iter) == -1) { 21717c478bd9Sstevel@tonic-gate uu_list_node_fini(iter, &iter->iter_node, iter_pool); 21727c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 21737c478bd9Sstevel@tonic-gate uu_free(iter); 21747c478bd9Sstevel@tonic-gate return (NULL); 21757c478bd9Sstevel@tonic-gate } 21767c478bd9Sstevel@tonic-gate (void) uu_list_insert_before(h->rh_iters, NULL, iter); 21777c478bd9Sstevel@tonic-gate h->rh_extrefs++; 21787c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 21797c478bd9Sstevel@tonic-gate return (iter); 21807c478bd9Sstevel@tonic-gate } 21817c478bd9Sstevel@tonic-gate 21827c478bd9Sstevel@tonic-gate scf_handle_t * 21837c478bd9Sstevel@tonic-gate scf_iter_handle(const scf_iter_t *iter) 21847c478bd9Sstevel@tonic-gate { 21857c478bd9Sstevel@tonic-gate return (handle_get(iter->iter_handle)); 21867c478bd9Sstevel@tonic-gate } 21877c478bd9Sstevel@tonic-gate 21887c478bd9Sstevel@tonic-gate static void 21897c478bd9Sstevel@tonic-gate scf_iter_reset_locked(scf_iter_t *iter) 21907c478bd9Sstevel@tonic-gate { 21917c478bd9Sstevel@tonic-gate struct rep_protocol_iter_request request; 21927c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 21937c478bd9Sstevel@tonic-gate 21947c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_RESET; 21957c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&iter->iter_handle->rh_lock)); 21987c478bd9Sstevel@tonic-gate 21997c478bd9Sstevel@tonic-gate (void) make_door_call(iter->iter_handle, 22007c478bd9Sstevel@tonic-gate &request, sizeof (request), &response, sizeof (response)); 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate iter->iter_type = REP_PROTOCOL_ENTITY_NONE; 22037c478bd9Sstevel@tonic-gate iter->iter_sequence = 1; 22047c478bd9Sstevel@tonic-gate } 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate void 22077c478bd9Sstevel@tonic-gate scf_iter_reset(scf_iter_t *iter) 22087c478bd9Sstevel@tonic-gate { 22097c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&iter->iter_handle->rh_lock); 22107c478bd9Sstevel@tonic-gate scf_iter_reset_locked(iter); 22117c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&iter->iter_handle->rh_lock); 22127c478bd9Sstevel@tonic-gate } 22137c478bd9Sstevel@tonic-gate 22147c478bd9Sstevel@tonic-gate void 22157c478bd9Sstevel@tonic-gate scf_iter_destroy(scf_iter_t *iter) 22167c478bd9Sstevel@tonic-gate { 22177c478bd9Sstevel@tonic-gate scf_handle_t *handle; 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate struct rep_protocol_iter_request request; 22207c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 22217c478bd9Sstevel@tonic-gate 22227c478bd9Sstevel@tonic-gate if (iter == NULL) 22237c478bd9Sstevel@tonic-gate return; 22247c478bd9Sstevel@tonic-gate 22257c478bd9Sstevel@tonic-gate handle = iter->iter_handle; 22267c478bd9Sstevel@tonic-gate 22277c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&handle->rh_lock); 22287c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_TEARDOWN; 22297c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 22307c478bd9Sstevel@tonic-gate 22317c478bd9Sstevel@tonic-gate (void) make_door_call(handle, &request, sizeof (request), 22327c478bd9Sstevel@tonic-gate &response, sizeof (response)); 22337c478bd9Sstevel@tonic-gate 22347c478bd9Sstevel@tonic-gate uu_list_remove(handle->rh_iters, iter); 22357c478bd9Sstevel@tonic-gate --handle->rh_extrefs; 22367c478bd9Sstevel@tonic-gate handle_unrefed(handle); /* drops h->rh_lock */ 22377c478bd9Sstevel@tonic-gate iter->iter_handle = NULL; 22387c478bd9Sstevel@tonic-gate 22397c478bd9Sstevel@tonic-gate uu_list_node_fini(iter, &iter->iter_node, iter_pool); 22407c478bd9Sstevel@tonic-gate uu_free(iter); 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate 22437c478bd9Sstevel@tonic-gate static int 22447c478bd9Sstevel@tonic-gate handle_get_local_scope_locked(scf_handle_t *handle, scf_scope_t *out) 22457c478bd9Sstevel@tonic-gate { 22467c478bd9Sstevel@tonic-gate struct rep_protocol_entity_get request; 22477c478bd9Sstevel@tonic-gate struct rep_protocol_name_response response; 22487c478bd9Sstevel@tonic-gate ssize_t r; 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&handle->rh_lock)); 22517c478bd9Sstevel@tonic-gate 22527c478bd9Sstevel@tonic-gate if (handle != out->rd_d.rd_handle) 22537c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 22547c478bd9Sstevel@tonic-gate 22557c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_GET; 22567c478bd9Sstevel@tonic-gate request.rpr_entityid = out->rd_d.rd_entity; 22577c478bd9Sstevel@tonic-gate request.rpr_object = RP_ENTITY_GET_MOST_LOCAL_SCOPE; 22587c478bd9Sstevel@tonic-gate 22597c478bd9Sstevel@tonic-gate datael_finish_reset(&out->rd_d); 22607c478bd9Sstevel@tonic-gate r = make_door_call(handle, &request, sizeof (request), 22617c478bd9Sstevel@tonic-gate &response, sizeof (response)); 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate if (r < 0) 22647c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 22657c478bd9Sstevel@tonic-gate 22667c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 22677c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 22707c478bd9Sstevel@tonic-gate } 22717c478bd9Sstevel@tonic-gate 22727c478bd9Sstevel@tonic-gate int 22737c478bd9Sstevel@tonic-gate scf_iter_handle_scopes(scf_iter_t *iter, const scf_handle_t *handle) 22747c478bd9Sstevel@tonic-gate { 22757c478bd9Sstevel@tonic-gate scf_handle_t *h = iter->iter_handle; 22767c478bd9Sstevel@tonic-gate if (h != handle) 22777c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 22807c478bd9Sstevel@tonic-gate scf_iter_reset_locked(iter); 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate if (!handle_is_bound(h)) { 22837c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 22847c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_BOUND)); 22857c478bd9Sstevel@tonic-gate } 22867c478bd9Sstevel@tonic-gate 22878918dff3Sjwadams if (!handle_has_server_locked(h)) { 22887c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 22897c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN)); 22907c478bd9Sstevel@tonic-gate } 22917c478bd9Sstevel@tonic-gate 22927c478bd9Sstevel@tonic-gate iter->iter_type = REP_PROTOCOL_ENTITY_SCOPE; 22937c478bd9Sstevel@tonic-gate iter->iter_sequence = 1; 22947c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 22957c478bd9Sstevel@tonic-gate return (0); 22967c478bd9Sstevel@tonic-gate } 22977c478bd9Sstevel@tonic-gate 22987c478bd9Sstevel@tonic-gate int 22997c478bd9Sstevel@tonic-gate scf_iter_next_scope(scf_iter_t *iter, scf_scope_t *out) 23007c478bd9Sstevel@tonic-gate { 23017c478bd9Sstevel@tonic-gate int ret; 23027c478bd9Sstevel@tonic-gate scf_handle_t *h = iter->iter_handle; 23037c478bd9Sstevel@tonic-gate 23047c478bd9Sstevel@tonic-gate if (h != out->rd_d.rd_handle) 23057c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 23067c478bd9Sstevel@tonic-gate 23077c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 23087c478bd9Sstevel@tonic-gate if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE) { 23097c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23107c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 23117c478bd9Sstevel@tonic-gate } 23127c478bd9Sstevel@tonic-gate if (iter->iter_type != REP_PROTOCOL_ENTITY_SCOPE) { 23137c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23147c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 23157c478bd9Sstevel@tonic-gate } 23167c478bd9Sstevel@tonic-gate if (iter->iter_sequence == 1) { 23177c478bd9Sstevel@tonic-gate if ((ret = handle_get_local_scope_locked(h, out)) == 23187c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 23197c478bd9Sstevel@tonic-gate iter->iter_sequence++; 23207c478bd9Sstevel@tonic-gate ret = 1; 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate } else { 23237c478bd9Sstevel@tonic-gate datael_reset_locked(&out->rd_d); 23247c478bd9Sstevel@tonic-gate ret = 0; 23257c478bd9Sstevel@tonic-gate } 23267c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23277c478bd9Sstevel@tonic-gate return (ret); 23287c478bd9Sstevel@tonic-gate } 23297c478bd9Sstevel@tonic-gate 23307c478bd9Sstevel@tonic-gate int 23317c478bd9Sstevel@tonic-gate scf_handle_get_scope(scf_handle_t *h, const char *name, scf_scope_t *out) 23327c478bd9Sstevel@tonic-gate { 23337c478bd9Sstevel@tonic-gate int ret; 23347c478bd9Sstevel@tonic-gate 23357c478bd9Sstevel@tonic-gate if (h != out->rd_d.rd_handle) 23367c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 23397c478bd9Sstevel@tonic-gate if (strcmp(name, SCF_SCOPE_LOCAL) == 0) { 23407c478bd9Sstevel@tonic-gate ret = handle_get_local_scope_locked(h, out); 23417c478bd9Sstevel@tonic-gate } else { 23427c478bd9Sstevel@tonic-gate datael_reset_locked(&out->rd_d); 23437c478bd9Sstevel@tonic-gate if (uu_check_name(name, 0) == -1) 23447c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 23457c478bd9Sstevel@tonic-gate else 23467c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_NOT_FOUND); 23477c478bd9Sstevel@tonic-gate } 23487c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23497c478bd9Sstevel@tonic-gate return (ret); 23507c478bd9Sstevel@tonic-gate } 23517c478bd9Sstevel@tonic-gate 23527c478bd9Sstevel@tonic-gate static int 23537c478bd9Sstevel@tonic-gate datael_setup_iter(scf_iter_t *iter, const scf_datael_t *dp, uint32_t res_type, 23547c478bd9Sstevel@tonic-gate boolean_t composed) 23557c478bd9Sstevel@tonic-gate { 23567c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 23577c478bd9Sstevel@tonic-gate 23587c478bd9Sstevel@tonic-gate struct rep_protocol_iter_start request; 23597c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 23607c478bd9Sstevel@tonic-gate 23617c478bd9Sstevel@tonic-gate ssize_t r; 23627c478bd9Sstevel@tonic-gate 23637c478bd9Sstevel@tonic-gate if (h != iter->iter_handle) 23647c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 23657c478bd9Sstevel@tonic-gate 23667c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 23677c478bd9Sstevel@tonic-gate scf_iter_reset_locked(iter); 23687c478bd9Sstevel@tonic-gate iter->iter_type = res_type; 23697c478bd9Sstevel@tonic-gate 23707c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_START; 23717c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 23727c478bd9Sstevel@tonic-gate request.rpr_entity = dp->rd_entity; 23737c478bd9Sstevel@tonic-gate request.rpr_itertype = res_type; 23747c478bd9Sstevel@tonic-gate request.rpr_flags = RP_ITER_START_ALL | 23757c478bd9Sstevel@tonic-gate (composed ? RP_ITER_START_COMPOSED : 0); 23767c478bd9Sstevel@tonic-gate request.rpr_pattern[0] = 0; 23777c478bd9Sstevel@tonic-gate 23787c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 23797c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 23807c478bd9Sstevel@tonic-gate &response, sizeof (response)); 23817c478bd9Sstevel@tonic-gate 23827c478bd9Sstevel@tonic-gate if (r < 0) { 23837c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23847c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 23857c478bd9Sstevel@tonic-gate } 23867c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 23877c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23887c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 23897c478bd9Sstevel@tonic-gate } 23907c478bd9Sstevel@tonic-gate iter->iter_sequence++; 23917c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 23927c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 23937c478bd9Sstevel@tonic-gate } 23947c478bd9Sstevel@tonic-gate 23957c478bd9Sstevel@tonic-gate static int 23967c478bd9Sstevel@tonic-gate datael_setup_iter_pgtyped(scf_iter_t *iter, const scf_datael_t *dp, 23977c478bd9Sstevel@tonic-gate const char *pgtype, boolean_t composed) 23987c478bd9Sstevel@tonic-gate { 23997c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 24007c478bd9Sstevel@tonic-gate 24017c478bd9Sstevel@tonic-gate struct rep_protocol_iter_start request; 24027c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate ssize_t r; 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate if (h != iter->iter_handle) 24077c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate if (pgtype == NULL || strlcpy(request.rpr_pattern, pgtype, 24107c478bd9Sstevel@tonic-gate sizeof (request.rpr_pattern)) >= sizeof (request.rpr_pattern)) { 24117c478bd9Sstevel@tonic-gate scf_iter_reset(iter); 24127c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 24137c478bd9Sstevel@tonic-gate } 24147c478bd9Sstevel@tonic-gate 24157c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 24167c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_START; 24177c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 24187c478bd9Sstevel@tonic-gate request.rpr_entity = dp->rd_entity; 24197c478bd9Sstevel@tonic-gate request.rpr_itertype = REP_PROTOCOL_ENTITY_PROPERTYGRP; 24207c478bd9Sstevel@tonic-gate request.rpr_flags = RP_ITER_START_PGTYPE | 24217c478bd9Sstevel@tonic-gate (composed ? RP_ITER_START_COMPOSED : 0); 24227c478bd9Sstevel@tonic-gate 24237c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 24247c478bd9Sstevel@tonic-gate scf_iter_reset_locked(iter); 24257c478bd9Sstevel@tonic-gate iter->iter_type = REP_PROTOCOL_ENTITY_PROPERTYGRP; 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 24287c478bd9Sstevel@tonic-gate &response, sizeof (response)); 24297c478bd9Sstevel@tonic-gate 24307c478bd9Sstevel@tonic-gate if (r < 0) { 24317c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24327c478bd9Sstevel@tonic-gate 24337c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 24347c478bd9Sstevel@tonic-gate } 24357c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 24367c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24377c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 24387c478bd9Sstevel@tonic-gate } 24397c478bd9Sstevel@tonic-gate iter->iter_sequence++; 24407c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24417c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 24427c478bd9Sstevel@tonic-gate } 24437c478bd9Sstevel@tonic-gate 24447c478bd9Sstevel@tonic-gate static int 24457c478bd9Sstevel@tonic-gate datael_iter_next(scf_iter_t *iter, scf_datael_t *out) 24467c478bd9Sstevel@tonic-gate { 24477c478bd9Sstevel@tonic-gate scf_handle_t *h = iter->iter_handle; 24487c478bd9Sstevel@tonic-gate 24497c478bd9Sstevel@tonic-gate struct rep_protocol_iter_read request; 24507c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 24517c478bd9Sstevel@tonic-gate ssize_t r; 24527c478bd9Sstevel@tonic-gate 24537c478bd9Sstevel@tonic-gate if (h != out->rd_handle) 24547c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 24557c478bd9Sstevel@tonic-gate 24567c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 24577c478bd9Sstevel@tonic-gate if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE || 24587c478bd9Sstevel@tonic-gate iter->iter_sequence == 1) { 24597c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24607c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 24617c478bd9Sstevel@tonic-gate } 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate if (out->rd_type != iter->iter_type) { 24647c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24657c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 24667c478bd9Sstevel@tonic-gate } 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_READ; 24697c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 24707c478bd9Sstevel@tonic-gate request.rpr_sequence = iter->iter_sequence; 24717c478bd9Sstevel@tonic-gate request.rpr_entityid = out->rd_entity; 24727c478bd9Sstevel@tonic-gate 24737c478bd9Sstevel@tonic-gate datael_finish_reset(out); 24747c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 24757c478bd9Sstevel@tonic-gate &response, sizeof (response)); 24767c478bd9Sstevel@tonic-gate 24777c478bd9Sstevel@tonic-gate if (r < 0) { 24787c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24797c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 24807c478bd9Sstevel@tonic-gate } 24817c478bd9Sstevel@tonic-gate 24827c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_DONE) { 24837c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24847c478bd9Sstevel@tonic-gate return (0); 24857c478bd9Sstevel@tonic-gate } 24867c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 24877c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24887c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 24897c478bd9Sstevel@tonic-gate } 24907c478bd9Sstevel@tonic-gate iter->iter_sequence++; 24917c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 24927c478bd9Sstevel@tonic-gate 24937c478bd9Sstevel@tonic-gate return (1); 24947c478bd9Sstevel@tonic-gate } 24957c478bd9Sstevel@tonic-gate 24967c478bd9Sstevel@tonic-gate int 24977c478bd9Sstevel@tonic-gate scf_iter_scope_services(scf_iter_t *iter, const scf_scope_t *s) 24987c478bd9Sstevel@tonic-gate { 24997c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &s->rd_d, 25007c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SERVICE, 0)); 25017c478bd9Sstevel@tonic-gate } 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate int 25047c478bd9Sstevel@tonic-gate scf_iter_next_service(scf_iter_t *iter, scf_service_t *out) 25057c478bd9Sstevel@tonic-gate { 25067c478bd9Sstevel@tonic-gate return (datael_iter_next(iter, &out->rd_d)); 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate 25097c478bd9Sstevel@tonic-gate int 25107c478bd9Sstevel@tonic-gate scf_iter_service_instances(scf_iter_t *iter, const scf_service_t *svc) 25117c478bd9Sstevel@tonic-gate { 25127c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &svc->rd_d, 25137c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_INSTANCE, 0)); 25147c478bd9Sstevel@tonic-gate } 25157c478bd9Sstevel@tonic-gate 25167c478bd9Sstevel@tonic-gate int 25177c478bd9Sstevel@tonic-gate scf_iter_next_instance(scf_iter_t *iter, scf_instance_t *out) 25187c478bd9Sstevel@tonic-gate { 25197c478bd9Sstevel@tonic-gate return (datael_iter_next(iter, &out->rd_d)); 25207c478bd9Sstevel@tonic-gate } 25217c478bd9Sstevel@tonic-gate 25227c478bd9Sstevel@tonic-gate int 25237c478bd9Sstevel@tonic-gate scf_iter_service_pgs(scf_iter_t *iter, const scf_service_t *svc) 25247c478bd9Sstevel@tonic-gate { 25257c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &svc->rd_d, 25267c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, 0)); 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate int 25307c478bd9Sstevel@tonic-gate scf_iter_service_pgs_typed(scf_iter_t *iter, const scf_service_t *svc, 25317c478bd9Sstevel@tonic-gate const char *type) 25327c478bd9Sstevel@tonic-gate { 25337c478bd9Sstevel@tonic-gate return (datael_setup_iter_pgtyped(iter, &svc->rd_d, type, 0)); 25347c478bd9Sstevel@tonic-gate } 25357c478bd9Sstevel@tonic-gate 25367c478bd9Sstevel@tonic-gate int 25377c478bd9Sstevel@tonic-gate scf_iter_instance_snapshots(scf_iter_t *iter, const scf_instance_t *inst) 25387c478bd9Sstevel@tonic-gate { 25397c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &inst->rd_d, 25407c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SNAPSHOT, 0)); 25417c478bd9Sstevel@tonic-gate } 25427c478bd9Sstevel@tonic-gate 25437c478bd9Sstevel@tonic-gate int 25447c478bd9Sstevel@tonic-gate scf_iter_next_snapshot(scf_iter_t *iter, scf_snapshot_t *out) 25457c478bd9Sstevel@tonic-gate { 25467c478bd9Sstevel@tonic-gate return (datael_iter_next(iter, &out->rd_d)); 25477c478bd9Sstevel@tonic-gate } 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate int 25507c478bd9Sstevel@tonic-gate scf_iter_instance_pgs(scf_iter_t *iter, const scf_instance_t *inst) 25517c478bd9Sstevel@tonic-gate { 25527c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &inst->rd_d, 25537c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, 0)); 25547c478bd9Sstevel@tonic-gate } 25557c478bd9Sstevel@tonic-gate 25567c478bd9Sstevel@tonic-gate int 25577c478bd9Sstevel@tonic-gate scf_iter_instance_pgs_typed(scf_iter_t *iter, const scf_instance_t *inst, 25587c478bd9Sstevel@tonic-gate const char *type) 25597c478bd9Sstevel@tonic-gate { 25607c478bd9Sstevel@tonic-gate return (datael_setup_iter_pgtyped(iter, &inst->rd_d, type, 0)); 25617c478bd9Sstevel@tonic-gate } 25627c478bd9Sstevel@tonic-gate 25637c478bd9Sstevel@tonic-gate int 25647c478bd9Sstevel@tonic-gate scf_iter_instance_pgs_composed(scf_iter_t *iter, const scf_instance_t *inst, 25657c478bd9Sstevel@tonic-gate const scf_snapshot_t *snap) 25667c478bd9Sstevel@tonic-gate { 25677c478bd9Sstevel@tonic-gate if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle) 25687c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 25697c478bd9Sstevel@tonic-gate 25707c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, snap ? &snap->rd_d : &inst->rd_d, 25717c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, 1)); 25727c478bd9Sstevel@tonic-gate } 25737c478bd9Sstevel@tonic-gate 25747c478bd9Sstevel@tonic-gate int 25757c478bd9Sstevel@tonic-gate scf_iter_instance_pgs_typed_composed(scf_iter_t *iter, 25767c478bd9Sstevel@tonic-gate const scf_instance_t *inst, const scf_snapshot_t *snap, const char *type) 25777c478bd9Sstevel@tonic-gate { 25787c478bd9Sstevel@tonic-gate if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle) 25797c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate return (datael_setup_iter_pgtyped(iter, 25827c478bd9Sstevel@tonic-gate snap ? &snap->rd_d : &inst->rd_d, type, 1)); 25837c478bd9Sstevel@tonic-gate } 25847c478bd9Sstevel@tonic-gate 25857c478bd9Sstevel@tonic-gate int 25867c478bd9Sstevel@tonic-gate scf_iter_snaplevel_pgs(scf_iter_t *iter, const scf_snaplevel_t *inst) 25877c478bd9Sstevel@tonic-gate { 25887c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &inst->rd_d, 25897c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, 0)); 25907c478bd9Sstevel@tonic-gate } 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate int 25937c478bd9Sstevel@tonic-gate scf_iter_snaplevel_pgs_typed(scf_iter_t *iter, const scf_snaplevel_t *inst, 25947c478bd9Sstevel@tonic-gate const char *type) 25957c478bd9Sstevel@tonic-gate { 25967c478bd9Sstevel@tonic-gate return (datael_setup_iter_pgtyped(iter, &inst->rd_d, type, 0)); 25977c478bd9Sstevel@tonic-gate } 25987c478bd9Sstevel@tonic-gate 25997c478bd9Sstevel@tonic-gate int 26007c478bd9Sstevel@tonic-gate scf_iter_next_pg(scf_iter_t *iter, scf_propertygroup_t *out) 26017c478bd9Sstevel@tonic-gate { 26027c478bd9Sstevel@tonic-gate return (datael_iter_next(iter, &out->rd_d)); 26037c478bd9Sstevel@tonic-gate } 26047c478bd9Sstevel@tonic-gate 26057c478bd9Sstevel@tonic-gate int 26067c478bd9Sstevel@tonic-gate scf_iter_pg_properties(scf_iter_t *iter, const scf_propertygroup_t *pg) 26077c478bd9Sstevel@tonic-gate { 26087c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &pg->rd_d, 26097c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTY, 0)); 26107c478bd9Sstevel@tonic-gate } 26117c478bd9Sstevel@tonic-gate 26127c478bd9Sstevel@tonic-gate int 26137c478bd9Sstevel@tonic-gate scf_iter_next_property(scf_iter_t *iter, scf_property_t *out) 26147c478bd9Sstevel@tonic-gate { 26157c478bd9Sstevel@tonic-gate return (datael_iter_next(iter, &out->rd_d)); 26167c478bd9Sstevel@tonic-gate } 26177c478bd9Sstevel@tonic-gate 26187c478bd9Sstevel@tonic-gate /* 26197c478bd9Sstevel@tonic-gate * Fails with 26207c478bd9Sstevel@tonic-gate * _INVALID_ARGUMENT - handle is NULL 26217c478bd9Sstevel@tonic-gate * _INTERNAL - server response too big 26227c478bd9Sstevel@tonic-gate * entity already set up with different type 26237c478bd9Sstevel@tonic-gate * _NO_RESOURCES 26247c478bd9Sstevel@tonic-gate * _NO_MEMORY 26257c478bd9Sstevel@tonic-gate */ 26267c478bd9Sstevel@tonic-gate scf_scope_t * 26277c478bd9Sstevel@tonic-gate scf_scope_create(scf_handle_t *handle) 26287c478bd9Sstevel@tonic-gate { 26297c478bd9Sstevel@tonic-gate scf_scope_t *ret; 26307c478bd9Sstevel@tonic-gate 26317c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 26327c478bd9Sstevel@tonic-gate if (ret != NULL) { 26337c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 26347c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SCOPE) == -1) { 26357c478bd9Sstevel@tonic-gate uu_free(ret); 26367c478bd9Sstevel@tonic-gate return (NULL); 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate } else { 26397c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 26407c478bd9Sstevel@tonic-gate } 26417c478bd9Sstevel@tonic-gate 26427c478bd9Sstevel@tonic-gate return (ret); 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate 26457c478bd9Sstevel@tonic-gate scf_handle_t * 26467c478bd9Sstevel@tonic-gate scf_scope_handle(const scf_scope_t *val) 26477c478bd9Sstevel@tonic-gate { 26487c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 26497c478bd9Sstevel@tonic-gate } 26507c478bd9Sstevel@tonic-gate 26517c478bd9Sstevel@tonic-gate void 26527c478bd9Sstevel@tonic-gate scf_scope_destroy(scf_scope_t *val) 26537c478bd9Sstevel@tonic-gate { 26547c478bd9Sstevel@tonic-gate if (val == NULL) 26557c478bd9Sstevel@tonic-gate return; 26567c478bd9Sstevel@tonic-gate 26577c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 26587c478bd9Sstevel@tonic-gate uu_free(val); 26597c478bd9Sstevel@tonic-gate } 26607c478bd9Sstevel@tonic-gate 26617c478bd9Sstevel@tonic-gate ssize_t 26627c478bd9Sstevel@tonic-gate scf_scope_get_name(const scf_scope_t *rep, char *out, size_t len) 26637c478bd9Sstevel@tonic-gate { 26647c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME)); 26657c478bd9Sstevel@tonic-gate } 26667c478bd9Sstevel@tonic-gate 26677c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 26687c478bd9Sstevel@tonic-gate int 26697c478bd9Sstevel@tonic-gate scf_scope_get_parent(const scf_scope_t *child, scf_scope_t *parent) 26707c478bd9Sstevel@tonic-gate { 26717c478bd9Sstevel@tonic-gate char name[1]; 26727c478bd9Sstevel@tonic-gate 26737c478bd9Sstevel@tonic-gate /* fake up the side-effects */ 26747c478bd9Sstevel@tonic-gate datael_reset(&parent->rd_d); 26757c478bd9Sstevel@tonic-gate if (scf_scope_get_name(child, name, sizeof (name)) < 0) 26767c478bd9Sstevel@tonic-gate return (-1); 26777c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_FOUND)); 26787c478bd9Sstevel@tonic-gate } 26797c478bd9Sstevel@tonic-gate 26807c478bd9Sstevel@tonic-gate /* 26817c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL 26827c478bd9Sstevel@tonic-gate * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY. 26837c478bd9Sstevel@tonic-gate */ 26847c478bd9Sstevel@tonic-gate scf_service_t * 26857c478bd9Sstevel@tonic-gate scf_service_create(scf_handle_t *handle) 26867c478bd9Sstevel@tonic-gate { 26877c478bd9Sstevel@tonic-gate scf_service_t *ret; 26887c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 26897c478bd9Sstevel@tonic-gate if (ret != NULL) { 26907c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 26917c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SERVICE) == -1) { 26927c478bd9Sstevel@tonic-gate uu_free(ret); 26937c478bd9Sstevel@tonic-gate return (NULL); 26947c478bd9Sstevel@tonic-gate } 26957c478bd9Sstevel@tonic-gate } else { 26967c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 26977c478bd9Sstevel@tonic-gate } 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate return (ret); 27007c478bd9Sstevel@tonic-gate } 27017c478bd9Sstevel@tonic-gate 270276cf44abSjeanm 270376cf44abSjeanm /* 270476cf44abSjeanm * Fails with 270576cf44abSjeanm * _HANDLE_MISMATCH 270676cf44abSjeanm * _INVALID_ARGUMENT 270776cf44abSjeanm * _NOT_BOUND 270876cf44abSjeanm * _CONNECTION_BROKEN 270976cf44abSjeanm * _INTERNAL 271076cf44abSjeanm * _EXISTS 271176cf44abSjeanm * _DELETED 271276cf44abSjeanm * _NOT_SET 271376cf44abSjeanm * _NO_RESOURCES 271476cf44abSjeanm * _PERMISSION_DENIED 271576cf44abSjeanm * _BACKEND_ACCESS 271676cf44abSjeanm * _BACKEND_READONLY 271776cf44abSjeanm */ 27187c478bd9Sstevel@tonic-gate int 27197c478bd9Sstevel@tonic-gate scf_scope_add_service(const scf_scope_t *scope, const char *name, 27207c478bd9Sstevel@tonic-gate scf_service_t *svc) 27217c478bd9Sstevel@tonic-gate { 27227c478bd9Sstevel@tonic-gate return (datael_add_child(&scope->rd_d, name, 27237c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SERVICE, (svc != NULL)? &svc->rd_d : NULL)); 27247c478bd9Sstevel@tonic-gate } 27257c478bd9Sstevel@tonic-gate 272676cf44abSjeanm /* 272776cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 272876cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 272976cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 273076cf44abSjeanm */ 27317c478bd9Sstevel@tonic-gate int 27327c478bd9Sstevel@tonic-gate scf_scope_get_service(const scf_scope_t *s, const char *name, 27337c478bd9Sstevel@tonic-gate scf_service_t *svc) 27347c478bd9Sstevel@tonic-gate { 27357c478bd9Sstevel@tonic-gate return (datael_get_child(&s->rd_d, name, REP_PROTOCOL_ENTITY_SERVICE, 27367c478bd9Sstevel@tonic-gate svc ? &svc->rd_d : NULL, 0)); 27377c478bd9Sstevel@tonic-gate } 27387c478bd9Sstevel@tonic-gate 27397c478bd9Sstevel@tonic-gate scf_handle_t * 27407c478bd9Sstevel@tonic-gate scf_service_handle(const scf_service_t *val) 27417c478bd9Sstevel@tonic-gate { 27427c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 27437c478bd9Sstevel@tonic-gate } 27447c478bd9Sstevel@tonic-gate 27457c478bd9Sstevel@tonic-gate int 27467c478bd9Sstevel@tonic-gate scf_service_delete(scf_service_t *svc) 27477c478bd9Sstevel@tonic-gate { 27487c478bd9Sstevel@tonic-gate return (datael_delete(&svc->rd_d)); 27497c478bd9Sstevel@tonic-gate } 27507c478bd9Sstevel@tonic-gate 27517c478bd9Sstevel@tonic-gate int 27527c478bd9Sstevel@tonic-gate scf_instance_delete(scf_instance_t *inst) 27537c478bd9Sstevel@tonic-gate { 27547c478bd9Sstevel@tonic-gate return (datael_delete(&inst->rd_d)); 27557c478bd9Sstevel@tonic-gate } 27567c478bd9Sstevel@tonic-gate 27577c478bd9Sstevel@tonic-gate int 27587c478bd9Sstevel@tonic-gate scf_pg_delete(scf_propertygroup_t *pg) 27597c478bd9Sstevel@tonic-gate { 27607c478bd9Sstevel@tonic-gate return (datael_delete(&pg->rd_d)); 27617c478bd9Sstevel@tonic-gate } 27627c478bd9Sstevel@tonic-gate 27637c478bd9Sstevel@tonic-gate int 27647c478bd9Sstevel@tonic-gate _scf_snapshot_delete(scf_snapshot_t *snap) 27657c478bd9Sstevel@tonic-gate { 27667c478bd9Sstevel@tonic-gate return (datael_delete(&snap->rd_d)); 27677c478bd9Sstevel@tonic-gate } 27687c478bd9Sstevel@tonic-gate 276976cf44abSjeanm /* 277076cf44abSjeanm * Fails with 277176cf44abSjeanm * _HANDLE_MISMATCH 277276cf44abSjeanm * _INVALID_ARGUMENT 277376cf44abSjeanm * _NOT_BOUND 277476cf44abSjeanm * _CONNECTION_BROKEN 277576cf44abSjeanm * _INTERNAL 277676cf44abSjeanm * _EXISTS 277776cf44abSjeanm * _DELETED 277876cf44abSjeanm * _NOT_SET 277976cf44abSjeanm * _NO_RESOURCES 278076cf44abSjeanm * _PERMISSION_DENIED 278176cf44abSjeanm * _BACKEND_ACCESS 278276cf44abSjeanm * _BACKEND_READONLY 278376cf44abSjeanm */ 27847c478bd9Sstevel@tonic-gate int 27857c478bd9Sstevel@tonic-gate scf_service_add_instance(const scf_service_t *svc, const char *name, 27867c478bd9Sstevel@tonic-gate scf_instance_t *instance) 27877c478bd9Sstevel@tonic-gate { 27887c478bd9Sstevel@tonic-gate return (datael_add_child(&svc->rd_d, name, 27897c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_INSTANCE, 27907c478bd9Sstevel@tonic-gate (instance != NULL)? &instance->rd_d : NULL)); 27917c478bd9Sstevel@tonic-gate } 27927c478bd9Sstevel@tonic-gate 279376cf44abSjeanm 279476cf44abSjeanm /* 279576cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 279676cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 279776cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 279876cf44abSjeanm */ 27997c478bd9Sstevel@tonic-gate int 28007c478bd9Sstevel@tonic-gate scf_service_get_instance(const scf_service_t *svc, const char *name, 28017c478bd9Sstevel@tonic-gate scf_instance_t *inst) 28027c478bd9Sstevel@tonic-gate { 28037c478bd9Sstevel@tonic-gate return (datael_get_child(&svc->rd_d, name, REP_PROTOCOL_ENTITY_INSTANCE, 28047c478bd9Sstevel@tonic-gate inst ? &inst->rd_d : NULL, 0)); 28057c478bd9Sstevel@tonic-gate } 28067c478bd9Sstevel@tonic-gate 28077c478bd9Sstevel@tonic-gate int 28087c478bd9Sstevel@tonic-gate scf_service_add_pg(const scf_service_t *svc, const char *name, 28097c478bd9Sstevel@tonic-gate const char *type, uint32_t flags, scf_propertygroup_t *pg) 28107c478bd9Sstevel@tonic-gate { 28117c478bd9Sstevel@tonic-gate return (datael_add_pg(&svc->rd_d, name, type, flags, 28127c478bd9Sstevel@tonic-gate (pg != NULL)?&pg->rd_d : NULL)); 28137c478bd9Sstevel@tonic-gate } 28147c478bd9Sstevel@tonic-gate 281576cf44abSjeanm /* 281676cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 281776cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 281876cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 281976cf44abSjeanm */ 28207c478bd9Sstevel@tonic-gate int 28217c478bd9Sstevel@tonic-gate scf_service_get_pg(const scf_service_t *svc, const char *name, 28227c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg) 28237c478bd9Sstevel@tonic-gate { 28247c478bd9Sstevel@tonic-gate return (datael_get_child(&svc->rd_d, name, 28257c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0)); 28267c478bd9Sstevel@tonic-gate } 28277c478bd9Sstevel@tonic-gate 28287c478bd9Sstevel@tonic-gate int 28297c478bd9Sstevel@tonic-gate scf_instance_add_pg(const scf_instance_t *inst, const char *name, 28307c478bd9Sstevel@tonic-gate const char *type, uint32_t flags, scf_propertygroup_t *pg) 28317c478bd9Sstevel@tonic-gate { 28327c478bd9Sstevel@tonic-gate return (datael_add_pg(&inst->rd_d, name, type, flags, 28337c478bd9Sstevel@tonic-gate (pg != NULL)?&pg->rd_d : NULL)); 28347c478bd9Sstevel@tonic-gate } 28357c478bd9Sstevel@tonic-gate 283676cf44abSjeanm /* 283776cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 283876cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 283976cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 284076cf44abSjeanm */ 28417c478bd9Sstevel@tonic-gate int 28427c478bd9Sstevel@tonic-gate scf_instance_get_snapshot(const scf_instance_t *inst, const char *name, 28437c478bd9Sstevel@tonic-gate scf_snapshot_t *pg) 28447c478bd9Sstevel@tonic-gate { 28457c478bd9Sstevel@tonic-gate return (datael_get_child(&inst->rd_d, name, 28467c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SNAPSHOT, pg ? &pg->rd_d : NULL, 0)); 28477c478bd9Sstevel@tonic-gate } 28487c478bd9Sstevel@tonic-gate 284976cf44abSjeanm /* 285076cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 285176cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 285276cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 285376cf44abSjeanm */ 28547c478bd9Sstevel@tonic-gate int 28557c478bd9Sstevel@tonic-gate scf_instance_get_pg(const scf_instance_t *inst, const char *name, 28567c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg) 28577c478bd9Sstevel@tonic-gate { 28587c478bd9Sstevel@tonic-gate return (datael_get_child(&inst->rd_d, name, 28597c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0)); 28607c478bd9Sstevel@tonic-gate } 28617c478bd9Sstevel@tonic-gate 286276cf44abSjeanm /* 286376cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 286476cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 286576cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 286676cf44abSjeanm */ 28677c478bd9Sstevel@tonic-gate int 28687c478bd9Sstevel@tonic-gate scf_instance_get_pg_composed(const scf_instance_t *inst, 28697c478bd9Sstevel@tonic-gate const scf_snapshot_t *snap, const char *name, scf_propertygroup_t *pg) 28707c478bd9Sstevel@tonic-gate { 28717c478bd9Sstevel@tonic-gate if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle) 28727c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 28737c478bd9Sstevel@tonic-gate 28747c478bd9Sstevel@tonic-gate return (datael_get_child(snap ? &snap->rd_d : &inst->rd_d, name, 28757c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 1)); 28767c478bd9Sstevel@tonic-gate } 28777c478bd9Sstevel@tonic-gate 287876cf44abSjeanm /* 287976cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 288076cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 288176cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 288276cf44abSjeanm */ 28837c478bd9Sstevel@tonic-gate int 28847c478bd9Sstevel@tonic-gate scf_pg_get_property(const scf_propertygroup_t *pg, const char *name, 28857c478bd9Sstevel@tonic-gate scf_property_t *prop) 28867c478bd9Sstevel@tonic-gate { 28877c478bd9Sstevel@tonic-gate return (datael_get_child(&pg->rd_d, name, REP_PROTOCOL_ENTITY_PROPERTY, 28887c478bd9Sstevel@tonic-gate prop ? &prop->rd_d : NULL, 0)); 28897c478bd9Sstevel@tonic-gate } 28907c478bd9Sstevel@tonic-gate 28917c478bd9Sstevel@tonic-gate void 28927c478bd9Sstevel@tonic-gate scf_service_destroy(scf_service_t *val) 28937c478bd9Sstevel@tonic-gate { 28947c478bd9Sstevel@tonic-gate if (val == NULL) 28957c478bd9Sstevel@tonic-gate return; 28967c478bd9Sstevel@tonic-gate 28977c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 28987c478bd9Sstevel@tonic-gate uu_free(val); 28997c478bd9Sstevel@tonic-gate } 29007c478bd9Sstevel@tonic-gate 29017c478bd9Sstevel@tonic-gate ssize_t 29027c478bd9Sstevel@tonic-gate scf_service_get_name(const scf_service_t *rep, char *out, size_t len) 29037c478bd9Sstevel@tonic-gate { 29047c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME)); 29057c478bd9Sstevel@tonic-gate } 29067c478bd9Sstevel@tonic-gate 29077c478bd9Sstevel@tonic-gate /* 29087c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL 29097c478bd9Sstevel@tonic-gate * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY. 29107c478bd9Sstevel@tonic-gate */ 29117c478bd9Sstevel@tonic-gate scf_instance_t * 29127c478bd9Sstevel@tonic-gate scf_instance_create(scf_handle_t *handle) 29137c478bd9Sstevel@tonic-gate { 29147c478bd9Sstevel@tonic-gate scf_instance_t *ret; 29157c478bd9Sstevel@tonic-gate 29167c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 29177c478bd9Sstevel@tonic-gate if (ret != NULL) { 29187c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 29197c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_INSTANCE) == -1) { 29207c478bd9Sstevel@tonic-gate uu_free(ret); 29217c478bd9Sstevel@tonic-gate return (NULL); 29227c478bd9Sstevel@tonic-gate } 29237c478bd9Sstevel@tonic-gate } else { 29247c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 29257c478bd9Sstevel@tonic-gate } 29267c478bd9Sstevel@tonic-gate 29277c478bd9Sstevel@tonic-gate return (ret); 29287c478bd9Sstevel@tonic-gate } 29297c478bd9Sstevel@tonic-gate 29307c478bd9Sstevel@tonic-gate scf_handle_t * 29317c478bd9Sstevel@tonic-gate scf_instance_handle(const scf_instance_t *val) 29327c478bd9Sstevel@tonic-gate { 29337c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 29347c478bd9Sstevel@tonic-gate } 29357c478bd9Sstevel@tonic-gate 29367c478bd9Sstevel@tonic-gate void 29377c478bd9Sstevel@tonic-gate scf_instance_destroy(scf_instance_t *val) 29387c478bd9Sstevel@tonic-gate { 29397c478bd9Sstevel@tonic-gate if (val == NULL) 29407c478bd9Sstevel@tonic-gate return; 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 29437c478bd9Sstevel@tonic-gate uu_free(val); 29447c478bd9Sstevel@tonic-gate } 29457c478bd9Sstevel@tonic-gate 29467c478bd9Sstevel@tonic-gate ssize_t 29477c478bd9Sstevel@tonic-gate scf_instance_get_name(const scf_instance_t *rep, char *out, size_t len) 29487c478bd9Sstevel@tonic-gate { 29497c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME)); 29507c478bd9Sstevel@tonic-gate } 29517c478bd9Sstevel@tonic-gate 29527c478bd9Sstevel@tonic-gate /* 29537c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL 29547c478bd9Sstevel@tonic-gate * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY. 29557c478bd9Sstevel@tonic-gate */ 29567c478bd9Sstevel@tonic-gate scf_snapshot_t * 29577c478bd9Sstevel@tonic-gate scf_snapshot_create(scf_handle_t *handle) 29587c478bd9Sstevel@tonic-gate { 29597c478bd9Sstevel@tonic-gate scf_snapshot_t *ret; 29607c478bd9Sstevel@tonic-gate 29617c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 29627c478bd9Sstevel@tonic-gate if (ret != NULL) { 29637c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 29647c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SNAPSHOT) == -1) { 29657c478bd9Sstevel@tonic-gate uu_free(ret); 29667c478bd9Sstevel@tonic-gate return (NULL); 29677c478bd9Sstevel@tonic-gate } 29687c478bd9Sstevel@tonic-gate } else { 29697c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate 29727c478bd9Sstevel@tonic-gate return (ret); 29737c478bd9Sstevel@tonic-gate } 29747c478bd9Sstevel@tonic-gate 29757c478bd9Sstevel@tonic-gate scf_handle_t * 29767c478bd9Sstevel@tonic-gate scf_snapshot_handle(const scf_snapshot_t *val) 29777c478bd9Sstevel@tonic-gate { 29787c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 29797c478bd9Sstevel@tonic-gate } 29807c478bd9Sstevel@tonic-gate 29817c478bd9Sstevel@tonic-gate void 29827c478bd9Sstevel@tonic-gate scf_snapshot_destroy(scf_snapshot_t *val) 29837c478bd9Sstevel@tonic-gate { 29847c478bd9Sstevel@tonic-gate if (val == NULL) 29857c478bd9Sstevel@tonic-gate return; 29867c478bd9Sstevel@tonic-gate 29877c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 29887c478bd9Sstevel@tonic-gate uu_free(val); 29897c478bd9Sstevel@tonic-gate } 29907c478bd9Sstevel@tonic-gate 29917c478bd9Sstevel@tonic-gate ssize_t 29927c478bd9Sstevel@tonic-gate scf_snapshot_get_name(const scf_snapshot_t *rep, char *out, size_t len) 29937c478bd9Sstevel@tonic-gate { 29947c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME)); 29957c478bd9Sstevel@tonic-gate } 29967c478bd9Sstevel@tonic-gate 29977c478bd9Sstevel@tonic-gate /* 29987c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL 29997c478bd9Sstevel@tonic-gate * (bad server response or id in use), _NO_RESOURCES, _NO_MEMORY. 30007c478bd9Sstevel@tonic-gate */ 30017c478bd9Sstevel@tonic-gate scf_snaplevel_t * 30027c478bd9Sstevel@tonic-gate scf_snaplevel_create(scf_handle_t *handle) 30037c478bd9Sstevel@tonic-gate { 30047c478bd9Sstevel@tonic-gate scf_snaplevel_t *ret; 30057c478bd9Sstevel@tonic-gate 30067c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 30077c478bd9Sstevel@tonic-gate if (ret != NULL) { 30087c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 30097c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_SNAPLEVEL) == -1) { 30107c478bd9Sstevel@tonic-gate uu_free(ret); 30117c478bd9Sstevel@tonic-gate return (NULL); 30127c478bd9Sstevel@tonic-gate } 30137c478bd9Sstevel@tonic-gate } else { 30147c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 30157c478bd9Sstevel@tonic-gate } 30167c478bd9Sstevel@tonic-gate 30177c478bd9Sstevel@tonic-gate return (ret); 30187c478bd9Sstevel@tonic-gate } 30197c478bd9Sstevel@tonic-gate 30207c478bd9Sstevel@tonic-gate scf_handle_t * 30217c478bd9Sstevel@tonic-gate scf_snaplevel_handle(const scf_snaplevel_t *val) 30227c478bd9Sstevel@tonic-gate { 30237c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 30247c478bd9Sstevel@tonic-gate } 30257c478bd9Sstevel@tonic-gate 30267c478bd9Sstevel@tonic-gate void 30277c478bd9Sstevel@tonic-gate scf_snaplevel_destroy(scf_snaplevel_t *val) 30287c478bd9Sstevel@tonic-gate { 30297c478bd9Sstevel@tonic-gate if (val == NULL) 30307c478bd9Sstevel@tonic-gate return; 30317c478bd9Sstevel@tonic-gate 30327c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 30337c478bd9Sstevel@tonic-gate uu_free(val); 30347c478bd9Sstevel@tonic-gate } 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate ssize_t 30377c478bd9Sstevel@tonic-gate scf_snaplevel_get_scope_name(const scf_snaplevel_t *rep, char *out, size_t len) 30387c478bd9Sstevel@tonic-gate { 30397c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, 30407c478bd9Sstevel@tonic-gate RP_ENTITY_NAME_SNAPLEVEL_SCOPE)); 30417c478bd9Sstevel@tonic-gate } 30427c478bd9Sstevel@tonic-gate 30437c478bd9Sstevel@tonic-gate ssize_t 30447c478bd9Sstevel@tonic-gate scf_snaplevel_get_service_name(const scf_snaplevel_t *rep, char *out, 30457c478bd9Sstevel@tonic-gate size_t len) 30467c478bd9Sstevel@tonic-gate { 30477c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, 30487c478bd9Sstevel@tonic-gate RP_ENTITY_NAME_SNAPLEVEL_SERVICE)); 30497c478bd9Sstevel@tonic-gate } 30507c478bd9Sstevel@tonic-gate 30517c478bd9Sstevel@tonic-gate ssize_t 30527c478bd9Sstevel@tonic-gate scf_snaplevel_get_instance_name(const scf_snaplevel_t *rep, char *out, 30537c478bd9Sstevel@tonic-gate size_t len) 30547c478bd9Sstevel@tonic-gate { 30557c478bd9Sstevel@tonic-gate return (datael_get_name(&rep->rd_d, out, len, 30567c478bd9Sstevel@tonic-gate RP_ENTITY_NAME_SNAPLEVEL_INSTANCE)); 30577c478bd9Sstevel@tonic-gate } 30587c478bd9Sstevel@tonic-gate 305976cf44abSjeanm /* 306076cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 306176cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 306276cf44abSjeanm * _BACKEND_ACCESS, _NOT_FOUND. 306376cf44abSjeanm */ 30647c478bd9Sstevel@tonic-gate int 30657c478bd9Sstevel@tonic-gate scf_snaplevel_get_pg(const scf_snaplevel_t *snap, const char *name, 30667c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg) 30677c478bd9Sstevel@tonic-gate { 30687c478bd9Sstevel@tonic-gate return (datael_get_child(&snap->rd_d, name, 30697c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0)); 30707c478bd9Sstevel@tonic-gate } 30717c478bd9Sstevel@tonic-gate 30727c478bd9Sstevel@tonic-gate static int 30737c478bd9Sstevel@tonic-gate snaplevel_next(const scf_datael_t *src, scf_snaplevel_t *dst_arg) 30747c478bd9Sstevel@tonic-gate { 30757c478bd9Sstevel@tonic-gate scf_handle_t *h = src->rd_handle; 30767c478bd9Sstevel@tonic-gate scf_snaplevel_t *dst = dst_arg; 30777c478bd9Sstevel@tonic-gate struct rep_protocol_entity_pair request; 30787c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 30797c478bd9Sstevel@tonic-gate int r; 30807c478bd9Sstevel@tonic-gate int dups = 0; 30817c478bd9Sstevel@tonic-gate 30827c478bd9Sstevel@tonic-gate if (h != dst->rd_d.rd_handle) 30837c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 30847c478bd9Sstevel@tonic-gate 30857c478bd9Sstevel@tonic-gate if (src == &dst->rd_d) { 30867c478bd9Sstevel@tonic-gate dups = 1; 30877c478bd9Sstevel@tonic-gate dst = HANDLE_HOLD_SNAPLVL(h); 30887c478bd9Sstevel@tonic-gate } 30897c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 30907c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_NEXT_SNAPLEVEL; 30917c478bd9Sstevel@tonic-gate request.rpr_entity_src = src->rd_entity; 30927c478bd9Sstevel@tonic-gate request.rpr_entity_dst = dst->rd_d.rd_entity; 30937c478bd9Sstevel@tonic-gate 30947c478bd9Sstevel@tonic-gate datael_finish_reset(src); 30957c478bd9Sstevel@tonic-gate datael_finish_reset(&dst->rd_d); 30967c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 30977c478bd9Sstevel@tonic-gate &response, sizeof (response)); 30987c478bd9Sstevel@tonic-gate /* 30997c478bd9Sstevel@tonic-gate * if we succeeded, we need to swap dst and dst_arg's identity. We 31007c478bd9Sstevel@tonic-gate * take advantage of the fact that the only in-library knowledge is 31017c478bd9Sstevel@tonic-gate * their entity ids. 31027c478bd9Sstevel@tonic-gate */ 31037c478bd9Sstevel@tonic-gate if (dups && r >= 0 && 31047c478bd9Sstevel@tonic-gate (response.rpr_response == REP_PROTOCOL_SUCCESS || 31057c478bd9Sstevel@tonic-gate response.rpr_response == REP_PROTOCOL_DONE)) { 31067c478bd9Sstevel@tonic-gate int entity = dst->rd_d.rd_entity; 31077c478bd9Sstevel@tonic-gate 31087c478bd9Sstevel@tonic-gate dst->rd_d.rd_entity = dst_arg->rd_d.rd_entity; 31097c478bd9Sstevel@tonic-gate dst_arg->rd_d.rd_entity = entity; 31107c478bd9Sstevel@tonic-gate } 31117c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate if (dups) 31147c478bd9Sstevel@tonic-gate HANDLE_RELE_SNAPLVL(h); 31157c478bd9Sstevel@tonic-gate 31167c478bd9Sstevel@tonic-gate if (r < 0) 31177c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 31187c478bd9Sstevel@tonic-gate 31197c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS && 31207c478bd9Sstevel@tonic-gate response.rpr_response != REP_PROTOCOL_DONE) { 31217c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 31227c478bd9Sstevel@tonic-gate } 31237c478bd9Sstevel@tonic-gate 31247c478bd9Sstevel@tonic-gate return (response.rpr_response == REP_PROTOCOL_SUCCESS) ? 31257c478bd9Sstevel@tonic-gate SCF_SUCCESS : SCF_COMPLETE; 31267c478bd9Sstevel@tonic-gate } 31277c478bd9Sstevel@tonic-gate 31287c478bd9Sstevel@tonic-gate int scf_snapshot_get_base_snaplevel(const scf_snapshot_t *base, 31297c478bd9Sstevel@tonic-gate scf_snaplevel_t *out) 31307c478bd9Sstevel@tonic-gate { 31317c478bd9Sstevel@tonic-gate return (snaplevel_next(&base->rd_d, out)); 31327c478bd9Sstevel@tonic-gate } 31337c478bd9Sstevel@tonic-gate 31347c478bd9Sstevel@tonic-gate int scf_snaplevel_get_next_snaplevel(const scf_snaplevel_t *base, 31357c478bd9Sstevel@tonic-gate scf_snaplevel_t *out) 31367c478bd9Sstevel@tonic-gate { 31377c478bd9Sstevel@tonic-gate return (snaplevel_next(&base->rd_d, out)); 31387c478bd9Sstevel@tonic-gate } 31397c478bd9Sstevel@tonic-gate 31407c478bd9Sstevel@tonic-gate /* 31417c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL 31427c478bd9Sstevel@tonic-gate * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY. 31437c478bd9Sstevel@tonic-gate */ 31447c478bd9Sstevel@tonic-gate scf_propertygroup_t * 31457c478bd9Sstevel@tonic-gate scf_pg_create(scf_handle_t *handle) 31467c478bd9Sstevel@tonic-gate { 31477c478bd9Sstevel@tonic-gate scf_propertygroup_t *ret; 31487c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 31497c478bd9Sstevel@tonic-gate if (ret != NULL) { 31507c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 31517c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP) == -1) { 31527c478bd9Sstevel@tonic-gate uu_free(ret); 31537c478bd9Sstevel@tonic-gate return (NULL); 31547c478bd9Sstevel@tonic-gate } 31557c478bd9Sstevel@tonic-gate } else { 31567c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 31577c478bd9Sstevel@tonic-gate } 31587c478bd9Sstevel@tonic-gate 31597c478bd9Sstevel@tonic-gate return (ret); 31607c478bd9Sstevel@tonic-gate } 31617c478bd9Sstevel@tonic-gate 31627c478bd9Sstevel@tonic-gate scf_handle_t * 31637c478bd9Sstevel@tonic-gate scf_pg_handle(const scf_propertygroup_t *val) 31647c478bd9Sstevel@tonic-gate { 31657c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 31667c478bd9Sstevel@tonic-gate } 31677c478bd9Sstevel@tonic-gate 31687c478bd9Sstevel@tonic-gate void 31697c478bd9Sstevel@tonic-gate scf_pg_destroy(scf_propertygroup_t *val) 31707c478bd9Sstevel@tonic-gate { 31717c478bd9Sstevel@tonic-gate if (val == NULL) 31727c478bd9Sstevel@tonic-gate return; 31737c478bd9Sstevel@tonic-gate 31747c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 31757c478bd9Sstevel@tonic-gate uu_free(val); 31767c478bd9Sstevel@tonic-gate } 31777c478bd9Sstevel@tonic-gate 31787c478bd9Sstevel@tonic-gate ssize_t 31797c478bd9Sstevel@tonic-gate scf_pg_get_name(const scf_propertygroup_t *pg, char *out, size_t len) 31807c478bd9Sstevel@tonic-gate { 31817c478bd9Sstevel@tonic-gate return (datael_get_name(&pg->rd_d, out, len, RP_ENTITY_NAME_NAME)); 31827c478bd9Sstevel@tonic-gate } 31837c478bd9Sstevel@tonic-gate 31847c478bd9Sstevel@tonic-gate ssize_t 31857c478bd9Sstevel@tonic-gate scf_pg_get_type(const scf_propertygroup_t *pg, char *out, size_t len) 31867c478bd9Sstevel@tonic-gate { 31877c478bd9Sstevel@tonic-gate return (datael_get_name(&pg->rd_d, out, len, RP_ENTITY_NAME_PGTYPE)); 31887c478bd9Sstevel@tonic-gate } 31897c478bd9Sstevel@tonic-gate 31907c478bd9Sstevel@tonic-gate int 31917c478bd9Sstevel@tonic-gate scf_pg_get_flags(const scf_propertygroup_t *pg, uint32_t *out) 31927c478bd9Sstevel@tonic-gate { 31937c478bd9Sstevel@tonic-gate char buf[REP_PROTOCOL_NAME_LEN]; 31947c478bd9Sstevel@tonic-gate ssize_t res; 31957c478bd9Sstevel@tonic-gate 31967c478bd9Sstevel@tonic-gate res = datael_get_name(&pg->rd_d, buf, sizeof (buf), 31977c478bd9Sstevel@tonic-gate RP_ENTITY_NAME_PGFLAGS); 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate if (res == -1) 32007c478bd9Sstevel@tonic-gate return (-1); 32017c478bd9Sstevel@tonic-gate 32027c478bd9Sstevel@tonic-gate if (uu_strtouint(buf, out, sizeof (*out), 0, 0, UINT32_MAX) == -1) 32037c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 32047c478bd9Sstevel@tonic-gate 32057c478bd9Sstevel@tonic-gate return (0); 32067c478bd9Sstevel@tonic-gate } 32077c478bd9Sstevel@tonic-gate 32087c478bd9Sstevel@tonic-gate static int 32097c478bd9Sstevel@tonic-gate datael_update(scf_datael_t *dp) 32107c478bd9Sstevel@tonic-gate { 32117c478bd9Sstevel@tonic-gate scf_handle_t *h = dp->rd_handle; 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate struct rep_protocol_entity_update request; 32147c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 32157c478bd9Sstevel@tonic-gate 32167c478bd9Sstevel@tonic-gate int r; 32177c478bd9Sstevel@tonic-gate 32187c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 32197c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_UPDATE; 32207c478bd9Sstevel@tonic-gate request.rpr_entityid = dp->rd_entity; 32217c478bd9Sstevel@tonic-gate 32227c478bd9Sstevel@tonic-gate datael_finish_reset(dp); 32238918dff3Sjwadams request.rpr_changeid = handle_next_changeid(h); 32247c478bd9Sstevel@tonic-gate 32257c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 32267c478bd9Sstevel@tonic-gate &response, sizeof (response)); 32277c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate if (r < 0) 32307c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 32317c478bd9Sstevel@tonic-gate 323276cf44abSjeanm /* 323376cf44abSjeanm * This should never happen but if it does something has 323476cf44abSjeanm * gone terribly wrong and we should abort. 323576cf44abSjeanm */ 323676cf44abSjeanm if (response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST) 323776cf44abSjeanm abort(); 323876cf44abSjeanm 32397c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS && 32407c478bd9Sstevel@tonic-gate response.rpr_response != REP_PROTOCOL_DONE) { 32417c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 32427c478bd9Sstevel@tonic-gate } 32437c478bd9Sstevel@tonic-gate 32447c478bd9Sstevel@tonic-gate return (response.rpr_response == REP_PROTOCOL_SUCCESS) ? 32457c478bd9Sstevel@tonic-gate SCF_SUCCESS : SCF_COMPLETE; 32467c478bd9Sstevel@tonic-gate } 32477c478bd9Sstevel@tonic-gate 32487c478bd9Sstevel@tonic-gate int 32497c478bd9Sstevel@tonic-gate scf_pg_update(scf_propertygroup_t *pg) 32507c478bd9Sstevel@tonic-gate { 32517c478bd9Sstevel@tonic-gate return (datael_update(&pg->rd_d)); 32527c478bd9Sstevel@tonic-gate } 32537c478bd9Sstevel@tonic-gate 32547c478bd9Sstevel@tonic-gate int 32557c478bd9Sstevel@tonic-gate scf_snapshot_update(scf_snapshot_t *snap) 32567c478bd9Sstevel@tonic-gate { 32577c478bd9Sstevel@tonic-gate return (datael_update(&snap->rd_d)); 32587c478bd9Sstevel@tonic-gate } 32597c478bd9Sstevel@tonic-gate 32607c478bd9Sstevel@tonic-gate int 32617c478bd9Sstevel@tonic-gate _scf_pg_wait(scf_propertygroup_t *pg, int timeout) 32627c478bd9Sstevel@tonic-gate { 32637c478bd9Sstevel@tonic-gate scf_handle_t *h = pg->rd_d.rd_handle; 32647c478bd9Sstevel@tonic-gate 32657c478bd9Sstevel@tonic-gate struct rep_protocol_propertygrp_request request; 32667c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate struct pollfd pollfd; 32697c478bd9Sstevel@tonic-gate 32707c478bd9Sstevel@tonic-gate int r; 32717c478bd9Sstevel@tonic-gate 32727c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 32737c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_PROPERTYGRP_SETUP_WAIT; 32747c478bd9Sstevel@tonic-gate request.rpr_entityid = pg->rd_d.rd_entity; 32757c478bd9Sstevel@tonic-gate 32767c478bd9Sstevel@tonic-gate datael_finish_reset(&pg->rd_d); 32777c478bd9Sstevel@tonic-gate if (!handle_is_bound(h)) { 32787c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 32797c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN)); 32807c478bd9Sstevel@tonic-gate } 32817c478bd9Sstevel@tonic-gate r = make_door_call_retfd(h->rh_doorfd, &request, sizeof (request), 32827c478bd9Sstevel@tonic-gate &response, sizeof (response), &pollfd.fd); 32837c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 32847c478bd9Sstevel@tonic-gate 32857c478bd9Sstevel@tonic-gate if (r < 0) 32867c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 32877c478bd9Sstevel@tonic-gate 32887c478bd9Sstevel@tonic-gate assert((response.rpr_response == REP_PROTOCOL_SUCCESS) == 32897c478bd9Sstevel@tonic-gate (pollfd.fd != -1)); 32907c478bd9Sstevel@tonic-gate 32917c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_LATEST) 32927c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 32937c478bd9Sstevel@tonic-gate 32947c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 32957c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 32967c478bd9Sstevel@tonic-gate 32977c478bd9Sstevel@tonic-gate pollfd.events = 0; 32987c478bd9Sstevel@tonic-gate pollfd.revents = 0; 32997c478bd9Sstevel@tonic-gate 33007c478bd9Sstevel@tonic-gate r = poll(&pollfd, 1, timeout * MILLISEC); 33017c478bd9Sstevel@tonic-gate 33027c478bd9Sstevel@tonic-gate (void) close(pollfd.fd); 33037c478bd9Sstevel@tonic-gate return (pollfd.revents ? SCF_SUCCESS : SCF_COMPLETE); 33047c478bd9Sstevel@tonic-gate } 33057c478bd9Sstevel@tonic-gate 33067c478bd9Sstevel@tonic-gate static int 33077c478bd9Sstevel@tonic-gate scf_notify_add_pattern(scf_handle_t *h, int type, const char *name) 33087c478bd9Sstevel@tonic-gate { 33097c478bd9Sstevel@tonic-gate struct rep_protocol_notify_request request; 33107c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 33117c478bd9Sstevel@tonic-gate int r; 33127c478bd9Sstevel@tonic-gate 33137c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 33147c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_CLIENT_ADD_NOTIFY; 33157c478bd9Sstevel@tonic-gate request.rpr_type = type; 33167c478bd9Sstevel@tonic-gate (void) strlcpy(request.rpr_pattern, name, sizeof (request.rpr_pattern)); 33177c478bd9Sstevel@tonic-gate 33187c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 33197c478bd9Sstevel@tonic-gate &response, sizeof (response)); 33207c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate if (r < 0) 33237c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 33247c478bd9Sstevel@tonic-gate 33257c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 33267c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 33277c478bd9Sstevel@tonic-gate 33287c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 33297c478bd9Sstevel@tonic-gate } 33307c478bd9Sstevel@tonic-gate 33317c478bd9Sstevel@tonic-gate int 33327c478bd9Sstevel@tonic-gate _scf_notify_add_pgname(scf_handle_t *h, const char *name) 33337c478bd9Sstevel@tonic-gate { 33347c478bd9Sstevel@tonic-gate return (scf_notify_add_pattern(h, REP_PROTOCOL_NOTIFY_PGNAME, name)); 33357c478bd9Sstevel@tonic-gate } 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate int 33387c478bd9Sstevel@tonic-gate _scf_notify_add_pgtype(scf_handle_t *h, const char *type) 33397c478bd9Sstevel@tonic-gate { 33407c478bd9Sstevel@tonic-gate return (scf_notify_add_pattern(h, REP_PROTOCOL_NOTIFY_PGTYPE, type)); 33417c478bd9Sstevel@tonic-gate } 33427c478bd9Sstevel@tonic-gate 33437c478bd9Sstevel@tonic-gate int 33447c478bd9Sstevel@tonic-gate _scf_notify_wait(scf_propertygroup_t *pg, char *out, size_t sz) 33457c478bd9Sstevel@tonic-gate { 33467c478bd9Sstevel@tonic-gate struct rep_protocol_wait_request request; 33477c478bd9Sstevel@tonic-gate struct rep_protocol_fmri_response response; 33487c478bd9Sstevel@tonic-gate 33497c478bd9Sstevel@tonic-gate scf_handle_t *h = pg->rd_d.rd_handle; 33507c478bd9Sstevel@tonic-gate int dummy; 33517c478bd9Sstevel@tonic-gate int fd; 33527c478bd9Sstevel@tonic-gate int r; 33537c478bd9Sstevel@tonic-gate 33547c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 33557c478bd9Sstevel@tonic-gate datael_finish_reset(&pg->rd_d); 33567c478bd9Sstevel@tonic-gate if (!handle_is_bound(h)) { 33577c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 33587c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN)); 33597c478bd9Sstevel@tonic-gate } 33607c478bd9Sstevel@tonic-gate fd = h->rh_doorfd; 33617c478bd9Sstevel@tonic-gate ++h->rh_fd_users; 33627c478bd9Sstevel@tonic-gate assert(h->rh_fd_users > 0); 33637c478bd9Sstevel@tonic-gate 33647c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_CLIENT_WAIT; 33657c478bd9Sstevel@tonic-gate request.rpr_entityid = pg->rd_d.rd_entity; 33667c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 33677c478bd9Sstevel@tonic-gate 33687c478bd9Sstevel@tonic-gate r = make_door_call_retfd(fd, &request, sizeof (request), 33697c478bd9Sstevel@tonic-gate &response, sizeof (response), &dummy); 33707c478bd9Sstevel@tonic-gate 33717c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 33727c478bd9Sstevel@tonic-gate assert(h->rh_fd_users > 0); 33737c478bd9Sstevel@tonic-gate if (--h->rh_fd_users == 0) { 33747c478bd9Sstevel@tonic-gate (void) pthread_cond_broadcast(&h->rh_cv); 33757c478bd9Sstevel@tonic-gate /* 33767c478bd9Sstevel@tonic-gate * check for a delayed close, now that there are no other 33777c478bd9Sstevel@tonic-gate * users. 33787c478bd9Sstevel@tonic-gate */ 33797c478bd9Sstevel@tonic-gate if (h->rh_doorfd_old != -1) { 33807c478bd9Sstevel@tonic-gate assert(h->rh_doorfd == -1); 33817c478bd9Sstevel@tonic-gate assert(fd == h->rh_doorfd_old); 33827c478bd9Sstevel@tonic-gate (void) close(h->rh_doorfd_old); 33837c478bd9Sstevel@tonic-gate h->rh_doorfd_old = -1; 33847c478bd9Sstevel@tonic-gate } 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate handle_unrefed(h); /* drops h->rh_lock */ 33877c478bd9Sstevel@tonic-gate 33887c478bd9Sstevel@tonic-gate if (r < 0) 33897c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_DONE) 33927c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 33937c478bd9Sstevel@tonic-gate 33947c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 33957c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 33967c478bd9Sstevel@tonic-gate 33977c478bd9Sstevel@tonic-gate /* the following will be non-zero for delete notifications */ 33987c478bd9Sstevel@tonic-gate return (strlcpy(out, response.rpr_fmri, sz)); 33997c478bd9Sstevel@tonic-gate } 34007c478bd9Sstevel@tonic-gate 34017c478bd9Sstevel@tonic-gate static int 34027c478bd9Sstevel@tonic-gate _scf_snapshot_take(scf_instance_t *inst, const char *name, 34037c478bd9Sstevel@tonic-gate scf_snapshot_t *snap, int flags) 34047c478bd9Sstevel@tonic-gate { 34057c478bd9Sstevel@tonic-gate scf_handle_t *h = inst->rd_d.rd_handle; 34067c478bd9Sstevel@tonic-gate 34077c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_take request; 34087c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 34097c478bd9Sstevel@tonic-gate 34107c478bd9Sstevel@tonic-gate int r; 34117c478bd9Sstevel@tonic-gate 34127c478bd9Sstevel@tonic-gate if (h != snap->rd_d.rd_handle) 34137c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 34147c478bd9Sstevel@tonic-gate 34157c478bd9Sstevel@tonic-gate if (strlcpy(request.rpr_name, (name != NULL)? name : "", 34167c478bd9Sstevel@tonic-gate sizeof (request.rpr_name)) >= sizeof (request.rpr_name)) 34177c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 34187c478bd9Sstevel@tonic-gate 34197c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 34207c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_SNAPSHOT_TAKE; 34217c478bd9Sstevel@tonic-gate request.rpr_entityid_src = inst->rd_d.rd_entity; 34227c478bd9Sstevel@tonic-gate request.rpr_entityid_dest = snap->rd_d.rd_entity; 34237c478bd9Sstevel@tonic-gate request.rpr_flags = flags; 34247c478bd9Sstevel@tonic-gate 34257c478bd9Sstevel@tonic-gate datael_finish_reset(&inst->rd_d); 34267c478bd9Sstevel@tonic-gate datael_finish_reset(&snap->rd_d); 34277c478bd9Sstevel@tonic-gate 34287c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 34297c478bd9Sstevel@tonic-gate &response, sizeof (response)); 34307c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 34317c478bd9Sstevel@tonic-gate 34327c478bd9Sstevel@tonic-gate if (r < 0) 34337c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 34367c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 34377c478bd9Sstevel@tonic-gate 34387c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 34397c478bd9Sstevel@tonic-gate } 34407c478bd9Sstevel@tonic-gate 34417c478bd9Sstevel@tonic-gate int 34427c478bd9Sstevel@tonic-gate _scf_snapshot_take_new_named(scf_instance_t *inst, 34437c478bd9Sstevel@tonic-gate const char *svcname, const char *instname, const char *snapname, 34447c478bd9Sstevel@tonic-gate scf_snapshot_t *snap) 34457c478bd9Sstevel@tonic-gate { 34467c478bd9Sstevel@tonic-gate scf_handle_t *h = inst->rd_d.rd_handle; 34477c478bd9Sstevel@tonic-gate 34487c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_take_named request; 34497c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 34507c478bd9Sstevel@tonic-gate 34517c478bd9Sstevel@tonic-gate int r; 34527c478bd9Sstevel@tonic-gate 34537c478bd9Sstevel@tonic-gate if (h != snap->rd_d.rd_handle) 34547c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 34557c478bd9Sstevel@tonic-gate 34567c478bd9Sstevel@tonic-gate if (strlcpy(request.rpr_svcname, svcname, 34577c478bd9Sstevel@tonic-gate sizeof (request.rpr_svcname)) >= sizeof (request.rpr_svcname)) 34587c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 34597c478bd9Sstevel@tonic-gate 34607c478bd9Sstevel@tonic-gate if (strlcpy(request.rpr_instname, instname, 34617c478bd9Sstevel@tonic-gate sizeof (request.rpr_instname)) >= sizeof (request.rpr_instname)) 34627c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 34637c478bd9Sstevel@tonic-gate 34647c478bd9Sstevel@tonic-gate if (strlcpy(request.rpr_name, snapname, 34657c478bd9Sstevel@tonic-gate sizeof (request.rpr_name)) >= sizeof (request.rpr_name)) 34667c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 34677c478bd9Sstevel@tonic-gate 34687c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 34697c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_SNAPSHOT_TAKE_NAMED; 34707c478bd9Sstevel@tonic-gate request.rpr_entityid_src = inst->rd_d.rd_entity; 34717c478bd9Sstevel@tonic-gate request.rpr_entityid_dest = snap->rd_d.rd_entity; 34727c478bd9Sstevel@tonic-gate 34737c478bd9Sstevel@tonic-gate datael_finish_reset(&inst->rd_d); 34747c478bd9Sstevel@tonic-gate datael_finish_reset(&snap->rd_d); 34757c478bd9Sstevel@tonic-gate 34767c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 34777c478bd9Sstevel@tonic-gate &response, sizeof (response)); 34787c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate if (r < 0) 34817c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 34827c478bd9Sstevel@tonic-gate 34837c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 34847c478bd9Sstevel@tonic-gate assert(response.rpr_response != 34857c478bd9Sstevel@tonic-gate REP_PROTOCOL_FAIL_TYPE_MISMATCH); 34867c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 34877c478bd9Sstevel@tonic-gate } 34887c478bd9Sstevel@tonic-gate 34897c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 34907c478bd9Sstevel@tonic-gate } 34917c478bd9Sstevel@tonic-gate 34927c478bd9Sstevel@tonic-gate int 34937c478bd9Sstevel@tonic-gate _scf_snapshot_take_new(scf_instance_t *inst, const char *name, 34947c478bd9Sstevel@tonic-gate scf_snapshot_t *snap) 34957c478bd9Sstevel@tonic-gate { 34967c478bd9Sstevel@tonic-gate return (_scf_snapshot_take(inst, name, snap, REP_SNAPSHOT_NEW)); 34977c478bd9Sstevel@tonic-gate } 34987c478bd9Sstevel@tonic-gate 34997c478bd9Sstevel@tonic-gate int 35007c478bd9Sstevel@tonic-gate _scf_snapshot_take_attach(scf_instance_t *inst, scf_snapshot_t *snap) 35017c478bd9Sstevel@tonic-gate { 35027c478bd9Sstevel@tonic-gate return (_scf_snapshot_take(inst, NULL, snap, REP_SNAPSHOT_ATTACH)); 35037c478bd9Sstevel@tonic-gate } 35047c478bd9Sstevel@tonic-gate 35057c478bd9Sstevel@tonic-gate int 35067c478bd9Sstevel@tonic-gate _scf_snapshot_attach(scf_snapshot_t *src, scf_snapshot_t *dest) 35077c478bd9Sstevel@tonic-gate { 35087c478bd9Sstevel@tonic-gate scf_handle_t *h = dest->rd_d.rd_handle; 35097c478bd9Sstevel@tonic-gate 35107c478bd9Sstevel@tonic-gate struct rep_protocol_snapshot_attach request; 35117c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 35127c478bd9Sstevel@tonic-gate 35137c478bd9Sstevel@tonic-gate int r; 35147c478bd9Sstevel@tonic-gate 35157c478bd9Sstevel@tonic-gate if (h != src->rd_d.rd_handle) 35167c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 35177c478bd9Sstevel@tonic-gate 35187c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 35197c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_SNAPSHOT_ATTACH; 35207c478bd9Sstevel@tonic-gate request.rpr_entityid_src = src->rd_d.rd_entity; 35217c478bd9Sstevel@tonic-gate request.rpr_entityid_dest = dest->rd_d.rd_entity; 35227c478bd9Sstevel@tonic-gate 35237c478bd9Sstevel@tonic-gate datael_finish_reset(&src->rd_d); 35247c478bd9Sstevel@tonic-gate datael_finish_reset(&dest->rd_d); 35257c478bd9Sstevel@tonic-gate 35267c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 35277c478bd9Sstevel@tonic-gate &response, sizeof (response)); 35287c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 35297c478bd9Sstevel@tonic-gate 35307c478bd9Sstevel@tonic-gate if (r < 0) 35317c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 35327c478bd9Sstevel@tonic-gate 35337c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 35347c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 35377c478bd9Sstevel@tonic-gate } 35387c478bd9Sstevel@tonic-gate 35397c478bd9Sstevel@tonic-gate /* 35407c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL 35417c478bd9Sstevel@tonic-gate * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY. 35427c478bd9Sstevel@tonic-gate */ 35437c478bd9Sstevel@tonic-gate scf_property_t * 35447c478bd9Sstevel@tonic-gate scf_property_create(scf_handle_t *handle) 35457c478bd9Sstevel@tonic-gate { 35467c478bd9Sstevel@tonic-gate scf_property_t *ret; 35477c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 35487c478bd9Sstevel@tonic-gate if (ret != NULL) { 35497c478bd9Sstevel@tonic-gate if (datael_init(&ret->rd_d, handle, 35507c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTY) == -1) { 35517c478bd9Sstevel@tonic-gate uu_free(ret); 35527c478bd9Sstevel@tonic-gate return (NULL); 35537c478bd9Sstevel@tonic-gate } 35547c478bd9Sstevel@tonic-gate } else { 35557c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 35567c478bd9Sstevel@tonic-gate } 35577c478bd9Sstevel@tonic-gate 35587c478bd9Sstevel@tonic-gate return (ret); 35597c478bd9Sstevel@tonic-gate } 35607c478bd9Sstevel@tonic-gate 35617c478bd9Sstevel@tonic-gate scf_handle_t * 35627c478bd9Sstevel@tonic-gate scf_property_handle(const scf_property_t *val) 35637c478bd9Sstevel@tonic-gate { 35647c478bd9Sstevel@tonic-gate return (datael_handle(&val->rd_d)); 35657c478bd9Sstevel@tonic-gate } 35667c478bd9Sstevel@tonic-gate 35677c478bd9Sstevel@tonic-gate void 35687c478bd9Sstevel@tonic-gate scf_property_destroy(scf_property_t *val) 35697c478bd9Sstevel@tonic-gate { 35707c478bd9Sstevel@tonic-gate if (val == NULL) 35717c478bd9Sstevel@tonic-gate return; 35727c478bd9Sstevel@tonic-gate 35737c478bd9Sstevel@tonic-gate datael_destroy(&val->rd_d); 35747c478bd9Sstevel@tonic-gate uu_free(val); 35757c478bd9Sstevel@tonic-gate } 35767c478bd9Sstevel@tonic-gate 35777c478bd9Sstevel@tonic-gate static int 35787c478bd9Sstevel@tonic-gate property_type_locked(const scf_property_t *prop, 35797c478bd9Sstevel@tonic-gate rep_protocol_value_type_t *out) 35807c478bd9Sstevel@tonic-gate { 35817c478bd9Sstevel@tonic-gate scf_handle_t *h = prop->rd_d.rd_handle; 35827c478bd9Sstevel@tonic-gate 35837c478bd9Sstevel@tonic-gate struct rep_protocol_property_request request; 35847c478bd9Sstevel@tonic-gate struct rep_protocol_integer_response response; 35857c478bd9Sstevel@tonic-gate 35867c478bd9Sstevel@tonic-gate int r; 35877c478bd9Sstevel@tonic-gate 35887c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 35897c478bd9Sstevel@tonic-gate 35907c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_PROPERTY_GET_TYPE; 35917c478bd9Sstevel@tonic-gate request.rpr_entityid = prop->rd_d.rd_entity; 35927c478bd9Sstevel@tonic-gate 35937c478bd9Sstevel@tonic-gate datael_finish_reset(&prop->rd_d); 35947c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 35957c478bd9Sstevel@tonic-gate &response, sizeof (response)); 35967c478bd9Sstevel@tonic-gate 35977c478bd9Sstevel@tonic-gate if (r < 0) 35987c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 35997c478bd9Sstevel@tonic-gate 36007c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS || 36017c478bd9Sstevel@tonic-gate r < sizeof (response)) { 36027c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 36037c478bd9Sstevel@tonic-gate } 36047c478bd9Sstevel@tonic-gate *out = response.rpr_value; 36057c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 36067c478bd9Sstevel@tonic-gate } 36077c478bd9Sstevel@tonic-gate 36087c478bd9Sstevel@tonic-gate int 36097c478bd9Sstevel@tonic-gate scf_property_type(const scf_property_t *prop, scf_type_t *out) 36107c478bd9Sstevel@tonic-gate { 36117c478bd9Sstevel@tonic-gate scf_handle_t *h = prop->rd_d.rd_handle; 36127c478bd9Sstevel@tonic-gate rep_protocol_value_type_t out_raw; 36137c478bd9Sstevel@tonic-gate int ret; 36147c478bd9Sstevel@tonic-gate 36157c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 36167c478bd9Sstevel@tonic-gate ret = property_type_locked(prop, &out_raw); 36177c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 36187c478bd9Sstevel@tonic-gate 36197c478bd9Sstevel@tonic-gate if (ret == SCF_SUCCESS) 36207c478bd9Sstevel@tonic-gate *out = scf_protocol_type_to_type(out_raw); 36217c478bd9Sstevel@tonic-gate 36227c478bd9Sstevel@tonic-gate return (ret); 36237c478bd9Sstevel@tonic-gate } 36247c478bd9Sstevel@tonic-gate 36257c478bd9Sstevel@tonic-gate int 36267c478bd9Sstevel@tonic-gate scf_property_is_type(const scf_property_t *prop, scf_type_t base_arg) 36277c478bd9Sstevel@tonic-gate { 36287c478bd9Sstevel@tonic-gate scf_handle_t *h = prop->rd_d.rd_handle; 36297c478bd9Sstevel@tonic-gate rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg); 36307c478bd9Sstevel@tonic-gate rep_protocol_value_type_t type; 36317c478bd9Sstevel@tonic-gate int ret; 36327c478bd9Sstevel@tonic-gate 36337c478bd9Sstevel@tonic-gate if (base == REP_PROTOCOL_TYPE_INVALID) 36347c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 36357c478bd9Sstevel@tonic-gate 36367c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 36377c478bd9Sstevel@tonic-gate ret = property_type_locked(prop, &type); 36387c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 36397c478bd9Sstevel@tonic-gate 36407c478bd9Sstevel@tonic-gate if (ret == SCF_SUCCESS) { 3641870ad75aSSean Wilcox if (!scf_is_compatible_protocol_type(base, type)) 36427c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_TYPE_MISMATCH)); 36437c478bd9Sstevel@tonic-gate } 36447c478bd9Sstevel@tonic-gate return (ret); 36457c478bd9Sstevel@tonic-gate } 36467c478bd9Sstevel@tonic-gate 3647870ad75aSSean Wilcox int 3648870ad75aSSean Wilcox scf_is_compatible_type(scf_type_t base_arg, scf_type_t type_arg) 3649870ad75aSSean Wilcox { 3650870ad75aSSean Wilcox rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg); 3651870ad75aSSean Wilcox rep_protocol_value_type_t type = scf_type_to_protocol_type(type_arg); 3652870ad75aSSean Wilcox 3653870ad75aSSean Wilcox if (base == REP_PROTOCOL_TYPE_INVALID || 3654870ad75aSSean Wilcox type == REP_PROTOCOL_TYPE_INVALID) 3655870ad75aSSean Wilcox return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 3656870ad75aSSean Wilcox 3657870ad75aSSean Wilcox if (!scf_is_compatible_protocol_type(base, type)) 3658870ad75aSSean Wilcox return (scf_set_error(SCF_ERROR_TYPE_MISMATCH)); 3659870ad75aSSean Wilcox 3660870ad75aSSean Wilcox return (SCF_SUCCESS); 3661870ad75aSSean Wilcox } 3662870ad75aSSean Wilcox 36637c478bd9Sstevel@tonic-gate ssize_t 36647c478bd9Sstevel@tonic-gate scf_property_get_name(const scf_property_t *prop, char *out, size_t len) 36657c478bd9Sstevel@tonic-gate { 36667c478bd9Sstevel@tonic-gate return (datael_get_name(&prop->rd_d, out, len, RP_ENTITY_NAME_NAME)); 36677c478bd9Sstevel@tonic-gate } 36687c478bd9Sstevel@tonic-gate 36697c478bd9Sstevel@tonic-gate /* 36707c478bd9Sstevel@tonic-gate * transaction functions 36717c478bd9Sstevel@tonic-gate */ 36727c478bd9Sstevel@tonic-gate 36737c478bd9Sstevel@tonic-gate /* 36747c478bd9Sstevel@tonic-gate * Fails with _NO_MEMORY, _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, 36757c478bd9Sstevel@tonic-gate * _INTERNAL (bad server response or id in use), or _NO_RESOURCES. 36767c478bd9Sstevel@tonic-gate */ 36777c478bd9Sstevel@tonic-gate scf_transaction_t * 36787c478bd9Sstevel@tonic-gate scf_transaction_create(scf_handle_t *handle) 36797c478bd9Sstevel@tonic-gate { 36807c478bd9Sstevel@tonic-gate scf_transaction_t *ret; 36817c478bd9Sstevel@tonic-gate 36827c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (scf_transaction_t)); 36837c478bd9Sstevel@tonic-gate if (ret == NULL) { 36847c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 36857c478bd9Sstevel@tonic-gate return (NULL); 36867c478bd9Sstevel@tonic-gate } 36877c478bd9Sstevel@tonic-gate if (datael_init(&ret->tran_pg.rd_d, handle, 36887c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTYGRP) == -1) { 36897c478bd9Sstevel@tonic-gate uu_free(ret); 36907c478bd9Sstevel@tonic-gate return (NULL); /* error already set */ 36917c478bd9Sstevel@tonic-gate } 36927c478bd9Sstevel@tonic-gate ret->tran_state = TRAN_STATE_NEW; 36937c478bd9Sstevel@tonic-gate ret->tran_props = uu_list_create(tran_entry_pool, ret, UU_LIST_SORTED); 36947c478bd9Sstevel@tonic-gate if (ret->tran_props == NULL) { 36957c478bd9Sstevel@tonic-gate datael_destroy(&ret->tran_pg.rd_d); 36967c478bd9Sstevel@tonic-gate uu_free(ret); 36977c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 36987c478bd9Sstevel@tonic-gate return (NULL); 36997c478bd9Sstevel@tonic-gate } 37007c478bd9Sstevel@tonic-gate 37017c478bd9Sstevel@tonic-gate return (ret); 37027c478bd9Sstevel@tonic-gate } 37037c478bd9Sstevel@tonic-gate 37047c478bd9Sstevel@tonic-gate scf_handle_t * 37057c478bd9Sstevel@tonic-gate scf_transaction_handle(const scf_transaction_t *val) 37067c478bd9Sstevel@tonic-gate { 37077c478bd9Sstevel@tonic-gate return (handle_get(val->tran_pg.rd_d.rd_handle)); 37087c478bd9Sstevel@tonic-gate } 37097c478bd9Sstevel@tonic-gate 37107c478bd9Sstevel@tonic-gate int 37117c478bd9Sstevel@tonic-gate scf_transaction_start(scf_transaction_t *tran, scf_propertygroup_t *pg) 37127c478bd9Sstevel@tonic-gate { 37137c478bd9Sstevel@tonic-gate scf_handle_t *h = tran->tran_pg.rd_d.rd_handle; 37147c478bd9Sstevel@tonic-gate 37157c478bd9Sstevel@tonic-gate struct rep_protocol_transaction_start request; 37167c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 37177c478bd9Sstevel@tonic-gate int r; 37187c478bd9Sstevel@tonic-gate 37197c478bd9Sstevel@tonic-gate if (h != pg->rd_d.rd_handle) 37207c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 37217c478bd9Sstevel@tonic-gate 37227c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 37237c478bd9Sstevel@tonic-gate if (tran->tran_state != TRAN_STATE_NEW) { 37247c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 37257c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_IN_USE)); 37267c478bd9Sstevel@tonic-gate } 37277c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_PROPERTYGRP_TX_START; 37287c478bd9Sstevel@tonic-gate request.rpr_entityid_tx = tran->tran_pg.rd_d.rd_entity; 37297c478bd9Sstevel@tonic-gate request.rpr_entityid = pg->rd_d.rd_entity; 37307c478bd9Sstevel@tonic-gate 37317c478bd9Sstevel@tonic-gate datael_finish_reset(&tran->tran_pg.rd_d); 37327c478bd9Sstevel@tonic-gate datael_finish_reset(&pg->rd_d); 37337c478bd9Sstevel@tonic-gate 37347c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 37357c478bd9Sstevel@tonic-gate &response, sizeof (response)); 37367c478bd9Sstevel@tonic-gate 37377c478bd9Sstevel@tonic-gate if (r < 0) { 37387c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 37397c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 37407c478bd9Sstevel@tonic-gate } 37417c478bd9Sstevel@tonic-gate 37427c478bd9Sstevel@tonic-gate /* r < sizeof (response) cannot happen because sizeof (response) == 4 */ 37437c478bd9Sstevel@tonic-gate 37447c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS || 37457c478bd9Sstevel@tonic-gate r < sizeof (response)) { 37467c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 37477c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 37487c478bd9Sstevel@tonic-gate } 37497c478bd9Sstevel@tonic-gate 37507c478bd9Sstevel@tonic-gate tran->tran_state = TRAN_STATE_SETUP; 37517c478bd9Sstevel@tonic-gate tran->tran_invalid = 0; 37527c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 37537c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 37547c478bd9Sstevel@tonic-gate } 37557c478bd9Sstevel@tonic-gate 37567c478bd9Sstevel@tonic-gate static void 37577c478bd9Sstevel@tonic-gate entry_invalidate(scf_transaction_entry_t *cur, int and_destroy, 37587c478bd9Sstevel@tonic-gate int and_reset_value) 37597c478bd9Sstevel@tonic-gate { 37607c478bd9Sstevel@tonic-gate scf_value_t *v, *next; 37617c478bd9Sstevel@tonic-gate scf_transaction_t *tx; 37627c478bd9Sstevel@tonic-gate scf_handle_t *h = cur->entry_handle; 37637c478bd9Sstevel@tonic-gate 37647c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 37657c478bd9Sstevel@tonic-gate 37667c478bd9Sstevel@tonic-gate if ((tx = cur->entry_tx) != NULL) { 37677c478bd9Sstevel@tonic-gate tx->tran_invalid = 1; 37687c478bd9Sstevel@tonic-gate uu_list_remove(tx->tran_props, cur); 37697c478bd9Sstevel@tonic-gate cur->entry_tx = NULL; 37707c478bd9Sstevel@tonic-gate } 37717c478bd9Sstevel@tonic-gate 37727c478bd9Sstevel@tonic-gate cur->entry_property = NULL; 37737c478bd9Sstevel@tonic-gate cur->entry_state = ENTRY_STATE_INVALID; 37747c478bd9Sstevel@tonic-gate cur->entry_action = REP_PROTOCOL_TX_ENTRY_INVALID; 37757c478bd9Sstevel@tonic-gate cur->entry_type = REP_PROTOCOL_TYPE_INVALID; 37767c478bd9Sstevel@tonic-gate 37777c478bd9Sstevel@tonic-gate for (v = cur->entry_head; v != NULL; v = next) { 37787c478bd9Sstevel@tonic-gate next = v->value_next; 37797c478bd9Sstevel@tonic-gate v->value_tx = NULL; 37807c478bd9Sstevel@tonic-gate v->value_next = NULL; 37817c478bd9Sstevel@tonic-gate if (and_destroy || and_reset_value) 37827c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, and_destroy); 37837c478bd9Sstevel@tonic-gate } 37847c478bd9Sstevel@tonic-gate cur->entry_head = NULL; 37856e1d2b42Samaguire cur->entry_tail = NULL; 37867c478bd9Sstevel@tonic-gate } 37877c478bd9Sstevel@tonic-gate 37887c478bd9Sstevel@tonic-gate static void 37897c478bd9Sstevel@tonic-gate entry_destroy_locked(scf_transaction_entry_t *entry) 37907c478bd9Sstevel@tonic-gate { 37917c478bd9Sstevel@tonic-gate scf_handle_t *h = entry->entry_handle; 37927c478bd9Sstevel@tonic-gate 37937c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 37947c478bd9Sstevel@tonic-gate 37957c478bd9Sstevel@tonic-gate entry_invalidate(entry, 0, 0); 37967c478bd9Sstevel@tonic-gate 37977c478bd9Sstevel@tonic-gate entry->entry_handle = NULL; 37987c478bd9Sstevel@tonic-gate assert(h->rh_entries > 0); 37997c478bd9Sstevel@tonic-gate --h->rh_entries; 38007c478bd9Sstevel@tonic-gate --h->rh_extrefs; 38017c478bd9Sstevel@tonic-gate uu_list_node_fini(entry, &entry->entry_link, tran_entry_pool); 38027c478bd9Sstevel@tonic-gate uu_free(entry); 38037c478bd9Sstevel@tonic-gate } 38047c478bd9Sstevel@tonic-gate 380576cf44abSjeanm /* 380676cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 380776cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 380876cf44abSjeanm * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH. 380976cf44abSjeanm */ 38107c478bd9Sstevel@tonic-gate static int 38117c478bd9Sstevel@tonic-gate transaction_add(scf_transaction_t *tran, scf_transaction_entry_t *entry, 38127c478bd9Sstevel@tonic-gate enum rep_protocol_transaction_action action, 38137c478bd9Sstevel@tonic-gate const char *prop, rep_protocol_value_type_t type) 38147c478bd9Sstevel@tonic-gate { 38157c478bd9Sstevel@tonic-gate scf_handle_t *h = tran->tran_pg.rd_d.rd_handle; 38167c478bd9Sstevel@tonic-gate scf_transaction_entry_t *old; 38177c478bd9Sstevel@tonic-gate scf_property_t *prop_p; 38187c478bd9Sstevel@tonic-gate rep_protocol_value_type_t oldtype; 38197c478bd9Sstevel@tonic-gate scf_error_t error = SCF_ERROR_NONE; 38207c478bd9Sstevel@tonic-gate int ret; 38217c478bd9Sstevel@tonic-gate uu_list_index_t idx; 38227c478bd9Sstevel@tonic-gate 38237c478bd9Sstevel@tonic-gate if (h != entry->entry_handle) 38247c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 38257c478bd9Sstevel@tonic-gate 38267c478bd9Sstevel@tonic-gate if (action == REP_PROTOCOL_TX_ENTRY_DELETE) 38277c478bd9Sstevel@tonic-gate assert(type == REP_PROTOCOL_TYPE_INVALID); 38287c478bd9Sstevel@tonic-gate else if (type == REP_PROTOCOL_TYPE_INVALID) 38297c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 38307c478bd9Sstevel@tonic-gate 38317c478bd9Sstevel@tonic-gate prop_p = HANDLE_HOLD_PROPERTY(h); 38327c478bd9Sstevel@tonic-gate 38337c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 38347c478bd9Sstevel@tonic-gate if (tran->tran_state != TRAN_STATE_SETUP) { 38357c478bd9Sstevel@tonic-gate error = SCF_ERROR_NOT_SET; 38367c478bd9Sstevel@tonic-gate goto error; 38377c478bd9Sstevel@tonic-gate } 38387c478bd9Sstevel@tonic-gate if (tran->tran_invalid) { 38397c478bd9Sstevel@tonic-gate error = SCF_ERROR_NOT_SET; 38407c478bd9Sstevel@tonic-gate goto error; 38417c478bd9Sstevel@tonic-gate } 38427c478bd9Sstevel@tonic-gate 38437c478bd9Sstevel@tonic-gate if (entry->entry_state != ENTRY_STATE_INVALID) 38447c478bd9Sstevel@tonic-gate entry_invalidate(entry, 0, 0); 38457c478bd9Sstevel@tonic-gate 38467c478bd9Sstevel@tonic-gate old = uu_list_find(tran->tran_props, &prop, NULL, &idx); 38477c478bd9Sstevel@tonic-gate if (old != NULL) { 38487c478bd9Sstevel@tonic-gate error = SCF_ERROR_IN_USE; 38497c478bd9Sstevel@tonic-gate goto error; 38507c478bd9Sstevel@tonic-gate } 38517c478bd9Sstevel@tonic-gate 38527c478bd9Sstevel@tonic-gate ret = datael_get_child_locked(&tran->tran_pg.rd_d, prop, 38537c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_PROPERTY, &prop_p->rd_d); 38547c478bd9Sstevel@tonic-gate if (ret == -1 && (error = scf_error()) != SCF_ERROR_NOT_FOUND) { 38557c478bd9Sstevel@tonic-gate goto error; 38567c478bd9Sstevel@tonic-gate } 38577c478bd9Sstevel@tonic-gate 38587c478bd9Sstevel@tonic-gate switch (action) { 38597c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TX_ENTRY_DELETE: 38607c478bd9Sstevel@tonic-gate if (ret == -1) { 38617c478bd9Sstevel@tonic-gate error = SCF_ERROR_NOT_FOUND; 38627c478bd9Sstevel@tonic-gate goto error; 38637c478bd9Sstevel@tonic-gate } 38647c478bd9Sstevel@tonic-gate break; 38657c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TX_ENTRY_NEW: 38667c478bd9Sstevel@tonic-gate if (ret != -1) { 38677c478bd9Sstevel@tonic-gate error = SCF_ERROR_EXISTS; 38687c478bd9Sstevel@tonic-gate goto error; 38697c478bd9Sstevel@tonic-gate } 38707c478bd9Sstevel@tonic-gate break; 38717c478bd9Sstevel@tonic-gate 38727c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TX_ENTRY_CLEAR: 38737c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TX_ENTRY_REPLACE: 38747c478bd9Sstevel@tonic-gate if (ret == -1) { 38757c478bd9Sstevel@tonic-gate error = SCF_ERROR_NOT_FOUND; 38767c478bd9Sstevel@tonic-gate goto error; 38777c478bd9Sstevel@tonic-gate } 38787c478bd9Sstevel@tonic-gate if (action == REP_PROTOCOL_TX_ENTRY_CLEAR) { 38797c478bd9Sstevel@tonic-gate if (property_type_locked(prop_p, &oldtype) == -1) { 38807c478bd9Sstevel@tonic-gate error = scf_error(); 38817c478bd9Sstevel@tonic-gate goto error; 38827c478bd9Sstevel@tonic-gate } 38837c478bd9Sstevel@tonic-gate if (oldtype != type) { 38847c478bd9Sstevel@tonic-gate error = SCF_ERROR_TYPE_MISMATCH; 38857c478bd9Sstevel@tonic-gate goto error; 38867c478bd9Sstevel@tonic-gate } 38877c478bd9Sstevel@tonic-gate } 38887c478bd9Sstevel@tonic-gate break; 38897c478bd9Sstevel@tonic-gate default: 38907c478bd9Sstevel@tonic-gate assert(0); 38917c478bd9Sstevel@tonic-gate abort(); 38927c478bd9Sstevel@tonic-gate } 38937c478bd9Sstevel@tonic-gate 38947c478bd9Sstevel@tonic-gate (void) strlcpy(entry->entry_namebuf, prop, 38957c478bd9Sstevel@tonic-gate sizeof (entry->entry_namebuf)); 38967c478bd9Sstevel@tonic-gate entry->entry_property = entry->entry_namebuf; 38977c478bd9Sstevel@tonic-gate entry->entry_action = action; 38987c478bd9Sstevel@tonic-gate entry->entry_type = type; 38997c478bd9Sstevel@tonic-gate 39007c478bd9Sstevel@tonic-gate entry->entry_state = ENTRY_STATE_IN_TX_ACTION; 39017c478bd9Sstevel@tonic-gate entry->entry_tx = tran; 39027c478bd9Sstevel@tonic-gate uu_list_insert(tran->tran_props, entry, idx); 39037c478bd9Sstevel@tonic-gate 39047c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 39057c478bd9Sstevel@tonic-gate 39067c478bd9Sstevel@tonic-gate HANDLE_RELE_PROPERTY(h); 39077c478bd9Sstevel@tonic-gate 39087c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 39097c478bd9Sstevel@tonic-gate 39107c478bd9Sstevel@tonic-gate error: 39117c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 39127c478bd9Sstevel@tonic-gate 39137c478bd9Sstevel@tonic-gate HANDLE_RELE_PROPERTY(h); 39147c478bd9Sstevel@tonic-gate 39157c478bd9Sstevel@tonic-gate return (scf_set_error(error)); 39167c478bd9Sstevel@tonic-gate } 39177c478bd9Sstevel@tonic-gate 391876cf44abSjeanm /* 391976cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 392076cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 392176cf44abSjeanm * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH. 392276cf44abSjeanm */ 39237c478bd9Sstevel@tonic-gate int 39247c478bd9Sstevel@tonic-gate scf_transaction_property_new(scf_transaction_t *tx, 39257c478bd9Sstevel@tonic-gate scf_transaction_entry_t *entry, const char *prop, scf_type_t type) 39267c478bd9Sstevel@tonic-gate { 39277c478bd9Sstevel@tonic-gate return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_NEW, 39287c478bd9Sstevel@tonic-gate prop, scf_type_to_protocol_type(type))); 39297c478bd9Sstevel@tonic-gate } 39307c478bd9Sstevel@tonic-gate 393176cf44abSjeanm /* 393276cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 393376cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 393476cf44abSjeanm * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH. 393576cf44abSjeanm */ 39367c478bd9Sstevel@tonic-gate int 39377c478bd9Sstevel@tonic-gate scf_transaction_property_change(scf_transaction_t *tx, 39387c478bd9Sstevel@tonic-gate scf_transaction_entry_t *entry, const char *prop, scf_type_t type) 39397c478bd9Sstevel@tonic-gate { 39407c478bd9Sstevel@tonic-gate return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_CLEAR, 39417c478bd9Sstevel@tonic-gate prop, scf_type_to_protocol_type(type))); 39427c478bd9Sstevel@tonic-gate } 39437c478bd9Sstevel@tonic-gate 394476cf44abSjeanm /* 394576cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 394676cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 394776cf44abSjeanm * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH. 394876cf44abSjeanm */ 39497c478bd9Sstevel@tonic-gate int 39507c478bd9Sstevel@tonic-gate scf_transaction_property_change_type(scf_transaction_t *tx, 39517c478bd9Sstevel@tonic-gate scf_transaction_entry_t *entry, const char *prop, scf_type_t type) 39527c478bd9Sstevel@tonic-gate { 39537c478bd9Sstevel@tonic-gate return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_REPLACE, 39547c478bd9Sstevel@tonic-gate prop, scf_type_to_protocol_type(type))); 39557c478bd9Sstevel@tonic-gate } 39567c478bd9Sstevel@tonic-gate 395776cf44abSjeanm /* 395876cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND, 395976cf44abSjeanm * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES, 396076cf44abSjeanm * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH. 396176cf44abSjeanm */ 39627c478bd9Sstevel@tonic-gate int 39637c478bd9Sstevel@tonic-gate scf_transaction_property_delete(scf_transaction_t *tx, 39647c478bd9Sstevel@tonic-gate scf_transaction_entry_t *entry, const char *prop) 39657c478bd9Sstevel@tonic-gate { 39667c478bd9Sstevel@tonic-gate return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_DELETE, 39677c478bd9Sstevel@tonic-gate prop, REP_PROTOCOL_TYPE_INVALID)); 39687c478bd9Sstevel@tonic-gate } 39697c478bd9Sstevel@tonic-gate 39707c478bd9Sstevel@tonic-gate #define BAD_SIZE (-1UL) 39717c478bd9Sstevel@tonic-gate 39727c478bd9Sstevel@tonic-gate static size_t 39737c478bd9Sstevel@tonic-gate commit_value(caddr_t data, scf_value_t *val, rep_protocol_value_type_t t) 39747c478bd9Sstevel@tonic-gate { 39757c478bd9Sstevel@tonic-gate size_t len; 39767c478bd9Sstevel@tonic-gate 39777c478bd9Sstevel@tonic-gate assert(val->value_type == t); 39787c478bd9Sstevel@tonic-gate 39797c478bd9Sstevel@tonic-gate if (t == REP_PROTOCOL_TYPE_OPAQUE) { 39807c478bd9Sstevel@tonic-gate len = scf_opaque_encode(data, val->value_value, 39817c478bd9Sstevel@tonic-gate val->value_size); 39827c478bd9Sstevel@tonic-gate } else { 39837c478bd9Sstevel@tonic-gate if (data != NULL) 39847c478bd9Sstevel@tonic-gate len = strlcpy(data, val->value_value, 39857c478bd9Sstevel@tonic-gate REP_PROTOCOL_VALUE_LEN); 39867c478bd9Sstevel@tonic-gate else 39877c478bd9Sstevel@tonic-gate len = strlen(val->value_value); 39887c478bd9Sstevel@tonic-gate if (len >= REP_PROTOCOL_VALUE_LEN) 39897c478bd9Sstevel@tonic-gate return (BAD_SIZE); 39907c478bd9Sstevel@tonic-gate } 39917c478bd9Sstevel@tonic-gate return (len + 1); /* count the '\0' */ 39927c478bd9Sstevel@tonic-gate } 39937c478bd9Sstevel@tonic-gate 39947c478bd9Sstevel@tonic-gate static size_t 39957c478bd9Sstevel@tonic-gate commit_process(scf_transaction_entry_t *cur, 39967c478bd9Sstevel@tonic-gate struct rep_protocol_transaction_cmd *out) 39977c478bd9Sstevel@tonic-gate { 39987c478bd9Sstevel@tonic-gate scf_value_t *child; 39997c478bd9Sstevel@tonic-gate size_t sz = 0; 40007c478bd9Sstevel@tonic-gate size_t len; 40017c478bd9Sstevel@tonic-gate caddr_t data = (caddr_t)out->rptc_data; 40027c478bd9Sstevel@tonic-gate caddr_t val_data; 40037c478bd9Sstevel@tonic-gate 40047c478bd9Sstevel@tonic-gate if (out != NULL) { 40057c478bd9Sstevel@tonic-gate len = strlcpy(data, cur->entry_property, REP_PROTOCOL_NAME_LEN); 40067c478bd9Sstevel@tonic-gate 40077c478bd9Sstevel@tonic-gate out->rptc_action = cur->entry_action; 40087c478bd9Sstevel@tonic-gate out->rptc_type = cur->entry_type; 40097c478bd9Sstevel@tonic-gate out->rptc_name_len = len + 1; 40107c478bd9Sstevel@tonic-gate } else { 40117c478bd9Sstevel@tonic-gate len = strlen(cur->entry_property); 40127c478bd9Sstevel@tonic-gate } 40137c478bd9Sstevel@tonic-gate 40147c478bd9Sstevel@tonic-gate if (len >= REP_PROTOCOL_NAME_LEN) 40157c478bd9Sstevel@tonic-gate return (BAD_SIZE); 40167c478bd9Sstevel@tonic-gate 40177c478bd9Sstevel@tonic-gate len = TX_SIZE(len + 1); 40187c478bd9Sstevel@tonic-gate 40197c478bd9Sstevel@tonic-gate sz += len; 40207c478bd9Sstevel@tonic-gate val_data = data + len; 40217c478bd9Sstevel@tonic-gate 40227c478bd9Sstevel@tonic-gate for (child = cur->entry_head; child != NULL; 40237c478bd9Sstevel@tonic-gate child = child->value_next) { 40247c478bd9Sstevel@tonic-gate assert(cur->entry_action != REP_PROTOCOL_TX_ENTRY_DELETE); 40257c478bd9Sstevel@tonic-gate if (out != NULL) { 40267c478bd9Sstevel@tonic-gate len = commit_value(val_data + sizeof (uint32_t), child, 40277c478bd9Sstevel@tonic-gate cur->entry_type); 40287c478bd9Sstevel@tonic-gate /* LINTED alignment */ 40297c478bd9Sstevel@tonic-gate *(uint32_t *)val_data = len; 40307c478bd9Sstevel@tonic-gate } else 40317c478bd9Sstevel@tonic-gate len = commit_value(NULL, child, cur->entry_type); 40327c478bd9Sstevel@tonic-gate 40337c478bd9Sstevel@tonic-gate if (len == BAD_SIZE) 40347c478bd9Sstevel@tonic-gate return (BAD_SIZE); 40357c478bd9Sstevel@tonic-gate 40367c478bd9Sstevel@tonic-gate len += sizeof (uint32_t); 40377c478bd9Sstevel@tonic-gate len = TX_SIZE(len); 40387c478bd9Sstevel@tonic-gate 40397c478bd9Sstevel@tonic-gate sz += len; 40407c478bd9Sstevel@tonic-gate val_data += len; 40417c478bd9Sstevel@tonic-gate } 40427c478bd9Sstevel@tonic-gate 40437c478bd9Sstevel@tonic-gate assert(val_data - data == sz); 40447c478bd9Sstevel@tonic-gate 40457c478bd9Sstevel@tonic-gate if (out != NULL) 40467c478bd9Sstevel@tonic-gate out->rptc_size = REP_PROTOCOL_TRANSACTION_CMD_SIZE(sz); 40477c478bd9Sstevel@tonic-gate 40487c478bd9Sstevel@tonic-gate return (REP_PROTOCOL_TRANSACTION_CMD_SIZE(sz)); 40497c478bd9Sstevel@tonic-gate } 40507c478bd9Sstevel@tonic-gate 40517c478bd9Sstevel@tonic-gate int 40527c478bd9Sstevel@tonic-gate scf_transaction_commit(scf_transaction_t *tran) 40537c478bd9Sstevel@tonic-gate { 40547c478bd9Sstevel@tonic-gate scf_handle_t *h = tran->tran_pg.rd_d.rd_handle; 40557c478bd9Sstevel@tonic-gate 40567c478bd9Sstevel@tonic-gate struct rep_protocol_transaction_commit *request; 40577c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 40587c478bd9Sstevel@tonic-gate uintptr_t cmd; 40597c478bd9Sstevel@tonic-gate scf_transaction_entry_t *cur; 40607c478bd9Sstevel@tonic-gate size_t total, size; 40617c478bd9Sstevel@tonic-gate size_t request_size; 40627c478bd9Sstevel@tonic-gate size_t new_total; 40637c478bd9Sstevel@tonic-gate int r; 40647c478bd9Sstevel@tonic-gate 40657c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 40667c478bd9Sstevel@tonic-gate if (tran->tran_state != TRAN_STATE_SETUP || 40677c478bd9Sstevel@tonic-gate tran->tran_invalid) { 40687c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 40697c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 40707c478bd9Sstevel@tonic-gate } 40717c478bd9Sstevel@tonic-gate 40727c478bd9Sstevel@tonic-gate total = 0; 40737c478bd9Sstevel@tonic-gate for (cur = uu_list_first(tran->tran_props); cur != NULL; 40747c478bd9Sstevel@tonic-gate cur = uu_list_next(tran->tran_props, cur)) { 40757c478bd9Sstevel@tonic-gate size = commit_process(cur, NULL); 40767c478bd9Sstevel@tonic-gate if (size == BAD_SIZE) { 40777c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 40787c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 40797c478bd9Sstevel@tonic-gate } 40807c478bd9Sstevel@tonic-gate assert(TX_SIZE(size) == size); 40817c478bd9Sstevel@tonic-gate total += size; 40827c478bd9Sstevel@tonic-gate } 40837c478bd9Sstevel@tonic-gate 40847c478bd9Sstevel@tonic-gate request_size = REP_PROTOCOL_TRANSACTION_COMMIT_SIZE(total); 40857c478bd9Sstevel@tonic-gate request = alloca(request_size); 40867c478bd9Sstevel@tonic-gate (void) memset(request, '\0', request_size); 40877c478bd9Sstevel@tonic-gate request->rpr_request = REP_PROTOCOL_PROPERTYGRP_TX_COMMIT; 40887c478bd9Sstevel@tonic-gate request->rpr_entityid = tran->tran_pg.rd_d.rd_entity; 40897c478bd9Sstevel@tonic-gate request->rpr_size = request_size; 40907c478bd9Sstevel@tonic-gate cmd = (uintptr_t)request->rpr_cmd; 40917c478bd9Sstevel@tonic-gate 40927c478bd9Sstevel@tonic-gate datael_finish_reset(&tran->tran_pg.rd_d); 40937c478bd9Sstevel@tonic-gate 40947c478bd9Sstevel@tonic-gate new_total = 0; 40957c478bd9Sstevel@tonic-gate for (cur = uu_list_first(tran->tran_props); cur != NULL; 40967c478bd9Sstevel@tonic-gate cur = uu_list_next(tran->tran_props, cur)) { 40977c478bd9Sstevel@tonic-gate size = commit_process(cur, (void *)cmd); 40987c478bd9Sstevel@tonic-gate if (size == BAD_SIZE) { 40997c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 41007c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 41017c478bd9Sstevel@tonic-gate } 41027c478bd9Sstevel@tonic-gate cmd += size; 41037c478bd9Sstevel@tonic-gate new_total += size; 41047c478bd9Sstevel@tonic-gate } 41057c478bd9Sstevel@tonic-gate assert(new_total == total); 41067c478bd9Sstevel@tonic-gate 41077c478bd9Sstevel@tonic-gate r = make_door_call(h, request, request_size, 41087c478bd9Sstevel@tonic-gate &response, sizeof (response)); 41097c478bd9Sstevel@tonic-gate 41107c478bd9Sstevel@tonic-gate if (r < 0) { 41117c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 41127c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 41137c478bd9Sstevel@tonic-gate } 41147c478bd9Sstevel@tonic-gate 41157c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS && 41167c478bd9Sstevel@tonic-gate response.rpr_response != REP_PROTOCOL_FAIL_NOT_LATEST) { 41177c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 41187c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 41197c478bd9Sstevel@tonic-gate } 41207c478bd9Sstevel@tonic-gate 41217c478bd9Sstevel@tonic-gate tran->tran_state = TRAN_STATE_COMMITTED; 41227c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 41237c478bd9Sstevel@tonic-gate return (response.rpr_response == REP_PROTOCOL_SUCCESS); 41247c478bd9Sstevel@tonic-gate } 41257c478bd9Sstevel@tonic-gate 41267c478bd9Sstevel@tonic-gate static void 41277c478bd9Sstevel@tonic-gate transaction_reset(scf_transaction_t *tran) 41287c478bd9Sstevel@tonic-gate { 41297c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&tran->tran_pg.rd_d.rd_handle->rh_lock)); 41307c478bd9Sstevel@tonic-gate 41317c478bd9Sstevel@tonic-gate tran->tran_state = TRAN_STATE_NEW; 41327c478bd9Sstevel@tonic-gate datael_reset_locked(&tran->tran_pg.rd_d); 41337c478bd9Sstevel@tonic-gate } 41347c478bd9Sstevel@tonic-gate 41357c478bd9Sstevel@tonic-gate static void 41367c478bd9Sstevel@tonic-gate scf_transaction_reset_impl(scf_transaction_t *tran, int and_destroy, 41377c478bd9Sstevel@tonic-gate int and_reset_value) 41387c478bd9Sstevel@tonic-gate { 41397c478bd9Sstevel@tonic-gate scf_transaction_entry_t *cur; 41407c478bd9Sstevel@tonic-gate void *cookie; 41417c478bd9Sstevel@tonic-gate 41427c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&tran->tran_pg.rd_d.rd_handle->rh_lock); 41437c478bd9Sstevel@tonic-gate cookie = NULL; 41447c478bd9Sstevel@tonic-gate while ((cur = uu_list_teardown(tran->tran_props, &cookie)) != NULL) { 41457c478bd9Sstevel@tonic-gate cur->entry_tx = NULL; 41467c478bd9Sstevel@tonic-gate 41477c478bd9Sstevel@tonic-gate assert(cur->entry_state == ENTRY_STATE_IN_TX_ACTION); 41487c478bd9Sstevel@tonic-gate cur->entry_state = ENTRY_STATE_INVALID; 41497c478bd9Sstevel@tonic-gate 41507c478bd9Sstevel@tonic-gate entry_invalidate(cur, and_destroy, and_reset_value); 41517c478bd9Sstevel@tonic-gate if (and_destroy) 41527c478bd9Sstevel@tonic-gate entry_destroy_locked(cur); 41537c478bd9Sstevel@tonic-gate } 41547c478bd9Sstevel@tonic-gate transaction_reset(tran); 41557c478bd9Sstevel@tonic-gate handle_unrefed(tran->tran_pg.rd_d.rd_handle); 41567c478bd9Sstevel@tonic-gate } 41577c478bd9Sstevel@tonic-gate 41587c478bd9Sstevel@tonic-gate void 41597c478bd9Sstevel@tonic-gate scf_transaction_reset(scf_transaction_t *tran) 41607c478bd9Sstevel@tonic-gate { 41617c478bd9Sstevel@tonic-gate scf_transaction_reset_impl(tran, 0, 0); 41627c478bd9Sstevel@tonic-gate } 41637c478bd9Sstevel@tonic-gate 41647c478bd9Sstevel@tonic-gate void 41657c478bd9Sstevel@tonic-gate scf_transaction_reset_all(scf_transaction_t *tran) 41667c478bd9Sstevel@tonic-gate { 41677c478bd9Sstevel@tonic-gate scf_transaction_reset_impl(tran, 0, 1); 41687c478bd9Sstevel@tonic-gate } 41697c478bd9Sstevel@tonic-gate 41707c478bd9Sstevel@tonic-gate void 41717c478bd9Sstevel@tonic-gate scf_transaction_destroy(scf_transaction_t *val) 41727c478bd9Sstevel@tonic-gate { 41737c478bd9Sstevel@tonic-gate if (val == NULL) 41747c478bd9Sstevel@tonic-gate return; 41757c478bd9Sstevel@tonic-gate 41767c478bd9Sstevel@tonic-gate scf_transaction_reset(val); 41777c478bd9Sstevel@tonic-gate 41787c478bd9Sstevel@tonic-gate datael_destroy(&val->tran_pg.rd_d); 41797c478bd9Sstevel@tonic-gate 41807c478bd9Sstevel@tonic-gate uu_list_destroy(val->tran_props); 41817c478bd9Sstevel@tonic-gate uu_free(val); 41827c478bd9Sstevel@tonic-gate } 41837c478bd9Sstevel@tonic-gate 41847c478bd9Sstevel@tonic-gate void 41857c478bd9Sstevel@tonic-gate scf_transaction_destroy_children(scf_transaction_t *tran) 41867c478bd9Sstevel@tonic-gate { 4187f6e214c7SGavin Maltby if (tran == NULL) 4188f6e214c7SGavin Maltby return; 4189f6e214c7SGavin Maltby 41907c478bd9Sstevel@tonic-gate scf_transaction_reset_impl(tran, 1, 0); 41917c478bd9Sstevel@tonic-gate } 41927c478bd9Sstevel@tonic-gate 41937c478bd9Sstevel@tonic-gate scf_transaction_entry_t * 41947c478bd9Sstevel@tonic-gate scf_entry_create(scf_handle_t *h) 41957c478bd9Sstevel@tonic-gate { 41967c478bd9Sstevel@tonic-gate scf_transaction_entry_t *ret; 41977c478bd9Sstevel@tonic-gate 41987c478bd9Sstevel@tonic-gate if (h == NULL) { 41997c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 42007c478bd9Sstevel@tonic-gate return (NULL); 42017c478bd9Sstevel@tonic-gate } 42027c478bd9Sstevel@tonic-gate 42037c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (scf_transaction_entry_t)); 42047c478bd9Sstevel@tonic-gate if (ret == NULL) { 42057c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 42067c478bd9Sstevel@tonic-gate return (NULL); 42077c478bd9Sstevel@tonic-gate } 42087c478bd9Sstevel@tonic-gate ret->entry_action = REP_PROTOCOL_TX_ENTRY_INVALID; 42097c478bd9Sstevel@tonic-gate ret->entry_handle = h; 42107c478bd9Sstevel@tonic-gate 42117c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 42127c478bd9Sstevel@tonic-gate if (h->rh_flags & HANDLE_DEAD) { 42137c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 42147c478bd9Sstevel@tonic-gate uu_free(ret); 42157c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED); 42167c478bd9Sstevel@tonic-gate return (NULL); 42177c478bd9Sstevel@tonic-gate } 42187c478bd9Sstevel@tonic-gate h->rh_entries++; 42197c478bd9Sstevel@tonic-gate h->rh_extrefs++; 42207c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 42217c478bd9Sstevel@tonic-gate 42227c478bd9Sstevel@tonic-gate uu_list_node_init(ret, &ret->entry_link, tran_entry_pool); 42237c478bd9Sstevel@tonic-gate 42247c478bd9Sstevel@tonic-gate return (ret); 42257c478bd9Sstevel@tonic-gate } 42267c478bd9Sstevel@tonic-gate 42277c478bd9Sstevel@tonic-gate scf_handle_t * 42287c478bd9Sstevel@tonic-gate scf_entry_handle(const scf_transaction_entry_t *val) 42297c478bd9Sstevel@tonic-gate { 42307c478bd9Sstevel@tonic-gate return (handle_get(val->entry_handle)); 42317c478bd9Sstevel@tonic-gate } 42327c478bd9Sstevel@tonic-gate 42337c478bd9Sstevel@tonic-gate void 42347c478bd9Sstevel@tonic-gate scf_entry_reset(scf_transaction_entry_t *entry) 42357c478bd9Sstevel@tonic-gate { 42367c478bd9Sstevel@tonic-gate scf_handle_t *h = entry->entry_handle; 42377c478bd9Sstevel@tonic-gate 42387c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 42397c478bd9Sstevel@tonic-gate entry_invalidate(entry, 0, 0); 42407c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 42417c478bd9Sstevel@tonic-gate } 42427c478bd9Sstevel@tonic-gate 42437c478bd9Sstevel@tonic-gate void 42447c478bd9Sstevel@tonic-gate scf_entry_destroy_children(scf_transaction_entry_t *entry) 42457c478bd9Sstevel@tonic-gate { 42467c478bd9Sstevel@tonic-gate scf_handle_t *h = entry->entry_handle; 42477c478bd9Sstevel@tonic-gate 42487c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 42497c478bd9Sstevel@tonic-gate entry_invalidate(entry, 1, 0); 42507c478bd9Sstevel@tonic-gate handle_unrefed(h); /* drops h->rh_lock */ 42517c478bd9Sstevel@tonic-gate } 42527c478bd9Sstevel@tonic-gate 42537c478bd9Sstevel@tonic-gate void 42547c478bd9Sstevel@tonic-gate scf_entry_destroy(scf_transaction_entry_t *entry) 42557c478bd9Sstevel@tonic-gate { 42567c478bd9Sstevel@tonic-gate scf_handle_t *h; 42577c478bd9Sstevel@tonic-gate 42587c478bd9Sstevel@tonic-gate if (entry == NULL) 42597c478bd9Sstevel@tonic-gate return; 42607c478bd9Sstevel@tonic-gate 42617c478bd9Sstevel@tonic-gate h = entry->entry_handle; 42627c478bd9Sstevel@tonic-gate 42637c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 42647c478bd9Sstevel@tonic-gate entry_destroy_locked(entry); 42657c478bd9Sstevel@tonic-gate handle_unrefed(h); /* drops h->rh_lock */ 42667c478bd9Sstevel@tonic-gate } 42677c478bd9Sstevel@tonic-gate 42687c478bd9Sstevel@tonic-gate /* 42697c478bd9Sstevel@tonic-gate * Fails with 42707c478bd9Sstevel@tonic-gate * _HANDLE_MISMATCH 42717c478bd9Sstevel@tonic-gate * _NOT_SET - has not been added to a transaction 42727c478bd9Sstevel@tonic-gate * _INTERNAL - entry is corrupt 42737c478bd9Sstevel@tonic-gate * _INVALID_ARGUMENT - entry's transaction is not started or corrupt 42747c478bd9Sstevel@tonic-gate * entry is set to delete a property 42757c478bd9Sstevel@tonic-gate * v is reset or corrupt 42767c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - entry & v's types aren't compatible 42777c478bd9Sstevel@tonic-gate * _IN_USE - v has been added to another entry 42787c478bd9Sstevel@tonic-gate */ 42797c478bd9Sstevel@tonic-gate int 42807c478bd9Sstevel@tonic-gate scf_entry_add_value(scf_transaction_entry_t *entry, scf_value_t *v) 42817c478bd9Sstevel@tonic-gate { 42827c478bd9Sstevel@tonic-gate scf_handle_t *h = entry->entry_handle; 42837c478bd9Sstevel@tonic-gate 42847c478bd9Sstevel@tonic-gate if (h != v->value_handle) 42857c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 42867c478bd9Sstevel@tonic-gate 42877c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 42887c478bd9Sstevel@tonic-gate 42897c478bd9Sstevel@tonic-gate if (entry->entry_state == ENTRY_STATE_INVALID) { 42907c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 42917c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 42927c478bd9Sstevel@tonic-gate } 4293f2fa366aSjeanm 4294f2fa366aSjeanm if (entry->entry_state != ENTRY_STATE_IN_TX_ACTION) { 4295f2fa366aSjeanm (void) pthread_mutex_unlock(&h->rh_lock); 4296f2fa366aSjeanm return (scf_set_error(SCF_ERROR_INTERNAL)); 4297f2fa366aSjeanm } 42987c478bd9Sstevel@tonic-gate 42997c478bd9Sstevel@tonic-gate if (entry->entry_tx->tran_state != TRAN_STATE_SETUP) { 43007c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43017c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 43027c478bd9Sstevel@tonic-gate } 43037c478bd9Sstevel@tonic-gate 43047c478bd9Sstevel@tonic-gate if (entry->entry_action == REP_PROTOCOL_TX_ENTRY_DELETE) { 43057c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43067c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 43077c478bd9Sstevel@tonic-gate } 43087c478bd9Sstevel@tonic-gate 43097c478bd9Sstevel@tonic-gate if (v->value_type == REP_PROTOCOL_TYPE_INVALID) { 43107c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43117c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 43127c478bd9Sstevel@tonic-gate } 43137c478bd9Sstevel@tonic-gate 4314870ad75aSSean Wilcox if (!scf_is_compatible_protocol_type(entry->entry_type, 4315870ad75aSSean Wilcox v->value_type)) { 43167c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43177c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_TYPE_MISMATCH)); 43187c478bd9Sstevel@tonic-gate } 43197c478bd9Sstevel@tonic-gate 43207c478bd9Sstevel@tonic-gate if (v->value_tx != NULL) { 43217c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43227c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_IN_USE)); 43237c478bd9Sstevel@tonic-gate } 43247c478bd9Sstevel@tonic-gate 43257c478bd9Sstevel@tonic-gate v->value_tx = entry; 43266e1d2b42Samaguire v->value_next = NULL; 43276e1d2b42Samaguire if (entry->entry_head == NULL) { 43286e1d2b42Samaguire entry->entry_head = v; 43296e1d2b42Samaguire entry->entry_tail = v; 43306e1d2b42Samaguire } else { 43316e1d2b42Samaguire entry->entry_tail->value_next = v; 43326e1d2b42Samaguire entry->entry_tail = v; 43336e1d2b42Samaguire } 43346e1d2b42Samaguire 43357c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43367c478bd9Sstevel@tonic-gate 43377c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 43387c478bd9Sstevel@tonic-gate } 43397c478bd9Sstevel@tonic-gate 43407c478bd9Sstevel@tonic-gate /* 43417c478bd9Sstevel@tonic-gate * value functions 43427c478bd9Sstevel@tonic-gate */ 43437c478bd9Sstevel@tonic-gate scf_value_t * 43447c478bd9Sstevel@tonic-gate scf_value_create(scf_handle_t *h) 43457c478bd9Sstevel@tonic-gate { 43467c478bd9Sstevel@tonic-gate scf_value_t *ret; 43477c478bd9Sstevel@tonic-gate 43487c478bd9Sstevel@tonic-gate if (h == NULL) { 43497c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 43507c478bd9Sstevel@tonic-gate return (NULL); 43517c478bd9Sstevel@tonic-gate } 43527c478bd9Sstevel@tonic-gate 43537c478bd9Sstevel@tonic-gate ret = uu_zalloc(sizeof (*ret)); 43547c478bd9Sstevel@tonic-gate if (ret != NULL) { 43557c478bd9Sstevel@tonic-gate ret->value_type = REP_PROTOCOL_TYPE_INVALID; 43567c478bd9Sstevel@tonic-gate ret->value_handle = h; 43577c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 43587c478bd9Sstevel@tonic-gate if (h->rh_flags & HANDLE_DEAD) { 43597c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43607c478bd9Sstevel@tonic-gate uu_free(ret); 43611f6eb021SLiane Praza (void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED); 43627c478bd9Sstevel@tonic-gate return (NULL); 43637c478bd9Sstevel@tonic-gate } 43647c478bd9Sstevel@tonic-gate h->rh_values++; 43657c478bd9Sstevel@tonic-gate h->rh_extrefs++; 43667c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 43677c478bd9Sstevel@tonic-gate } else { 43687c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NO_MEMORY); 43697c478bd9Sstevel@tonic-gate } 43707c478bd9Sstevel@tonic-gate 43717c478bd9Sstevel@tonic-gate return (ret); 43727c478bd9Sstevel@tonic-gate } 43737c478bd9Sstevel@tonic-gate 43747c478bd9Sstevel@tonic-gate static void 43757c478bd9Sstevel@tonic-gate scf_value_reset_locked(scf_value_t *val, int and_destroy) 43767c478bd9Sstevel@tonic-gate { 43777c478bd9Sstevel@tonic-gate scf_value_t **curp; 43787c478bd9Sstevel@tonic-gate scf_transaction_entry_t *te; 43797c478bd9Sstevel@tonic-gate 43807c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 43817c478bd9Sstevel@tonic-gate assert(MUTEX_HELD(&h->rh_lock)); 43827c478bd9Sstevel@tonic-gate if (val->value_tx != NULL) { 43837c478bd9Sstevel@tonic-gate te = val->value_tx; 43847c478bd9Sstevel@tonic-gate te->entry_tx->tran_invalid = 1; 43857c478bd9Sstevel@tonic-gate 43867c478bd9Sstevel@tonic-gate val->value_tx = NULL; 43877c478bd9Sstevel@tonic-gate 43887c478bd9Sstevel@tonic-gate for (curp = &te->entry_head; *curp != NULL; 43897c478bd9Sstevel@tonic-gate curp = &(*curp)->value_next) { 43907c478bd9Sstevel@tonic-gate if (*curp == val) { 43917c478bd9Sstevel@tonic-gate *curp = val->value_next; 43927c478bd9Sstevel@tonic-gate curp = NULL; 43937c478bd9Sstevel@tonic-gate break; 43947c478bd9Sstevel@tonic-gate } 43957c478bd9Sstevel@tonic-gate } 43967c478bd9Sstevel@tonic-gate assert(curp == NULL); 43977c478bd9Sstevel@tonic-gate } 43987c478bd9Sstevel@tonic-gate val->value_type = REP_PROTOCOL_TYPE_INVALID; 43997c478bd9Sstevel@tonic-gate 44007c478bd9Sstevel@tonic-gate if (and_destroy) { 44017c478bd9Sstevel@tonic-gate val->value_handle = NULL; 44027c478bd9Sstevel@tonic-gate assert(h->rh_values > 0); 44037c478bd9Sstevel@tonic-gate --h->rh_values; 44047c478bd9Sstevel@tonic-gate --h->rh_extrefs; 44057c478bd9Sstevel@tonic-gate uu_free(val); 44067c478bd9Sstevel@tonic-gate } 44077c478bd9Sstevel@tonic-gate } 44087c478bd9Sstevel@tonic-gate 44097c478bd9Sstevel@tonic-gate void 44107c478bd9Sstevel@tonic-gate scf_value_reset(scf_value_t *val) 44117c478bd9Sstevel@tonic-gate { 44127c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 44137c478bd9Sstevel@tonic-gate 44147c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 44157c478bd9Sstevel@tonic-gate scf_value_reset_locked(val, 0); 44167c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 44177c478bd9Sstevel@tonic-gate } 44187c478bd9Sstevel@tonic-gate 44197c478bd9Sstevel@tonic-gate scf_handle_t * 44207c478bd9Sstevel@tonic-gate scf_value_handle(const scf_value_t *val) 44217c478bd9Sstevel@tonic-gate { 44227c478bd9Sstevel@tonic-gate return (handle_get(val->value_handle)); 44237c478bd9Sstevel@tonic-gate } 44247c478bd9Sstevel@tonic-gate 44257c478bd9Sstevel@tonic-gate void 44267c478bd9Sstevel@tonic-gate scf_value_destroy(scf_value_t *val) 44277c478bd9Sstevel@tonic-gate { 44287c478bd9Sstevel@tonic-gate scf_handle_t *h; 44297c478bd9Sstevel@tonic-gate 44307c478bd9Sstevel@tonic-gate if (val == NULL) 44317c478bd9Sstevel@tonic-gate return; 44327c478bd9Sstevel@tonic-gate 44337c478bd9Sstevel@tonic-gate h = val->value_handle; 44347c478bd9Sstevel@tonic-gate 44357c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 44367c478bd9Sstevel@tonic-gate scf_value_reset_locked(val, 1); 44377c478bd9Sstevel@tonic-gate handle_unrefed(h); /* drops h->rh_lock */ 44387c478bd9Sstevel@tonic-gate } 44397c478bd9Sstevel@tonic-gate 44407c478bd9Sstevel@tonic-gate scf_type_t 44417c478bd9Sstevel@tonic-gate scf_value_base_type(const scf_value_t *val) 44427c478bd9Sstevel@tonic-gate { 44437c478bd9Sstevel@tonic-gate rep_protocol_value_type_t t, cur; 44447c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 44457c478bd9Sstevel@tonic-gate 44467c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 44477c478bd9Sstevel@tonic-gate t = val->value_type; 44487c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 44497c478bd9Sstevel@tonic-gate 44507c478bd9Sstevel@tonic-gate for (;;) { 44517c478bd9Sstevel@tonic-gate cur = scf_proto_underlying_type(t); 44527c478bd9Sstevel@tonic-gate if (cur == t) 44537c478bd9Sstevel@tonic-gate break; 44547c478bd9Sstevel@tonic-gate t = cur; 44557c478bd9Sstevel@tonic-gate } 44567c478bd9Sstevel@tonic-gate 44577c478bd9Sstevel@tonic-gate return (scf_protocol_type_to_type(t)); 44587c478bd9Sstevel@tonic-gate } 44597c478bd9Sstevel@tonic-gate 44607c478bd9Sstevel@tonic-gate scf_type_t 44617c478bd9Sstevel@tonic-gate scf_value_type(const scf_value_t *val) 44627c478bd9Sstevel@tonic-gate { 44637c478bd9Sstevel@tonic-gate rep_protocol_value_type_t t; 44647c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 44657c478bd9Sstevel@tonic-gate 44667c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 44677c478bd9Sstevel@tonic-gate t = val->value_type; 44687c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 44697c478bd9Sstevel@tonic-gate 44707c478bd9Sstevel@tonic-gate return (scf_protocol_type_to_type(t)); 44717c478bd9Sstevel@tonic-gate } 44727c478bd9Sstevel@tonic-gate 44737c478bd9Sstevel@tonic-gate int 44747c478bd9Sstevel@tonic-gate scf_value_is_type(const scf_value_t *val, scf_type_t base_arg) 44757c478bd9Sstevel@tonic-gate { 44767c478bd9Sstevel@tonic-gate rep_protocol_value_type_t t; 44777c478bd9Sstevel@tonic-gate rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg); 44787c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 44797c478bd9Sstevel@tonic-gate 44807c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 44817c478bd9Sstevel@tonic-gate t = val->value_type; 44827c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 44837c478bd9Sstevel@tonic-gate 44847c478bd9Sstevel@tonic-gate if (t == REP_PROTOCOL_TYPE_INVALID) 44857c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 44867c478bd9Sstevel@tonic-gate if (base == REP_PROTOCOL_TYPE_INVALID) 44877c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 4488870ad75aSSean Wilcox if (!scf_is_compatible_protocol_type(base, t)) 44897c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_TYPE_MISMATCH)); 44907c478bd9Sstevel@tonic-gate 44917c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 44927c478bd9Sstevel@tonic-gate } 44937c478bd9Sstevel@tonic-gate 44947c478bd9Sstevel@tonic-gate /* 44957c478bd9Sstevel@tonic-gate * Fails with 44967c478bd9Sstevel@tonic-gate * _NOT_SET - val is reset 44977c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - val's type is not compatible with t 44987c478bd9Sstevel@tonic-gate */ 44997c478bd9Sstevel@tonic-gate static int 45007c478bd9Sstevel@tonic-gate scf_value_check_type(const scf_value_t *val, rep_protocol_value_type_t t) 45017c478bd9Sstevel@tonic-gate { 45027c478bd9Sstevel@tonic-gate if (val->value_type == REP_PROTOCOL_TYPE_INVALID) { 45037c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NOT_SET); 45047c478bd9Sstevel@tonic-gate return (0); 45057c478bd9Sstevel@tonic-gate } 4506870ad75aSSean Wilcox if (!scf_is_compatible_protocol_type(t, val->value_type)) { 45077c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_TYPE_MISMATCH); 45087c478bd9Sstevel@tonic-gate return (0); 45097c478bd9Sstevel@tonic-gate } 45107c478bd9Sstevel@tonic-gate return (1); 45117c478bd9Sstevel@tonic-gate } 45127c478bd9Sstevel@tonic-gate 45137c478bd9Sstevel@tonic-gate /* 45147c478bd9Sstevel@tonic-gate * Fails with 45157c478bd9Sstevel@tonic-gate * _NOT_SET - val is reset 45167c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - val is not _TYPE_BOOLEAN 45177c478bd9Sstevel@tonic-gate */ 45187c478bd9Sstevel@tonic-gate int 45197c478bd9Sstevel@tonic-gate scf_value_get_boolean(const scf_value_t *val, uint8_t *out) 45207c478bd9Sstevel@tonic-gate { 45217c478bd9Sstevel@tonic-gate char c; 45227c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 45237c478bd9Sstevel@tonic-gate uint8_t o; 45247c478bd9Sstevel@tonic-gate 45257c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 45267c478bd9Sstevel@tonic-gate if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_BOOLEAN)) { 45277c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45287c478bd9Sstevel@tonic-gate return (-1); 45297c478bd9Sstevel@tonic-gate } 45307c478bd9Sstevel@tonic-gate 45317c478bd9Sstevel@tonic-gate c = val->value_value[0]; 45327c478bd9Sstevel@tonic-gate assert((c == '0' || c == '1') && val->value_value[1] == 0); 45337c478bd9Sstevel@tonic-gate 45347c478bd9Sstevel@tonic-gate o = (c != '0'); 45357c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45367c478bd9Sstevel@tonic-gate if (out != NULL) 45377c478bd9Sstevel@tonic-gate *out = o; 45387c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 45397c478bd9Sstevel@tonic-gate } 45407c478bd9Sstevel@tonic-gate 45417c478bd9Sstevel@tonic-gate int 45427c478bd9Sstevel@tonic-gate scf_value_get_count(const scf_value_t *val, uint64_t *out) 45437c478bd9Sstevel@tonic-gate { 45447c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 45457c478bd9Sstevel@tonic-gate uint64_t o; 45467c478bd9Sstevel@tonic-gate 45477c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 45487c478bd9Sstevel@tonic-gate if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_COUNT)) { 45497c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45507c478bd9Sstevel@tonic-gate return (-1); 45517c478bd9Sstevel@tonic-gate } 45527c478bd9Sstevel@tonic-gate 45537c478bd9Sstevel@tonic-gate o = strtoull(val->value_value, NULL, 10); 45547c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45557c478bd9Sstevel@tonic-gate if (out != NULL) 45567c478bd9Sstevel@tonic-gate *out = o; 45577c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 45587c478bd9Sstevel@tonic-gate } 45597c478bd9Sstevel@tonic-gate 45607c478bd9Sstevel@tonic-gate int 45617c478bd9Sstevel@tonic-gate scf_value_get_integer(const scf_value_t *val, int64_t *out) 45627c478bd9Sstevel@tonic-gate { 45637c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 45647c478bd9Sstevel@tonic-gate int64_t o; 45657c478bd9Sstevel@tonic-gate 45667c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 45677c478bd9Sstevel@tonic-gate if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_INTEGER)) { 45687c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45697c478bd9Sstevel@tonic-gate return (-1); 45707c478bd9Sstevel@tonic-gate } 45717c478bd9Sstevel@tonic-gate 45727c478bd9Sstevel@tonic-gate o = strtoll(val->value_value, NULL, 10); 45737c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45747c478bd9Sstevel@tonic-gate if (out != NULL) 45757c478bd9Sstevel@tonic-gate *out = o; 45767c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 45777c478bd9Sstevel@tonic-gate } 45787c478bd9Sstevel@tonic-gate 45797c478bd9Sstevel@tonic-gate int 45807c478bd9Sstevel@tonic-gate scf_value_get_time(const scf_value_t *val, int64_t *sec_out, int32_t *nsec_out) 45817c478bd9Sstevel@tonic-gate { 45827c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 45837c478bd9Sstevel@tonic-gate char *p; 45847c478bd9Sstevel@tonic-gate int64_t os; 45857c478bd9Sstevel@tonic-gate int32_t ons; 45867c478bd9Sstevel@tonic-gate 45877c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 45887c478bd9Sstevel@tonic-gate if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_TIME)) { 45897c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45907c478bd9Sstevel@tonic-gate return (-1); 45917c478bd9Sstevel@tonic-gate } 45927c478bd9Sstevel@tonic-gate 45937c478bd9Sstevel@tonic-gate os = strtoll(val->value_value, &p, 10); 45947c478bd9Sstevel@tonic-gate if (*p == '.') 45957c478bd9Sstevel@tonic-gate ons = strtoul(p + 1, NULL, 10); 45967c478bd9Sstevel@tonic-gate else 45977c478bd9Sstevel@tonic-gate ons = 0; 45987c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 45997c478bd9Sstevel@tonic-gate if (sec_out != NULL) 46007c478bd9Sstevel@tonic-gate *sec_out = os; 46017c478bd9Sstevel@tonic-gate if (nsec_out != NULL) 46027c478bd9Sstevel@tonic-gate *nsec_out = ons; 46037c478bd9Sstevel@tonic-gate 46047c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 46057c478bd9Sstevel@tonic-gate } 46067c478bd9Sstevel@tonic-gate 46077c478bd9Sstevel@tonic-gate /* 46087c478bd9Sstevel@tonic-gate * Fails with 46097c478bd9Sstevel@tonic-gate * _NOT_SET - val is reset 46107c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - val's type is not compatible with _TYPE_STRING. 46117c478bd9Sstevel@tonic-gate */ 46127c478bd9Sstevel@tonic-gate ssize_t 46137c478bd9Sstevel@tonic-gate scf_value_get_astring(const scf_value_t *val, char *out, size_t len) 46147c478bd9Sstevel@tonic-gate { 46157c478bd9Sstevel@tonic-gate ssize_t ret; 46167c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 46177c478bd9Sstevel@tonic-gate 46187c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 46197c478bd9Sstevel@tonic-gate if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_STRING)) { 46207c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46217c478bd9Sstevel@tonic-gate return ((ssize_t)-1); 46227c478bd9Sstevel@tonic-gate } 46237c478bd9Sstevel@tonic-gate ret = (ssize_t)strlcpy(out, val->value_value, len); 46247c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46257c478bd9Sstevel@tonic-gate return (ret); 46267c478bd9Sstevel@tonic-gate } 46277c478bd9Sstevel@tonic-gate 46287c478bd9Sstevel@tonic-gate ssize_t 46297c478bd9Sstevel@tonic-gate scf_value_get_ustring(const scf_value_t *val, char *out, size_t len) 46307c478bd9Sstevel@tonic-gate { 46317c478bd9Sstevel@tonic-gate ssize_t ret; 46327c478bd9Sstevel@tonic-gate scf_handle_t *h = val->value_handle; 46337c478bd9Sstevel@tonic-gate 46347c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 46357c478bd9Sstevel@tonic-gate if (!scf_value_check_type(val, REP_PROTOCOL_SUBTYPE_USTRING)) { 46367c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46377c478bd9Sstevel@tonic-gate return ((ssize_t)-1); 46387c478bd9Sstevel@tonic-gate } 46397c478bd9Sstevel@tonic-gate ret = (ssize_t)strlcpy(out, val->value_value, len); 46407c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46417c478bd9Sstevel@tonic-gate return (ret); 46427c478bd9Sstevel@tonic-gate } 46437c478bd9Sstevel@tonic-gate 46447c478bd9Sstevel@tonic-gate ssize_t 46457c478bd9Sstevel@tonic-gate scf_value_get_opaque(const scf_value_t *v, void *out, size_t len) 46467c478bd9Sstevel@tonic-gate { 46477c478bd9Sstevel@tonic-gate ssize_t ret; 46487c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 46497c478bd9Sstevel@tonic-gate 46507c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 46517c478bd9Sstevel@tonic-gate if (!scf_value_check_type(v, REP_PROTOCOL_TYPE_OPAQUE)) { 46527c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46537c478bd9Sstevel@tonic-gate return ((ssize_t)-1); 46547c478bd9Sstevel@tonic-gate } 46557c478bd9Sstevel@tonic-gate if (len > v->value_size) 46567c478bd9Sstevel@tonic-gate len = v->value_size; 46577c478bd9Sstevel@tonic-gate ret = len; 46587c478bd9Sstevel@tonic-gate 46597c478bd9Sstevel@tonic-gate (void) memcpy(out, v->value_value, len); 46607c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46617c478bd9Sstevel@tonic-gate return (ret); 46627c478bd9Sstevel@tonic-gate } 46637c478bd9Sstevel@tonic-gate 46647c478bd9Sstevel@tonic-gate void 46657c478bd9Sstevel@tonic-gate scf_value_set_boolean(scf_value_t *v, uint8_t new) 46667c478bd9Sstevel@tonic-gate { 46677c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 46687c478bd9Sstevel@tonic-gate 46697c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 46707c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 46717c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_TYPE_BOOLEAN; 46727c478bd9Sstevel@tonic-gate (void) sprintf(v->value_value, "%d", (new != 0)); 46737c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46747c478bd9Sstevel@tonic-gate } 46757c478bd9Sstevel@tonic-gate 46767c478bd9Sstevel@tonic-gate void 46777c478bd9Sstevel@tonic-gate scf_value_set_count(scf_value_t *v, uint64_t new) 46787c478bd9Sstevel@tonic-gate { 46797c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 46807c478bd9Sstevel@tonic-gate 46817c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 46827c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 46837c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_TYPE_COUNT; 46847c478bd9Sstevel@tonic-gate (void) sprintf(v->value_value, "%llu", (unsigned long long)new); 46857c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46867c478bd9Sstevel@tonic-gate } 46877c478bd9Sstevel@tonic-gate 46887c478bd9Sstevel@tonic-gate void 46897c478bd9Sstevel@tonic-gate scf_value_set_integer(scf_value_t *v, int64_t new) 46907c478bd9Sstevel@tonic-gate { 46917c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 46927c478bd9Sstevel@tonic-gate 46937c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 46947c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 46957c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_TYPE_INTEGER; 46967c478bd9Sstevel@tonic-gate (void) sprintf(v->value_value, "%lld", (long long)new); 46977c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 46987c478bd9Sstevel@tonic-gate } 46997c478bd9Sstevel@tonic-gate 47007c478bd9Sstevel@tonic-gate int 47017c478bd9Sstevel@tonic-gate scf_value_set_time(scf_value_t *v, int64_t new_sec, int32_t new_nsec) 47027c478bd9Sstevel@tonic-gate { 47037c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 47047c478bd9Sstevel@tonic-gate 47057c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 47067c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 47077c478bd9Sstevel@tonic-gate if (new_nsec < 0 || new_nsec >= NANOSEC) { 47087c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47097c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 47107c478bd9Sstevel@tonic-gate } 47117c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_TYPE_TIME; 47127c478bd9Sstevel@tonic-gate if (new_nsec == 0) 47137c478bd9Sstevel@tonic-gate (void) sprintf(v->value_value, "%lld", (long long)new_sec); 47147c478bd9Sstevel@tonic-gate else 47157c478bd9Sstevel@tonic-gate (void) sprintf(v->value_value, "%lld.%09u", (long long)new_sec, 47167c478bd9Sstevel@tonic-gate (unsigned)new_nsec); 47177c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47187c478bd9Sstevel@tonic-gate return (0); 47197c478bd9Sstevel@tonic-gate } 47207c478bd9Sstevel@tonic-gate 47217c478bd9Sstevel@tonic-gate int 47227c478bd9Sstevel@tonic-gate scf_value_set_astring(scf_value_t *v, const char *new) 47237c478bd9Sstevel@tonic-gate { 47247c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 47257c478bd9Sstevel@tonic-gate 47267c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 47277c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 47287c478bd9Sstevel@tonic-gate if (!scf_validate_encoded_value(REP_PROTOCOL_TYPE_STRING, new)) { 47297c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47307c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 47317c478bd9Sstevel@tonic-gate } 47327c478bd9Sstevel@tonic-gate if (strlcpy(v->value_value, new, sizeof (v->value_value)) >= 47337c478bd9Sstevel@tonic-gate sizeof (v->value_value)) { 47347c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47357c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 47367c478bd9Sstevel@tonic-gate } 47377c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_TYPE_STRING; 47387c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47397c478bd9Sstevel@tonic-gate return (0); 47407c478bd9Sstevel@tonic-gate } 47417c478bd9Sstevel@tonic-gate 47427c478bd9Sstevel@tonic-gate int 47437c478bd9Sstevel@tonic-gate scf_value_set_ustring(scf_value_t *v, const char *new) 47447c478bd9Sstevel@tonic-gate { 47457c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 47467c478bd9Sstevel@tonic-gate 47477c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 47487c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 47497c478bd9Sstevel@tonic-gate if (!scf_validate_encoded_value(REP_PROTOCOL_SUBTYPE_USTRING, new)) { 47507c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47517c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 47527c478bd9Sstevel@tonic-gate } 47537c478bd9Sstevel@tonic-gate if (strlcpy(v->value_value, new, sizeof (v->value_value)) >= 47547c478bd9Sstevel@tonic-gate sizeof (v->value_value)) { 47557c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47567c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 47577c478bd9Sstevel@tonic-gate } 47587c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_SUBTYPE_USTRING; 47597c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47607c478bd9Sstevel@tonic-gate return (0); 47617c478bd9Sstevel@tonic-gate } 47627c478bd9Sstevel@tonic-gate 47637c478bd9Sstevel@tonic-gate int 47647c478bd9Sstevel@tonic-gate scf_value_set_opaque(scf_value_t *v, const void *new, size_t len) 47657c478bd9Sstevel@tonic-gate { 47667c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 47677c478bd9Sstevel@tonic-gate 47687c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 47697c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 47707c478bd9Sstevel@tonic-gate if (len > sizeof (v->value_value)) { 47717c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47727c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 47737c478bd9Sstevel@tonic-gate } 47747c478bd9Sstevel@tonic-gate (void) memcpy(v->value_value, new, len); 47757c478bd9Sstevel@tonic-gate v->value_size = len; 47767c478bd9Sstevel@tonic-gate v->value_type = REP_PROTOCOL_TYPE_OPAQUE; 47777c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 47787c478bd9Sstevel@tonic-gate return (0); 47797c478bd9Sstevel@tonic-gate } 47807c478bd9Sstevel@tonic-gate 47817c478bd9Sstevel@tonic-gate /* 47827c478bd9Sstevel@tonic-gate * Fails with 47837c478bd9Sstevel@tonic-gate * _NOT_SET - v_arg is reset 47847c478bd9Sstevel@tonic-gate * _INTERNAL - v_arg is corrupt 47857c478bd9Sstevel@tonic-gate * 47867c478bd9Sstevel@tonic-gate * If t is not _TYPE_INVALID, fails with 47877c478bd9Sstevel@tonic-gate * _TYPE_MISMATCH - v_arg's type is not compatible with t 47887c478bd9Sstevel@tonic-gate */ 47897c478bd9Sstevel@tonic-gate static ssize_t 47907c478bd9Sstevel@tonic-gate scf_value_get_as_string_common(const scf_value_t *v_arg, 47917c478bd9Sstevel@tonic-gate rep_protocol_value_type_t t, char *buf, size_t bufsz) 47927c478bd9Sstevel@tonic-gate { 47937c478bd9Sstevel@tonic-gate scf_handle_t *h = v_arg->value_handle; 47947c478bd9Sstevel@tonic-gate scf_value_t v_s; 47957c478bd9Sstevel@tonic-gate scf_value_t *v = &v_s; 47967c478bd9Sstevel@tonic-gate ssize_t r; 47977c478bd9Sstevel@tonic-gate uint8_t b; 47987c478bd9Sstevel@tonic-gate 47997c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 48007c478bd9Sstevel@tonic-gate if (t != REP_PROTOCOL_TYPE_INVALID && !scf_value_check_type(v_arg, t)) { 48017c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 48027c478bd9Sstevel@tonic-gate return (-1); 48037c478bd9Sstevel@tonic-gate } 48047c478bd9Sstevel@tonic-gate 48057c478bd9Sstevel@tonic-gate v_s = *v_arg; /* copy locally so we can unlock */ 48067c478bd9Sstevel@tonic-gate h->rh_values++; /* keep the handle from going away */ 48077c478bd9Sstevel@tonic-gate h->rh_extrefs++; 48087c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 48097c478bd9Sstevel@tonic-gate 48107c478bd9Sstevel@tonic-gate 48117c478bd9Sstevel@tonic-gate switch (REP_PROTOCOL_BASE_TYPE(v->value_type)) { 48127c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_BOOLEAN: 48137c478bd9Sstevel@tonic-gate r = scf_value_get_boolean(v, &b); 48147c478bd9Sstevel@tonic-gate assert(r == SCF_SUCCESS); 48157c478bd9Sstevel@tonic-gate 48167c478bd9Sstevel@tonic-gate r = strlcpy(buf, b ? "true" : "false", bufsz); 48177c478bd9Sstevel@tonic-gate break; 48187c478bd9Sstevel@tonic-gate 48197c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_COUNT: 48207c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_INTEGER: 48217c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_TIME: 48227c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_STRING: 48237c478bd9Sstevel@tonic-gate r = strlcpy(buf, v->value_value, bufsz); 48247c478bd9Sstevel@tonic-gate break; 48257c478bd9Sstevel@tonic-gate 48267c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_OPAQUE: 48277c478bd9Sstevel@tonic-gate /* 48287c478bd9Sstevel@tonic-gate * Note that we only write out full hex bytes -- if they're 48297c478bd9Sstevel@tonic-gate * short, and bufsz is even, we'll only fill (bufsz - 2) bytes 48307c478bd9Sstevel@tonic-gate * with data. 48317c478bd9Sstevel@tonic-gate */ 48327c478bd9Sstevel@tonic-gate if (bufsz > 0) 48337c478bd9Sstevel@tonic-gate (void) scf_opaque_encode(buf, v->value_value, 48347c478bd9Sstevel@tonic-gate MIN(v->value_size, (bufsz - 1)/2)); 48357c478bd9Sstevel@tonic-gate r = (v->value_size * 2); 48367c478bd9Sstevel@tonic-gate break; 48377c478bd9Sstevel@tonic-gate 48387c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_INVALID: 48397c478bd9Sstevel@tonic-gate r = scf_set_error(SCF_ERROR_NOT_SET); 48407c478bd9Sstevel@tonic-gate break; 48417c478bd9Sstevel@tonic-gate 48427c478bd9Sstevel@tonic-gate default: 48437c478bd9Sstevel@tonic-gate r = (scf_set_error(SCF_ERROR_INTERNAL)); 48447c478bd9Sstevel@tonic-gate break; 48457c478bd9Sstevel@tonic-gate } 48467c478bd9Sstevel@tonic-gate 48477c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 48487c478bd9Sstevel@tonic-gate h->rh_values--; 48497c478bd9Sstevel@tonic-gate h->rh_extrefs--; 48507c478bd9Sstevel@tonic-gate handle_unrefed(h); 48517c478bd9Sstevel@tonic-gate 48527c478bd9Sstevel@tonic-gate return (r); 48537c478bd9Sstevel@tonic-gate } 48547c478bd9Sstevel@tonic-gate 48557c478bd9Sstevel@tonic-gate ssize_t 48567c478bd9Sstevel@tonic-gate scf_value_get_as_string(const scf_value_t *v, char *buf, size_t bufsz) 48577c478bd9Sstevel@tonic-gate { 48587c478bd9Sstevel@tonic-gate return (scf_value_get_as_string_common(v, REP_PROTOCOL_TYPE_INVALID, 48597c478bd9Sstevel@tonic-gate buf, bufsz)); 48607c478bd9Sstevel@tonic-gate } 48617c478bd9Sstevel@tonic-gate 48627c478bd9Sstevel@tonic-gate ssize_t 48637c478bd9Sstevel@tonic-gate scf_value_get_as_string_typed(const scf_value_t *v, scf_type_t type, 48647c478bd9Sstevel@tonic-gate char *buf, size_t bufsz) 48657c478bd9Sstevel@tonic-gate { 48667c478bd9Sstevel@tonic-gate rep_protocol_value_type_t ty = scf_type_to_protocol_type(type); 48677c478bd9Sstevel@tonic-gate if (ty == REP_PROTOCOL_TYPE_INVALID) 48687c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 48697c478bd9Sstevel@tonic-gate 48707c478bd9Sstevel@tonic-gate return (scf_value_get_as_string_common(v, ty, buf, bufsz)); 48717c478bd9Sstevel@tonic-gate } 48727c478bd9Sstevel@tonic-gate 48737c478bd9Sstevel@tonic-gate int 48747c478bd9Sstevel@tonic-gate scf_value_set_from_string(scf_value_t *v, scf_type_t type, const char *str) 48757c478bd9Sstevel@tonic-gate { 48767c478bd9Sstevel@tonic-gate scf_handle_t *h = v->value_handle; 48777c478bd9Sstevel@tonic-gate rep_protocol_value_type_t ty; 48787c478bd9Sstevel@tonic-gate 48797c478bd9Sstevel@tonic-gate switch (type) { 48807c478bd9Sstevel@tonic-gate case SCF_TYPE_BOOLEAN: { 48817c478bd9Sstevel@tonic-gate uint8_t b; 48827c478bd9Sstevel@tonic-gate 48837c478bd9Sstevel@tonic-gate if (strcmp(str, "true") == 0 || strcmp(str, "t") == 0 || 48847c478bd9Sstevel@tonic-gate strcmp(str, "1") == 0) 48857c478bd9Sstevel@tonic-gate b = 1; 48867c478bd9Sstevel@tonic-gate else if (strcmp(str, "false") == 0 || 48877c478bd9Sstevel@tonic-gate strcmp(str, "f") == 0 || strcmp(str, "0") == 0) 48887c478bd9Sstevel@tonic-gate b = 0; 48897c478bd9Sstevel@tonic-gate else { 48907c478bd9Sstevel@tonic-gate goto bad; 48917c478bd9Sstevel@tonic-gate } 48927c478bd9Sstevel@tonic-gate 48937c478bd9Sstevel@tonic-gate scf_value_set_boolean(v, b); 48947c478bd9Sstevel@tonic-gate return (0); 48957c478bd9Sstevel@tonic-gate } 48967c478bd9Sstevel@tonic-gate 48977c478bd9Sstevel@tonic-gate case SCF_TYPE_COUNT: { 48987c478bd9Sstevel@tonic-gate uint64_t c; 48997c478bd9Sstevel@tonic-gate char *endp; 49007c478bd9Sstevel@tonic-gate 49017c478bd9Sstevel@tonic-gate errno = 0; 4902f2fa366aSjeanm c = strtoull(str, &endp, 0); 49037c478bd9Sstevel@tonic-gate 49047c478bd9Sstevel@tonic-gate if (errno != 0 || endp == str || *endp != '\0') 49057c478bd9Sstevel@tonic-gate goto bad; 49067c478bd9Sstevel@tonic-gate 49077c478bd9Sstevel@tonic-gate scf_value_set_count(v, c); 49087c478bd9Sstevel@tonic-gate return (0); 49097c478bd9Sstevel@tonic-gate } 49107c478bd9Sstevel@tonic-gate 49117c478bd9Sstevel@tonic-gate case SCF_TYPE_INTEGER: { 49127c478bd9Sstevel@tonic-gate int64_t i; 49137c478bd9Sstevel@tonic-gate char *endp; 49147c478bd9Sstevel@tonic-gate 49157c478bd9Sstevel@tonic-gate errno = 0; 4916f2fa366aSjeanm i = strtoll(str, &endp, 0); 49177c478bd9Sstevel@tonic-gate 49187c478bd9Sstevel@tonic-gate if (errno != 0 || endp == str || *endp != '\0') 49197c478bd9Sstevel@tonic-gate goto bad; 49207c478bd9Sstevel@tonic-gate 49217c478bd9Sstevel@tonic-gate scf_value_set_integer(v, i); 49227c478bd9Sstevel@tonic-gate return (0); 49237c478bd9Sstevel@tonic-gate } 49247c478bd9Sstevel@tonic-gate 49257c478bd9Sstevel@tonic-gate case SCF_TYPE_TIME: { 49267c478bd9Sstevel@tonic-gate int64_t s; 49277c478bd9Sstevel@tonic-gate uint32_t ns = 0; 49287c478bd9Sstevel@tonic-gate char *endp, *ns_str; 49297c478bd9Sstevel@tonic-gate size_t len; 49307c478bd9Sstevel@tonic-gate 49317c478bd9Sstevel@tonic-gate errno = 0; 49327c478bd9Sstevel@tonic-gate s = strtoll(str, &endp, 10); 49337c478bd9Sstevel@tonic-gate if (errno != 0 || endp == str || 49347c478bd9Sstevel@tonic-gate (*endp != '\0' && *endp != '.')) 49357c478bd9Sstevel@tonic-gate goto bad; 49367c478bd9Sstevel@tonic-gate 49377c478bd9Sstevel@tonic-gate if (*endp == '.') { 49387c478bd9Sstevel@tonic-gate ns_str = endp + 1; 49397c478bd9Sstevel@tonic-gate len = strlen(ns_str); 49407c478bd9Sstevel@tonic-gate if (len == 0 || len > 9) 49417c478bd9Sstevel@tonic-gate goto bad; 49427c478bd9Sstevel@tonic-gate 49437c478bd9Sstevel@tonic-gate ns = strtoul(ns_str, &endp, 10); 49447c478bd9Sstevel@tonic-gate if (errno != 0 || endp == ns_str || *endp != '\0') 49457c478bd9Sstevel@tonic-gate goto bad; 49467c478bd9Sstevel@tonic-gate 49477c478bd9Sstevel@tonic-gate while (len++ < 9) 49487c478bd9Sstevel@tonic-gate ns *= 10; 49497c478bd9Sstevel@tonic-gate assert(ns < NANOSEC); 49507c478bd9Sstevel@tonic-gate } 49517c478bd9Sstevel@tonic-gate 49527c478bd9Sstevel@tonic-gate return (scf_value_set_time(v, s, ns)); 49537c478bd9Sstevel@tonic-gate } 49547c478bd9Sstevel@tonic-gate 49557c478bd9Sstevel@tonic-gate case SCF_TYPE_ASTRING: 49567c478bd9Sstevel@tonic-gate case SCF_TYPE_USTRING: 49577c478bd9Sstevel@tonic-gate case SCF_TYPE_OPAQUE: 49587c478bd9Sstevel@tonic-gate case SCF_TYPE_URI: 49597c478bd9Sstevel@tonic-gate case SCF_TYPE_FMRI: 49607c478bd9Sstevel@tonic-gate case SCF_TYPE_HOST: 49617c478bd9Sstevel@tonic-gate case SCF_TYPE_HOSTNAME: 4962b56bf881SAntonello Cruz case SCF_TYPE_NET_ADDR: 49637c478bd9Sstevel@tonic-gate case SCF_TYPE_NET_ADDR_V4: 49647c478bd9Sstevel@tonic-gate case SCF_TYPE_NET_ADDR_V6: 49657c478bd9Sstevel@tonic-gate ty = scf_type_to_protocol_type(type); 49667c478bd9Sstevel@tonic-gate 49677c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 49687c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 49697c478bd9Sstevel@tonic-gate if (type == SCF_TYPE_OPAQUE) { 49707c478bd9Sstevel@tonic-gate v->value_size = scf_opaque_decode(v->value_value, 49717c478bd9Sstevel@tonic-gate str, sizeof (v->value_value)); 49727c478bd9Sstevel@tonic-gate if (!scf_validate_encoded_value(ty, str)) { 49737c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 49747c478bd9Sstevel@tonic-gate goto bad; 49757c478bd9Sstevel@tonic-gate } 49767c478bd9Sstevel@tonic-gate } else { 49777c478bd9Sstevel@tonic-gate (void) strlcpy(v->value_value, str, 49787c478bd9Sstevel@tonic-gate sizeof (v->value_value)); 49797c478bd9Sstevel@tonic-gate if (!scf_validate_encoded_value(ty, v->value_value)) { 49807c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 49817c478bd9Sstevel@tonic-gate goto bad; 49827c478bd9Sstevel@tonic-gate } 49837c478bd9Sstevel@tonic-gate } 49847c478bd9Sstevel@tonic-gate v->value_type = ty; 49857c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 49867c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 49877c478bd9Sstevel@tonic-gate 49887c478bd9Sstevel@tonic-gate case REP_PROTOCOL_TYPE_INVALID: 49897c478bd9Sstevel@tonic-gate default: 49907c478bd9Sstevel@tonic-gate scf_value_reset(v); 49917c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_TYPE_MISMATCH)); 49927c478bd9Sstevel@tonic-gate } 49937c478bd9Sstevel@tonic-gate bad: 49947c478bd9Sstevel@tonic-gate scf_value_reset(v); 49957c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 49967c478bd9Sstevel@tonic-gate } 49977c478bd9Sstevel@tonic-gate 49987c478bd9Sstevel@tonic-gate int 49997c478bd9Sstevel@tonic-gate scf_iter_property_values(scf_iter_t *iter, const scf_property_t *prop) 50007c478bd9Sstevel@tonic-gate { 50017c478bd9Sstevel@tonic-gate return (datael_setup_iter(iter, &prop->rd_d, 50027c478bd9Sstevel@tonic-gate REP_PROTOCOL_ENTITY_VALUE, 0)); 50037c478bd9Sstevel@tonic-gate } 50047c478bd9Sstevel@tonic-gate 50057c478bd9Sstevel@tonic-gate int 50067c478bd9Sstevel@tonic-gate scf_iter_next_value(scf_iter_t *iter, scf_value_t *v) 50077c478bd9Sstevel@tonic-gate { 50087c478bd9Sstevel@tonic-gate scf_handle_t *h = iter->iter_handle; 50097c478bd9Sstevel@tonic-gate 50107c478bd9Sstevel@tonic-gate struct rep_protocol_iter_read_value request; 50117c478bd9Sstevel@tonic-gate struct rep_protocol_value_response response; 50127c478bd9Sstevel@tonic-gate 50137c478bd9Sstevel@tonic-gate int r; 50147c478bd9Sstevel@tonic-gate 50157c478bd9Sstevel@tonic-gate if (h != v->value_handle) 50167c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 50177c478bd9Sstevel@tonic-gate 50187c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 50197c478bd9Sstevel@tonic-gate 50207c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 50217c478bd9Sstevel@tonic-gate 50227c478bd9Sstevel@tonic-gate if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE) { 50237c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50247c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_NOT_SET)); 50257c478bd9Sstevel@tonic-gate } 50267c478bd9Sstevel@tonic-gate 50277c478bd9Sstevel@tonic-gate if (iter->iter_type != REP_PROTOCOL_ENTITY_VALUE) { 50287c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50297c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 50307c478bd9Sstevel@tonic-gate } 50317c478bd9Sstevel@tonic-gate 50327c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ITER_READ_VALUE; 50337c478bd9Sstevel@tonic-gate request.rpr_iterid = iter->iter_id; 50347c478bd9Sstevel@tonic-gate request.rpr_sequence = iter->iter_sequence; 50357c478bd9Sstevel@tonic-gate 50367c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 50377c478bd9Sstevel@tonic-gate &response, sizeof (response)); 50387c478bd9Sstevel@tonic-gate 50397c478bd9Sstevel@tonic-gate if (r < 0) { 50407c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50417c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 50427c478bd9Sstevel@tonic-gate } 50437c478bd9Sstevel@tonic-gate 50447c478bd9Sstevel@tonic-gate if (response.rpr_response == REP_PROTOCOL_DONE) { 50457c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50467c478bd9Sstevel@tonic-gate return (0); 50477c478bd9Sstevel@tonic-gate } 50487c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) { 50497c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50507c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 50517c478bd9Sstevel@tonic-gate } 50527c478bd9Sstevel@tonic-gate iter->iter_sequence++; 50537c478bd9Sstevel@tonic-gate 50547c478bd9Sstevel@tonic-gate v->value_type = response.rpr_type; 50557c478bd9Sstevel@tonic-gate 50567c478bd9Sstevel@tonic-gate assert(scf_validate_encoded_value(response.rpr_type, 50577c478bd9Sstevel@tonic-gate response.rpr_value)); 50587c478bd9Sstevel@tonic-gate 50597c478bd9Sstevel@tonic-gate if (v->value_type != REP_PROTOCOL_TYPE_OPAQUE) { 50607c478bd9Sstevel@tonic-gate (void) strlcpy(v->value_value, response.rpr_value, 50617c478bd9Sstevel@tonic-gate sizeof (v->value_value)); 50627c478bd9Sstevel@tonic-gate } else { 50637c478bd9Sstevel@tonic-gate v->value_size = scf_opaque_decode(v->value_value, 50647c478bd9Sstevel@tonic-gate response.rpr_value, sizeof (v->value_value)); 50657c478bd9Sstevel@tonic-gate } 50667c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50677c478bd9Sstevel@tonic-gate 50687c478bd9Sstevel@tonic-gate return (1); 50697c478bd9Sstevel@tonic-gate } 50707c478bd9Sstevel@tonic-gate 50717c478bd9Sstevel@tonic-gate int 50727c478bd9Sstevel@tonic-gate scf_property_get_value(const scf_property_t *prop, scf_value_t *v) 50737c478bd9Sstevel@tonic-gate { 50747c478bd9Sstevel@tonic-gate scf_handle_t *h = prop->rd_d.rd_handle; 50757c478bd9Sstevel@tonic-gate struct rep_protocol_property_request request; 50767c478bd9Sstevel@tonic-gate struct rep_protocol_value_response response; 50777c478bd9Sstevel@tonic-gate int r; 50787c478bd9Sstevel@tonic-gate 50797c478bd9Sstevel@tonic-gate if (h != v->value_handle) 50807c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 50817c478bd9Sstevel@tonic-gate 50827c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 50837c478bd9Sstevel@tonic-gate 50847c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_PROPERTY_GET_VALUE; 50857c478bd9Sstevel@tonic-gate request.rpr_entityid = prop->rd_d.rd_entity; 50867c478bd9Sstevel@tonic-gate 50877c478bd9Sstevel@tonic-gate scf_value_reset_locked(v, 0); 50887c478bd9Sstevel@tonic-gate datael_finish_reset(&prop->rd_d); 50897c478bd9Sstevel@tonic-gate 50907c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 50917c478bd9Sstevel@tonic-gate &response, sizeof (response)); 50927c478bd9Sstevel@tonic-gate 50937c478bd9Sstevel@tonic-gate if (r < 0) { 50947c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 50957c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 50967c478bd9Sstevel@tonic-gate } 50977c478bd9Sstevel@tonic-gate 50987c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS && 50997c478bd9Sstevel@tonic-gate response.rpr_response != REP_PROTOCOL_FAIL_TRUNCATED) { 51007c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 51017c478bd9Sstevel@tonic-gate assert(response.rpr_response != 51027c478bd9Sstevel@tonic-gate REP_PROTOCOL_FAIL_TYPE_MISMATCH); 51037c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 51047c478bd9Sstevel@tonic-gate } 51057c478bd9Sstevel@tonic-gate 51067c478bd9Sstevel@tonic-gate v->value_type = response.rpr_type; 51077c478bd9Sstevel@tonic-gate if (v->value_type != REP_PROTOCOL_TYPE_OPAQUE) { 51087c478bd9Sstevel@tonic-gate (void) strlcpy(v->value_value, response.rpr_value, 51097c478bd9Sstevel@tonic-gate sizeof (v->value_value)); 51107c478bd9Sstevel@tonic-gate } else { 51117c478bd9Sstevel@tonic-gate v->value_size = scf_opaque_decode(v->value_value, 51127c478bd9Sstevel@tonic-gate response.rpr_value, sizeof (v->value_value)); 51137c478bd9Sstevel@tonic-gate } 51147c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 51157c478bd9Sstevel@tonic-gate return ((response.rpr_response == REP_PROTOCOL_SUCCESS)? 51167c478bd9Sstevel@tonic-gate SCF_SUCCESS : scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED)); 51177c478bd9Sstevel@tonic-gate } 51187c478bd9Sstevel@tonic-gate 51197c478bd9Sstevel@tonic-gate int 51207c478bd9Sstevel@tonic-gate scf_pg_get_parent_service(const scf_propertygroup_t *pg, scf_service_t *svc) 51217c478bd9Sstevel@tonic-gate { 51227c478bd9Sstevel@tonic-gate return (datael_get_parent(&pg->rd_d, &svc->rd_d)); 51237c478bd9Sstevel@tonic-gate } 51247c478bd9Sstevel@tonic-gate 51257c478bd9Sstevel@tonic-gate int 51267c478bd9Sstevel@tonic-gate scf_pg_get_parent_instance(const scf_propertygroup_t *pg, scf_instance_t *inst) 51277c478bd9Sstevel@tonic-gate { 51287c478bd9Sstevel@tonic-gate return (datael_get_parent(&pg->rd_d, &inst->rd_d)); 51297c478bd9Sstevel@tonic-gate } 51307c478bd9Sstevel@tonic-gate 51317c478bd9Sstevel@tonic-gate int 51327c478bd9Sstevel@tonic-gate scf_pg_get_parent_snaplevel(const scf_propertygroup_t *pg, 51337c478bd9Sstevel@tonic-gate scf_snaplevel_t *level) 51347c478bd9Sstevel@tonic-gate { 51357c478bd9Sstevel@tonic-gate return (datael_get_parent(&pg->rd_d, &level->rd_d)); 51367c478bd9Sstevel@tonic-gate } 51377c478bd9Sstevel@tonic-gate 51387c478bd9Sstevel@tonic-gate int 51397c478bd9Sstevel@tonic-gate scf_service_get_parent(const scf_service_t *svc, scf_scope_t *s) 51407c478bd9Sstevel@tonic-gate { 51417c478bd9Sstevel@tonic-gate return (datael_get_parent(&svc->rd_d, &s->rd_d)); 51427c478bd9Sstevel@tonic-gate } 51437c478bd9Sstevel@tonic-gate 51447c478bd9Sstevel@tonic-gate int 51457c478bd9Sstevel@tonic-gate scf_instance_get_parent(const scf_instance_t *inst, scf_service_t *svc) 51467c478bd9Sstevel@tonic-gate { 51477c478bd9Sstevel@tonic-gate return (datael_get_parent(&inst->rd_d, &svc->rd_d)); 51487c478bd9Sstevel@tonic-gate } 51497c478bd9Sstevel@tonic-gate 51507c478bd9Sstevel@tonic-gate int 51517c478bd9Sstevel@tonic-gate scf_snapshot_get_parent(const scf_snapshot_t *inst, scf_instance_t *svc) 51527c478bd9Sstevel@tonic-gate { 51537c478bd9Sstevel@tonic-gate return (datael_get_parent(&inst->rd_d, &svc->rd_d)); 51547c478bd9Sstevel@tonic-gate } 51557c478bd9Sstevel@tonic-gate 51567c478bd9Sstevel@tonic-gate int 51577c478bd9Sstevel@tonic-gate scf_snaplevel_get_parent(const scf_snaplevel_t *inst, scf_snapshot_t *svc) 51587c478bd9Sstevel@tonic-gate { 51597c478bd9Sstevel@tonic-gate return (datael_get_parent(&inst->rd_d, &svc->rd_d)); 51607c478bd9Sstevel@tonic-gate } 51617c478bd9Sstevel@tonic-gate 51627c478bd9Sstevel@tonic-gate /* 51637c478bd9Sstevel@tonic-gate * FMRI functions 51647c478bd9Sstevel@tonic-gate * 51657c478bd9Sstevel@tonic-gate * Note: In the scf_parse_svc_fmri(), scf_parse_file_fmri() and 51667c478bd9Sstevel@tonic-gate * scf_parse_fmri(), fmri isn't const because that would require 51677c478bd9Sstevel@tonic-gate * allocating memory. Also, note that scope, at least, is not necessarily 51687c478bd9Sstevel@tonic-gate * in the passed in fmri. 51697c478bd9Sstevel@tonic-gate */ 51707c478bd9Sstevel@tonic-gate 51717c478bd9Sstevel@tonic-gate int 51727c478bd9Sstevel@tonic-gate scf_parse_svc_fmri(char *fmri, const char **scope, const char **service, 51737c478bd9Sstevel@tonic-gate const char **instance, const char **propertygroup, const char **property) 51747c478bd9Sstevel@tonic-gate { 51757c478bd9Sstevel@tonic-gate char *s, *e, *te, *tpg; 51767c478bd9Sstevel@tonic-gate char *my_s = NULL, *my_i = NULL, *my_pg = NULL, *my_p = NULL; 51777c478bd9Sstevel@tonic-gate 51787c478bd9Sstevel@tonic-gate if (scope != NULL) 51797c478bd9Sstevel@tonic-gate *scope = NULL; 51807c478bd9Sstevel@tonic-gate if (service != NULL) 51817c478bd9Sstevel@tonic-gate *service = NULL; 51827c478bd9Sstevel@tonic-gate if (instance != NULL) 51837c478bd9Sstevel@tonic-gate *instance = NULL; 51847c478bd9Sstevel@tonic-gate if (propertygroup != NULL) 51857c478bd9Sstevel@tonic-gate *propertygroup = NULL; 51867c478bd9Sstevel@tonic-gate if (property != NULL) 51877c478bd9Sstevel@tonic-gate *property = NULL; 51887c478bd9Sstevel@tonic-gate 51897c478bd9Sstevel@tonic-gate s = fmri; 51907c478bd9Sstevel@tonic-gate e = strchr(s, '\0'); 51917c478bd9Sstevel@tonic-gate 51927c478bd9Sstevel@tonic-gate if (strncmp(s, SCF_FMRI_SVC_PREFIX, 51937c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SVC_PREFIX) - 1) == 0) 51947c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_SVC_PREFIX) - 1; 51957c478bd9Sstevel@tonic-gate 51967c478bd9Sstevel@tonic-gate if (strncmp(s, SCF_FMRI_SCOPE_PREFIX, 51977c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SCOPE_PREFIX) - 1) == 0) { 51987c478bd9Sstevel@tonic-gate char *my_scope; 51997c478bd9Sstevel@tonic-gate 52007c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_SCOPE_PREFIX) - 1; 52017c478bd9Sstevel@tonic-gate te = strstr(s, SCF_FMRI_SERVICE_PREFIX); 52027c478bd9Sstevel@tonic-gate if (te == NULL) 52037c478bd9Sstevel@tonic-gate te = e; 52047c478bd9Sstevel@tonic-gate 52057c478bd9Sstevel@tonic-gate *te = 0; 52067c478bd9Sstevel@tonic-gate my_scope = s; 52077c478bd9Sstevel@tonic-gate 52087c478bd9Sstevel@tonic-gate s = te; 52097c478bd9Sstevel@tonic-gate if (s < e) 52107c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1; 52117c478bd9Sstevel@tonic-gate 52127c478bd9Sstevel@tonic-gate /* If the scope ends with the suffix, remove it. */ 52137c478bd9Sstevel@tonic-gate te = strstr(my_scope, SCF_FMRI_SCOPE_SUFFIX); 52147c478bd9Sstevel@tonic-gate if (te != NULL && te[sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1] == 0) 52157c478bd9Sstevel@tonic-gate *te = 0; 52167c478bd9Sstevel@tonic-gate 52177c478bd9Sstevel@tonic-gate /* Validate the scope. */ 52187c478bd9Sstevel@tonic-gate if (my_scope[0] == '\0') 52197c478bd9Sstevel@tonic-gate my_scope = SCF_FMRI_LOCAL_SCOPE; 52207c478bd9Sstevel@tonic-gate else if (uu_check_name(my_scope, 0) == -1) { 52217c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 52227c478bd9Sstevel@tonic-gate } 52237c478bd9Sstevel@tonic-gate 52247c478bd9Sstevel@tonic-gate if (scope != NULL) 52257c478bd9Sstevel@tonic-gate *scope = my_scope; 52267c478bd9Sstevel@tonic-gate } else { 52277c478bd9Sstevel@tonic-gate if (scope != NULL) 52287c478bd9Sstevel@tonic-gate *scope = SCF_FMRI_LOCAL_SCOPE; 52297c478bd9Sstevel@tonic-gate } 52307c478bd9Sstevel@tonic-gate 52317c478bd9Sstevel@tonic-gate if (s[0] != 0) { 52327c478bd9Sstevel@tonic-gate if (strncmp(s, SCF_FMRI_SERVICE_PREFIX, 52337c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SERVICE_PREFIX) - 1) == 0) 52347c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1; 52357c478bd9Sstevel@tonic-gate 52367c478bd9Sstevel@tonic-gate /* 52377c478bd9Sstevel@tonic-gate * Can't validate service here because it might not be null 52387c478bd9Sstevel@tonic-gate * terminated. 52397c478bd9Sstevel@tonic-gate */ 52407c478bd9Sstevel@tonic-gate my_s = s; 52417c478bd9Sstevel@tonic-gate } 52427c478bd9Sstevel@tonic-gate 52437c478bd9Sstevel@tonic-gate tpg = strstr(s, SCF_FMRI_PROPERTYGRP_PREFIX); 52447c478bd9Sstevel@tonic-gate te = strstr(s, SCF_FMRI_INSTANCE_PREFIX); 52457c478bd9Sstevel@tonic-gate if (te != NULL && (tpg == NULL || te < tpg)) { 52467c478bd9Sstevel@tonic-gate *te = 0; 52477c478bd9Sstevel@tonic-gate te += sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1; 52487c478bd9Sstevel@tonic-gate 52497c478bd9Sstevel@tonic-gate /* Can't validate instance here either. */ 52507c478bd9Sstevel@tonic-gate my_i = s = te; 52517c478bd9Sstevel@tonic-gate 52527c478bd9Sstevel@tonic-gate te = strstr(s, SCF_FMRI_PROPERTYGRP_PREFIX); 52537c478bd9Sstevel@tonic-gate } else { 52547c478bd9Sstevel@tonic-gate te = tpg; 52557c478bd9Sstevel@tonic-gate } 52567c478bd9Sstevel@tonic-gate 52577c478bd9Sstevel@tonic-gate if (te != NULL) { 52587c478bd9Sstevel@tonic-gate *te = 0; 52597c478bd9Sstevel@tonic-gate te += sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1; 52607c478bd9Sstevel@tonic-gate 52617c478bd9Sstevel@tonic-gate my_pg = s = te; 52627c478bd9Sstevel@tonic-gate te = strstr(s, SCF_FMRI_PROPERTY_PREFIX); 52637c478bd9Sstevel@tonic-gate if (te != NULL) { 52647c478bd9Sstevel@tonic-gate *te = 0; 52657c478bd9Sstevel@tonic-gate te += sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1; 52667c478bd9Sstevel@tonic-gate 52677c478bd9Sstevel@tonic-gate my_p = te; 52687c478bd9Sstevel@tonic-gate s = te; 52697c478bd9Sstevel@tonic-gate } 52707c478bd9Sstevel@tonic-gate } 52717c478bd9Sstevel@tonic-gate 52727c478bd9Sstevel@tonic-gate if (my_s != NULL) { 52737c478bd9Sstevel@tonic-gate if (uu_check_name(my_s, UU_NAME_DOMAIN | UU_NAME_PATH) == -1) 52747c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 52757c478bd9Sstevel@tonic-gate 52767c478bd9Sstevel@tonic-gate if (service != NULL) 52777c478bd9Sstevel@tonic-gate *service = my_s; 52787c478bd9Sstevel@tonic-gate } 52797c478bd9Sstevel@tonic-gate 52807c478bd9Sstevel@tonic-gate if (my_i != NULL) { 52817c478bd9Sstevel@tonic-gate if (uu_check_name(my_i, UU_NAME_DOMAIN) == -1) 52827c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 52837c478bd9Sstevel@tonic-gate 52847c478bd9Sstevel@tonic-gate if (instance != NULL) 52857c478bd9Sstevel@tonic-gate *instance = my_i; 52867c478bd9Sstevel@tonic-gate } 52877c478bd9Sstevel@tonic-gate 52887c478bd9Sstevel@tonic-gate if (my_pg != NULL) { 52897c478bd9Sstevel@tonic-gate if (uu_check_name(my_pg, UU_NAME_DOMAIN) == -1) 52907c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 52917c478bd9Sstevel@tonic-gate 52927c478bd9Sstevel@tonic-gate if (propertygroup != NULL) 52937c478bd9Sstevel@tonic-gate *propertygroup = my_pg; 52947c478bd9Sstevel@tonic-gate } 52957c478bd9Sstevel@tonic-gate 52967c478bd9Sstevel@tonic-gate if (my_p != NULL) { 52977c478bd9Sstevel@tonic-gate if (uu_check_name(my_p, UU_NAME_DOMAIN) == -1) 52987c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 52997c478bd9Sstevel@tonic-gate 53007c478bd9Sstevel@tonic-gate if (property != NULL) 53017c478bd9Sstevel@tonic-gate *property = my_p; 53027c478bd9Sstevel@tonic-gate } 53037c478bd9Sstevel@tonic-gate 53047c478bd9Sstevel@tonic-gate return (0); 53057c478bd9Sstevel@tonic-gate } 53067c478bd9Sstevel@tonic-gate 53077c478bd9Sstevel@tonic-gate int 53087c478bd9Sstevel@tonic-gate scf_parse_file_fmri(char *fmri, const char **scope, const char **path) 53097c478bd9Sstevel@tonic-gate { 53107c478bd9Sstevel@tonic-gate char *s, *e, *te; 53117c478bd9Sstevel@tonic-gate 53127c478bd9Sstevel@tonic-gate if (scope != NULL) 53137c478bd9Sstevel@tonic-gate *scope = NULL; 53147c478bd9Sstevel@tonic-gate 53157c478bd9Sstevel@tonic-gate s = fmri; 53167c478bd9Sstevel@tonic-gate e = strchr(s, '\0'); 53177c478bd9Sstevel@tonic-gate 53187c478bd9Sstevel@tonic-gate if (strncmp(s, SCF_FMRI_FILE_PREFIX, 53197c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_FILE_PREFIX) - 1) == 0) 53207c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_FILE_PREFIX) - 1; 53217c478bd9Sstevel@tonic-gate 53227c478bd9Sstevel@tonic-gate if (strncmp(s, SCF_FMRI_SCOPE_PREFIX, 53237c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SCOPE_PREFIX) - 1) == 0) { 53247c478bd9Sstevel@tonic-gate char *my_scope; 53257c478bd9Sstevel@tonic-gate 53267c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_SCOPE_PREFIX) - 1; 53277c478bd9Sstevel@tonic-gate te = strstr(s, SCF_FMRI_SERVICE_PREFIX); 53287c478bd9Sstevel@tonic-gate if (te == NULL) 53297c478bd9Sstevel@tonic-gate te = e; 53307c478bd9Sstevel@tonic-gate 53317c478bd9Sstevel@tonic-gate *te = 0; 53327c478bd9Sstevel@tonic-gate my_scope = s; 53337c478bd9Sstevel@tonic-gate 53347c478bd9Sstevel@tonic-gate s = te; 53357c478bd9Sstevel@tonic-gate 53367c478bd9Sstevel@tonic-gate /* Validate the scope. */ 53377c478bd9Sstevel@tonic-gate if (my_scope[0] != '\0' && 53387c478bd9Sstevel@tonic-gate strcmp(my_scope, SCF_FMRI_LOCAL_SCOPE) != 0) { 53397c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 53407c478bd9Sstevel@tonic-gate } 53417c478bd9Sstevel@tonic-gate 53427c478bd9Sstevel@tonic-gate if (scope != NULL) 53437c478bd9Sstevel@tonic-gate *scope = my_scope; 53447c478bd9Sstevel@tonic-gate } else { 53457c478bd9Sstevel@tonic-gate /* 53467c478bd9Sstevel@tonic-gate * FMRI paths must be absolute 53477c478bd9Sstevel@tonic-gate */ 53487c478bd9Sstevel@tonic-gate if (s[0] != '/') 53497c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 53507c478bd9Sstevel@tonic-gate } 53517c478bd9Sstevel@tonic-gate 53527c478bd9Sstevel@tonic-gate s += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1; 53537c478bd9Sstevel@tonic-gate 53547c478bd9Sstevel@tonic-gate if (s >= e) 53557c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 53567c478bd9Sstevel@tonic-gate 53577c478bd9Sstevel@tonic-gate /* 53587c478bd9Sstevel@tonic-gate * If the user requests it, return the full path of the file. 53597c478bd9Sstevel@tonic-gate */ 53607c478bd9Sstevel@tonic-gate if (path != NULL) { 53617c478bd9Sstevel@tonic-gate assert(s > fmri); 53627c478bd9Sstevel@tonic-gate s[-1] = '/'; 53637c478bd9Sstevel@tonic-gate *path = s - 1; 53647c478bd9Sstevel@tonic-gate } 53657c478bd9Sstevel@tonic-gate 53667c478bd9Sstevel@tonic-gate return (0); 53677c478bd9Sstevel@tonic-gate } 53687c478bd9Sstevel@tonic-gate 53697c478bd9Sstevel@tonic-gate int 53707c478bd9Sstevel@tonic-gate scf_parse_fmri(char *fmri, int *type, const char **scope, const char **service, 53717c478bd9Sstevel@tonic-gate const char **instance, const char **propertygroup, const char **property) 53727c478bd9Sstevel@tonic-gate { 53737c478bd9Sstevel@tonic-gate if (strncmp(fmri, SCF_FMRI_SVC_PREFIX, 53747c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_SVC_PREFIX) - 1) == 0) { 53757c478bd9Sstevel@tonic-gate if (type) 53767c478bd9Sstevel@tonic-gate *type = SCF_FMRI_TYPE_SVC; 53777c478bd9Sstevel@tonic-gate return (scf_parse_svc_fmri(fmri, scope, service, instance, 537876cf44abSjeanm propertygroup, property)); 53797c478bd9Sstevel@tonic-gate } else if (strncmp(fmri, SCF_FMRI_FILE_PREFIX, 53807c478bd9Sstevel@tonic-gate sizeof (SCF_FMRI_FILE_PREFIX) - 1) == 0) { 53817c478bd9Sstevel@tonic-gate if (type) 53827c478bd9Sstevel@tonic-gate *type = SCF_FMRI_TYPE_FILE; 53837c478bd9Sstevel@tonic-gate return (scf_parse_file_fmri(fmri, scope, NULL)); 53847c478bd9Sstevel@tonic-gate } else { 53857c478bd9Sstevel@tonic-gate /* 53867c478bd9Sstevel@tonic-gate * Parse as a svc if the fmri type is not explicitly 53877c478bd9Sstevel@tonic-gate * specified. 53887c478bd9Sstevel@tonic-gate */ 53897c478bd9Sstevel@tonic-gate if (type) 53907c478bd9Sstevel@tonic-gate *type = SCF_FMRI_TYPE_SVC; 53917c478bd9Sstevel@tonic-gate return (scf_parse_svc_fmri(fmri, scope, service, instance, 53927c478bd9Sstevel@tonic-gate propertygroup, property)); 53937c478bd9Sstevel@tonic-gate } 53947c478bd9Sstevel@tonic-gate } 53957c478bd9Sstevel@tonic-gate 53967c478bd9Sstevel@tonic-gate /* 53977c478bd9Sstevel@tonic-gate * Fails with _INVALID_ARGUMENT. fmri and buf may be equal. 53987c478bd9Sstevel@tonic-gate */ 53997c478bd9Sstevel@tonic-gate ssize_t 54007c478bd9Sstevel@tonic-gate scf_canonify_fmri(const char *fmri, char *buf, size_t bufsz) 54017c478bd9Sstevel@tonic-gate { 54027c478bd9Sstevel@tonic-gate const char *scope, *service, *instance, *pg, *property; 54037c478bd9Sstevel@tonic-gate char local[6 * REP_PROTOCOL_NAME_LEN]; 54047c478bd9Sstevel@tonic-gate int r; 54057c478bd9Sstevel@tonic-gate size_t len; 54067c478bd9Sstevel@tonic-gate 54077c478bd9Sstevel@tonic-gate if (strlcpy(local, fmri, sizeof (local)) >= sizeof (local)) { 54087c478bd9Sstevel@tonic-gate /* Should this be CONSTRAINT_VIOLATED? */ 54097c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 54107c478bd9Sstevel@tonic-gate return (-1); 54117c478bd9Sstevel@tonic-gate } 54127c478bd9Sstevel@tonic-gate 54137c478bd9Sstevel@tonic-gate 54147c478bd9Sstevel@tonic-gate r = scf_parse_svc_fmri(local, &scope, &service, &instance, &pg, 54157c478bd9Sstevel@tonic-gate &property); 54167c478bd9Sstevel@tonic-gate if (r != 0) 54177c478bd9Sstevel@tonic-gate return (-1); 54187c478bd9Sstevel@tonic-gate 54197c478bd9Sstevel@tonic-gate len = strlcpy(buf, "svc:/", bufsz); 54207c478bd9Sstevel@tonic-gate 54217c478bd9Sstevel@tonic-gate if (scope != NULL && strcmp(scope, SCF_SCOPE_LOCAL) != 0) { 54227c478bd9Sstevel@tonic-gate len += strlcat(buf, "/", bufsz); 54237c478bd9Sstevel@tonic-gate len += strlcat(buf, scope, bufsz); 54247c478bd9Sstevel@tonic-gate } 54257c478bd9Sstevel@tonic-gate 54267c478bd9Sstevel@tonic-gate if (service) 54277c478bd9Sstevel@tonic-gate len += strlcat(buf, service, bufsz); 54287c478bd9Sstevel@tonic-gate 54297c478bd9Sstevel@tonic-gate if (instance) { 54307c478bd9Sstevel@tonic-gate len += strlcat(buf, ":", bufsz); 54317c478bd9Sstevel@tonic-gate len += strlcat(buf, instance, bufsz); 54327c478bd9Sstevel@tonic-gate } 54337c478bd9Sstevel@tonic-gate 54347c478bd9Sstevel@tonic-gate if (pg) { 54357c478bd9Sstevel@tonic-gate len += strlcat(buf, "/:properties/", bufsz); 54367c478bd9Sstevel@tonic-gate len += strlcat(buf, pg, bufsz); 54377c478bd9Sstevel@tonic-gate } 54387c478bd9Sstevel@tonic-gate 54397c478bd9Sstevel@tonic-gate if (property) { 54407c478bd9Sstevel@tonic-gate len += strlcat(buf, "/", bufsz); 54417c478bd9Sstevel@tonic-gate len += strlcat(buf, property, bufsz); 54427c478bd9Sstevel@tonic-gate } 54437c478bd9Sstevel@tonic-gate 54447c478bd9Sstevel@tonic-gate return (len); 54457c478bd9Sstevel@tonic-gate } 54467c478bd9Sstevel@tonic-gate 544776cf44abSjeanm /* 544876cf44abSjeanm * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _CONSTRAINT_VIOLATED, 544976cf44abSjeanm * _NOT_FOUND, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, 545076cf44abSjeanm * _NO_RESOURCES, _BACKEND_ACCESS. 545176cf44abSjeanm */ 54527c478bd9Sstevel@tonic-gate int 54537c478bd9Sstevel@tonic-gate scf_handle_decode_fmri(scf_handle_t *h, const char *fmri, scf_scope_t *sc, 54547c478bd9Sstevel@tonic-gate scf_service_t *svc, scf_instance_t *inst, scf_propertygroup_t *pg, 54557c478bd9Sstevel@tonic-gate scf_property_t *prop, int flags) 54567c478bd9Sstevel@tonic-gate { 54577c478bd9Sstevel@tonic-gate const char *scope, *service, *instance, *propertygroup, *property; 54587c478bd9Sstevel@tonic-gate int last; 54597c478bd9Sstevel@tonic-gate char local[6 * REP_PROTOCOL_NAME_LEN]; 54607c478bd9Sstevel@tonic-gate int ret; 54617c478bd9Sstevel@tonic-gate const uint32_t holds = RH_HOLD_SCOPE | RH_HOLD_SERVICE | 54627c478bd9Sstevel@tonic-gate RH_HOLD_INSTANCE | RH_HOLD_PG | RH_HOLD_PROPERTY; 54637c478bd9Sstevel@tonic-gate 54647c478bd9Sstevel@tonic-gate /* 54657c478bd9Sstevel@tonic-gate * verify that all handles match 54667c478bd9Sstevel@tonic-gate */ 54677c478bd9Sstevel@tonic-gate if ((sc != NULL && h != sc->rd_d.rd_handle) || 54687c478bd9Sstevel@tonic-gate (svc != NULL && h != svc->rd_d.rd_handle) || 54697c478bd9Sstevel@tonic-gate (inst != NULL && h != inst->rd_d.rd_handle) || 54707c478bd9Sstevel@tonic-gate (pg != NULL && h != pg->rd_d.rd_handle) || 54717c478bd9Sstevel@tonic-gate (prop != NULL && h != prop->rd_d.rd_handle)) 54727c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 54737c478bd9Sstevel@tonic-gate 54747c478bd9Sstevel@tonic-gate if (strlcpy(local, fmri, sizeof (local)) >= sizeof (local)) { 54757c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_INVALID_ARGUMENT); 54767c478bd9Sstevel@tonic-gate goto reset_args; 54777c478bd9Sstevel@tonic-gate } 54787c478bd9Sstevel@tonic-gate 54797c478bd9Sstevel@tonic-gate /* 54807c478bd9Sstevel@tonic-gate * We can simply return from an error in parsing, because 54817c478bd9Sstevel@tonic-gate * scf_parse_fmri sets the error code correctly. 54827c478bd9Sstevel@tonic-gate */ 54837c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(local, &scope, &service, &instance, 54847c478bd9Sstevel@tonic-gate &propertygroup, &property) == -1) { 54857c478bd9Sstevel@tonic-gate ret = -1; 54867c478bd9Sstevel@tonic-gate goto reset_args; 54877c478bd9Sstevel@tonic-gate } 54887c478bd9Sstevel@tonic-gate 54897c478bd9Sstevel@tonic-gate /* 54907c478bd9Sstevel@tonic-gate * the FMRI looks valid at this point -- do constraint checks. 54917c478bd9Sstevel@tonic-gate */ 54927c478bd9Sstevel@tonic-gate 54937c478bd9Sstevel@tonic-gate if (instance != NULL && (flags & SCF_DECODE_FMRI_REQUIRE_NO_INSTANCE)) { 54947c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED); 54957c478bd9Sstevel@tonic-gate goto reset_args; 54967c478bd9Sstevel@tonic-gate } 54977c478bd9Sstevel@tonic-gate if (instance == NULL && (flags & SCF_DECODE_FMRI_REQUIRE_INSTANCE)) { 54987c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED); 54997c478bd9Sstevel@tonic-gate goto reset_args; 55007c478bd9Sstevel@tonic-gate } 55017c478bd9Sstevel@tonic-gate 55027c478bd9Sstevel@tonic-gate if (prop != NULL) 55037c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_PROPERTY; 55047c478bd9Sstevel@tonic-gate else if (pg != NULL) 55057c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_PROPERTYGRP; 55067c478bd9Sstevel@tonic-gate else if (inst != NULL) 55077c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_INSTANCE; 55087c478bd9Sstevel@tonic-gate else if (svc != NULL) 55097c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_SERVICE; 55107c478bd9Sstevel@tonic-gate else if (sc != NULL) 55117c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_SCOPE; 55127c478bd9Sstevel@tonic-gate else 55137c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_NONE; 55147c478bd9Sstevel@tonic-gate 55157c478bd9Sstevel@tonic-gate if (flags & SCF_DECODE_FMRI_EXACT) { 55167c478bd9Sstevel@tonic-gate int last_fmri; 55177c478bd9Sstevel@tonic-gate 55187c478bd9Sstevel@tonic-gate if (property != NULL) 55197c478bd9Sstevel@tonic-gate last_fmri = REP_PROTOCOL_ENTITY_PROPERTY; 55207c478bd9Sstevel@tonic-gate else if (propertygroup != NULL) 55217c478bd9Sstevel@tonic-gate last_fmri = REP_PROTOCOL_ENTITY_PROPERTYGRP; 55227c478bd9Sstevel@tonic-gate else if (instance != NULL) 55237c478bd9Sstevel@tonic-gate last_fmri = REP_PROTOCOL_ENTITY_INSTANCE; 55247c478bd9Sstevel@tonic-gate else if (service != NULL) 55257c478bd9Sstevel@tonic-gate last_fmri = REP_PROTOCOL_ENTITY_SERVICE; 55267c478bd9Sstevel@tonic-gate else if (scope != NULL) 55277c478bd9Sstevel@tonic-gate last_fmri = REP_PROTOCOL_ENTITY_SCOPE; 55287c478bd9Sstevel@tonic-gate else 55297c478bd9Sstevel@tonic-gate last_fmri = REP_PROTOCOL_ENTITY_NONE; 55307c478bd9Sstevel@tonic-gate 55317c478bd9Sstevel@tonic-gate if (last != last_fmri) { 55327c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED); 55337c478bd9Sstevel@tonic-gate goto reset_args; 55347c478bd9Sstevel@tonic-gate } 55357c478bd9Sstevel@tonic-gate } 55367c478bd9Sstevel@tonic-gate 55377c478bd9Sstevel@tonic-gate if ((flags & SCF_DECODE_FMRI_TRUNCATE) && 55387c478bd9Sstevel@tonic-gate last == REP_PROTOCOL_ENTITY_NONE) { 55397c478bd9Sstevel@tonic-gate ret = 0; /* nothing to do */ 55407c478bd9Sstevel@tonic-gate goto reset_args; 55417c478bd9Sstevel@tonic-gate } 55427c478bd9Sstevel@tonic-gate 55437c478bd9Sstevel@tonic-gate if (!(flags & SCF_DECODE_FMRI_TRUNCATE)) 55447c478bd9Sstevel@tonic-gate last = REP_PROTOCOL_ENTITY_NONE; /* never stop */ 55457c478bd9Sstevel@tonic-gate 55467c478bd9Sstevel@tonic-gate /* 55477c478bd9Sstevel@tonic-gate * passed the constraint checks -- try to grab the thing itself. 55487c478bd9Sstevel@tonic-gate */ 55497c478bd9Sstevel@tonic-gate 55507c478bd9Sstevel@tonic-gate handle_hold_subhandles(h, holds); 55517c478bd9Sstevel@tonic-gate if (sc == NULL) 55527c478bd9Sstevel@tonic-gate sc = h->rh_scope; 55537c478bd9Sstevel@tonic-gate else 55547c478bd9Sstevel@tonic-gate datael_reset(&sc->rd_d); 55557c478bd9Sstevel@tonic-gate 55567c478bd9Sstevel@tonic-gate if (svc == NULL) 55577c478bd9Sstevel@tonic-gate svc = h->rh_service; 55587c478bd9Sstevel@tonic-gate else 55597c478bd9Sstevel@tonic-gate datael_reset(&svc->rd_d); 55607c478bd9Sstevel@tonic-gate 55617c478bd9Sstevel@tonic-gate if (inst == NULL) 55627c478bd9Sstevel@tonic-gate inst = h->rh_instance; 55637c478bd9Sstevel@tonic-gate else 55647c478bd9Sstevel@tonic-gate datael_reset(&inst->rd_d); 55657c478bd9Sstevel@tonic-gate 55667c478bd9Sstevel@tonic-gate if (pg == NULL) 55677c478bd9Sstevel@tonic-gate pg = h->rh_pg; 55687c478bd9Sstevel@tonic-gate else 55697c478bd9Sstevel@tonic-gate datael_reset(&pg->rd_d); 55707c478bd9Sstevel@tonic-gate 55717c478bd9Sstevel@tonic-gate if (prop == NULL) 55727c478bd9Sstevel@tonic-gate prop = h->rh_property; 55737c478bd9Sstevel@tonic-gate else 55747c478bd9Sstevel@tonic-gate datael_reset(&prop->rd_d); 55757c478bd9Sstevel@tonic-gate 55767c478bd9Sstevel@tonic-gate /* 55777c478bd9Sstevel@tonic-gate * We only support local scopes, but we check *after* getting 55787c478bd9Sstevel@tonic-gate * the local scope, so that any repository-related errors take 55797c478bd9Sstevel@tonic-gate * precedence. 55807c478bd9Sstevel@tonic-gate */ 55817c478bd9Sstevel@tonic-gate if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, sc) == -1) { 55827c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 55837c478bd9Sstevel@tonic-gate ret = -1; 55847c478bd9Sstevel@tonic-gate goto reset_args; 55857c478bd9Sstevel@tonic-gate } 55867c478bd9Sstevel@tonic-gate 55877c478bd9Sstevel@tonic-gate if (scope != NULL && strcmp(scope, SCF_FMRI_LOCAL_SCOPE) != 0) { 55887c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 55897c478bd9Sstevel@tonic-gate ret = scf_set_error(SCF_ERROR_NOT_FOUND); 55907c478bd9Sstevel@tonic-gate goto reset_args; 55917c478bd9Sstevel@tonic-gate } 55927c478bd9Sstevel@tonic-gate 55937c478bd9Sstevel@tonic-gate 55947c478bd9Sstevel@tonic-gate if (service == NULL || last == REP_PROTOCOL_ENTITY_SCOPE) { 55957c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 55967c478bd9Sstevel@tonic-gate return (0); 55977c478bd9Sstevel@tonic-gate } 55987c478bd9Sstevel@tonic-gate 55997c478bd9Sstevel@tonic-gate if (scf_scope_get_service(sc, service, svc) == -1) { 56007c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56017c478bd9Sstevel@tonic-gate ret = -1; 56027c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_NOT_SET); 56037c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 56047c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NOT_FOUND); 56057c478bd9Sstevel@tonic-gate goto reset_args; 56067c478bd9Sstevel@tonic-gate } 56077c478bd9Sstevel@tonic-gate 56087c478bd9Sstevel@tonic-gate if (last == REP_PROTOCOL_ENTITY_SERVICE) { 56097c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56107c478bd9Sstevel@tonic-gate return (0); 56117c478bd9Sstevel@tonic-gate } 56127c478bd9Sstevel@tonic-gate 56137c478bd9Sstevel@tonic-gate if (instance == NULL) { 56147c478bd9Sstevel@tonic-gate if (propertygroup == NULL || 56157c478bd9Sstevel@tonic-gate last == REP_PROTOCOL_ENTITY_INSTANCE) { 56167c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56177c478bd9Sstevel@tonic-gate return (0); 56187c478bd9Sstevel@tonic-gate } 56197c478bd9Sstevel@tonic-gate 56207c478bd9Sstevel@tonic-gate if (scf_service_get_pg(svc, propertygroup, pg) == -1) { 56217c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56227c478bd9Sstevel@tonic-gate ret = -1; 56237c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_NOT_SET); 56247c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 56257c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NOT_FOUND); 56267c478bd9Sstevel@tonic-gate goto reset_args; 56277c478bd9Sstevel@tonic-gate } 56287c478bd9Sstevel@tonic-gate } else { 56297c478bd9Sstevel@tonic-gate if (scf_service_get_instance(svc, instance, inst) == -1) { 56307c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56317c478bd9Sstevel@tonic-gate ret = -1; 56327c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_NOT_SET); 56337c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 56347c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NOT_FOUND); 56357c478bd9Sstevel@tonic-gate goto reset_args; 56367c478bd9Sstevel@tonic-gate } 56377c478bd9Sstevel@tonic-gate 56387c478bd9Sstevel@tonic-gate if (propertygroup == NULL || 56397c478bd9Sstevel@tonic-gate last == REP_PROTOCOL_ENTITY_INSTANCE) { 56407c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56417c478bd9Sstevel@tonic-gate return (0); 56427c478bd9Sstevel@tonic-gate } 56437c478bd9Sstevel@tonic-gate 56447c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, propertygroup, pg) == -1) { 56457c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56467c478bd9Sstevel@tonic-gate ret = -1; 56477c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_NOT_SET); 56487c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 56497c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NOT_FOUND); 56507c478bd9Sstevel@tonic-gate goto reset_args; 56517c478bd9Sstevel@tonic-gate } 56527c478bd9Sstevel@tonic-gate } 56537c478bd9Sstevel@tonic-gate 56547c478bd9Sstevel@tonic-gate if (property == NULL || last == REP_PROTOCOL_ENTITY_PROPERTYGRP) { 56557c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56567c478bd9Sstevel@tonic-gate return (0); 56577c478bd9Sstevel@tonic-gate } 56587c478bd9Sstevel@tonic-gate 56597c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, property, prop) == -1) { 56607c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56617c478bd9Sstevel@tonic-gate ret = -1; 56627c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_NOT_SET); 56637c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 56647c478bd9Sstevel@tonic-gate (void) scf_set_error(SCF_ERROR_NOT_FOUND); 56657c478bd9Sstevel@tonic-gate goto reset_args; 56667c478bd9Sstevel@tonic-gate } 56677c478bd9Sstevel@tonic-gate 56687c478bd9Sstevel@tonic-gate handle_rele_subhandles(h, holds); 56697c478bd9Sstevel@tonic-gate return (0); 56707c478bd9Sstevel@tonic-gate 56717c478bd9Sstevel@tonic-gate reset_args: 56727c478bd9Sstevel@tonic-gate if (sc != NULL) 56737c478bd9Sstevel@tonic-gate datael_reset(&sc->rd_d); 56747c478bd9Sstevel@tonic-gate if (svc != NULL) 56757c478bd9Sstevel@tonic-gate datael_reset(&svc->rd_d); 56767c478bd9Sstevel@tonic-gate if (inst != NULL) 56777c478bd9Sstevel@tonic-gate datael_reset(&inst->rd_d); 56787c478bd9Sstevel@tonic-gate if (pg != NULL) 56797c478bd9Sstevel@tonic-gate datael_reset(&pg->rd_d); 56807c478bd9Sstevel@tonic-gate if (prop != NULL) 56817c478bd9Sstevel@tonic-gate datael_reset(&prop->rd_d); 56827c478bd9Sstevel@tonic-gate 56837c478bd9Sstevel@tonic-gate return (ret); 56847c478bd9Sstevel@tonic-gate } 56857c478bd9Sstevel@tonic-gate 56867c478bd9Sstevel@tonic-gate /* 56877c478bd9Sstevel@tonic-gate * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too 56887c478bd9Sstevel@tonic-gate * big, bad entity id, request not applicable to entity, name too long for 56897c478bd9Sstevel@tonic-gate * buffer), _NOT_SET, or _DELETED. 56907c478bd9Sstevel@tonic-gate */ 56917c478bd9Sstevel@tonic-gate ssize_t 56927c478bd9Sstevel@tonic-gate scf_scope_to_fmri(const scf_scope_t *scope, char *out, size_t sz) 56937c478bd9Sstevel@tonic-gate { 56947c478bd9Sstevel@tonic-gate ssize_t r, len; 56957c478bd9Sstevel@tonic-gate 56967c478bd9Sstevel@tonic-gate char tmp[REP_PROTOCOL_NAME_LEN]; 56977c478bd9Sstevel@tonic-gate 56987c478bd9Sstevel@tonic-gate r = scf_scope_get_name(scope, tmp, sizeof (tmp)); 56997c478bd9Sstevel@tonic-gate 57007c478bd9Sstevel@tonic-gate if (r <= 0) 57017c478bd9Sstevel@tonic-gate return (r); 57027c478bd9Sstevel@tonic-gate 57037c478bd9Sstevel@tonic-gate len = strlcpy(out, SCF_FMRI_SVC_PREFIX, sz); 57047c478bd9Sstevel@tonic-gate if (strcmp(tmp, SCF_FMRI_LOCAL_SCOPE) != 0) { 57057c478bd9Sstevel@tonic-gate if (len >= sz) 57067c478bd9Sstevel@tonic-gate return (len + r + sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1); 57077c478bd9Sstevel@tonic-gate 57087c478bd9Sstevel@tonic-gate len = strlcat(out, tmp, sz); 57097c478bd9Sstevel@tonic-gate if (len >= sz) 57107c478bd9Sstevel@tonic-gate return (len + sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1); 57117c478bd9Sstevel@tonic-gate len = strlcat(out, 57127c478bd9Sstevel@tonic-gate SCF_FMRI_SCOPE_SUFFIX SCF_FMRI_SERVICE_PREFIX, sz); 57137c478bd9Sstevel@tonic-gate } 57147c478bd9Sstevel@tonic-gate 57157c478bd9Sstevel@tonic-gate return (len); 57167c478bd9Sstevel@tonic-gate } 57177c478bd9Sstevel@tonic-gate 57187c478bd9Sstevel@tonic-gate /* 57197c478bd9Sstevel@tonic-gate * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too 57207c478bd9Sstevel@tonic-gate * big, bad element id, bad ids, bad types, scope has no parent, request not 57217c478bd9Sstevel@tonic-gate * applicable to entity, name too long), _NOT_SET, _DELETED, 57227c478bd9Sstevel@tonic-gate */ 57237c478bd9Sstevel@tonic-gate ssize_t 57247c478bd9Sstevel@tonic-gate scf_service_to_fmri(const scf_service_t *svc, char *out, size_t sz) 57257c478bd9Sstevel@tonic-gate { 57267c478bd9Sstevel@tonic-gate scf_handle_t *h = svc->rd_d.rd_handle; 57277c478bd9Sstevel@tonic-gate scf_scope_t *scope = HANDLE_HOLD_SCOPE(h); 57287c478bd9Sstevel@tonic-gate ssize_t r, len; 57297c478bd9Sstevel@tonic-gate 57307c478bd9Sstevel@tonic-gate char tmp[REP_PROTOCOL_NAME_LEN]; 57317c478bd9Sstevel@tonic-gate 57327c478bd9Sstevel@tonic-gate r = datael_get_parent(&svc->rd_d, &scope->rd_d); 57337c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) { 57347c478bd9Sstevel@tonic-gate HANDLE_RELE_SCOPE(h); 57357c478bd9Sstevel@tonic-gate 57367c478bd9Sstevel@tonic-gate assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH); 57377c478bd9Sstevel@tonic-gate return (-1); 57387c478bd9Sstevel@tonic-gate } 57397c478bd9Sstevel@tonic-gate if (out != NULL && sz > 0) 57407c478bd9Sstevel@tonic-gate len = scf_scope_to_fmri(scope, out, sz); 57417c478bd9Sstevel@tonic-gate else 57427c478bd9Sstevel@tonic-gate len = scf_scope_to_fmri(scope, tmp, 2); 57437c478bd9Sstevel@tonic-gate 57447c478bd9Sstevel@tonic-gate HANDLE_RELE_SCOPE(h); 57457c478bd9Sstevel@tonic-gate 57467c478bd9Sstevel@tonic-gate if (len < 0) 57477c478bd9Sstevel@tonic-gate return (-1); 57487c478bd9Sstevel@tonic-gate 57497c478bd9Sstevel@tonic-gate if (out == NULL || len >= sz) 57507c478bd9Sstevel@tonic-gate len += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1; 57517c478bd9Sstevel@tonic-gate else 57527c478bd9Sstevel@tonic-gate len = strlcat(out, SCF_FMRI_SERVICE_PREFIX, sz); 57537c478bd9Sstevel@tonic-gate 57547c478bd9Sstevel@tonic-gate r = scf_service_get_name(svc, tmp, sizeof (tmp)); 57557c478bd9Sstevel@tonic-gate if (r < 0) 57567c478bd9Sstevel@tonic-gate return (r); 57577c478bd9Sstevel@tonic-gate 57587c478bd9Sstevel@tonic-gate if (out == NULL || len >= sz) 57597c478bd9Sstevel@tonic-gate len += r; 57607c478bd9Sstevel@tonic-gate else 57617c478bd9Sstevel@tonic-gate len = strlcat(out, tmp, sz); 57627c478bd9Sstevel@tonic-gate 57637c478bd9Sstevel@tonic-gate return (len); 57647c478bd9Sstevel@tonic-gate } 57657c478bd9Sstevel@tonic-gate 57667c478bd9Sstevel@tonic-gate ssize_t 57677c478bd9Sstevel@tonic-gate scf_instance_to_fmri(const scf_instance_t *inst, char *out, size_t sz) 57687c478bd9Sstevel@tonic-gate { 57697c478bd9Sstevel@tonic-gate scf_handle_t *h = inst->rd_d.rd_handle; 57707c478bd9Sstevel@tonic-gate scf_service_t *svc = HANDLE_HOLD_SERVICE(h); 57717c478bd9Sstevel@tonic-gate ssize_t r, len; 57727c478bd9Sstevel@tonic-gate 57737c478bd9Sstevel@tonic-gate char tmp[REP_PROTOCOL_NAME_LEN]; 57747c478bd9Sstevel@tonic-gate 57757c478bd9Sstevel@tonic-gate r = datael_get_parent(&inst->rd_d, &svc->rd_d); 57767c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) { 57777c478bd9Sstevel@tonic-gate HANDLE_RELE_SERVICE(h); 57787c478bd9Sstevel@tonic-gate return (-1); 57797c478bd9Sstevel@tonic-gate } 57807c478bd9Sstevel@tonic-gate 57817c478bd9Sstevel@tonic-gate len = scf_service_to_fmri(svc, out, sz); 57827c478bd9Sstevel@tonic-gate 57837c478bd9Sstevel@tonic-gate HANDLE_RELE_SERVICE(h); 57847c478bd9Sstevel@tonic-gate 57857c478bd9Sstevel@tonic-gate if (len < 0) 57867c478bd9Sstevel@tonic-gate return (len); 57877c478bd9Sstevel@tonic-gate 57887c478bd9Sstevel@tonic-gate if (len >= sz) 57897c478bd9Sstevel@tonic-gate len += sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1; 57907c478bd9Sstevel@tonic-gate else 57917c478bd9Sstevel@tonic-gate len = strlcat(out, SCF_FMRI_INSTANCE_PREFIX, sz); 57927c478bd9Sstevel@tonic-gate 57937c478bd9Sstevel@tonic-gate r = scf_instance_get_name(inst, tmp, sizeof (tmp)); 57947c478bd9Sstevel@tonic-gate if (r < 0) 57957c478bd9Sstevel@tonic-gate return (r); 57967c478bd9Sstevel@tonic-gate 57977c478bd9Sstevel@tonic-gate if (len >= sz) 57987c478bd9Sstevel@tonic-gate len += r; 57997c478bd9Sstevel@tonic-gate else 58007c478bd9Sstevel@tonic-gate len = strlcat(out, tmp, sz); 58017c478bd9Sstevel@tonic-gate 58027c478bd9Sstevel@tonic-gate return (len); 58037c478bd9Sstevel@tonic-gate } 58047c478bd9Sstevel@tonic-gate 58057c478bd9Sstevel@tonic-gate ssize_t 58067c478bd9Sstevel@tonic-gate scf_pg_to_fmri(const scf_propertygroup_t *pg, char *out, size_t sz) 58077c478bd9Sstevel@tonic-gate { 58087c478bd9Sstevel@tonic-gate scf_handle_t *h = pg->rd_d.rd_handle; 58097c478bd9Sstevel@tonic-gate 58107c478bd9Sstevel@tonic-gate struct rep_protocol_entity_parent_type request; 58117c478bd9Sstevel@tonic-gate struct rep_protocol_integer_response response; 58127c478bd9Sstevel@tonic-gate 58137c478bd9Sstevel@tonic-gate char tmp[REP_PROTOCOL_NAME_LEN]; 58147c478bd9Sstevel@tonic-gate ssize_t len, r; 58157c478bd9Sstevel@tonic-gate 58167c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 58177c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_ENTITY_PARENT_TYPE; 58187c478bd9Sstevel@tonic-gate request.rpr_entityid = pg->rd_d.rd_entity; 58197c478bd9Sstevel@tonic-gate 58207c478bd9Sstevel@tonic-gate datael_finish_reset(&pg->rd_d); 58217c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 58227c478bd9Sstevel@tonic-gate &response, sizeof (response)); 58237c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 58247c478bd9Sstevel@tonic-gate 58257c478bd9Sstevel@tonic-gate if (r < 0) 58267c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 58277c478bd9Sstevel@tonic-gate 58287c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS || 58297c478bd9Sstevel@tonic-gate r < sizeof (response)) { 58307c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 58317c478bd9Sstevel@tonic-gate } 58327c478bd9Sstevel@tonic-gate 58337c478bd9Sstevel@tonic-gate switch (response.rpr_value) { 58347c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SERVICE: { 58357c478bd9Sstevel@tonic-gate scf_service_t *svc; 58367c478bd9Sstevel@tonic-gate 58377c478bd9Sstevel@tonic-gate svc = HANDLE_HOLD_SERVICE(h); 58387c478bd9Sstevel@tonic-gate 58397c478bd9Sstevel@tonic-gate r = datael_get_parent(&pg->rd_d, &svc->rd_d); 58407c478bd9Sstevel@tonic-gate 58417c478bd9Sstevel@tonic-gate if (r == SCF_SUCCESS) 58427c478bd9Sstevel@tonic-gate len = scf_service_to_fmri(svc, out, sz); 58437c478bd9Sstevel@tonic-gate 58447c478bd9Sstevel@tonic-gate HANDLE_RELE_SERVICE(h); 58457c478bd9Sstevel@tonic-gate break; 58467c478bd9Sstevel@tonic-gate } 58477c478bd9Sstevel@tonic-gate 58487c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_INSTANCE: { 58497c478bd9Sstevel@tonic-gate scf_instance_t *inst; 58507c478bd9Sstevel@tonic-gate 58517c478bd9Sstevel@tonic-gate inst = HANDLE_HOLD_INSTANCE(h); 58527c478bd9Sstevel@tonic-gate 58537c478bd9Sstevel@tonic-gate r = datael_get_parent(&pg->rd_d, &inst->rd_d); 58547c478bd9Sstevel@tonic-gate 58557c478bd9Sstevel@tonic-gate if (r == SCF_SUCCESS) 58567c478bd9Sstevel@tonic-gate len = scf_instance_to_fmri(inst, out, sz); 58577c478bd9Sstevel@tonic-gate 58587c478bd9Sstevel@tonic-gate HANDLE_RELE_INSTANCE(h); 58597c478bd9Sstevel@tonic-gate break; 58607c478bd9Sstevel@tonic-gate } 58617c478bd9Sstevel@tonic-gate 58627c478bd9Sstevel@tonic-gate case REP_PROTOCOL_ENTITY_SNAPLEVEL: { 58637c478bd9Sstevel@tonic-gate scf_instance_t *inst = HANDLE_HOLD_INSTANCE(h); 58647c478bd9Sstevel@tonic-gate scf_snapshot_t *snap = HANDLE_HOLD_SNAPSHOT(h); 58657c478bd9Sstevel@tonic-gate scf_snaplevel_t *level = HANDLE_HOLD_SNAPLVL(h); 58667c478bd9Sstevel@tonic-gate 58677c478bd9Sstevel@tonic-gate r = datael_get_parent(&pg->rd_d, &level->rd_d); 58687c478bd9Sstevel@tonic-gate 58697c478bd9Sstevel@tonic-gate if (r == SCF_SUCCESS) 58707c478bd9Sstevel@tonic-gate r = datael_get_parent(&level->rd_d, &snap->rd_d); 58717c478bd9Sstevel@tonic-gate 58727c478bd9Sstevel@tonic-gate if (r == SCF_SUCCESS) 58737c478bd9Sstevel@tonic-gate r = datael_get_parent(&snap->rd_d, &inst->rd_d); 58747c478bd9Sstevel@tonic-gate 58757c478bd9Sstevel@tonic-gate if (r == SCF_SUCCESS) 58767c478bd9Sstevel@tonic-gate len = scf_instance_to_fmri(inst, out, sz); 58777c478bd9Sstevel@tonic-gate 58787c478bd9Sstevel@tonic-gate HANDLE_RELE_INSTANCE(h); 58797c478bd9Sstevel@tonic-gate HANDLE_RELE_SNAPSHOT(h); 58807c478bd9Sstevel@tonic-gate HANDLE_RELE_SNAPLVL(h); 58817c478bd9Sstevel@tonic-gate break; 58827c478bd9Sstevel@tonic-gate } 58837c478bd9Sstevel@tonic-gate 58847c478bd9Sstevel@tonic-gate default: 58857c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INTERNAL)); 58867c478bd9Sstevel@tonic-gate } 58877c478bd9Sstevel@tonic-gate 58887c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) 58897c478bd9Sstevel@tonic-gate return (r); 58907c478bd9Sstevel@tonic-gate 58917c478bd9Sstevel@tonic-gate if (len >= sz) 58927c478bd9Sstevel@tonic-gate len += sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1; 58937c478bd9Sstevel@tonic-gate else 58947c478bd9Sstevel@tonic-gate len = strlcat(out, SCF_FMRI_PROPERTYGRP_PREFIX, sz); 58957c478bd9Sstevel@tonic-gate 58967c478bd9Sstevel@tonic-gate r = scf_pg_get_name(pg, tmp, sizeof (tmp)); 58977c478bd9Sstevel@tonic-gate 58987c478bd9Sstevel@tonic-gate if (r < 0) 58997c478bd9Sstevel@tonic-gate return (r); 59007c478bd9Sstevel@tonic-gate 59017c478bd9Sstevel@tonic-gate if (len >= sz) 59027c478bd9Sstevel@tonic-gate len += r; 59037c478bd9Sstevel@tonic-gate else 59047c478bd9Sstevel@tonic-gate len = strlcat(out, tmp, sz); 59057c478bd9Sstevel@tonic-gate 59067c478bd9Sstevel@tonic-gate return (len); 59077c478bd9Sstevel@tonic-gate } 59087c478bd9Sstevel@tonic-gate 59097c478bd9Sstevel@tonic-gate ssize_t 59107c478bd9Sstevel@tonic-gate scf_property_to_fmri(const scf_property_t *prop, char *out, size_t sz) 59117c478bd9Sstevel@tonic-gate { 59127c478bd9Sstevel@tonic-gate scf_handle_t *h = prop->rd_d.rd_handle; 59137c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = HANDLE_HOLD_PG(h); 59147c478bd9Sstevel@tonic-gate 59157c478bd9Sstevel@tonic-gate char tmp[REP_PROTOCOL_NAME_LEN]; 59167c478bd9Sstevel@tonic-gate ssize_t len; 59177c478bd9Sstevel@tonic-gate int r; 59187c478bd9Sstevel@tonic-gate 59197c478bd9Sstevel@tonic-gate r = datael_get_parent(&prop->rd_d, &pg->rd_d); 59207c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) { 59217c478bd9Sstevel@tonic-gate HANDLE_RELE_PG(h); 59227c478bd9Sstevel@tonic-gate return (-1); 59237c478bd9Sstevel@tonic-gate } 59247c478bd9Sstevel@tonic-gate 59257c478bd9Sstevel@tonic-gate len = scf_pg_to_fmri(pg, out, sz); 59267c478bd9Sstevel@tonic-gate 59277c478bd9Sstevel@tonic-gate HANDLE_RELE_PG(h); 59287c478bd9Sstevel@tonic-gate 59297c478bd9Sstevel@tonic-gate if (len >= sz) 59307c478bd9Sstevel@tonic-gate len += sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1; 59317c478bd9Sstevel@tonic-gate else 59327c478bd9Sstevel@tonic-gate len = strlcat(out, SCF_FMRI_PROPERTY_PREFIX, sz); 59337c478bd9Sstevel@tonic-gate 59347c478bd9Sstevel@tonic-gate r = scf_property_get_name(prop, tmp, sizeof (tmp)); 59357c478bd9Sstevel@tonic-gate 59367c478bd9Sstevel@tonic-gate if (r < 0) 59377c478bd9Sstevel@tonic-gate return (r); 59387c478bd9Sstevel@tonic-gate 59397c478bd9Sstevel@tonic-gate if (len >= sz) 59407c478bd9Sstevel@tonic-gate len += r; 59417c478bd9Sstevel@tonic-gate else 59427c478bd9Sstevel@tonic-gate len = strlcat(out, tmp, sz); 59437c478bd9Sstevel@tonic-gate 59447c478bd9Sstevel@tonic-gate return (len); 59457c478bd9Sstevel@tonic-gate } 59467c478bd9Sstevel@tonic-gate 594776cf44abSjeanm /* 594876cf44abSjeanm * Fails with _HANDLE_MISMATCH, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL 594976cf44abSjeanm * (server response too big, bad entity id, request not applicable to entity, 595076cf44abSjeanm * name too long for buffer, bad element id, iter already exists, element 595176cf44abSjeanm * cannot have children of type, type is invalid, iter was reset, sequence 595276cf44abSjeanm * was bad, iter walks values, iter does not walk type entities), 595376cf44abSjeanm * _NOT_SET, _DELETED, or _CONSTRAINT_VIOLATED, 595476cf44abSjeanm * _NOT_FOUND (scope has no parent), _INVALID_ARGUMENT, _NO_RESOURCES, 595576cf44abSjeanm * _BACKEND_ACCESS. 595676cf44abSjeanm */ 59577c478bd9Sstevel@tonic-gate int 59587c478bd9Sstevel@tonic-gate scf_pg_get_underlying_pg(const scf_propertygroup_t *pg, 59597c478bd9Sstevel@tonic-gate scf_propertygroup_t *out) 59607c478bd9Sstevel@tonic-gate { 59617c478bd9Sstevel@tonic-gate scf_handle_t *h = pg->rd_d.rd_handle; 59627c478bd9Sstevel@tonic-gate scf_service_t *svc; 59637c478bd9Sstevel@tonic-gate scf_instance_t *inst; 59647c478bd9Sstevel@tonic-gate 59657c478bd9Sstevel@tonic-gate char me[REP_PROTOCOL_NAME_LEN]; 59667c478bd9Sstevel@tonic-gate int r; 59677c478bd9Sstevel@tonic-gate 59687c478bd9Sstevel@tonic-gate if (h != out->rd_d.rd_handle) 59697c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH)); 59707c478bd9Sstevel@tonic-gate 59717c478bd9Sstevel@tonic-gate r = scf_pg_get_name(pg, me, sizeof (me)); 59727c478bd9Sstevel@tonic-gate 59737c478bd9Sstevel@tonic-gate if (r < 0) 59747c478bd9Sstevel@tonic-gate return (r); 59757c478bd9Sstevel@tonic-gate 59767c478bd9Sstevel@tonic-gate svc = HANDLE_HOLD_SERVICE(h); 59777c478bd9Sstevel@tonic-gate inst = HANDLE_HOLD_INSTANCE(h); 59787c478bd9Sstevel@tonic-gate 59797c478bd9Sstevel@tonic-gate r = datael_get_parent(&pg->rd_d, &inst->rd_d); 59807c478bd9Sstevel@tonic-gate 59817c478bd9Sstevel@tonic-gate if (r == SCF_SUCCESS) { 59827c478bd9Sstevel@tonic-gate r = datael_get_parent(&inst->rd_d, &svc->rd_d); 59837c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) { 59847c478bd9Sstevel@tonic-gate goto out; 59857c478bd9Sstevel@tonic-gate } 59867c478bd9Sstevel@tonic-gate r = scf_service_get_pg(svc, me, out); 59877c478bd9Sstevel@tonic-gate } else { 59887c478bd9Sstevel@tonic-gate r = scf_set_error(SCF_ERROR_NOT_FOUND); 59897c478bd9Sstevel@tonic-gate } 59907c478bd9Sstevel@tonic-gate 59917c478bd9Sstevel@tonic-gate out: 59927c478bd9Sstevel@tonic-gate HANDLE_RELE_SERVICE(h); 59937c478bd9Sstevel@tonic-gate HANDLE_RELE_INSTANCE(h); 59947c478bd9Sstevel@tonic-gate return (r); 59957c478bd9Sstevel@tonic-gate } 59967c478bd9Sstevel@tonic-gate 59977c478bd9Sstevel@tonic-gate #define LEGACY_SCHEME "lrc:" 59987c478bd9Sstevel@tonic-gate #define LEGACY_UNKNOWN "unknown" 59997c478bd9Sstevel@tonic-gate 60007c478bd9Sstevel@tonic-gate /* 60017c478bd9Sstevel@tonic-gate * Implementation of scf_walk_fmri() 60027c478bd9Sstevel@tonic-gate * 60037c478bd9Sstevel@tonic-gate * This is a little tricky due to the many-to-many relationship between patterns 60047c478bd9Sstevel@tonic-gate * and matches. We need to be able to satisfy the following requirements: 60057c478bd9Sstevel@tonic-gate * 60067c478bd9Sstevel@tonic-gate * 1) Detect patterns which match more than one FMRI, and be able to 60077c478bd9Sstevel@tonic-gate * report which FMRIs have been matched. 60087c478bd9Sstevel@tonic-gate * 2) Detect patterns which have not matched any FMRIs 60097c478bd9Sstevel@tonic-gate * 3) Visit each matching FMRI exactly once across all patterns 60107c478bd9Sstevel@tonic-gate * 4) Ignore FMRIs which have only been matched due to multiply-matching 60117c478bd9Sstevel@tonic-gate * patterns. 60127c478bd9Sstevel@tonic-gate * 60137c478bd9Sstevel@tonic-gate * We maintain an array of scf_pattern_t structures, one for each argument, and 60147c478bd9Sstevel@tonic-gate * maintain a linked list of scf_match_t structures for each one. We first 60157c478bd9Sstevel@tonic-gate * qualify each pattern's type: 60167c478bd9Sstevel@tonic-gate * 60177c478bd9Sstevel@tonic-gate * PATTERN_INVALID The argument is invalid (too long). 60187c478bd9Sstevel@tonic-gate * 60197c478bd9Sstevel@tonic-gate * PATTERN_EXACT The pattern is a complete FMRI. The list of 60207c478bd9Sstevel@tonic-gate * matches contains only a single entry. 60217c478bd9Sstevel@tonic-gate * 60227c478bd9Sstevel@tonic-gate * PATTERN_GLOB The pattern will be matched against all 60237c478bd9Sstevel@tonic-gate * FMRIs via fnmatch() in the second phase. 60247c478bd9Sstevel@tonic-gate * Matches will be added to the pattern's list 60257c478bd9Sstevel@tonic-gate * as they are found. 60267c478bd9Sstevel@tonic-gate * 60277c478bd9Sstevel@tonic-gate * PATTERN_PARTIAL Everything else. We will assume that this is 60287c478bd9Sstevel@tonic-gate * an abbreviated FMRI, and match according to 60297c478bd9Sstevel@tonic-gate * our abbreviated FMRI rules. Matches will be 60307c478bd9Sstevel@tonic-gate * added to the pattern's list as they are found. 60317c478bd9Sstevel@tonic-gate * 60327c478bd9Sstevel@tonic-gate * The first pass searches for arguments that are complete FMRIs. These are 60337c478bd9Sstevel@tonic-gate * classified as EXACT patterns and do not necessitate searching the entire 60347c478bd9Sstevel@tonic-gate * tree. 60357c478bd9Sstevel@tonic-gate * 60367c478bd9Sstevel@tonic-gate * Once this is done, if we have any GLOB or PARTIAL patterns (or if no 60377c478bd9Sstevel@tonic-gate * arguments were given), we iterate over all services and instances in the 60387c478bd9Sstevel@tonic-gate * repository, looking for matches. 60397c478bd9Sstevel@tonic-gate * 60407c478bd9Sstevel@tonic-gate * When a match is found, we add the match to the pattern's list. We also enter 60417c478bd9Sstevel@tonic-gate * the match into a hash table, resulting in something like this: 60427c478bd9Sstevel@tonic-gate * 60437c478bd9Sstevel@tonic-gate * scf_pattern_t scf_match_t 60447c478bd9Sstevel@tonic-gate * +---------------+ +-------+ +-------+ 60457c478bd9Sstevel@tonic-gate * | pattern 'foo' |----->| match |---->| match | 60467c478bd9Sstevel@tonic-gate * +---------------+ +-------+ +-------+ 60477c478bd9Sstevel@tonic-gate * | | 60487c478bd9Sstevel@tonic-gate * scf_match_key_t | | 60497c478bd9Sstevel@tonic-gate * +--------------+ | | 60507c478bd9Sstevel@tonic-gate * | FMRI bar/foo |<----+ | 60517c478bd9Sstevel@tonic-gate * +--------------+ | 60527c478bd9Sstevel@tonic-gate * | FMRI baz/foo |<------------------+ 60537c478bd9Sstevel@tonic-gate * +--------------+ 60547c478bd9Sstevel@tonic-gate * 60557c478bd9Sstevel@tonic-gate * Once we have all of this set up, we do one pass to report patterns matching 60567c478bd9Sstevel@tonic-gate * multiple FMRIs (if SCF_WALK_MULTIPLE is not set) and patterns for which no 60577c478bd9Sstevel@tonic-gate * match was found. 60587c478bd9Sstevel@tonic-gate * 60597c478bd9Sstevel@tonic-gate * Finally, we walk through all valid patterns, and for each match, if we 60607c478bd9Sstevel@tonic-gate * haven't already seen the match (as recorded in the hash table), then we 60617c478bd9Sstevel@tonic-gate * execute the callback. 60627c478bd9Sstevel@tonic-gate */ 60637c478bd9Sstevel@tonic-gate 60647c478bd9Sstevel@tonic-gate struct scf_matchkey; 60657c478bd9Sstevel@tonic-gate struct scf_match; 60667c478bd9Sstevel@tonic-gate 60677c478bd9Sstevel@tonic-gate /* 60687c478bd9Sstevel@tonic-gate * scf_matchkey_t 60697c478bd9Sstevel@tonic-gate */ 60707c478bd9Sstevel@tonic-gate typedef struct scf_matchkey { 60717c478bd9Sstevel@tonic-gate char *sk_fmri; /* Matching FMRI */ 60727c478bd9Sstevel@tonic-gate char *sk_legacy; /* Legacy name */ 60737c478bd9Sstevel@tonic-gate int sk_seen; /* If we've been seen */ 60747c478bd9Sstevel@tonic-gate struct scf_matchkey *sk_next; /* Next in hash chain */ 60757c478bd9Sstevel@tonic-gate } scf_matchkey_t; 60767c478bd9Sstevel@tonic-gate 60777c478bd9Sstevel@tonic-gate /* 60787c478bd9Sstevel@tonic-gate * scf_match_t 60797c478bd9Sstevel@tonic-gate */ 60807c478bd9Sstevel@tonic-gate typedef struct scf_match { 60817c478bd9Sstevel@tonic-gate scf_matchkey_t *sm_key; 60827c478bd9Sstevel@tonic-gate struct scf_match *sm_next; 60837c478bd9Sstevel@tonic-gate } scf_match_t; 60847c478bd9Sstevel@tonic-gate 60857c478bd9Sstevel@tonic-gate #define WALK_HTABLE_SIZE 123 60867c478bd9Sstevel@tonic-gate 60877c478bd9Sstevel@tonic-gate /* 60887c478bd9Sstevel@tonic-gate * scf_get_key() 60897c478bd9Sstevel@tonic-gate * 60907c478bd9Sstevel@tonic-gate * Given an FMRI and a hash table, returns the scf_matchkey_t corresponding to 60917c478bd9Sstevel@tonic-gate * this FMRI. If the FMRI does not exist, it is added to the hash table. If a 60927c478bd9Sstevel@tonic-gate * new entry cannot be allocated due to lack of memory, NULL is returned. 60937c478bd9Sstevel@tonic-gate */ 60947c478bd9Sstevel@tonic-gate static scf_matchkey_t * 60957c478bd9Sstevel@tonic-gate scf_get_key(scf_matchkey_t **htable, const char *fmri, const char *legacy) 60967c478bd9Sstevel@tonic-gate { 60977c478bd9Sstevel@tonic-gate uint_t h = 0, g; 60987c478bd9Sstevel@tonic-gate const char *p, *k; 60997c478bd9Sstevel@tonic-gate scf_matchkey_t *key; 61007c478bd9Sstevel@tonic-gate 61017c478bd9Sstevel@tonic-gate k = strstr(fmri, ":/"); 61027c478bd9Sstevel@tonic-gate assert(k != NULL); 61037c478bd9Sstevel@tonic-gate k += 2; 61047c478bd9Sstevel@tonic-gate 61057c478bd9Sstevel@tonic-gate /* 61067c478bd9Sstevel@tonic-gate * Generic hash function from uts/common/os/modhash.c. 61077c478bd9Sstevel@tonic-gate */ 61087c478bd9Sstevel@tonic-gate for (p = k; *p != '\0'; ++p) { 61097c478bd9Sstevel@tonic-gate h = (h << 4) + *p; 61107c478bd9Sstevel@tonic-gate if ((g = (h & 0xf0000000)) != 0) { 61117c478bd9Sstevel@tonic-gate h ^= (g >> 24); 61127c478bd9Sstevel@tonic-gate h ^= g; 61137c478bd9Sstevel@tonic-gate } 61147c478bd9Sstevel@tonic-gate } 61157c478bd9Sstevel@tonic-gate 61167c478bd9Sstevel@tonic-gate h %= WALK_HTABLE_SIZE; 61177c478bd9Sstevel@tonic-gate 61187c478bd9Sstevel@tonic-gate /* 61197c478bd9Sstevel@tonic-gate * Search for an existing key 61207c478bd9Sstevel@tonic-gate */ 61217c478bd9Sstevel@tonic-gate for (key = htable[h]; key != NULL; key = key->sk_next) { 61227c478bd9Sstevel@tonic-gate if (strcmp(key->sk_fmri, fmri) == 0) 61237c478bd9Sstevel@tonic-gate return (key); 61247c478bd9Sstevel@tonic-gate } 61257c478bd9Sstevel@tonic-gate 61267c478bd9Sstevel@tonic-gate if ((key = calloc(sizeof (scf_matchkey_t), 1)) == NULL) 61277c478bd9Sstevel@tonic-gate return (NULL); 61287c478bd9Sstevel@tonic-gate 61297c478bd9Sstevel@tonic-gate /* 61307c478bd9Sstevel@tonic-gate * Add new key to hash table. 61317c478bd9Sstevel@tonic-gate */ 61327c478bd9Sstevel@tonic-gate if ((key->sk_fmri = strdup(fmri)) == NULL) { 61337c478bd9Sstevel@tonic-gate free(key); 61347c478bd9Sstevel@tonic-gate return (NULL); 61357c478bd9Sstevel@tonic-gate } 61367c478bd9Sstevel@tonic-gate 61377c478bd9Sstevel@tonic-gate if (legacy == NULL) { 61387c478bd9Sstevel@tonic-gate key->sk_legacy = NULL; 61397c478bd9Sstevel@tonic-gate } else if ((key->sk_legacy = strdup(legacy)) == NULL) { 61407c478bd9Sstevel@tonic-gate free(key->sk_fmri); 61417c478bd9Sstevel@tonic-gate free(key); 61427c478bd9Sstevel@tonic-gate return (NULL); 61437c478bd9Sstevel@tonic-gate } 61447c478bd9Sstevel@tonic-gate 61457c478bd9Sstevel@tonic-gate key->sk_next = htable[h]; 61467c478bd9Sstevel@tonic-gate htable[h] = key; 61477c478bd9Sstevel@tonic-gate 61487c478bd9Sstevel@tonic-gate return (key); 61497c478bd9Sstevel@tonic-gate } 61507c478bd9Sstevel@tonic-gate 61517c478bd9Sstevel@tonic-gate /* 61527c478bd9Sstevel@tonic-gate * Given an FMRI, insert it into the pattern's list appropriately. 61537c478bd9Sstevel@tonic-gate * svc_explicit indicates whether matching services should take 61547c478bd9Sstevel@tonic-gate * precedence over matching instances. 61557c478bd9Sstevel@tonic-gate */ 61567c478bd9Sstevel@tonic-gate static scf_error_t 61577c478bd9Sstevel@tonic-gate scf_add_match(scf_matchkey_t **htable, const char *fmri, const char *legacy, 61587c478bd9Sstevel@tonic-gate scf_pattern_t *pattern, int svc_explicit) 61597c478bd9Sstevel@tonic-gate { 61607c478bd9Sstevel@tonic-gate scf_match_t *match; 61617c478bd9Sstevel@tonic-gate 61627c478bd9Sstevel@tonic-gate /* 61637c478bd9Sstevel@tonic-gate * If svc_explicit is set, enforce the constaint that matching 61647c478bd9Sstevel@tonic-gate * instances take precedence over matching services. Otherwise, 61657c478bd9Sstevel@tonic-gate * matching services take precedence over matching instances. 61667c478bd9Sstevel@tonic-gate */ 61677c478bd9Sstevel@tonic-gate if (svc_explicit) { 61687c478bd9Sstevel@tonic-gate scf_match_t *next, *prev; 61697c478bd9Sstevel@tonic-gate /* 61707c478bd9Sstevel@tonic-gate * If we match an instance, check to see if we must remove 61717c478bd9Sstevel@tonic-gate * any matching services (for SCF_WALK_EXPLICIT). 61727c478bd9Sstevel@tonic-gate */ 61737c478bd9Sstevel@tonic-gate for (prev = match = pattern->sp_matches; match != NULL; 61747c478bd9Sstevel@tonic-gate match = next) { 61757c478bd9Sstevel@tonic-gate size_t len = strlen(match->sm_key->sk_fmri); 61767c478bd9Sstevel@tonic-gate next = match->sm_next; 61777c478bd9Sstevel@tonic-gate if (strncmp(match->sm_key->sk_fmri, fmri, len) == 0 && 61787c478bd9Sstevel@tonic-gate fmri[len] == ':') { 61797c478bd9Sstevel@tonic-gate if (prev == match) 61807c478bd9Sstevel@tonic-gate pattern->sp_matches = match->sm_next; 61817c478bd9Sstevel@tonic-gate else 61827c478bd9Sstevel@tonic-gate prev->sm_next = match->sm_next; 61837c478bd9Sstevel@tonic-gate pattern->sp_matchcount--; 61847c478bd9Sstevel@tonic-gate free(match); 61857c478bd9Sstevel@tonic-gate } else 61867c478bd9Sstevel@tonic-gate prev = match; 61877c478bd9Sstevel@tonic-gate } 61887c478bd9Sstevel@tonic-gate } else { 61897c478bd9Sstevel@tonic-gate /* 61907c478bd9Sstevel@tonic-gate * If we've matched a service don't add any instances (for 61917c478bd9Sstevel@tonic-gate * SCF_WALK_SERVICE). 61927c478bd9Sstevel@tonic-gate */ 61937c478bd9Sstevel@tonic-gate for (match = pattern->sp_matches; match != NULL; 61947c478bd9Sstevel@tonic-gate match = match->sm_next) { 61957c478bd9Sstevel@tonic-gate size_t len = strlen(match->sm_key->sk_fmri); 61967c478bd9Sstevel@tonic-gate if (strncmp(match->sm_key->sk_fmri, fmri, len) == 0 && 61977c478bd9Sstevel@tonic-gate fmri[len] == ':') 61987c478bd9Sstevel@tonic-gate return (0); 61997c478bd9Sstevel@tonic-gate } 62007c478bd9Sstevel@tonic-gate } 62017c478bd9Sstevel@tonic-gate 62027c478bd9Sstevel@tonic-gate if ((match = malloc(sizeof (scf_match_t))) == NULL) 62037c478bd9Sstevel@tonic-gate return (SCF_ERROR_NO_MEMORY); 62047c478bd9Sstevel@tonic-gate 62057c478bd9Sstevel@tonic-gate if ((match->sm_key = scf_get_key(htable, fmri, legacy)) == NULL) { 62067c478bd9Sstevel@tonic-gate free(match); 62077c478bd9Sstevel@tonic-gate return (SCF_ERROR_NO_MEMORY); 62087c478bd9Sstevel@tonic-gate } 62097c478bd9Sstevel@tonic-gate 62107c478bd9Sstevel@tonic-gate match->sm_next = pattern->sp_matches; 62117c478bd9Sstevel@tonic-gate pattern->sp_matches = match; 62127c478bd9Sstevel@tonic-gate pattern->sp_matchcount++; 62137c478bd9Sstevel@tonic-gate 62147c478bd9Sstevel@tonic-gate return (0); 62157c478bd9Sstevel@tonic-gate } 62167c478bd9Sstevel@tonic-gate 62177c478bd9Sstevel@tonic-gate /* 62187c478bd9Sstevel@tonic-gate * Returns 1 if the fmri matches the given pattern, 0 otherwise. 62197c478bd9Sstevel@tonic-gate */ 6220103b2b15Sgww int 62217c478bd9Sstevel@tonic-gate scf_cmp_pattern(char *fmri, scf_pattern_t *pattern) 62227c478bd9Sstevel@tonic-gate { 62237c478bd9Sstevel@tonic-gate char *tmp; 62247c478bd9Sstevel@tonic-gate 62257c478bd9Sstevel@tonic-gate if (pattern->sp_type == PATTERN_GLOB) { 62267c478bd9Sstevel@tonic-gate if (fnmatch(pattern->sp_arg, fmri, 0) == 0) 62277c478bd9Sstevel@tonic-gate return (1); 62287c478bd9Sstevel@tonic-gate } else if (pattern->sp_type == PATTERN_PARTIAL && 62297c478bd9Sstevel@tonic-gate (tmp = strstr(fmri, pattern->sp_arg)) != NULL) { 62307c478bd9Sstevel@tonic-gate /* 62317c478bd9Sstevel@tonic-gate * We only allow partial matches anchored on the end of 62327c478bd9Sstevel@tonic-gate * a service or instance, and beginning on an element 62337c478bd9Sstevel@tonic-gate * boundary. 62347c478bd9Sstevel@tonic-gate */ 62357c478bd9Sstevel@tonic-gate if (tmp != fmri && tmp[-1] != '/' && tmp[-1] != ':' && 62367c478bd9Sstevel@tonic-gate tmp[0] != ':') 62377c478bd9Sstevel@tonic-gate return (0); 62387c478bd9Sstevel@tonic-gate tmp += strlen(pattern->sp_arg); 62397c478bd9Sstevel@tonic-gate if (tmp != fmri + strlen(fmri) && tmp[0] != ':' && 62407c478bd9Sstevel@tonic-gate tmp[-1] != ':') 62417c478bd9Sstevel@tonic-gate return (0); 62427c478bd9Sstevel@tonic-gate 62437c478bd9Sstevel@tonic-gate /* 62447c478bd9Sstevel@tonic-gate * If the user has supplied a short pattern that matches 62457c478bd9Sstevel@tonic-gate * 'svc:/' or 'lrc:/', ignore it. 62467c478bd9Sstevel@tonic-gate */ 62477c478bd9Sstevel@tonic-gate if (tmp <= fmri + 4) 62487c478bd9Sstevel@tonic-gate return (0); 62497c478bd9Sstevel@tonic-gate 62507c478bd9Sstevel@tonic-gate return (1); 62517c478bd9Sstevel@tonic-gate } 62527c478bd9Sstevel@tonic-gate 62537c478bd9Sstevel@tonic-gate return (0); 62547c478bd9Sstevel@tonic-gate } 62557c478bd9Sstevel@tonic-gate 62567c478bd9Sstevel@tonic-gate /* 62577c478bd9Sstevel@tonic-gate * Attempts to match the given FMRI against a set of patterns, keeping track of 62587c478bd9Sstevel@tonic-gate * the results. 62597c478bd9Sstevel@tonic-gate */ 62607c478bd9Sstevel@tonic-gate static scf_error_t 62617c478bd9Sstevel@tonic-gate scf_pattern_match(scf_matchkey_t **htable, char *fmri, const char *legacy, 62627c478bd9Sstevel@tonic-gate int npattern, scf_pattern_t *pattern, int svc_explicit) 62637c478bd9Sstevel@tonic-gate { 62647c478bd9Sstevel@tonic-gate int i; 62657c478bd9Sstevel@tonic-gate int ret = 0; 62667c478bd9Sstevel@tonic-gate 62677c478bd9Sstevel@tonic-gate for (i = 0; i < npattern; i++) { 62687c478bd9Sstevel@tonic-gate if (scf_cmp_pattern(fmri, &pattern[i]) && 62697c478bd9Sstevel@tonic-gate (ret = scf_add_match(htable, fmri, 62707c478bd9Sstevel@tonic-gate legacy, &pattern[i], svc_explicit)) != 0) 62717c478bd9Sstevel@tonic-gate return (ret); 62727c478bd9Sstevel@tonic-gate } 62737c478bd9Sstevel@tonic-gate 62747c478bd9Sstevel@tonic-gate return (0); 62757c478bd9Sstevel@tonic-gate } 62767c478bd9Sstevel@tonic-gate 6277*ad3ad82aSAndy Fiddaman /* 6278*ad3ad82aSAndy Fiddaman * Construct an error message from a provided format string and include all 6279*ad3ad82aSAndy Fiddaman * of the matched FMRIs. 6280*ad3ad82aSAndy Fiddaman */ 6281*ad3ad82aSAndy Fiddaman static char * 6282*ad3ad82aSAndy Fiddaman scf_multiple_match_error(scf_pattern_t *pattern, const char *format) 6283*ad3ad82aSAndy Fiddaman { 6284*ad3ad82aSAndy Fiddaman scf_match_t *match; 6285*ad3ad82aSAndy Fiddaman size_t len, off; 6286*ad3ad82aSAndy Fiddaman char *msg; 6287*ad3ad82aSAndy Fiddaman 6288*ad3ad82aSAndy Fiddaman /* 6289*ad3ad82aSAndy Fiddaman * Note that strlen(format) includes the length of '%s', which 6290*ad3ad82aSAndy Fiddaman * accounts for the terminating null byte. 6291*ad3ad82aSAndy Fiddaman */ 6292*ad3ad82aSAndy Fiddaman assert(strstr(format, "%s") != NULL); 6293*ad3ad82aSAndy Fiddaman len = strlen(format) + strlen(pattern->sp_arg); 6294*ad3ad82aSAndy Fiddaman for (match = pattern->sp_matches; match != NULL; 6295*ad3ad82aSAndy Fiddaman match = match->sm_next) 6296*ad3ad82aSAndy Fiddaman len += strlen(match->sm_key->sk_fmri) + 2; 6297*ad3ad82aSAndy Fiddaman 6298*ad3ad82aSAndy Fiddaman if ((msg = malloc(len)) == NULL) 6299*ad3ad82aSAndy Fiddaman return (NULL); 6300*ad3ad82aSAndy Fiddaman 6301*ad3ad82aSAndy Fiddaman (void) snprintf(msg, len, format, pattern->sp_arg); 6302*ad3ad82aSAndy Fiddaman off = strlen(msg); 6303*ad3ad82aSAndy Fiddaman for (match = pattern->sp_matches; match != NULL; 6304*ad3ad82aSAndy Fiddaman match = match->sm_next) { 6305*ad3ad82aSAndy Fiddaman assert(off < len); 6306*ad3ad82aSAndy Fiddaman off += snprintf(msg + off, len - off, "\t%s\n", 6307*ad3ad82aSAndy Fiddaman match->sm_key->sk_fmri); 6308*ad3ad82aSAndy Fiddaman } 6309*ad3ad82aSAndy Fiddaman 6310*ad3ad82aSAndy Fiddaman return (msg); 6311*ad3ad82aSAndy Fiddaman } 6312*ad3ad82aSAndy Fiddaman 631376cf44abSjeanm /* 631476cf44abSjeanm * Fails with _INVALID_ARGUMENT, _HANDLE_DESTROYED, _INTERNAL (bad server 631576cf44abSjeanm * response or id in use), _NO_MEMORY, _HANDLE_MISMATCH, _CONSTRAINT_VIOLATED, 631676cf44abSjeanm * _NOT_FOUND, _NOT_BOUND, _CONNECTION_BROKEN, _NOT_SET, _DELETED, 631776cf44abSjeanm * _NO_RESOURCES, _BACKEND_ACCESS, _TYPE_MISMATCH. 631876cf44abSjeanm */ 63197c478bd9Sstevel@tonic-gate scf_error_t 63207c478bd9Sstevel@tonic-gate scf_walk_fmri(scf_handle_t *h, int argc, char **argv, int flags, 63217c478bd9Sstevel@tonic-gate scf_walk_callback callback, void *data, int *err, 63227c478bd9Sstevel@tonic-gate void (*errfunc)(const char *, ...)) 63237c478bd9Sstevel@tonic-gate { 63247c478bd9Sstevel@tonic-gate scf_pattern_t *pattern = NULL; 63257c478bd9Sstevel@tonic-gate int i; 63267c478bd9Sstevel@tonic-gate char *fmri = NULL; 63277c478bd9Sstevel@tonic-gate ssize_t max_fmri_length; 63287c478bd9Sstevel@tonic-gate scf_service_t *svc = NULL; 63297c478bd9Sstevel@tonic-gate scf_instance_t *inst = NULL; 63307c478bd9Sstevel@tonic-gate scf_iter_t *iter = NULL, *sciter = NULL, *siter = NULL; 63317c478bd9Sstevel@tonic-gate scf_scope_t *scope = NULL; 63327c478bd9Sstevel@tonic-gate scf_propertygroup_t *pg = NULL; 63337c478bd9Sstevel@tonic-gate scf_property_t *prop = NULL; 63347c478bd9Sstevel@tonic-gate scf_value_t *value = NULL; 63357c478bd9Sstevel@tonic-gate int ret = 0; 63367c478bd9Sstevel@tonic-gate scf_matchkey_t **htable = NULL; 63377c478bd9Sstevel@tonic-gate int pattern_search = 0; 63387c478bd9Sstevel@tonic-gate ssize_t max_name_length; 63397c478bd9Sstevel@tonic-gate char *pgname = NULL; 63407c478bd9Sstevel@tonic-gate scf_walkinfo_t info; 63417c478bd9Sstevel@tonic-gate 63427c478bd9Sstevel@tonic-gate #ifndef NDEBUG 63437c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_EXPLICIT) 63447c478bd9Sstevel@tonic-gate assert(flags & SCF_WALK_SERVICE); 63457c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_NOINSTANCE) 63467c478bd9Sstevel@tonic-gate assert(flags & SCF_WALK_SERVICE); 63477c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_PROPERTY) 63487c478bd9Sstevel@tonic-gate assert(!(flags & SCF_WALK_LEGACY)); 63497c478bd9Sstevel@tonic-gate #endif 63507c478bd9Sstevel@tonic-gate 63517c478bd9Sstevel@tonic-gate /* 63527c478bd9Sstevel@tonic-gate * Setup initial variables 63537c478bd9Sstevel@tonic-gate */ 63541f6eb021SLiane Praza max_fmri_length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH); 63551f6eb021SLiane Praza assert(max_fmri_length != -1); 63561f6eb021SLiane Praza max_name_length = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH); 63571f6eb021SLiane Praza assert(max_name_length != -1); 63587c478bd9Sstevel@tonic-gate 63597c478bd9Sstevel@tonic-gate if ((fmri = malloc(max_fmri_length + 1)) == NULL || 63607c478bd9Sstevel@tonic-gate (pgname = malloc(max_name_length + 1)) == NULL) { 63617c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 63627c478bd9Sstevel@tonic-gate goto error; 63637c478bd9Sstevel@tonic-gate } 63647c478bd9Sstevel@tonic-gate 63657c478bd9Sstevel@tonic-gate if (argc == 0) { 63667c478bd9Sstevel@tonic-gate pattern = NULL; 63677c478bd9Sstevel@tonic-gate } else if ((pattern = calloc(argc, sizeof (scf_pattern_t))) 63687c478bd9Sstevel@tonic-gate == NULL) { 63697c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 63707c478bd9Sstevel@tonic-gate goto error; 63717c478bd9Sstevel@tonic-gate } 63727c478bd9Sstevel@tonic-gate 63737c478bd9Sstevel@tonic-gate if ((htable = calloc(WALK_HTABLE_SIZE, sizeof (void *))) == NULL) { 63747c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 63757c478bd9Sstevel@tonic-gate goto error; 63767c478bd9Sstevel@tonic-gate } 63777c478bd9Sstevel@tonic-gate 63787c478bd9Sstevel@tonic-gate if ((inst = scf_instance_create(h)) == NULL || 63797c478bd9Sstevel@tonic-gate (svc = scf_service_create(h)) == NULL || 63807c478bd9Sstevel@tonic-gate (iter = scf_iter_create(h)) == NULL || 63817c478bd9Sstevel@tonic-gate (sciter = scf_iter_create(h)) == NULL || 63827c478bd9Sstevel@tonic-gate (siter = scf_iter_create(h)) == NULL || 63837c478bd9Sstevel@tonic-gate (scope = scf_scope_create(h)) == NULL || 63847c478bd9Sstevel@tonic-gate (pg = scf_pg_create(h)) == NULL || 63857c478bd9Sstevel@tonic-gate (prop = scf_property_create(h)) == NULL || 63867c478bd9Sstevel@tonic-gate (value = scf_value_create(h)) == NULL) { 63877c478bd9Sstevel@tonic-gate ret = scf_error(); 63887c478bd9Sstevel@tonic-gate goto error; 63897c478bd9Sstevel@tonic-gate } 63907c478bd9Sstevel@tonic-gate 63917c478bd9Sstevel@tonic-gate /* 63927c478bd9Sstevel@tonic-gate * For each fmri given, we first check to see if it's a full service, 63937c478bd9Sstevel@tonic-gate * instance, property group, or property FMRI. This avoids having to do 63947c478bd9Sstevel@tonic-gate * the (rather expensive) walk of all instances. Any element which does 63957c478bd9Sstevel@tonic-gate * not match a full fmri is identified as a globbed pattern or a partial 63967c478bd9Sstevel@tonic-gate * fmri and stored in a private array when walking instances. 63977c478bd9Sstevel@tonic-gate */ 63987c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 63997c478bd9Sstevel@tonic-gate const char *scope_name, *svc_name, *inst_name, *pg_name; 64007c478bd9Sstevel@tonic-gate const char *prop_name; 64017c478bd9Sstevel@tonic-gate 64027c478bd9Sstevel@tonic-gate if (strlen(argv[i]) > max_fmri_length) { 64037c478bd9Sstevel@tonic-gate errfunc(scf_get_msg(SCF_MSG_ARGTOOLONG), argv[i]); 64047c478bd9Sstevel@tonic-gate if (err != NULL) 64057c478bd9Sstevel@tonic-gate *err = UU_EXIT_FATAL; 64067c478bd9Sstevel@tonic-gate continue; 64077c478bd9Sstevel@tonic-gate } 64087c478bd9Sstevel@tonic-gate 64097c478bd9Sstevel@tonic-gate (void) strcpy(fmri, argv[i]); 64107c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(fmri, &scope_name, &svc_name, &inst_name, 64117c478bd9Sstevel@tonic-gate &pg_name, &prop_name) != SCF_SUCCESS) 64127c478bd9Sstevel@tonic-gate goto badfmri; 64137c478bd9Sstevel@tonic-gate 64147c478bd9Sstevel@tonic-gate /* 64157c478bd9Sstevel@tonic-gate * If the user has specified SCF_WALK_PROPERTY, allow property 64167c478bd9Sstevel@tonic-gate * groups and properties. 64177c478bd9Sstevel@tonic-gate */ 64187c478bd9Sstevel@tonic-gate if (pg_name != NULL || prop_name != NULL) { 64197c478bd9Sstevel@tonic-gate if (!(flags & SCF_WALK_PROPERTY)) 64207c478bd9Sstevel@tonic-gate goto badfmri; 64217c478bd9Sstevel@tonic-gate 64227c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, argv[i], NULL, NULL, 64237c478bd9Sstevel@tonic-gate NULL, pg, prop, 0) != 0) 64247c478bd9Sstevel@tonic-gate goto badfmri; 64257c478bd9Sstevel@tonic-gate 64267c478bd9Sstevel@tonic-gate if (scf_pg_get_name(pg, NULL, 0) < 0 && 64277c478bd9Sstevel@tonic-gate scf_property_get_name(prop, NULL, 0) < 0) 64287c478bd9Sstevel@tonic-gate goto badfmri; 64297c478bd9Sstevel@tonic-gate 64307c478bd9Sstevel@tonic-gate if (scf_canonify_fmri(argv[i], fmri, max_fmri_length) 64317c478bd9Sstevel@tonic-gate <= 0) { 64327c478bd9Sstevel@tonic-gate /* 64337c478bd9Sstevel@tonic-gate * scf_parse_fmri() should have caught this. 64347c478bd9Sstevel@tonic-gate */ 64357c478bd9Sstevel@tonic-gate abort(); 64367c478bd9Sstevel@tonic-gate } 64377c478bd9Sstevel@tonic-gate 64387c478bd9Sstevel@tonic-gate if ((ret = scf_add_match(htable, fmri, NULL, 64397c478bd9Sstevel@tonic-gate &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0) 64407c478bd9Sstevel@tonic-gate goto error; 64417c478bd9Sstevel@tonic-gate 64427c478bd9Sstevel@tonic-gate if ((pattern[i].sp_arg = strdup(argv[i])) == NULL) { 64437c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 64447c478bd9Sstevel@tonic-gate goto error; 64457c478bd9Sstevel@tonic-gate } 64467c478bd9Sstevel@tonic-gate pattern[i].sp_type = PATTERN_EXACT; 64477c478bd9Sstevel@tonic-gate } 64487c478bd9Sstevel@tonic-gate 64497c478bd9Sstevel@tonic-gate /* 64507c478bd9Sstevel@tonic-gate * We need at least a service name 64517c478bd9Sstevel@tonic-gate */ 64527c478bd9Sstevel@tonic-gate if (scope_name == NULL || svc_name == NULL) 64537c478bd9Sstevel@tonic-gate goto badfmri; 64547c478bd9Sstevel@tonic-gate 64557c478bd9Sstevel@tonic-gate /* 64567c478bd9Sstevel@tonic-gate * If we have a fully qualified instance, add it to our list of 64577c478bd9Sstevel@tonic-gate * fmris to watch. 64587c478bd9Sstevel@tonic-gate */ 64597c478bd9Sstevel@tonic-gate if (inst_name != NULL) { 64607c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_NOINSTANCE) 64617c478bd9Sstevel@tonic-gate goto badfmri; 64627c478bd9Sstevel@tonic-gate 64637c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, argv[i], NULL, NULL, 64647c478bd9Sstevel@tonic-gate inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0) 64657c478bd9Sstevel@tonic-gate goto badfmri; 64667c478bd9Sstevel@tonic-gate 64677c478bd9Sstevel@tonic-gate if (scf_canonify_fmri(argv[i], fmri, max_fmri_length) 64687c478bd9Sstevel@tonic-gate <= 0) 64697c478bd9Sstevel@tonic-gate goto badfmri; 64707c478bd9Sstevel@tonic-gate 64717c478bd9Sstevel@tonic-gate if ((ret = scf_add_match(htable, fmri, NULL, 64727c478bd9Sstevel@tonic-gate &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0) 64737c478bd9Sstevel@tonic-gate goto error; 64747c478bd9Sstevel@tonic-gate 64757c478bd9Sstevel@tonic-gate if ((pattern[i].sp_arg = strdup(argv[i])) == NULL) { 64767c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 64777c478bd9Sstevel@tonic-gate goto error; 64787c478bd9Sstevel@tonic-gate } 64797c478bd9Sstevel@tonic-gate pattern[i].sp_type = PATTERN_EXACT; 64807c478bd9Sstevel@tonic-gate 64817c478bd9Sstevel@tonic-gate continue; 64827c478bd9Sstevel@tonic-gate } 64837c478bd9Sstevel@tonic-gate 64847c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, argv[i], NULL, svc, 64857c478bd9Sstevel@tonic-gate NULL, NULL, NULL, SCF_DECODE_FMRI_EXACT) != 64867c478bd9Sstevel@tonic-gate SCF_SUCCESS) 64877c478bd9Sstevel@tonic-gate goto badfmri; 64887c478bd9Sstevel@tonic-gate 64897c478bd9Sstevel@tonic-gate /* 64907c478bd9Sstevel@tonic-gate * If the user allows for bare services, then simply 64917c478bd9Sstevel@tonic-gate * pass this service on. 64927c478bd9Sstevel@tonic-gate */ 64937c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_SERVICE) { 64947c478bd9Sstevel@tonic-gate if (scf_service_to_fmri(svc, fmri, 64957c478bd9Sstevel@tonic-gate max_fmri_length + 1) <= 0) { 64967c478bd9Sstevel@tonic-gate ret = scf_error(); 64977c478bd9Sstevel@tonic-gate goto error; 64987c478bd9Sstevel@tonic-gate } 64997c478bd9Sstevel@tonic-gate 65007c478bd9Sstevel@tonic-gate if ((ret = scf_add_match(htable, fmri, NULL, 65017c478bd9Sstevel@tonic-gate &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0) 65027c478bd9Sstevel@tonic-gate goto error; 65037c478bd9Sstevel@tonic-gate 65047c478bd9Sstevel@tonic-gate if ((pattern[i].sp_arg = strdup(argv[i])) 65057c478bd9Sstevel@tonic-gate == NULL) { 65067c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 65077c478bd9Sstevel@tonic-gate goto error; 65087c478bd9Sstevel@tonic-gate } 65097c478bd9Sstevel@tonic-gate pattern[i].sp_type = PATTERN_EXACT; 65107c478bd9Sstevel@tonic-gate continue; 65117c478bd9Sstevel@tonic-gate } 65127c478bd9Sstevel@tonic-gate 65137c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_NOINSTANCE) 65147c478bd9Sstevel@tonic-gate goto badfmri; 65157c478bd9Sstevel@tonic-gate 65167c478bd9Sstevel@tonic-gate /* 65177c478bd9Sstevel@tonic-gate * Otherwise, iterate over all instances in the service. 65187c478bd9Sstevel@tonic-gate */ 65197c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(iter, svc) != 65207c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 65217c478bd9Sstevel@tonic-gate ret = scf_error(); 65227c478bd9Sstevel@tonic-gate goto error; 65237c478bd9Sstevel@tonic-gate } 65247c478bd9Sstevel@tonic-gate 65257c478bd9Sstevel@tonic-gate for (;;) { 65267c478bd9Sstevel@tonic-gate ret = scf_iter_next_instance(iter, inst); 65277c478bd9Sstevel@tonic-gate if (ret == 0) 65287c478bd9Sstevel@tonic-gate break; 65297c478bd9Sstevel@tonic-gate if (ret != 1) { 65307c478bd9Sstevel@tonic-gate ret = scf_error(); 65317c478bd9Sstevel@tonic-gate goto error; 65327c478bd9Sstevel@tonic-gate } 65337c478bd9Sstevel@tonic-gate 65347c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(inst, fmri, 65357c478bd9Sstevel@tonic-gate max_fmri_length + 1) == -1) 65367c478bd9Sstevel@tonic-gate goto badfmri; 65377c478bd9Sstevel@tonic-gate 65387c478bd9Sstevel@tonic-gate if ((ret = scf_add_match(htable, fmri, NULL, 65397c478bd9Sstevel@tonic-gate &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0) 65407c478bd9Sstevel@tonic-gate goto error; 65417c478bd9Sstevel@tonic-gate } 65427c478bd9Sstevel@tonic-gate 65437c478bd9Sstevel@tonic-gate if ((pattern[i].sp_arg = strdup(argv[i])) == NULL) { 65447c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 65457c478bd9Sstevel@tonic-gate goto error; 65467c478bd9Sstevel@tonic-gate } 65477c478bd9Sstevel@tonic-gate pattern[i].sp_type = PATTERN_EXACT; 65487c478bd9Sstevel@tonic-gate 65497c478bd9Sstevel@tonic-gate continue; 65507c478bd9Sstevel@tonic-gate 65517c478bd9Sstevel@tonic-gate badfmri: 65527c478bd9Sstevel@tonic-gate 65537c478bd9Sstevel@tonic-gate /* 65547c478bd9Sstevel@tonic-gate * If we got here because of a fatal error, bail out 65557c478bd9Sstevel@tonic-gate * immediately. 65567c478bd9Sstevel@tonic-gate */ 65577c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_CONNECTION_BROKEN) { 65587c478bd9Sstevel@tonic-gate ret = scf_error(); 65597c478bd9Sstevel@tonic-gate goto error; 65607c478bd9Sstevel@tonic-gate } 65617c478bd9Sstevel@tonic-gate 65627c478bd9Sstevel@tonic-gate /* 65637c478bd9Sstevel@tonic-gate * At this point we failed to interpret the argument as a 65647c478bd9Sstevel@tonic-gate * complete fmri, so mark it as a partial or globbed FMRI for 65657c478bd9Sstevel@tonic-gate * later processing. 65667c478bd9Sstevel@tonic-gate */ 65677c478bd9Sstevel@tonic-gate if (strpbrk(argv[i], "*?[") != NULL) { 65687c478bd9Sstevel@tonic-gate /* 65697c478bd9Sstevel@tonic-gate * Prepend svc:/ to patterns which don't begin with * or 65707c478bd9Sstevel@tonic-gate * svc: or lrc:. 65717c478bd9Sstevel@tonic-gate */ 65727c478bd9Sstevel@tonic-gate pattern[i].sp_type = PATTERN_GLOB; 65737c478bd9Sstevel@tonic-gate if (argv[i][0] == '*' || 65747c478bd9Sstevel@tonic-gate (strlen(argv[i]) >= 4 && argv[i][3] == ':')) 65757c478bd9Sstevel@tonic-gate pattern[i].sp_arg = strdup(argv[i]); 65767c478bd9Sstevel@tonic-gate else { 65777c478bd9Sstevel@tonic-gate pattern[i].sp_arg = malloc(strlen(argv[i]) + 6); 65787c478bd9Sstevel@tonic-gate if (pattern[i].sp_arg != NULL) 65797c478bd9Sstevel@tonic-gate (void) snprintf(pattern[i].sp_arg, 65807c478bd9Sstevel@tonic-gate strlen(argv[i]) + 6, "svc:/%s", 65817c478bd9Sstevel@tonic-gate argv[i]); 65827c478bd9Sstevel@tonic-gate } 65837c478bd9Sstevel@tonic-gate } else { 65847c478bd9Sstevel@tonic-gate pattern[i].sp_type = PATTERN_PARTIAL; 65857c478bd9Sstevel@tonic-gate pattern[i].sp_arg = strdup(argv[i]); 65867c478bd9Sstevel@tonic-gate } 65877c478bd9Sstevel@tonic-gate pattern_search = 1; 65887c478bd9Sstevel@tonic-gate if (pattern[i].sp_arg == NULL) { 65897c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 65907c478bd9Sstevel@tonic-gate goto error; 65917c478bd9Sstevel@tonic-gate } 65927c478bd9Sstevel@tonic-gate } 65937c478bd9Sstevel@tonic-gate 65947c478bd9Sstevel@tonic-gate if (pattern_search || argc == 0) { 65957c478bd9Sstevel@tonic-gate /* 65967c478bd9Sstevel@tonic-gate * We have a set of patterns to search for. Iterate over all 65977c478bd9Sstevel@tonic-gate * instances and legacy services searching for matches. 65987c478bd9Sstevel@tonic-gate */ 65997c478bd9Sstevel@tonic-gate if (scf_handle_get_local_scope(h, scope) != 0) { 66007c478bd9Sstevel@tonic-gate ret = scf_error(); 66017c478bd9Sstevel@tonic-gate goto error; 66027c478bd9Sstevel@tonic-gate } 66037c478bd9Sstevel@tonic-gate 66047c478bd9Sstevel@tonic-gate if (scf_iter_scope_services(sciter, scope) != 0) { 66057c478bd9Sstevel@tonic-gate ret = scf_error(); 66067c478bd9Sstevel@tonic-gate goto error; 66077c478bd9Sstevel@tonic-gate } 66087c478bd9Sstevel@tonic-gate 66097c478bd9Sstevel@tonic-gate for (;;) { 66107c478bd9Sstevel@tonic-gate ret = scf_iter_next_service(sciter, svc); 66117c478bd9Sstevel@tonic-gate if (ret == 0) 66127c478bd9Sstevel@tonic-gate break; 66137c478bd9Sstevel@tonic-gate if (ret != 1) { 66147c478bd9Sstevel@tonic-gate ret = scf_error(); 66157c478bd9Sstevel@tonic-gate goto error; 66167c478bd9Sstevel@tonic-gate } 66177c478bd9Sstevel@tonic-gate 66187c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_SERVICE) { 66197c478bd9Sstevel@tonic-gate /* 66207c478bd9Sstevel@tonic-gate * If the user is requesting bare services, try 66217c478bd9Sstevel@tonic-gate * to match the service first. 66227c478bd9Sstevel@tonic-gate */ 66237c478bd9Sstevel@tonic-gate if (scf_service_to_fmri(svc, fmri, 66247c478bd9Sstevel@tonic-gate max_fmri_length + 1) < 0) { 66257c478bd9Sstevel@tonic-gate ret = scf_error(); 66267c478bd9Sstevel@tonic-gate goto error; 66277c478bd9Sstevel@tonic-gate } 66287c478bd9Sstevel@tonic-gate 66297c478bd9Sstevel@tonic-gate if (argc == 0) { 66307c478bd9Sstevel@tonic-gate info.fmri = fmri; 66317c478bd9Sstevel@tonic-gate info.scope = scope; 66327c478bd9Sstevel@tonic-gate info.svc = svc; 66337c478bd9Sstevel@tonic-gate info.inst = NULL; 66347c478bd9Sstevel@tonic-gate info.pg = NULL; 66357c478bd9Sstevel@tonic-gate info.prop = NULL; 66367c478bd9Sstevel@tonic-gate if ((ret = callback(data, &info)) != 0) 66377c478bd9Sstevel@tonic-gate goto error; 66387c478bd9Sstevel@tonic-gate continue; 66397c478bd9Sstevel@tonic-gate } else if ((ret = scf_pattern_match(htable, 66407c478bd9Sstevel@tonic-gate fmri, NULL, argc, pattern, 66417c478bd9Sstevel@tonic-gate flags & SCF_WALK_EXPLICIT)) != 0) { 66427c478bd9Sstevel@tonic-gate goto error; 66437c478bd9Sstevel@tonic-gate } 66447c478bd9Sstevel@tonic-gate } 66457c478bd9Sstevel@tonic-gate 66467c478bd9Sstevel@tonic-gate if (flags & SCF_WALK_NOINSTANCE) 66477c478bd9Sstevel@tonic-gate continue; 66487c478bd9Sstevel@tonic-gate 66497c478bd9Sstevel@tonic-gate /* 66507c478bd9Sstevel@tonic-gate * Iterate over all instances in the service. 66517c478bd9Sstevel@tonic-gate */ 66527c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(siter, svc) != 0) { 66537c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_DELETED) { 66547c478bd9Sstevel@tonic-gate ret = scf_error(); 66557c478bd9Sstevel@tonic-gate goto error; 66567c478bd9Sstevel@tonic-gate } 66577c478bd9Sstevel@tonic-gate continue; 66587c478bd9Sstevel@tonic-gate } 66597c478bd9Sstevel@tonic-gate 66607c478bd9Sstevel@tonic-gate for (;;) { 66617c478bd9Sstevel@tonic-gate ret = scf_iter_next_instance(siter, inst); 66627c478bd9Sstevel@tonic-gate if (ret == 0) 66637c478bd9Sstevel@tonic-gate break; 66647c478bd9Sstevel@tonic-gate if (ret != 1) { 66657c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_DELETED) { 66667c478bd9Sstevel@tonic-gate ret = scf_error(); 66677c478bd9Sstevel@tonic-gate goto error; 66687c478bd9Sstevel@tonic-gate } 66697c478bd9Sstevel@tonic-gate break; 66707c478bd9Sstevel@tonic-gate } 66717c478bd9Sstevel@tonic-gate 66727c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(inst, fmri, 66737c478bd9Sstevel@tonic-gate max_fmri_length + 1) < 0) { 66747c478bd9Sstevel@tonic-gate ret = scf_error(); 66757c478bd9Sstevel@tonic-gate goto error; 66767c478bd9Sstevel@tonic-gate } 66777c478bd9Sstevel@tonic-gate 66787c478bd9Sstevel@tonic-gate /* 66797c478bd9Sstevel@tonic-gate * Without arguments, execute the callback 66807c478bd9Sstevel@tonic-gate * immediately. 66817c478bd9Sstevel@tonic-gate */ 66827c478bd9Sstevel@tonic-gate if (argc == 0) { 66837c478bd9Sstevel@tonic-gate info.fmri = fmri; 66847c478bd9Sstevel@tonic-gate info.scope = scope; 66857c478bd9Sstevel@tonic-gate info.svc = svc; 66867c478bd9Sstevel@tonic-gate info.inst = inst; 66877c478bd9Sstevel@tonic-gate info.pg = NULL; 66887c478bd9Sstevel@tonic-gate info.prop = NULL; 66897c478bd9Sstevel@tonic-gate if ((ret = callback(data, &info)) != 0) 66907c478bd9Sstevel@tonic-gate goto error; 66917c478bd9Sstevel@tonic-gate } else if ((ret = scf_pattern_match(htable, 66927c478bd9Sstevel@tonic-gate fmri, NULL, argc, pattern, 66937c478bd9Sstevel@tonic-gate flags & SCF_WALK_EXPLICIT)) != 0) { 66947c478bd9Sstevel@tonic-gate goto error; 66957c478bd9Sstevel@tonic-gate } 66967c478bd9Sstevel@tonic-gate } 66977c478bd9Sstevel@tonic-gate } 66987c478bd9Sstevel@tonic-gate 66997c478bd9Sstevel@tonic-gate /* 67007c478bd9Sstevel@tonic-gate * Search legacy services 67017c478bd9Sstevel@tonic-gate */ 67027c478bd9Sstevel@tonic-gate if ((flags & SCF_WALK_LEGACY)) { 67037c478bd9Sstevel@tonic-gate if (scf_scope_get_service(scope, SCF_LEGACY_SERVICE, 67047c478bd9Sstevel@tonic-gate svc) != 0) { 67057c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) { 67067c478bd9Sstevel@tonic-gate ret = scf_error(); 67077c478bd9Sstevel@tonic-gate goto error; 67087c478bd9Sstevel@tonic-gate } 67097c478bd9Sstevel@tonic-gate 67107c478bd9Sstevel@tonic-gate goto nolegacy; 67117c478bd9Sstevel@tonic-gate } 67127c478bd9Sstevel@tonic-gate 67137c478bd9Sstevel@tonic-gate if (scf_iter_service_pgs_typed(iter, svc, 67147c478bd9Sstevel@tonic-gate SCF_GROUP_FRAMEWORK) != SCF_SUCCESS) { 67157c478bd9Sstevel@tonic-gate ret = scf_error(); 67167c478bd9Sstevel@tonic-gate goto error; 67177c478bd9Sstevel@tonic-gate } 67187c478bd9Sstevel@tonic-gate 67197c478bd9Sstevel@tonic-gate (void) strcpy(fmri, LEGACY_SCHEME); 67207c478bd9Sstevel@tonic-gate 67217c478bd9Sstevel@tonic-gate for (;;) { 67227c478bd9Sstevel@tonic-gate ret = scf_iter_next_pg(iter, pg); 67237c478bd9Sstevel@tonic-gate if (ret == -1) { 67247c478bd9Sstevel@tonic-gate ret = scf_error(); 67257c478bd9Sstevel@tonic-gate goto error; 67267c478bd9Sstevel@tonic-gate } 67277c478bd9Sstevel@tonic-gate if (ret == 0) 67287c478bd9Sstevel@tonic-gate break; 67297c478bd9Sstevel@tonic-gate 67307c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, 67317c478bd9Sstevel@tonic-gate SCF_LEGACY_PROPERTY_NAME, prop) == -1) { 67327c478bd9Sstevel@tonic-gate ret = scf_error(); 67337c478bd9Sstevel@tonic-gate if (ret == SCF_ERROR_DELETED || 67347c478bd9Sstevel@tonic-gate ret == SCF_ERROR_NOT_FOUND) { 67357c478bd9Sstevel@tonic-gate ret = 0; 67367c478bd9Sstevel@tonic-gate continue; 67377c478bd9Sstevel@tonic-gate } 67387c478bd9Sstevel@tonic-gate goto error; 67397c478bd9Sstevel@tonic-gate } 67407c478bd9Sstevel@tonic-gate 67417c478bd9Sstevel@tonic-gate if (scf_property_is_type(prop, SCF_TYPE_ASTRING) 67427c478bd9Sstevel@tonic-gate != SCF_SUCCESS) { 67437c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 67447c478bd9Sstevel@tonic-gate continue; 67457c478bd9Sstevel@tonic-gate ret = scf_error(); 67467c478bd9Sstevel@tonic-gate goto error; 67477c478bd9Sstevel@tonic-gate } 67487c478bd9Sstevel@tonic-gate 67497c478bd9Sstevel@tonic-gate if (scf_property_get_value(prop, value) != 67507c478bd9Sstevel@tonic-gate SCF_SUCCESS) 67517c478bd9Sstevel@tonic-gate continue; 67527c478bd9Sstevel@tonic-gate 67537c478bd9Sstevel@tonic-gate if (scf_value_get_astring(value, 67547c478bd9Sstevel@tonic-gate fmri + sizeof (LEGACY_SCHEME) - 1, 67557c478bd9Sstevel@tonic-gate max_fmri_length + 2 - 67567c478bd9Sstevel@tonic-gate sizeof (LEGACY_SCHEME)) <= 0) 67577c478bd9Sstevel@tonic-gate continue; 67587c478bd9Sstevel@tonic-gate 67597c478bd9Sstevel@tonic-gate if (scf_pg_get_name(pg, pgname, 67607c478bd9Sstevel@tonic-gate max_name_length + 1) <= 0) { 67617c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_DELETED) 67627c478bd9Sstevel@tonic-gate continue; 67637c478bd9Sstevel@tonic-gate ret = scf_error(); 67647c478bd9Sstevel@tonic-gate goto error; 67657c478bd9Sstevel@tonic-gate } 67667c478bd9Sstevel@tonic-gate 67677c478bd9Sstevel@tonic-gate if (argc == 0) { 67687c478bd9Sstevel@tonic-gate info.fmri = fmri; 67697c478bd9Sstevel@tonic-gate info.scope = scope; 67707c478bd9Sstevel@tonic-gate info.svc = NULL; 67717c478bd9Sstevel@tonic-gate info.inst = NULL; 67727c478bd9Sstevel@tonic-gate info.pg = pg; 67737c478bd9Sstevel@tonic-gate info.prop = NULL; 67747c478bd9Sstevel@tonic-gate if ((ret = callback(data, &info)) != 0) 67757c478bd9Sstevel@tonic-gate goto error; 67767c478bd9Sstevel@tonic-gate } else if ((ret = scf_pattern_match(htable, 67777c478bd9Sstevel@tonic-gate fmri, pgname, argc, pattern, 67787c478bd9Sstevel@tonic-gate flags & SCF_WALK_EXPLICIT)) != 0) 67797c478bd9Sstevel@tonic-gate goto error; 67807c478bd9Sstevel@tonic-gate } 67817c478bd9Sstevel@tonic-gate 67827c478bd9Sstevel@tonic-gate } 67837c478bd9Sstevel@tonic-gate } 67847c478bd9Sstevel@tonic-gate nolegacy: 67857c478bd9Sstevel@tonic-gate ret = 0; 67867c478bd9Sstevel@tonic-gate 67877c478bd9Sstevel@tonic-gate if (argc == 0) 67887c478bd9Sstevel@tonic-gate goto error; 67897c478bd9Sstevel@tonic-gate 67907c478bd9Sstevel@tonic-gate /* 67917c478bd9Sstevel@tonic-gate * Check all patterns, and see if we have that any that didn't match 67927c478bd9Sstevel@tonic-gate * or any that matched multiple instances. For svcprop, add up the 67937c478bd9Sstevel@tonic-gate * total number of matching keys. 67947c478bd9Sstevel@tonic-gate */ 67957c478bd9Sstevel@tonic-gate info.count = 0; 67967c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 67977c478bd9Sstevel@tonic-gate scf_match_t *match; 67987c478bd9Sstevel@tonic-gate 67997c478bd9Sstevel@tonic-gate if (pattern[i].sp_type == PATTERN_INVALID) 68007c478bd9Sstevel@tonic-gate continue; 68017c478bd9Sstevel@tonic-gate if (pattern[i].sp_matchcount == 0) { 68027c478bd9Sstevel@tonic-gate scf_msg_t msgid; 68037c478bd9Sstevel@tonic-gate /* 68047c478bd9Sstevel@tonic-gate * Provide a useful error message based on the argument 68057c478bd9Sstevel@tonic-gate * and the type of entity requested. 68067c478bd9Sstevel@tonic-gate */ 68077c478bd9Sstevel@tonic-gate if (!(flags & SCF_WALK_LEGACY) && 68087c478bd9Sstevel@tonic-gate strncmp(pattern[i].sp_arg, "lrc:/", 5) == 0) 68097c478bd9Sstevel@tonic-gate msgid = SCF_MSG_PATTERN_LEGACY; 68107c478bd9Sstevel@tonic-gate else if (flags & SCF_WALK_PROPERTY) 68117c478bd9Sstevel@tonic-gate msgid = SCF_MSG_PATTERN_NOENTITY; 68127c478bd9Sstevel@tonic-gate else if (flags & SCF_WALK_NOINSTANCE) 68137c478bd9Sstevel@tonic-gate msgid = SCF_MSG_PATTERN_NOSERVICE; 68147c478bd9Sstevel@tonic-gate else if (flags & SCF_WALK_SERVICE) 68157c478bd9Sstevel@tonic-gate msgid = SCF_MSG_PATTERN_NOINSTSVC; 68167c478bd9Sstevel@tonic-gate else 68177c478bd9Sstevel@tonic-gate msgid = SCF_MSG_PATTERN_NOINSTANCE; 68187c478bd9Sstevel@tonic-gate 68197c478bd9Sstevel@tonic-gate errfunc(scf_get_msg(msgid), pattern[i].sp_arg); 68207c478bd9Sstevel@tonic-gate if (err) 68217c478bd9Sstevel@tonic-gate *err = UU_EXIT_FATAL; 68227c478bd9Sstevel@tonic-gate } else if (!(flags & SCF_WALK_MULTIPLE) && 68237c478bd9Sstevel@tonic-gate pattern[i].sp_matchcount > 1) { 68247c478bd9Sstevel@tonic-gate char *msg; 68257c478bd9Sstevel@tonic-gate 6826*ad3ad82aSAndy Fiddaman msg = scf_multiple_match_error(&pattern[i], 6827*ad3ad82aSAndy Fiddaman scf_get_msg(SCF_MSG_PATTERN_MULTIMATCH)); 6828*ad3ad82aSAndy Fiddaman 6829*ad3ad82aSAndy Fiddaman if (msg == NULL) { 68307c478bd9Sstevel@tonic-gate ret = SCF_ERROR_NO_MEMORY; 68317c478bd9Sstevel@tonic-gate goto error; 68327c478bd9Sstevel@tonic-gate } 68337c478bd9Sstevel@tonic-gate 6834*ad3ad82aSAndy Fiddaman errfunc(msg); 6835*ad3ad82aSAndy Fiddaman 6836*ad3ad82aSAndy Fiddaman if (err != NULL) 6837*ad3ad82aSAndy Fiddaman *err = UU_EXIT_FATAL; 6838*ad3ad82aSAndy Fiddaman 6839*ad3ad82aSAndy Fiddaman free(msg); 6840*ad3ad82aSAndy Fiddaman 6841*ad3ad82aSAndy Fiddaman /* 6842*ad3ad82aSAndy Fiddaman * Set matchcount to 0 so the callback is not 6843*ad3ad82aSAndy Fiddaman * performed for this pattern. 6844*ad3ad82aSAndy Fiddaman */ 6845*ad3ad82aSAndy Fiddaman pattern[i].sp_matchcount = 0; 6846*ad3ad82aSAndy Fiddaman 6847*ad3ad82aSAndy Fiddaman } else if ((flags & SCF_WALK_UNIPARTIAL) && 6848*ad3ad82aSAndy Fiddaman pattern[i].sp_type == PATTERN_PARTIAL && 6849*ad3ad82aSAndy Fiddaman pattern[i].sp_matchcount > 1) { 6850*ad3ad82aSAndy Fiddaman char *msg; 6851*ad3ad82aSAndy Fiddaman 6852*ad3ad82aSAndy Fiddaman msg = scf_multiple_match_error(&pattern[i], 6853*ad3ad82aSAndy Fiddaman scf_get_msg(SCF_MSG_PATTERN_MULTIPARTIAL)); 6854*ad3ad82aSAndy Fiddaman 6855*ad3ad82aSAndy Fiddaman if (msg == NULL) { 6856*ad3ad82aSAndy Fiddaman ret = SCF_ERROR_NO_MEMORY; 6857*ad3ad82aSAndy Fiddaman goto error; 68587c478bd9Sstevel@tonic-gate } 68597c478bd9Sstevel@tonic-gate 68607c478bd9Sstevel@tonic-gate errfunc(msg); 6861*ad3ad82aSAndy Fiddaman 68627c478bd9Sstevel@tonic-gate if (err != NULL) 68637c478bd9Sstevel@tonic-gate *err = UU_EXIT_FATAL; 68647c478bd9Sstevel@tonic-gate 68657c478bd9Sstevel@tonic-gate free(msg); 6866*ad3ad82aSAndy Fiddaman 6867*ad3ad82aSAndy Fiddaman /* 6868*ad3ad82aSAndy Fiddaman * Set matchcount to 0 so the callback is not 6869*ad3ad82aSAndy Fiddaman * performed for this pattern. 6870*ad3ad82aSAndy Fiddaman */ 6871*ad3ad82aSAndy Fiddaman pattern[i].sp_matchcount = 0; 6872*ad3ad82aSAndy Fiddaman 68737c478bd9Sstevel@tonic-gate } else { 68747c478bd9Sstevel@tonic-gate for (match = pattern[i].sp_matches; match != NULL; 68757c478bd9Sstevel@tonic-gate match = match->sm_next) { 68767c478bd9Sstevel@tonic-gate if (!match->sm_key->sk_seen) 68777c478bd9Sstevel@tonic-gate info.count++; 68787c478bd9Sstevel@tonic-gate match->sm_key->sk_seen = 1; 68797c478bd9Sstevel@tonic-gate } 68807c478bd9Sstevel@tonic-gate } 68817c478bd9Sstevel@tonic-gate } 68827c478bd9Sstevel@tonic-gate 68837c478bd9Sstevel@tonic-gate /* 68847c478bd9Sstevel@tonic-gate * Clear 'sk_seen' for all keys. 68857c478bd9Sstevel@tonic-gate */ 68867c478bd9Sstevel@tonic-gate for (i = 0; i < WALK_HTABLE_SIZE; i++) { 68877c478bd9Sstevel@tonic-gate scf_matchkey_t *key; 68887c478bd9Sstevel@tonic-gate for (key = htable[i]; key != NULL; key = key->sk_next) 68897c478bd9Sstevel@tonic-gate key->sk_seen = 0; 68907c478bd9Sstevel@tonic-gate } 68917c478bd9Sstevel@tonic-gate 68927c478bd9Sstevel@tonic-gate /* 68937c478bd9Sstevel@tonic-gate * Iterate over all the FMRIs in our hash table and execute the 68947c478bd9Sstevel@tonic-gate * callback. 68957c478bd9Sstevel@tonic-gate */ 68967c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 68977c478bd9Sstevel@tonic-gate scf_match_t *match; 68987c478bd9Sstevel@tonic-gate scf_matchkey_t *key; 68997c478bd9Sstevel@tonic-gate 69007c478bd9Sstevel@tonic-gate /* 6901*ad3ad82aSAndy Fiddaman * Ignore patterns which didn't match anything or 6902*ad3ad82aSAndy Fiddaman * for which the matchcount has been set to 0 due to an 6903*ad3ad82aSAndy Fiddaman * error detected above. 69047c478bd9Sstevel@tonic-gate */ 6905*ad3ad82aSAndy Fiddaman if (pattern[i].sp_matchcount == 0) 69067c478bd9Sstevel@tonic-gate continue; 69077c478bd9Sstevel@tonic-gate 69087c478bd9Sstevel@tonic-gate for (match = pattern[i].sp_matches; match != NULL; 69097c478bd9Sstevel@tonic-gate match = match->sm_next) { 69107c478bd9Sstevel@tonic-gate 69117c478bd9Sstevel@tonic-gate key = match->sm_key; 69127c478bd9Sstevel@tonic-gate if (key->sk_seen) 69137c478bd9Sstevel@tonic-gate continue; 69147c478bd9Sstevel@tonic-gate 69157c478bd9Sstevel@tonic-gate key->sk_seen = 1; 69167c478bd9Sstevel@tonic-gate 69177c478bd9Sstevel@tonic-gate if (key->sk_legacy != NULL) { 69187c478bd9Sstevel@tonic-gate if (scf_scope_get_service(scope, 69197c478bd9Sstevel@tonic-gate "smf/legacy_run", svc) != 0) { 69207c478bd9Sstevel@tonic-gate ret = scf_error(); 69217c478bd9Sstevel@tonic-gate goto error; 69227c478bd9Sstevel@tonic-gate } 69237c478bd9Sstevel@tonic-gate 69247c478bd9Sstevel@tonic-gate if (scf_service_get_pg(svc, key->sk_legacy, 69257c478bd9Sstevel@tonic-gate pg) != 0) 69267c478bd9Sstevel@tonic-gate continue; 69277c478bd9Sstevel@tonic-gate 69287c478bd9Sstevel@tonic-gate info.fmri = key->sk_fmri; 69297c478bd9Sstevel@tonic-gate info.scope = scope; 69307c478bd9Sstevel@tonic-gate info.svc = NULL; 69317c478bd9Sstevel@tonic-gate info.inst = NULL; 69327c478bd9Sstevel@tonic-gate info.pg = pg; 69337c478bd9Sstevel@tonic-gate info.prop = NULL; 69347c478bd9Sstevel@tonic-gate if ((ret = callback(data, &info)) != 0) 69357c478bd9Sstevel@tonic-gate goto error; 69367c478bd9Sstevel@tonic-gate } else { 69377c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, key->sk_fmri, 69387c478bd9Sstevel@tonic-gate scope, svc, inst, pg, prop, 0) != 69397c478bd9Sstevel@tonic-gate SCF_SUCCESS) 69407c478bd9Sstevel@tonic-gate continue; 69417c478bd9Sstevel@tonic-gate 69427c478bd9Sstevel@tonic-gate info.fmri = key->sk_fmri; 69437c478bd9Sstevel@tonic-gate info.scope = scope; 69447c478bd9Sstevel@tonic-gate info.svc = svc; 69457c478bd9Sstevel@tonic-gate if (scf_instance_get_name(inst, NULL, 0) < 0) { 69467c478bd9Sstevel@tonic-gate if (scf_error() == 69477c478bd9Sstevel@tonic-gate SCF_ERROR_CONNECTION_BROKEN) { 69487c478bd9Sstevel@tonic-gate ret = scf_error(); 69497c478bd9Sstevel@tonic-gate goto error; 69507c478bd9Sstevel@tonic-gate } 69517c478bd9Sstevel@tonic-gate info.inst = NULL; 69527c478bd9Sstevel@tonic-gate } else { 69537c478bd9Sstevel@tonic-gate info.inst = inst; 69547c478bd9Sstevel@tonic-gate } 69557c478bd9Sstevel@tonic-gate if (scf_pg_get_name(pg, NULL, 0) < 0) { 69567c478bd9Sstevel@tonic-gate if (scf_error() == 69577c478bd9Sstevel@tonic-gate SCF_ERROR_CONNECTION_BROKEN) { 69587c478bd9Sstevel@tonic-gate ret = scf_error(); 69597c478bd9Sstevel@tonic-gate goto error; 69607c478bd9Sstevel@tonic-gate } 69617c478bd9Sstevel@tonic-gate info.pg = NULL; 69627c478bd9Sstevel@tonic-gate } else { 69637c478bd9Sstevel@tonic-gate info.pg = pg; 69647c478bd9Sstevel@tonic-gate } 69657c478bd9Sstevel@tonic-gate if (scf_property_get_name(prop, NULL, 0) < 0) { 69667c478bd9Sstevel@tonic-gate if (scf_error() == 69677c478bd9Sstevel@tonic-gate SCF_ERROR_CONNECTION_BROKEN) { 69687c478bd9Sstevel@tonic-gate ret = scf_error(); 69697c478bd9Sstevel@tonic-gate goto error; 69707c478bd9Sstevel@tonic-gate } 69717c478bd9Sstevel@tonic-gate info.prop = NULL; 69727c478bd9Sstevel@tonic-gate } else { 69737c478bd9Sstevel@tonic-gate info.prop = prop; 69747c478bd9Sstevel@tonic-gate } 69757c478bd9Sstevel@tonic-gate 69767c478bd9Sstevel@tonic-gate if ((ret = callback(data, &info)) != 0) 69777c478bd9Sstevel@tonic-gate goto error; 69787c478bd9Sstevel@tonic-gate } 69797c478bd9Sstevel@tonic-gate } 69807c478bd9Sstevel@tonic-gate } 69817c478bd9Sstevel@tonic-gate 69827c478bd9Sstevel@tonic-gate error: 69837c478bd9Sstevel@tonic-gate if (htable) { 69847c478bd9Sstevel@tonic-gate scf_matchkey_t *key, *next; 69857c478bd9Sstevel@tonic-gate 69867c478bd9Sstevel@tonic-gate for (i = 0; i < WALK_HTABLE_SIZE; i++) { 69877c478bd9Sstevel@tonic-gate 69887c478bd9Sstevel@tonic-gate for (key = htable[i]; key != NULL; 69897c478bd9Sstevel@tonic-gate key = next) { 69907c478bd9Sstevel@tonic-gate 69917c478bd9Sstevel@tonic-gate next = key->sk_next; 69927c478bd9Sstevel@tonic-gate 69937c478bd9Sstevel@tonic-gate if (key->sk_fmri != NULL) 69947c478bd9Sstevel@tonic-gate free(key->sk_fmri); 69957c478bd9Sstevel@tonic-gate if (key->sk_legacy != NULL) 69967c478bd9Sstevel@tonic-gate free(key->sk_legacy); 69977c478bd9Sstevel@tonic-gate free(key); 69987c478bd9Sstevel@tonic-gate } 69997c478bd9Sstevel@tonic-gate } 70007c478bd9Sstevel@tonic-gate free(htable); 70017c478bd9Sstevel@tonic-gate } 70027c478bd9Sstevel@tonic-gate if (pattern != NULL) { 70037c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 70047c478bd9Sstevel@tonic-gate scf_match_t *match, *next; 70057c478bd9Sstevel@tonic-gate 70067c478bd9Sstevel@tonic-gate if (pattern[i].sp_arg != NULL) 70077c478bd9Sstevel@tonic-gate free(pattern[i].sp_arg); 70087c478bd9Sstevel@tonic-gate 70097c478bd9Sstevel@tonic-gate for (match = pattern[i].sp_matches; match != NULL; 70107c478bd9Sstevel@tonic-gate match = next) { 70117c478bd9Sstevel@tonic-gate 70127c478bd9Sstevel@tonic-gate next = match->sm_next; 70137c478bd9Sstevel@tonic-gate 70147c478bd9Sstevel@tonic-gate free(match); 70157c478bd9Sstevel@tonic-gate } 70167c478bd9Sstevel@tonic-gate } 70177c478bd9Sstevel@tonic-gate free(pattern); 70187c478bd9Sstevel@tonic-gate } 70197c478bd9Sstevel@tonic-gate 70207c478bd9Sstevel@tonic-gate free(fmri); 70217c478bd9Sstevel@tonic-gate free(pgname); 70227c478bd9Sstevel@tonic-gate 70237c478bd9Sstevel@tonic-gate scf_value_destroy(value); 70247c478bd9Sstevel@tonic-gate scf_property_destroy(prop); 70257c478bd9Sstevel@tonic-gate scf_pg_destroy(pg); 70267c478bd9Sstevel@tonic-gate scf_scope_destroy(scope); 70277c478bd9Sstevel@tonic-gate scf_iter_destroy(siter); 70287c478bd9Sstevel@tonic-gate scf_iter_destroy(sciter); 70297c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 70307c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 70317c478bd9Sstevel@tonic-gate scf_service_destroy(svc); 70327c478bd9Sstevel@tonic-gate 70337c478bd9Sstevel@tonic-gate return (ret); 70347c478bd9Sstevel@tonic-gate } 70357c478bd9Sstevel@tonic-gate 70361f6eb021SLiane Praza /* 70371f6eb021SLiane Praza * scf_encode32() is an implementation of Base32 encoding as described in 70381f6eb021SLiane Praza * section 6 of RFC 4648 - "The Base16, Base32, and Base64 Data 70391f6eb021SLiane Praza * Encodings". See http://www.ietf.org/rfc/rfc4648.txt?number=4648. The 70401f6eb021SLiane Praza * input stream is divided into groups of 5 characters (40 bits). Each 70411f6eb021SLiane Praza * group is encoded into 8 output characters where each output character 70421f6eb021SLiane Praza * represents 5 bits of input. 70431f6eb021SLiane Praza * 70441f6eb021SLiane Praza * If the input is not an even multiple of 5 characters, the output will be 70451f6eb021SLiane Praza * padded so that the output is an even multiple of 8 characters. The 70461f6eb021SLiane Praza * standard specifies that the pad character is '='. Unfortunately, '=' is 70471f6eb021SLiane Praza * not a legal character in SMF property names. Thus, the caller can 70481f6eb021SLiane Praza * specify an alternate pad character with the pad argument. If pad is 0, 70491f6eb021SLiane Praza * scf_encode32() will use '='. Note that use of anything other than '=' 70501f6eb021SLiane Praza * produces output that is not in conformance with RFC 4648. It is 70511f6eb021SLiane Praza * suitable, however, for internal use of SMF software. When the encoded 70521f6eb021SLiane Praza * data is used as part of an SMF property name, SCF_ENCODE32_PAD should be 70531f6eb021SLiane Praza * used as the pad character. 70541f6eb021SLiane Praza * 70551f6eb021SLiane Praza * Arguments: 70561f6eb021SLiane Praza * input - Address of the buffer to be encoded. 70571f6eb021SLiane Praza * inlen - Number of characters at input. 70581f6eb021SLiane Praza * output - Address of the buffer to receive the encoded data. 70591f6eb021SLiane Praza * outmax - Size of the buffer at output. 70601f6eb021SLiane Praza * outlen - If it is not NULL, outlen receives the number of 70611f6eb021SLiane Praza * bytes placed in output. 70621f6eb021SLiane Praza * pad - Alternate padding character. 70631f6eb021SLiane Praza * 70641f6eb021SLiane Praza * Returns: 70651f6eb021SLiane Praza * 0 Buffer was successfully encoded. 70661f6eb021SLiane Praza * -1 Indicates output buffer too small, or pad is one of the 70671f6eb021SLiane Praza * standard encoding characters. 70681f6eb021SLiane Praza */ 70691f6eb021SLiane Praza int 70701f6eb021SLiane Praza scf_encode32(const char *input, size_t inlen, char *output, size_t outmax, 70711f6eb021SLiane Praza size_t *outlen, char pad) 70721f6eb021SLiane Praza { 70731f6eb021SLiane Praza uint_t group_size = 5; 70741f6eb021SLiane Praza uint_t i; 70751f6eb021SLiane Praza const unsigned char *in = (const unsigned char *)input; 70761f6eb021SLiane Praza size_t olen; 70771f6eb021SLiane Praza uchar_t *out = (uchar_t *)output; 70781f6eb021SLiane Praza uint_t oval; 70791f6eb021SLiane Praza uint_t pad_count; 70801f6eb021SLiane Praza 70811f6eb021SLiane Praza /* Verify that there is enough room for the output. */ 70821f6eb021SLiane Praza olen = ((inlen + (group_size - 1)) / group_size) * 8; 70831f6eb021SLiane Praza if (outlen) 70841f6eb021SLiane Praza *outlen = olen; 70851f6eb021SLiane Praza if (olen > outmax) 70861f6eb021SLiane Praza return (-1); 70871f6eb021SLiane Praza 70881f6eb021SLiane Praza /* If caller did not provide pad character, use the default. */ 70891f6eb021SLiane Praza if (pad == 0) { 70901f6eb021SLiane Praza pad = '='; 70911f6eb021SLiane Praza } else { 70921f6eb021SLiane Praza /* 70931f6eb021SLiane Praza * Make sure that caller's pad is not one of the encoding 70941f6eb021SLiane Praza * characters. 70951f6eb021SLiane Praza */ 70961f6eb021SLiane Praza for (i = 0; i < sizeof (base32) - 1; i++) { 70971f6eb021SLiane Praza if (pad == base32[i]) 70981f6eb021SLiane Praza return (-1); 70991f6eb021SLiane Praza } 71001f6eb021SLiane Praza } 71011f6eb021SLiane Praza 71021f6eb021SLiane Praza /* Process full groups capturing 5 bits per output character. */ 71031f6eb021SLiane Praza for (; inlen >= group_size; in += group_size, inlen -= group_size) { 71041f6eb021SLiane Praza /* 71051f6eb021SLiane Praza * The comments in this section number the bits in an 71061f6eb021SLiane Praza * 8 bit byte 0 to 7. The high order bit is bit 7 and 71071f6eb021SLiane Praza * the low order bit is bit 0. 71081f6eb021SLiane Praza */ 71091f6eb021SLiane Praza 71101f6eb021SLiane Praza /* top 5 bits (7-3) from in[0] */ 71111f6eb021SLiane Praza *out++ = base32[in[0] >> 3]; 71121f6eb021SLiane Praza /* bits 2-0 from in[0] and top 2 (7-6) from in[1] */ 71131f6eb021SLiane Praza *out++ = base32[((in[0] << 2) & 0x1c) | (in[1] >> 6)]; 71141f6eb021SLiane Praza /* 5 bits (5-1) from in[1] */ 71151f6eb021SLiane Praza *out++ = base32[(in[1] >> 1) & 0x1f]; 71161f6eb021SLiane Praza /* low bit (0) from in[1] and top 4 (7-4) from in[2] */ 71171f6eb021SLiane Praza *out++ = base32[((in[1] << 4) & 0x10) | ((in[2] >> 4) & 0xf)]; 71181f6eb021SLiane Praza /* low 4 (3-0) from in[2] and top bit (7) from in[3] */ 71191f6eb021SLiane Praza *out++ = base32[((in[2] << 1) & 0x1e) | (in[3] >> 7)]; 71201f6eb021SLiane Praza /* 5 bits (6-2) from in[3] */ 71211f6eb021SLiane Praza *out++ = base32[(in[3] >> 2) & 0x1f]; 71221f6eb021SLiane Praza /* low 2 (1-0) from in[3] and top 3 (7-5) from in[4] */ 71231f6eb021SLiane Praza *out++ = base32[((in[3] << 3) & 0x18) | (in[4] >> 5)]; 71241f6eb021SLiane Praza /* low 5 (4-0) from in[4] */ 71251f6eb021SLiane Praza *out++ = base32[in[4] & 0x1f]; 71261f6eb021SLiane Praza } 71271f6eb021SLiane Praza 71281f6eb021SLiane Praza /* Take care of final input bytes. */ 71291f6eb021SLiane Praza pad_count = 0; 71301f6eb021SLiane Praza if (inlen) { 71311f6eb021SLiane Praza /* top 5 bits (7-3) from in[0] */ 71321f6eb021SLiane Praza *out++ = base32[in[0] >> 3]; 71331f6eb021SLiane Praza /* 71341f6eb021SLiane Praza * low 3 (2-0) from in[0] and top 2 (7-6) from in[1] if 71351f6eb021SLiane Praza * available. 71361f6eb021SLiane Praza */ 71371f6eb021SLiane Praza oval = (in[0] << 2) & 0x1c; 71381f6eb021SLiane Praza if (inlen == 1) { 71391f6eb021SLiane Praza *out++ = base32[oval]; 71401f6eb021SLiane Praza pad_count = 6; 71411f6eb021SLiane Praza goto padout; 71421f6eb021SLiane Praza } 71431f6eb021SLiane Praza oval |= in[1] >> 6; 71441f6eb021SLiane Praza *out++ = base32[oval]; 71451f6eb021SLiane Praza /* 5 bits (5-1) from in[1] */ 71461f6eb021SLiane Praza *out++ = base32[(in[1] >> 1) & 0x1f]; 71471f6eb021SLiane Praza /* 71481f6eb021SLiane Praza * low bit (0) from in[1] and top 4 (7-4) from in[2] if 71491f6eb021SLiane Praza * available. 71501f6eb021SLiane Praza */ 71511f6eb021SLiane Praza oval = (in[1] << 4) & 0x10; 71521f6eb021SLiane Praza if (inlen == 2) { 71531f6eb021SLiane Praza *out++ = base32[oval]; 71541f6eb021SLiane Praza pad_count = 4; 71551f6eb021SLiane Praza goto padout; 71561f6eb021SLiane Praza } 71571f6eb021SLiane Praza oval |= in[2] >> 4; 71581f6eb021SLiane Praza *out++ = base32[oval]; 71591f6eb021SLiane Praza /* 71601f6eb021SLiane Praza * low 4 (3-0) from in[2] and top 1 (7) from in[3] if 71611f6eb021SLiane Praza * available. 71621f6eb021SLiane Praza */ 71631f6eb021SLiane Praza oval = (in[2] << 1) & 0x1e; 71641f6eb021SLiane Praza if (inlen == 3) { 71651f6eb021SLiane Praza *out++ = base32[oval]; 71661f6eb021SLiane Praza pad_count = 3; 71671f6eb021SLiane Praza goto padout; 71681f6eb021SLiane Praza } 71691f6eb021SLiane Praza oval |= in[3] >> 7; 71701f6eb021SLiane Praza *out++ = base32[oval]; 71711f6eb021SLiane Praza /* 5 bits (6-2) from in[3] */ 71721f6eb021SLiane Praza *out++ = base32[(in[3] >> 2) & 0x1f]; 71731f6eb021SLiane Praza /* low 2 bits (1-0) from in[3] */ 71741f6eb021SLiane Praza *out++ = base32[(in[3] << 3) & 0x18]; 71751f6eb021SLiane Praza pad_count = 1; 71761f6eb021SLiane Praza } 71771f6eb021SLiane Praza padout: 71781f6eb021SLiane Praza /* 71791f6eb021SLiane Praza * Pad the output so that it is a multiple of 8 bytes. 71801f6eb021SLiane Praza */ 71811f6eb021SLiane Praza for (; pad_count > 0; pad_count--) { 71821f6eb021SLiane Praza *out++ = pad; 71831f6eb021SLiane Praza } 71841f6eb021SLiane Praza 71851f6eb021SLiane Praza /* 71861f6eb021SLiane Praza * Null terminate the output if there is enough room. 71871f6eb021SLiane Praza */ 71881f6eb021SLiane Praza if (olen < outmax) 71891f6eb021SLiane Praza *out = 0; 71901f6eb021SLiane Praza 71911f6eb021SLiane Praza return (0); 71921f6eb021SLiane Praza } 71931f6eb021SLiane Praza 71941f6eb021SLiane Praza /* 71951f6eb021SLiane Praza * scf_decode32() is an implementation of Base32 decoding as described in 71961f6eb021SLiane Praza * section 6 of RFC 4648 - "The Base16, Base32, and Base64 Data 71971f6eb021SLiane Praza * Encodings". See http://www.ietf.org/rfc/rfc4648.txt?number=4648. The 71981f6eb021SLiane Praza * input stream is divided into groups of 8 encoded characters. Each 71991f6eb021SLiane Praza * encoded character represents 5 bits of data. Thus, the 8 encoded 72001f6eb021SLiane Praza * characters are used to produce 40 bits or 5 bytes of unencoded data in 72011f6eb021SLiane Praza * outbuf. 72021f6eb021SLiane Praza * 72031f6eb021SLiane Praza * If the encoder did not have enough data to generate a mulitple of 8 72041f6eb021SLiane Praza * characters of encoded data, it used a pad character to get to the 8 72051f6eb021SLiane Praza * character boundry. The standard specifies that the pad character is '='. 72061f6eb021SLiane Praza * Unfortunately, '=' is not a legal character in SMF property names. 72071f6eb021SLiane Praza * Thus, the caller can specify an alternate pad character with the pad 72081f6eb021SLiane Praza * argument. If pad is 0, scf_decode32() will use '='. Note that use of 72091f6eb021SLiane Praza * anything other than '=' is not in conformance with RFC 4648. It is 72101f6eb021SLiane Praza * suitable, however, for internal use of SMF software. When the encoded 72111f6eb021SLiane Praza * data is used in SMF property names, SCF_ENCODE32_PAD should be used as 72121f6eb021SLiane Praza * the pad character. 72131f6eb021SLiane Praza * 72141f6eb021SLiane Praza * Arguments: 72151f6eb021SLiane Praza * in - Buffer of encoded characters. 72161f6eb021SLiane Praza * inlen - Number of characters at in. 72171f6eb021SLiane Praza * outbuf - Buffer to receive the decoded bytes. It can be the 72181f6eb021SLiane Praza * same buffer as in. 72191f6eb021SLiane Praza * outmax - Size of the buffer at outbuf. 72201f6eb021SLiane Praza * outlen - If it is not NULL, outlen receives the number of 72211f6eb021SLiane Praza * bytes placed in output. 72221f6eb021SLiane Praza * pad - Alternate padding character. 72231f6eb021SLiane Praza * 72241f6eb021SLiane Praza * Returns: 72251f6eb021SLiane Praza * 0 Buffer was successfully decoded. 72261f6eb021SLiane Praza * -1 Indicates an invalid input character, output buffer too 72271f6eb021SLiane Praza * small, or pad is one of the standard encoding characters. 72281f6eb021SLiane Praza */ 72291f6eb021SLiane Praza int 72301f6eb021SLiane Praza scf_decode32(const char *in, size_t inlen, char *outbuf, size_t outmax, 72311f6eb021SLiane Praza size_t *outlen, char pad) 72321f6eb021SLiane Praza { 72331f6eb021SLiane Praza char *bufend = outbuf + outmax; 72341f6eb021SLiane Praza char c; 72351f6eb021SLiane Praza uint_t count; 72361f6eb021SLiane Praza uint32_t g[DECODE32_GS]; 72371f6eb021SLiane Praza size_t i; 72381f6eb021SLiane Praza uint_t j; 72391f6eb021SLiane Praza char *out = outbuf; 72401f6eb021SLiane Praza boolean_t pad_seen = B_FALSE; 72411f6eb021SLiane Praza 72421f6eb021SLiane Praza /* If caller did not provide pad character, use the default. */ 72431f6eb021SLiane Praza if (pad == 0) { 72441f6eb021SLiane Praza pad = '='; 72451f6eb021SLiane Praza } else { 72461f6eb021SLiane Praza /* 72471f6eb021SLiane Praza * Make sure that caller's pad is not one of the encoding 72481f6eb021SLiane Praza * characters. 72491f6eb021SLiane Praza */ 72501f6eb021SLiane Praza for (i = 0; i < sizeof (base32) - 1; i++) { 72511f6eb021SLiane Praza if (pad == base32[i]) 72521f6eb021SLiane Praza return (-1); 72531f6eb021SLiane Praza } 72541f6eb021SLiane Praza } 72551f6eb021SLiane Praza 72561f6eb021SLiane Praza i = 0; 72571f6eb021SLiane Praza while ((i < inlen) && (out < bufend)) { 72581f6eb021SLiane Praza /* Get a group of input characters. */ 72591f6eb021SLiane Praza for (j = 0, count = 0; 72601f6eb021SLiane Praza (j < DECODE32_GS) && (i < inlen); 72611f6eb021SLiane Praza i++) { 72621f6eb021SLiane Praza c = in[i]; 72631f6eb021SLiane Praza /* 72641f6eb021SLiane Praza * RFC 4648 allows for the encoded data to be split 72651f6eb021SLiane Praza * into multiple lines, so skip carriage returns 72661f6eb021SLiane Praza * and new lines. 72671f6eb021SLiane Praza */ 72681f6eb021SLiane Praza if ((c == '\r') || (c == '\n')) 72691f6eb021SLiane Praza continue; 72701f6eb021SLiane Praza if ((pad_seen == B_TRUE) && (c != pad)) { 72711f6eb021SLiane Praza /* Group not completed by pads */ 72721f6eb021SLiane Praza return (-1); 72731f6eb021SLiane Praza } 72741f6eb021SLiane Praza if ((c < 0) || (c >= sizeof (index32))) { 72751f6eb021SLiane Praza /* Illegal character. */ 72761f6eb021SLiane Praza return (-1); 72771f6eb021SLiane Praza } 72781f6eb021SLiane Praza if (c == pad) { 72791f6eb021SLiane Praza pad_seen = B_TRUE; 72801f6eb021SLiane Praza continue; 72811f6eb021SLiane Praza } 72821f6eb021SLiane Praza if ((g[j++] = index32[c]) == 0xff) { 72831f6eb021SLiane Praza /* Illegal character */ 72841f6eb021SLiane Praza return (-1); 72851f6eb021SLiane Praza } 72861f6eb021SLiane Praza count++; 72871f6eb021SLiane Praza } 72881f6eb021SLiane Praza 72891f6eb021SLiane Praza /* Pack the group into five 8 bit bytes. */ 72901f6eb021SLiane Praza if ((count >= 2) && (out < bufend)) { 72911f6eb021SLiane Praza /* 72921f6eb021SLiane Praza * Output byte 0: 72931f6eb021SLiane Praza * 5 bits (7-3) from g[0] 72941f6eb021SLiane Praza * 3 bits (2-0) from g[1] (4-2) 72951f6eb021SLiane Praza */ 72961f6eb021SLiane Praza *out++ = (g[0] << 3) | ((g[1] >> 2) & 0x7); 72971f6eb021SLiane Praza } 72981f6eb021SLiane Praza if ((count >= 4) && (out < bufend)) { 72991f6eb021SLiane Praza /* 73001f6eb021SLiane Praza * Output byte 1: 73011f6eb021SLiane Praza * 2 bits (7-6) from g[1] (1-0) 73021f6eb021SLiane Praza * 5 bits (5-1) from g[2] (4-0) 73031f6eb021SLiane Praza * 1 bit (0) from g[3] (4) 73041f6eb021SLiane Praza */ 73051f6eb021SLiane Praza *out++ = (g[1] << 6) | (g[2] << 1) | \ 73061f6eb021SLiane Praza ((g[3] >> 4) & 0x1); 73071f6eb021SLiane Praza } 73081f6eb021SLiane Praza if ((count >= 5) && (out < bufend)) { 73091f6eb021SLiane Praza /* 73101f6eb021SLiane Praza * Output byte 2: 73111f6eb021SLiane Praza * 4 bits (7-4) from g[3] (3-0) 73121f6eb021SLiane Praza * 4 bits (3-0) from g[4] (4-1) 73131f6eb021SLiane Praza */ 73141f6eb021SLiane Praza *out++ = (g[3] << 4) | ((g[4] >> 1) & 0xf); 73151f6eb021SLiane Praza } 73161f6eb021SLiane Praza if ((count >= 7) && (out < bufend)) { 73171f6eb021SLiane Praza /* 73181f6eb021SLiane Praza * Output byte 3: 73191f6eb021SLiane Praza * 1 bit (7) from g[4] (0) 73201f6eb021SLiane Praza * 5 bits (6-2) from g[5] (4-0) 73211f6eb021SLiane Praza * 2 bits (0-1) from g[6] (4-3) 73221f6eb021SLiane Praza */ 73231f6eb021SLiane Praza *out++ = (g[4] << 7) | (g[5] << 2) | 73241f6eb021SLiane Praza ((g[6] >> 3) & 0x3); 73251f6eb021SLiane Praza } 73261f6eb021SLiane Praza if ((count == 8) && (out < bufend)) { 73271f6eb021SLiane Praza /* 73281f6eb021SLiane Praza * Output byte 4; 73291f6eb021SLiane Praza * 3 bits (7-5) from g[6] (2-0) 73301f6eb021SLiane Praza * 5 bits (4-0) from g[7] (4-0) 73311f6eb021SLiane Praza */ 73321f6eb021SLiane Praza *out++ = (g[6] << 5) | g[7]; 73331f6eb021SLiane Praza } 73341f6eb021SLiane Praza } 73351f6eb021SLiane Praza if (i < inlen) { 73361f6eb021SLiane Praza /* Did not process all input characters. */ 73371f6eb021SLiane Praza return (-1); 73381f6eb021SLiane Praza } 73391f6eb021SLiane Praza if (outlen) 73401f6eb021SLiane Praza *outlen = out - outbuf; 73411f6eb021SLiane Praza /* Null terminate the output if there is room. */ 73421f6eb021SLiane Praza if (out < bufend) 73431f6eb021SLiane Praza *out = 0; 73441f6eb021SLiane Praza return (0); 73451f6eb021SLiane Praza } 73461f6eb021SLiane Praza 73471f6eb021SLiane Praza 73487c478bd9Sstevel@tonic-gate /* 73497c478bd9Sstevel@tonic-gate * _scf_request_backup: a simple wrapper routine 73507c478bd9Sstevel@tonic-gate */ 73517c478bd9Sstevel@tonic-gate int 73527c478bd9Sstevel@tonic-gate _scf_request_backup(scf_handle_t *h, const char *name) 73537c478bd9Sstevel@tonic-gate { 73547c478bd9Sstevel@tonic-gate struct rep_protocol_backup_request request; 73557c478bd9Sstevel@tonic-gate struct rep_protocol_response response; 73567c478bd9Sstevel@tonic-gate 73577c478bd9Sstevel@tonic-gate int r; 73587c478bd9Sstevel@tonic-gate 73597c478bd9Sstevel@tonic-gate if (strlcpy(request.rpr_name, name, sizeof (request.rpr_name)) >= 73607c478bd9Sstevel@tonic-gate sizeof (request.rpr_name)) 73617c478bd9Sstevel@tonic-gate return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 73627c478bd9Sstevel@tonic-gate 73637c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&h->rh_lock); 73647c478bd9Sstevel@tonic-gate request.rpr_request = REP_PROTOCOL_BACKUP; 73658918dff3Sjwadams request.rpr_changeid = handle_next_changeid(h); 73667c478bd9Sstevel@tonic-gate 73677c478bd9Sstevel@tonic-gate r = make_door_call(h, &request, sizeof (request), 73687c478bd9Sstevel@tonic-gate &response, sizeof (response)); 73697c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&h->rh_lock); 73707c478bd9Sstevel@tonic-gate 73717c478bd9Sstevel@tonic-gate if (r < 0) { 73727c478bd9Sstevel@tonic-gate DOOR_ERRORS_BLOCK(r); 73737c478bd9Sstevel@tonic-gate } 73747c478bd9Sstevel@tonic-gate 73757c478bd9Sstevel@tonic-gate if (response.rpr_response != REP_PROTOCOL_SUCCESS) 73767c478bd9Sstevel@tonic-gate return (scf_set_error(proto_error(response.rpr_response))); 73777c478bd9Sstevel@tonic-gate return (SCF_SUCCESS); 73787c478bd9Sstevel@tonic-gate } 73793eae19d9Swesolows 7380c0889d7aSstevep /* 7381c0889d7aSstevep * Request svc.configd daemon to switch repository database. 7382c0889d7aSstevep * 7383c0889d7aSstevep * Can fail: 7384c0889d7aSstevep * 7385c0889d7aSstevep * _NOT_BOUND handle is not bound 7386c0889d7aSstevep * _CONNECTION_BROKEN server is not reachable 7387c0889d7aSstevep * _INTERNAL file operation error 7388c0889d7aSstevep * the server response is too big 7389c0889d7aSstevep * _PERMISSION_DENIED not enough privileges to do request 7390c0889d7aSstevep * _BACKEND_READONLY backend is not writable 7391c0889d7aSstevep * _BACKEND_ACCESS backend access fails 7392c0889d7aSstevep * _NO_RESOURCES svc.configd is out of memory 7393c0889d7aSstevep */ 7394c0889d7aSstevep int 7395c0889d7aSstevep _scf_repository_switch(scf_handle_t *h, int scf_sw) 7396c0889d7aSstevep { 7397c0889d7aSstevep struct rep_protocol_switch_request request; 7398c0889d7aSstevep struct rep_protocol_response response; 7399c0889d7aSstevep int r; 7400c0889d7aSstevep 7401c0889d7aSstevep /* 7402c0889d7aSstevep * Setup request protocol and make door call 7403c0889d7aSstevep * Hold rh_lock lock before handle_next_changeid call 7404c0889d7aSstevep */ 7405c0889d7aSstevep (void) pthread_mutex_lock(&h->rh_lock); 7406c0889d7aSstevep 7407c0889d7aSstevep request.rpr_flag = scf_sw; 7408c0889d7aSstevep request.rpr_request = REP_PROTOCOL_SWITCH; 7409c0889d7aSstevep request.rpr_changeid = handle_next_changeid(h); 7410c0889d7aSstevep 7411c0889d7aSstevep r = make_door_call(h, &request, sizeof (request), 7412c0889d7aSstevep &response, sizeof (response)); 7413c0889d7aSstevep 7414c0889d7aSstevep (void) pthread_mutex_unlock(&h->rh_lock); 7415c0889d7aSstevep 7416c0889d7aSstevep if (r < 0) { 7417c0889d7aSstevep DOOR_ERRORS_BLOCK(r); 7418c0889d7aSstevep } 7419c0889d7aSstevep 7420c0889d7aSstevep /* 7421c0889d7aSstevep * Pass protocol error up 7422c0889d7aSstevep */ 7423c0889d7aSstevep if (response.rpr_response != REP_PROTOCOL_SUCCESS) 7424c0889d7aSstevep return (scf_set_error(proto_error(response.rpr_response))); 7425c0889d7aSstevep 7426c0889d7aSstevep return (SCF_SUCCESS); 7427c0889d7aSstevep } 7428c0889d7aSstevep 74293eae19d9Swesolows int 74303eae19d9Swesolows _scf_pg_is_read_protected(const scf_propertygroup_t *pg, boolean_t *out) 74313eae19d9Swesolows { 74323eae19d9Swesolows char buf[REP_PROTOCOL_NAME_LEN]; 74333eae19d9Swesolows ssize_t res; 74343eae19d9Swesolows 74353eae19d9Swesolows res = datael_get_name(&pg->rd_d, buf, sizeof (buf), 74363eae19d9Swesolows RP_ENTITY_NAME_PGREADPROT); 74373eae19d9Swesolows 74383eae19d9Swesolows if (res == -1) 74393eae19d9Swesolows return (-1); 74403eae19d9Swesolows 74413eae19d9Swesolows if (uu_strtouint(buf, out, sizeof (*out), 0, 0, 1) == -1) 74423eae19d9Swesolows return (scf_set_error(SCF_ERROR_INTERNAL)); 74433eae19d9Swesolows return (SCF_SUCCESS); 74443eae19d9Swesolows } 74455b7f77adStw 74465b7f77adStw /* 74475b7f77adStw * _scf_set_annotation: a wrapper to set the annotation fields for SMF 74485b7f77adStw * security auditing. 74495b7f77adStw * 74505b7f77adStw * Fails with following in scf_error_key thread specific data: 74515b7f77adStw * _INVALID_ARGUMENT - operation or file too large 74525b7f77adStw * _NOT_BOUND 74535b7f77adStw * _CONNECTION_BROKEN 74545b7f77adStw * _INTERNAL 74555b7f77adStw * _NO_RESOURCES 74565b7f77adStw */ 74575b7f77adStw int 74585b7f77adStw _scf_set_annotation(scf_handle_t *h, const char *operation, const char *file) 74595b7f77adStw { 74605b7f77adStw struct rep_protocol_annotation request; 74615b7f77adStw struct rep_protocol_response response; 74625b7f77adStw size_t copied; 74635b7f77adStw int r; 74645b7f77adStw 7465a4dc1477STom Whitten if (h == NULL) { 7466a4dc1477STom Whitten /* We can't do anything if the handle is destroyed. */ 7467a4dc1477STom Whitten return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED)); 7468a4dc1477STom Whitten } 7469a4dc1477STom Whitten 74705b7f77adStw request.rpr_request = REP_PROTOCOL_SET_AUDIT_ANNOTATION; 74715b7f77adStw copied = strlcpy(request.rpr_operation, 74725b7f77adStw (operation == NULL) ? "" : operation, 74735b7f77adStw sizeof (request.rpr_operation)); 74745b7f77adStw if (copied >= sizeof (request.rpr_operation)) 74755b7f77adStw return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 74765b7f77adStw 74775b7f77adStw copied = strlcpy(request.rpr_file, 74785b7f77adStw (file == NULL) ? "" : file, 74795b7f77adStw sizeof (request.rpr_file)); 7480a4dc1477STom Whitten if (copied >= sizeof (request.rpr_file)) 74815b7f77adStw return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT)); 74825b7f77adStw 74835b7f77adStw (void) pthread_mutex_lock(&h->rh_lock); 74845b7f77adStw r = make_door_call(h, &request, sizeof (request), 74855b7f77adStw &response, sizeof (response)); 74865b7f77adStw (void) pthread_mutex_unlock(&h->rh_lock); 74875b7f77adStw 74885b7f77adStw if (r < 0) { 74895b7f77adStw DOOR_ERRORS_BLOCK(r); 74905b7f77adStw } 74915b7f77adStw 74925b7f77adStw if (response.rpr_response != REP_PROTOCOL_SUCCESS) 74935b7f77adStw return (scf_set_error(proto_error(response.rpr_response))); 74945b7f77adStw return (0); 74955b7f77adStw } 7496