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 5ee519a1fSgjelinek * Common Development and Distribution License (the "License"). 6ee519a1fSgjelinek * 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 */ 21ffbafc53Scomay 227c478bd9Sstevel@tonic-gate /* 23*a20ee416SGlenn Faden * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 26cf8f45c7Sdstaff #include <libsysevent.h> 27cf8f45c7Sdstaff #include <pthread.h> 28cf8f45c7Sdstaff #include <stdlib.h> 297c478bd9Sstevel@tonic-gate #include <errno.h> 307c478bd9Sstevel@tonic-gate #include <fnmatch.h> 317c478bd9Sstevel@tonic-gate #include <strings.h> 327c478bd9Sstevel@tonic-gate #include <unistd.h> 337c478bd9Sstevel@tonic-gate #include <assert.h> 347c478bd9Sstevel@tonic-gate #include <libgen.h> 357c478bd9Sstevel@tonic-gate #include <libintl.h> 367c478bd9Sstevel@tonic-gate #include <alloca.h> 377c478bd9Sstevel@tonic-gate #include <ctype.h> 389acbbeafSnn #include <sys/acl.h> 399acbbeafSnn #include <sys/stat.h> 409acbbeafSnn #include <sys/brand.h> 417c478bd9Sstevel@tonic-gate #include <sys/mntio.h> 427c478bd9Sstevel@tonic-gate #include <sys/mnttab.h> 43cf8f45c7Sdstaff #include <sys/nvpair.h> 449acbbeafSnn #include <sys/types.h> 45f4b3ec61Sdh #include <sys/sockio.h> 465679c89fSjv #include <sys/systeminfo.h> 47ee519a1fSgjelinek #include <ftw.h> 480209230bSgjelinek #include <pool.h> 490209230bSgjelinek #include <libscf.h> 500209230bSgjelinek #include <libproc.h> 510209230bSgjelinek #include <sys/priocntl.h> 5239935be5Sgjelinek #include <libuutil.h> 53ff17c8bfSgjelinek #include <wait.h> 54ff17c8bfSgjelinek #include <bsm/adt.h> 55cb8a054bSGlenn Faden #include <auth_attr.h> 56cb8a054bSGlenn Faden #include <auth_list.h> 57cb8a054bSGlenn Faden #include <secdb.h> 58cb8a054bSGlenn Faden #include <user_attr.h> 59cb8a054bSGlenn Faden #include <prof_attr.h> 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 627c478bd9Sstevel@tonic-gate #include <netdb.h> 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate #include <libxml/xmlmemory.h> 657c478bd9Sstevel@tonic-gate #include <libxml/parser.h> 667c478bd9Sstevel@tonic-gate 677c478bd9Sstevel@tonic-gate #include <libdevinfo.h> 68108322fbScarlsonj #include <uuid/uuid.h> 69ee519a1fSgjelinek #include <dirent.h> 709acbbeafSnn #include <libbrand.h> 71ee519a1fSgjelinek 727c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 737c478bd9Sstevel@tonic-gate #include "zonecfg_impl.h" 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate #define _PATH_TMPFILE "/zonecfg.XXXXXX" 76cf8f45c7Sdstaff #define ZONE_CB_RETRY_COUNT 10 77cf8f45c7Sdstaff #define ZONE_EVENT_PING_SUBCLASS "ping" 78cf8f45c7Sdstaff #define ZONE_EVENT_PING_PUBLISHER "solaris" 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate /* Hard-code the DTD element/attribute/entity names just once, here. */ 817c478bd9Sstevel@tonic-gate #define DTD_ELEM_ATTR (const xmlChar *) "attr" 827c478bd9Sstevel@tonic-gate #define DTD_ELEM_COMMENT (const xmlChar *) "comment" 837c478bd9Sstevel@tonic-gate #define DTD_ELEM_DEVICE (const xmlChar *) "device" 847c478bd9Sstevel@tonic-gate #define DTD_ELEM_FS (const xmlChar *) "filesystem" 857c478bd9Sstevel@tonic-gate #define DTD_ELEM_FSOPTION (const xmlChar *) "fsoption" 867c478bd9Sstevel@tonic-gate #define DTD_ELEM_IPD (const xmlChar *) "inherited-pkg-dir" 877c478bd9Sstevel@tonic-gate #define DTD_ELEM_NET (const xmlChar *) "network" 887c478bd9Sstevel@tonic-gate #define DTD_ELEM_RCTL (const xmlChar *) "rctl" 897c478bd9Sstevel@tonic-gate #define DTD_ELEM_RCTLVALUE (const xmlChar *) "rctl-value" 907c478bd9Sstevel@tonic-gate #define DTD_ELEM_ZONE (const xmlChar *) "zone" 91fa9e4066Sahrens #define DTD_ELEM_DATASET (const xmlChar *) "dataset" 920209230bSgjelinek #define DTD_ELEM_TMPPOOL (const xmlChar *) "tmp_pool" 930209230bSgjelinek #define DTD_ELEM_PSET (const xmlChar *) "pset" 940209230bSgjelinek #define DTD_ELEM_MCAP (const xmlChar *) "mcap" 95ee519a1fSgjelinek #define DTD_ELEM_PACKAGE (const xmlChar *) "package" 96ee519a1fSgjelinek #define DTD_ELEM_PATCH (const xmlChar *) "patch" 976cfd72c6Sgjelinek #define DTD_ELEM_OBSOLETES (const xmlChar *) "obsoletes" 98ee519a1fSgjelinek #define DTD_ELEM_DEV_PERM (const xmlChar *) "dev-perm" 99cb8a054bSGlenn Faden #define DTD_ELEM_ADMIN (const xmlChar *) "admin" 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate #define DTD_ATTR_ACTION (const xmlChar *) "action" 1027c478bd9Sstevel@tonic-gate #define DTD_ATTR_ADDRESS (const xmlChar *) "address" 1037c478bd9Sstevel@tonic-gate #define DTD_ATTR_AUTOBOOT (const xmlChar *) "autoboot" 104f4b3ec61Sdh #define DTD_ATTR_IPTYPE (const xmlChar *) "ip-type" 105de860bd9Sgfaden #define DTD_ATTR_DEFROUTER (const xmlChar *) "defrouter" 1067c478bd9Sstevel@tonic-gate #define DTD_ATTR_DIR (const xmlChar *) "directory" 1077c478bd9Sstevel@tonic-gate #define DTD_ATTR_LIMIT (const xmlChar *) "limit" 108ffbafc53Scomay #define DTD_ATTR_LIMITPRIV (const xmlChar *) "limitpriv" 1093f2f09c1Sdp #define DTD_ATTR_BOOTARGS (const xmlChar *) "bootargs" 1100209230bSgjelinek #define DTD_ATTR_SCHED (const xmlChar *) "scheduling-class" 1117c478bd9Sstevel@tonic-gate #define DTD_ATTR_MATCH (const xmlChar *) "match" 1127c478bd9Sstevel@tonic-gate #define DTD_ATTR_NAME (const xmlChar *) "name" 1137c478bd9Sstevel@tonic-gate #define DTD_ATTR_PHYSICAL (const xmlChar *) "physical" 1147c478bd9Sstevel@tonic-gate #define DTD_ATTR_POOL (const xmlChar *) "pool" 1157c478bd9Sstevel@tonic-gate #define DTD_ATTR_PRIV (const xmlChar *) "priv" 1167c478bd9Sstevel@tonic-gate #define DTD_ATTR_RAW (const xmlChar *) "raw" 1177c478bd9Sstevel@tonic-gate #define DTD_ATTR_SPECIAL (const xmlChar *) "special" 1187c478bd9Sstevel@tonic-gate #define DTD_ATTR_TYPE (const xmlChar *) "type" 1197c478bd9Sstevel@tonic-gate #define DTD_ATTR_VALUE (const xmlChar *) "value" 1207c478bd9Sstevel@tonic-gate #define DTD_ATTR_ZONEPATH (const xmlChar *) "zonepath" 1210209230bSgjelinek #define DTD_ATTR_NCPU_MIN (const xmlChar *) "ncpu_min" 1220209230bSgjelinek #define DTD_ATTR_NCPU_MAX (const xmlChar *) "ncpu_max" 1230209230bSgjelinek #define DTD_ATTR_IMPORTANCE (const xmlChar *) "importance" 1240209230bSgjelinek #define DTD_ATTR_PHYSCAP (const xmlChar *) "physcap" 125ee519a1fSgjelinek #define DTD_ATTR_VERSION (const xmlChar *) "version" 126ee519a1fSgjelinek #define DTD_ATTR_ID (const xmlChar *) "id" 127ee519a1fSgjelinek #define DTD_ATTR_UID (const xmlChar *) "uid" 128ee519a1fSgjelinek #define DTD_ATTR_GID (const xmlChar *) "gid" 129ee519a1fSgjelinek #define DTD_ATTR_MODE (const xmlChar *) "mode" 130ee519a1fSgjelinek #define DTD_ATTR_ACL (const xmlChar *) "acl" 1319acbbeafSnn #define DTD_ATTR_BRAND (const xmlChar *) "brand" 1325679c89fSjv #define DTD_ATTR_HOSTID (const xmlChar *) "hostid" 133cb8a054bSGlenn Faden #define DTD_ATTR_USER (const xmlChar *) "user" 134cb8a054bSGlenn Faden #define DTD_ATTR_AUTHS (const xmlChar *) "auths" 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate #define DTD_ENTITY_BOOLEAN "boolean" 1377c478bd9Sstevel@tonic-gate #define DTD_ENTITY_DEVPATH "devpath" 1387c478bd9Sstevel@tonic-gate #define DTD_ENTITY_DRIVER "driver" 1397c478bd9Sstevel@tonic-gate #define DTD_ENTITY_DRVMIN "drv_min" 1407c478bd9Sstevel@tonic-gate #define DTD_ENTITY_FALSE "false" 1417c478bd9Sstevel@tonic-gate #define DTD_ENTITY_INT "int" 1427c478bd9Sstevel@tonic-gate #define DTD_ENTITY_STRING "string" 1437c478bd9Sstevel@tonic-gate #define DTD_ENTITY_TRUE "true" 1447c478bd9Sstevel@tonic-gate #define DTD_ENTITY_UINT "uint" 1457c478bd9Sstevel@tonic-gate 146a1be23daSdp #define DTD_ENTITY_BOOL_LEN 6 /* "false" */ 147a1be23daSdp 148ee519a1fSgjelinek #define ATTACH_FORCED "SUNWattached.xml" 149ee519a1fSgjelinek 1500209230bSgjelinek #define TMP_POOL_NAME "SUNWtmp_%s" 1510209230bSgjelinek #define MAX_TMP_POOL_NAME (ZONENAME_MAX + 9) 1520209230bSgjelinek #define RCAP_SERVICE "system/rcap:default" 1530209230bSgjelinek #define POOLD_SERVICE "system/pools/dynamic:default" 1540209230bSgjelinek 1550209230bSgjelinek /* 1560209230bSgjelinek * rctl alias definitions 1570209230bSgjelinek * 1580209230bSgjelinek * This holds the alias, the full rctl name, the default priv value, action 1590209230bSgjelinek * and lower limit. The functions that handle rctl aliases step through 1600209230bSgjelinek * this table, matching on the alias, and using the full values for setting 1610209230bSgjelinek * the rctl entry as well the limit for validation. 1620209230bSgjelinek */ 1630209230bSgjelinek static struct alias { 1640209230bSgjelinek char *shortname; 1650209230bSgjelinek char *realname; 1660209230bSgjelinek char *priv; 1670209230bSgjelinek char *action; 1680209230bSgjelinek uint64_t low_limit; 1690209230bSgjelinek } aliases[] = { 1700209230bSgjelinek {ALIAS_MAXLWPS, "zone.max-lwps", "privileged", "deny", 100}, 1710209230bSgjelinek {ALIAS_MAXSHMMEM, "zone.max-shm-memory", "privileged", "deny", 0}, 1720209230bSgjelinek {ALIAS_MAXSHMIDS, "zone.max-shm-ids", "privileged", "deny", 0}, 1730209230bSgjelinek {ALIAS_MAXMSGIDS, "zone.max-msg-ids", "privileged", "deny", 0}, 1740209230bSgjelinek {ALIAS_MAXSEMIDS, "zone.max-sem-ids", "privileged", "deny", 0}, 1750209230bSgjelinek {ALIAS_MAXLOCKEDMEM, "zone.max-locked-memory", "privileged", "deny", 0}, 1760209230bSgjelinek {ALIAS_MAXSWAP, "zone.max-swap", "privileged", "deny", 0}, 1770209230bSgjelinek {ALIAS_SHARES, "zone.cpu-shares", "privileged", "none", 0}, 178c97ad5cdSakolb {ALIAS_CPUCAP, "zone.cpu-cap", "privileged", "deny", 0}, 1790209230bSgjelinek {NULL, NULL, NULL, NULL, 0} 1800209230bSgjelinek }; 1810209230bSgjelinek 1820209230bSgjelinek /* 1830209230bSgjelinek * Structure for applying rctls to a running zone. It allows important 1840209230bSgjelinek * process values to be passed together easily. 1850209230bSgjelinek */ 1860209230bSgjelinek typedef struct pr_info_handle { 1870209230bSgjelinek struct ps_prochandle *pr; 1880209230bSgjelinek pid_t pid; 1890209230bSgjelinek } pr_info_handle_t; 1900209230bSgjelinek 1917c478bd9Sstevel@tonic-gate struct zone_dochandle { 1927c478bd9Sstevel@tonic-gate char *zone_dh_rootdir; 1937c478bd9Sstevel@tonic-gate xmlDocPtr zone_dh_doc; 1947c478bd9Sstevel@tonic-gate xmlNodePtr zone_dh_cur; 1957c478bd9Sstevel@tonic-gate xmlNodePtr zone_dh_top; 196087719fdSdp boolean_t zone_dh_newzone; 197087719fdSdp boolean_t zone_dh_snapshot; 198ee519a1fSgjelinek boolean_t zone_dh_sw_inv; 199cb8a054bSGlenn Faden zone_userauths_t *zone_dh_userauths; 200087719fdSdp char zone_dh_delete_name[ZONENAME_MAX]; 2017c478bd9Sstevel@tonic-gate }; 2027c478bd9Sstevel@tonic-gate 203cf8f45c7Sdstaff struct znotify { 204cf8f45c7Sdstaff void * zn_private; 205cf8f45c7Sdstaff evchan_t *zn_eventchan; 206cf8f45c7Sdstaff int (*zn_callback)(const char *zonename, zoneid_t zid, 207cf8f45c7Sdstaff const char *newstate, const char *oldstate, hrtime_t when, void *p); 208cf8f45c7Sdstaff pthread_mutex_t zn_mutex; 209cf8f45c7Sdstaff pthread_cond_t zn_cond; 210cf8f45c7Sdstaff pthread_mutex_t zn_bigmutex; 211cf8f45c7Sdstaff volatile enum {ZN_UNLOCKED, ZN_LOCKED, ZN_PING_INFLIGHT, 212cf8f45c7Sdstaff ZN_PING_RECEIVED} zn_state; 213cf8f45c7Sdstaff char zn_subscriber_id[MAX_SUBID_LEN]; 214cf8f45c7Sdstaff volatile boolean_t zn_failed; 215cf8f45c7Sdstaff int zn_failure_count; 216cf8f45c7Sdstaff }; 217cf8f45c7Sdstaff 218ff17c8bfSgjelinek /* used to track nested zone-lock operations */ 219ff17c8bfSgjelinek static int zone_lock_cnt = 0; 2206cfd72c6Sgjelinek 221ff17c8bfSgjelinek /* used to communicate lock status to children */ 222ff17c8bfSgjelinek #define LOCK_ENV_VAR "_ZONEADM_LOCK_HELD" 223ff17c8bfSgjelinek static char zoneadm_lock_held[] = LOCK_ENV_VAR"=1"; 224ff17c8bfSgjelinek static char zoneadm_lock_not_held[] = LOCK_ENV_VAR"=0"; 22539935be5Sgjelinek 226108322fbScarlsonj char *zonecfg_root = ""; 227108322fbScarlsonj 2287c478bd9Sstevel@tonic-gate /* 2297c478bd9Sstevel@tonic-gate * For functions which return int, which is most of the functions herein, 2307c478bd9Sstevel@tonic-gate * the return values should be from the Z_foo set defined in <libzonecfg.h>. 2317c478bd9Sstevel@tonic-gate * In some instances, we take pains mapping some libc errno values to Z_foo 2327c478bd9Sstevel@tonic-gate * values from this set. 2337c478bd9Sstevel@tonic-gate */ 2347c478bd9Sstevel@tonic-gate 235108322fbScarlsonj /* 236108322fbScarlsonj * Set the root (/) path for all zonecfg configuration files. This is a 237108322fbScarlsonj * private interface used by Live Upgrade extensions to access zone 238108322fbScarlsonj * configuration inside mounted alternate boot environments. 239108322fbScarlsonj */ 240108322fbScarlsonj void 241108322fbScarlsonj zonecfg_set_root(const char *rootpath) 242108322fbScarlsonj { 243108322fbScarlsonj if (*zonecfg_root != '\0') 244108322fbScarlsonj free(zonecfg_root); 245108322fbScarlsonj if (rootpath == NULL || rootpath[0] == '\0' || rootpath[1] == '\0' || 246108322fbScarlsonj (zonecfg_root = strdup(rootpath)) == NULL) 247108322fbScarlsonj zonecfg_root = ""; 248108322fbScarlsonj } 249108322fbScarlsonj 250108322fbScarlsonj const char * 251108322fbScarlsonj zonecfg_get_root(void) 252108322fbScarlsonj { 253108322fbScarlsonj return (zonecfg_root); 254108322fbScarlsonj } 255108322fbScarlsonj 256108322fbScarlsonj boolean_t 257108322fbScarlsonj zonecfg_in_alt_root(void) 258108322fbScarlsonj { 259108322fbScarlsonj return (*zonecfg_root != '\0'); 260108322fbScarlsonj } 261108322fbScarlsonj 2627c478bd9Sstevel@tonic-gate /* 2637c478bd9Sstevel@tonic-gate * Callers of the _file_path() functions are expected to have the second 2647c478bd9Sstevel@tonic-gate * parameter be a (char foo[MAXPATHLEN]). 2657c478bd9Sstevel@tonic-gate */ 2667c478bd9Sstevel@tonic-gate 267108322fbScarlsonj static boolean_t 2687c478bd9Sstevel@tonic-gate config_file_path(const char *zonename, char *answer) 2697c478bd9Sstevel@tonic-gate { 270108322fbScarlsonj return (snprintf(answer, MAXPATHLEN, "%s%s/%s.xml", zonecfg_root, 271108322fbScarlsonj ZONE_CONFIG_ROOT, zonename) < MAXPATHLEN); 2727c478bd9Sstevel@tonic-gate } 2737c478bd9Sstevel@tonic-gate 274108322fbScarlsonj static boolean_t 275108322fbScarlsonj snap_file_path(const char *zonename, char *answer) 2767c478bd9Sstevel@tonic-gate { 277108322fbScarlsonj return (snprintf(answer, MAXPATHLEN, "%s%s/%s.snapshot.xml", 278108322fbScarlsonj zonecfg_root, ZONE_SNAPSHOT_ROOT, zonename) < MAXPATHLEN); 2797c478bd9Sstevel@tonic-gate } 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2827c478bd9Sstevel@tonic-gate static void 2837c478bd9Sstevel@tonic-gate zonecfg_error_func(void *ctx, const char *msg, ...) 2847c478bd9Sstevel@tonic-gate { 2857c478bd9Sstevel@tonic-gate /* 2867c478bd9Sstevel@tonic-gate * This function does nothing by design. Its purpose is to prevent 2877c478bd9Sstevel@tonic-gate * libxml from dumping unwanted messages to stdout/stderr. 2887c478bd9Sstevel@tonic-gate */ 2897c478bd9Sstevel@tonic-gate } 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate zone_dochandle_t 2927c478bd9Sstevel@tonic-gate zonecfg_init_handle(void) 2937c478bd9Sstevel@tonic-gate { 294087719fdSdp zone_dochandle_t handle = calloc(1, sizeof (struct zone_dochandle)); 2957c478bd9Sstevel@tonic-gate if (handle == NULL) { 2967c478bd9Sstevel@tonic-gate errno = Z_NOMEM; 2977c478bd9Sstevel@tonic-gate return (NULL); 2987c478bd9Sstevel@tonic-gate } 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate /* generic libxml initialization */ 301ced33dd6Sjv (void) xmlLineNumbersDefault(1); 3027c478bd9Sstevel@tonic-gate xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS; 3037c478bd9Sstevel@tonic-gate xmlDoValidityCheckingDefaultValue = 1; 3047c478bd9Sstevel@tonic-gate (void) xmlKeepBlanksDefault(0); 3057c478bd9Sstevel@tonic-gate xmlGetWarningsDefaultValue = 0; 3067c478bd9Sstevel@tonic-gate xmlSetGenericErrorFunc(NULL, zonecfg_error_func); 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate return (handle); 3097c478bd9Sstevel@tonic-gate } 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate int 3127c478bd9Sstevel@tonic-gate zonecfg_check_handle(zone_dochandle_t handle) 3137c478bd9Sstevel@tonic-gate { 3147c478bd9Sstevel@tonic-gate if (handle == NULL || handle->zone_dh_doc == NULL) 3157c478bd9Sstevel@tonic-gate return (Z_BAD_HANDLE); 3167c478bd9Sstevel@tonic-gate return (Z_OK); 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate void 3207c478bd9Sstevel@tonic-gate zonecfg_fini_handle(zone_dochandle_t handle) 3217c478bd9Sstevel@tonic-gate { 3227c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) == Z_OK) 3237c478bd9Sstevel@tonic-gate xmlFreeDoc(handle->zone_dh_doc); 3247c478bd9Sstevel@tonic-gate if (handle != NULL) 3257c478bd9Sstevel@tonic-gate free(handle); 3267c478bd9Sstevel@tonic-gate } 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate static int 3297c478bd9Sstevel@tonic-gate zonecfg_destroy_impl(char *filename) 3307c478bd9Sstevel@tonic-gate { 3317c478bd9Sstevel@tonic-gate if (unlink(filename) == -1) { 3327c478bd9Sstevel@tonic-gate if (errno == EACCES) 3337c478bd9Sstevel@tonic-gate return (Z_ACCES); 3347c478bd9Sstevel@tonic-gate if (errno == ENOENT) 3357c478bd9Sstevel@tonic-gate return (Z_NO_ZONE); 3367c478bd9Sstevel@tonic-gate return (Z_MISC_FS); 3377c478bd9Sstevel@tonic-gate } 3387c478bd9Sstevel@tonic-gate return (Z_OK); 3397c478bd9Sstevel@tonic-gate } 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate int 342087719fdSdp zonecfg_destroy(const char *zonename, boolean_t force) 3437c478bd9Sstevel@tonic-gate { 3447c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 345087719fdSdp struct zoneent ze; 346087719fdSdp int err, state_err; 347087719fdSdp zone_state_t state; 3487c478bd9Sstevel@tonic-gate 349108322fbScarlsonj if (!config_file_path(zonename, path)) 350108322fbScarlsonj return (Z_MISC_FS); 351087719fdSdp 352087719fdSdp state_err = zone_get_state((char *)zonename, &state); 353087719fdSdp err = access(path, W_OK); 354087719fdSdp 355087719fdSdp /* 356087719fdSdp * If there is no file, and no index entry, reliably indicate that no 357087719fdSdp * such zone exists. 358087719fdSdp */ 359087719fdSdp if ((state_err == Z_NO_ZONE) && (err == -1) && (errno == ENOENT)) 360087719fdSdp return (Z_NO_ZONE); 361087719fdSdp 362087719fdSdp /* 363087719fdSdp * Handle any other filesystem related errors (except if the XML 364087719fdSdp * file is missing, which we treat silently), unless we're forcing, 365087719fdSdp * in which case we plow on. 366087719fdSdp */ 367087719fdSdp if (err == -1 && errno != ENOENT) { 368087719fdSdp if (errno == EACCES) 369087719fdSdp return (Z_ACCES); 370087719fdSdp else if (!force) 371087719fdSdp return (Z_MISC_FS); 372087719fdSdp } 373087719fdSdp 374087719fdSdp if (state > ZONE_STATE_INSTALLED) 375087719fdSdp return (Z_BAD_ZONE_STATE); 376087719fdSdp 377087719fdSdp if (!force && state > ZONE_STATE_CONFIGURED) 378087719fdSdp return (Z_BAD_ZONE_STATE); 379087719fdSdp 380087719fdSdp /* 381087719fdSdp * Index deletion succeeds even if the entry doesn't exist. So this 382087719fdSdp * will fail only if we've had some more severe problem. 383087719fdSdp */ 384087719fdSdp bzero(&ze, sizeof (ze)); 385087719fdSdp (void) strlcpy(ze.zone_name, zonename, sizeof (ze.zone_name)); 386087719fdSdp if ((err = putzoneent(&ze, PZE_REMOVE)) != Z_OK) 387087719fdSdp if (!force) 388087719fdSdp return (err); 389087719fdSdp 390087719fdSdp err = zonecfg_destroy_impl(path); 391087719fdSdp 392087719fdSdp /* 393087719fdSdp * Treat failure to find the XML file silently, since, well, it's 394087719fdSdp * gone, and with the index file cleaned up, we're done. 395087719fdSdp */ 396087719fdSdp if (err == Z_OK || err == Z_NO_ZONE) 397087719fdSdp return (Z_OK); 398087719fdSdp return (err); 3997c478bd9Sstevel@tonic-gate } 4007c478bd9Sstevel@tonic-gate 4017c478bd9Sstevel@tonic-gate int 402108322fbScarlsonj zonecfg_destroy_snapshot(const char *zonename) 4037c478bd9Sstevel@tonic-gate { 4047c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 4057c478bd9Sstevel@tonic-gate 406108322fbScarlsonj if (!snap_file_path(zonename, path)) 407108322fbScarlsonj return (Z_MISC_FS); 4087c478bd9Sstevel@tonic-gate return (zonecfg_destroy_impl(path)); 4097c478bd9Sstevel@tonic-gate } 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate static int 412a1be23daSdp getroot(zone_dochandle_t handle, xmlNodePtr *root) 4137c478bd9Sstevel@tonic-gate { 4147c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) == Z_BAD_HANDLE) 4157c478bd9Sstevel@tonic-gate return (Z_BAD_HANDLE); 4167c478bd9Sstevel@tonic-gate 417a1be23daSdp *root = xmlDocGetRootElement(handle->zone_dh_doc); 418a1be23daSdp 419a1be23daSdp if (*root == NULL) 4207c478bd9Sstevel@tonic-gate return (Z_EMPTY_DOCUMENT); 4217c478bd9Sstevel@tonic-gate 422a1be23daSdp if (xmlStrcmp((*root)->name, DTD_ELEM_ZONE)) 4237c478bd9Sstevel@tonic-gate return (Z_WRONG_DOC_TYPE); 424a1be23daSdp 425a1be23daSdp return (Z_OK); 426a1be23daSdp } 427a1be23daSdp 428a1be23daSdp static int 429a1be23daSdp operation_prep(zone_dochandle_t handle) 430a1be23daSdp { 431a1be23daSdp xmlNodePtr root; 432a1be23daSdp int err; 433a1be23daSdp 434a1be23daSdp if ((err = getroot(handle, &root)) != 0) 435a1be23daSdp return (err); 436a1be23daSdp 437a1be23daSdp handle->zone_dh_cur = root; 438a1be23daSdp handle->zone_dh_top = root; 439a1be23daSdp return (Z_OK); 440a1be23daSdp } 441a1be23daSdp 442ffbafc53Scomay static int 443ffbafc53Scomay fetchprop(xmlNodePtr cur, const xmlChar *propname, char *dst, size_t dstsize) 444ffbafc53Scomay { 445ffbafc53Scomay xmlChar *property; 446ffbafc53Scomay size_t srcsize; 447ffbafc53Scomay 448ffbafc53Scomay if ((property = xmlGetProp(cur, propname)) == NULL) 449ffbafc53Scomay return (Z_BAD_PROPERTY); 450ffbafc53Scomay srcsize = strlcpy(dst, (char *)property, dstsize); 451ffbafc53Scomay xmlFree(property); 452ffbafc53Scomay if (srcsize >= dstsize) 453ffbafc53Scomay return (Z_TOO_BIG); 454ffbafc53Scomay return (Z_OK); 455ffbafc53Scomay } 456ffbafc53Scomay 457ffbafc53Scomay static int 458ffbafc53Scomay fetch_alloc_prop(xmlNodePtr cur, const xmlChar *propname, char **dst) 459ffbafc53Scomay { 460ffbafc53Scomay xmlChar *property; 461ffbafc53Scomay 462ffbafc53Scomay if ((property = xmlGetProp(cur, propname)) == NULL) 463ffbafc53Scomay return (Z_BAD_PROPERTY); 464ffbafc53Scomay if ((*dst = strdup((char *)property)) == NULL) { 465ffbafc53Scomay xmlFree(property); 466ffbafc53Scomay return (Z_NOMEM); 467ffbafc53Scomay } 468ffbafc53Scomay xmlFree(property); 469ffbafc53Scomay return (Z_OK); 470ffbafc53Scomay } 471ffbafc53Scomay 472a1be23daSdp static int 473a1be23daSdp getrootattr(zone_dochandle_t handle, const xmlChar *propname, 474a1be23daSdp char *propval, size_t propsize) 475a1be23daSdp { 476a1be23daSdp xmlNodePtr root; 477a1be23daSdp int err; 478a1be23daSdp 479a1be23daSdp if ((err = getroot(handle, &root)) != 0) 480a1be23daSdp return (err); 481a1be23daSdp 482ffbafc53Scomay return (fetchprop(root, propname, propval, propsize)); 483ffbafc53Scomay } 484ffbafc53Scomay 485ffbafc53Scomay static int 486ffbafc53Scomay get_alloc_rootattr(zone_dochandle_t handle, const xmlChar *propname, 487ffbafc53Scomay char **propval) 488ffbafc53Scomay { 489ffbafc53Scomay xmlNodePtr root; 490ffbafc53Scomay int err; 491ffbafc53Scomay 492ffbafc53Scomay if ((err = getroot(handle, &root)) != 0) 493ffbafc53Scomay return (err); 494ffbafc53Scomay 495ffbafc53Scomay return (fetch_alloc_prop(root, propname, propval)); 496a1be23daSdp } 497a1be23daSdp 498a1be23daSdp static int 499108322fbScarlsonj setrootattr(zone_dochandle_t handle, const xmlChar *propname, 500108322fbScarlsonj const char *propval) 501a1be23daSdp { 502a1be23daSdp int err; 503a1be23daSdp xmlNodePtr root; 504a1be23daSdp 505a1be23daSdp if ((err = getroot(handle, &root)) != Z_OK) 506a1be23daSdp return (err); 507a1be23daSdp 5080209230bSgjelinek /* 5090209230bSgjelinek * If we get a null propval remove the property (ignore return since it 5100209230bSgjelinek * may not be set to begin with). 5110209230bSgjelinek */ 5120209230bSgjelinek if (propval == NULL) { 5130209230bSgjelinek (void) xmlUnsetProp(root, propname); 5140209230bSgjelinek } else { 5150209230bSgjelinek if (xmlSetProp(root, propname, (const xmlChar *) propval) 5160209230bSgjelinek == NULL) 5170209230bSgjelinek return (Z_INVAL); 5180209230bSgjelinek } 5197c478bd9Sstevel@tonic-gate return (Z_OK); 5207c478bd9Sstevel@tonic-gate } 5217c478bd9Sstevel@tonic-gate 522087719fdSdp static void 523087719fdSdp addcomment(zone_dochandle_t handle, const char *comment) 524087719fdSdp { 525087719fdSdp xmlNodePtr node; 526087719fdSdp node = xmlNewComment((xmlChar *) comment); 527087719fdSdp 528087719fdSdp if (node != NULL) 529087719fdSdp (void) xmlAddPrevSibling(handle->zone_dh_top, node); 530087719fdSdp } 531087719fdSdp 532087719fdSdp static void 533087719fdSdp stripcomments(zone_dochandle_t handle) 534087719fdSdp { 535087719fdSdp xmlDocPtr top; 536087719fdSdp xmlNodePtr child, next; 537087719fdSdp 538087719fdSdp top = handle->zone_dh_doc; 539087719fdSdp for (child = top->xmlChildrenNode; child != NULL; child = next) { 540087719fdSdp next = child->next; 541087719fdSdp if (child->name == NULL) 542087719fdSdp continue; 543087719fdSdp if (xmlStrcmp(child->name, DTD_ELEM_COMMENT) == 0) { 544087719fdSdp next = child->next; 545087719fdSdp xmlUnlinkNode(child); 546087719fdSdp xmlFreeNode(child); 547087719fdSdp } 548087719fdSdp } 549087719fdSdp } 550087719fdSdp 551ee519a1fSgjelinek static void 552ee519a1fSgjelinek strip_sw_inv(zone_dochandle_t handle) 553ee519a1fSgjelinek { 554ee519a1fSgjelinek xmlNodePtr root, child, next; 555ee519a1fSgjelinek 556ee519a1fSgjelinek root = xmlDocGetRootElement(handle->zone_dh_doc); 557ee519a1fSgjelinek for (child = root->xmlChildrenNode; child != NULL; child = next) { 558ee519a1fSgjelinek next = child->next; 559ee519a1fSgjelinek if (child->name == NULL) 560ee519a1fSgjelinek continue; 561ee519a1fSgjelinek if (xmlStrcmp(child->name, DTD_ELEM_PACKAGE) == 0 || 562ee519a1fSgjelinek xmlStrcmp(child->name, DTD_ELEM_PATCH) == 0) { 563ee519a1fSgjelinek next = child->next; 564ee519a1fSgjelinek xmlUnlinkNode(child); 565ee519a1fSgjelinek xmlFreeNode(child); 566ee519a1fSgjelinek } 567ee519a1fSgjelinek } 568ee519a1fSgjelinek } 569ee519a1fSgjelinek 5707c478bd9Sstevel@tonic-gate static int 571108322fbScarlsonj zonecfg_get_handle_impl(const char *zonename, const char *filename, 572108322fbScarlsonj zone_dochandle_t handle) 5737c478bd9Sstevel@tonic-gate { 5747c478bd9Sstevel@tonic-gate xmlValidCtxtPtr cvp; 5757c478bd9Sstevel@tonic-gate struct stat statbuf; 5767c478bd9Sstevel@tonic-gate int valid; 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate if (zonename == NULL) 5797c478bd9Sstevel@tonic-gate return (Z_NO_ZONE); 5809acbbeafSnn 5817c478bd9Sstevel@tonic-gate if ((handle->zone_dh_doc = xmlParseFile(filename)) == NULL) { 5827c478bd9Sstevel@tonic-gate /* distinguish file not found vs. found but not parsed */ 5837c478bd9Sstevel@tonic-gate if (stat(filename, &statbuf) == 0) 5847c478bd9Sstevel@tonic-gate return (Z_INVALID_DOCUMENT); 5857c478bd9Sstevel@tonic-gate return (Z_NO_ZONE); 5867c478bd9Sstevel@tonic-gate } 5877c478bd9Sstevel@tonic-gate if ((cvp = xmlNewValidCtxt()) == NULL) 5887c478bd9Sstevel@tonic-gate return (Z_NOMEM); 5897c478bd9Sstevel@tonic-gate cvp->error = zonecfg_error_func; 5907c478bd9Sstevel@tonic-gate cvp->warning = zonecfg_error_func; 5917c478bd9Sstevel@tonic-gate valid = xmlValidateDocument(cvp, handle->zone_dh_doc); 5927c478bd9Sstevel@tonic-gate xmlFreeValidCtxt(cvp); 5937c478bd9Sstevel@tonic-gate if (valid == 0) 5947c478bd9Sstevel@tonic-gate return (Z_INVALID_DOCUMENT); 595087719fdSdp 5967c478bd9Sstevel@tonic-gate /* delete any comments such as inherited Sun copyright / ident str */ 597087719fdSdp stripcomments(handle); 5987c478bd9Sstevel@tonic-gate return (Z_OK); 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate int 602108322fbScarlsonj zonecfg_get_handle(const char *zonename, zone_dochandle_t handle) 6037c478bd9Sstevel@tonic-gate { 6047c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 6057c478bd9Sstevel@tonic-gate 606108322fbScarlsonj if (!config_file_path(zonename, path)) 607108322fbScarlsonj return (Z_MISC_FS); 608087719fdSdp handle->zone_dh_newzone = B_FALSE; 609087719fdSdp 6107c478bd9Sstevel@tonic-gate return (zonecfg_get_handle_impl(zonename, path, handle)); 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate 613ee519a1fSgjelinek int 61416ab8c7bSgjelinek zonecfg_get_attach_handle(const char *path, const char *fname, 61516ab8c7bSgjelinek const char *zonename, boolean_t preserve_sw, zone_dochandle_t handle) 616ee519a1fSgjelinek { 617ee519a1fSgjelinek char migpath[MAXPATHLEN]; 618ee519a1fSgjelinek int err; 619ee519a1fSgjelinek struct stat buf; 620ee519a1fSgjelinek 621ee519a1fSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/root", path) >= 622ee519a1fSgjelinek sizeof (migpath)) 623ee519a1fSgjelinek return (Z_NOMEM); 624ee519a1fSgjelinek 625ee519a1fSgjelinek if (stat(migpath, &buf) == -1 || !S_ISDIR(buf.st_mode)) 626ee519a1fSgjelinek return (Z_NO_ZONE); 627ee519a1fSgjelinek 62816ab8c7bSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/%s", path, fname) >= 629ee519a1fSgjelinek sizeof (migpath)) 630ee519a1fSgjelinek return (Z_NOMEM); 631ee519a1fSgjelinek 632ee519a1fSgjelinek if ((err = zonecfg_get_handle_impl(zonename, migpath, handle)) != Z_OK) 633ee519a1fSgjelinek return (err); 634ee519a1fSgjelinek 635ee519a1fSgjelinek if (!preserve_sw) 636ee519a1fSgjelinek strip_sw_inv(handle); 637ee519a1fSgjelinek 638ee519a1fSgjelinek handle->zone_dh_newzone = B_TRUE; 639ee519a1fSgjelinek if ((err = setrootattr(handle, DTD_ATTR_ZONEPATH, path)) != Z_OK) 640ee519a1fSgjelinek return (err); 641ee519a1fSgjelinek 642ee519a1fSgjelinek return (setrootattr(handle, DTD_ATTR_NAME, zonename)); 643ee519a1fSgjelinek } 644ee519a1fSgjelinek 6457c478bd9Sstevel@tonic-gate int 646108322fbScarlsonj zonecfg_get_snapshot_handle(const char *zonename, zone_dochandle_t handle) 6477c478bd9Sstevel@tonic-gate { 6487c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 6497c478bd9Sstevel@tonic-gate 650108322fbScarlsonj if (!snap_file_path(zonename, path)) 651108322fbScarlsonj return (Z_MISC_FS); 652087719fdSdp handle->zone_dh_newzone = B_FALSE; 6537c478bd9Sstevel@tonic-gate return (zonecfg_get_handle_impl(zonename, path, handle)); 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate 656087719fdSdp int 657108322fbScarlsonj zonecfg_get_template_handle(const char *template, const char *zonename, 658087719fdSdp zone_dochandle_t handle) 659087719fdSdp { 660087719fdSdp char path[MAXPATHLEN]; 661087719fdSdp int err; 662087719fdSdp 663108322fbScarlsonj if (!config_file_path(template, path)) 664108322fbScarlsonj return (Z_MISC_FS); 665087719fdSdp 666087719fdSdp if ((err = zonecfg_get_handle_impl(template, path, handle)) != Z_OK) 667087719fdSdp return (err); 668087719fdSdp handle->zone_dh_newzone = B_TRUE; 669087719fdSdp return (setrootattr(handle, DTD_ATTR_NAME, zonename)); 670087719fdSdp } 671087719fdSdp 6729acbbeafSnn int 6739acbbeafSnn zonecfg_get_xml_handle(const char *path, zone_dochandle_t handle) 6749acbbeafSnn { 6759acbbeafSnn struct stat buf; 6769acbbeafSnn int err; 6779acbbeafSnn 6789acbbeafSnn if (stat(path, &buf) == -1) 6799acbbeafSnn return (Z_MISC_FS); 6809acbbeafSnn 6819acbbeafSnn if ((err = zonecfg_get_handle_impl("xml", path, handle)) != Z_OK) 6829acbbeafSnn return (err); 6839acbbeafSnn handle->zone_dh_newzone = B_TRUE; 6849acbbeafSnn return (Z_OK); 6859acbbeafSnn } 6869acbbeafSnn 6878cd327d5Sgjelinek /* 6888cd327d5Sgjelinek * Initialize two handles from the manifest read on fd. The rem_handle 6898cd327d5Sgjelinek * is initialized from the input file, including the sw inventory. The 6908cd327d5Sgjelinek * local_handle is initialized with the same zone configuration but with 6918cd327d5Sgjelinek * no sw inventory. 6928cd327d5Sgjelinek */ 6938cd327d5Sgjelinek int 6948cd327d5Sgjelinek zonecfg_attach_manifest(int fd, zone_dochandle_t local_handle, 6958cd327d5Sgjelinek zone_dochandle_t rem_handle) 6968cd327d5Sgjelinek { 6978cd327d5Sgjelinek xmlValidCtxtPtr cvp; 6988cd327d5Sgjelinek int valid; 6998cd327d5Sgjelinek 7008cd327d5Sgjelinek /* load the manifest into the handle for the remote system */ 7018cd327d5Sgjelinek if ((rem_handle->zone_dh_doc = xmlReadFd(fd, NULL, NULL, 0)) == NULL) { 7028cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7038cd327d5Sgjelinek } 7048cd327d5Sgjelinek if ((cvp = xmlNewValidCtxt()) == NULL) 7058cd327d5Sgjelinek return (Z_NOMEM); 7068cd327d5Sgjelinek cvp->error = zonecfg_error_func; 7078cd327d5Sgjelinek cvp->warning = zonecfg_error_func; 7088cd327d5Sgjelinek valid = xmlValidateDocument(cvp, rem_handle->zone_dh_doc); 7098cd327d5Sgjelinek xmlFreeValidCtxt(cvp); 7108cd327d5Sgjelinek if (valid == 0) 7118cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7128cd327d5Sgjelinek 7138cd327d5Sgjelinek /* delete any comments such as inherited Sun copyright / ident str */ 7148cd327d5Sgjelinek stripcomments(rem_handle); 7158cd327d5Sgjelinek 7168cd327d5Sgjelinek rem_handle->zone_dh_newzone = B_TRUE; 7178cd327d5Sgjelinek rem_handle->zone_dh_sw_inv = B_TRUE; 7188cd327d5Sgjelinek 7198cd327d5Sgjelinek /* 7208cd327d5Sgjelinek * Now use the remote system handle to generate a local system handle 7218cd327d5Sgjelinek * with an identical zones configuration but no sw inventory. 7228cd327d5Sgjelinek */ 7238cd327d5Sgjelinek if ((local_handle->zone_dh_doc = xmlCopyDoc(rem_handle->zone_dh_doc, 7248cd327d5Sgjelinek 1)) == NULL) { 7258cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7268cd327d5Sgjelinek } 7278cd327d5Sgjelinek 7288cd327d5Sgjelinek /* 7298cd327d5Sgjelinek * We need to re-run xmlValidateDocument on local_handle to properly 7308cd327d5Sgjelinek * update the in-core representation of the configuration. 7318cd327d5Sgjelinek */ 7328cd327d5Sgjelinek if ((cvp = xmlNewValidCtxt()) == NULL) 7338cd327d5Sgjelinek return (Z_NOMEM); 7348cd327d5Sgjelinek cvp->error = zonecfg_error_func; 7358cd327d5Sgjelinek cvp->warning = zonecfg_error_func; 7368cd327d5Sgjelinek valid = xmlValidateDocument(cvp, local_handle->zone_dh_doc); 7378cd327d5Sgjelinek xmlFreeValidCtxt(cvp); 7388cd327d5Sgjelinek if (valid == 0) 7398cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7408cd327d5Sgjelinek 7418cd327d5Sgjelinek strip_sw_inv(local_handle); 7428cd327d5Sgjelinek 7438cd327d5Sgjelinek local_handle->zone_dh_newzone = B_TRUE; 7448cd327d5Sgjelinek local_handle->zone_dh_sw_inv = B_FALSE; 7458cd327d5Sgjelinek 7468cd327d5Sgjelinek return (Z_OK); 7478cd327d5Sgjelinek } 7488cd327d5Sgjelinek 749087719fdSdp static boolean_t 750087719fdSdp is_renaming(zone_dochandle_t handle) 751087719fdSdp { 752087719fdSdp if (handle->zone_dh_newzone) 753087719fdSdp return (B_FALSE); 754087719fdSdp if (strlen(handle->zone_dh_delete_name) > 0) 755087719fdSdp return (B_TRUE); 756087719fdSdp return (B_FALSE); 757087719fdSdp } 758087719fdSdp 759087719fdSdp static boolean_t 760087719fdSdp is_new(zone_dochandle_t handle) 761087719fdSdp { 762087719fdSdp return (handle->zone_dh_newzone || handle->zone_dh_snapshot); 763087719fdSdp } 764087719fdSdp 765087719fdSdp static boolean_t 766087719fdSdp is_snapshot(zone_dochandle_t handle) 767087719fdSdp { 768087719fdSdp return (handle->zone_dh_snapshot); 769087719fdSdp } 770087719fdSdp 771087719fdSdp /* 772087719fdSdp * It would be great to be able to use libc's ctype(3c) macros, but we 773087719fdSdp * can't, as they are locale sensitive, and it would break our limited thread 774087719fdSdp * safety if this routine had to change the app locale on the fly. 775087719fdSdp */ 776087719fdSdp int 777108322fbScarlsonj zonecfg_validate_zonename(const char *zone) 778087719fdSdp { 779087719fdSdp int i; 780087719fdSdp 781087719fdSdp if (strcmp(zone, GLOBAL_ZONENAME) == 0) 782087719fdSdp return (Z_BOGUS_ZONE_NAME); 783087719fdSdp 784087719fdSdp if (strlen(zone) >= ZONENAME_MAX) 785087719fdSdp return (Z_BOGUS_ZONE_NAME); 786087719fdSdp 787087719fdSdp if (!((zone[0] >= 'a' && zone[0] <= 'z') || 788087719fdSdp (zone[0] >= 'A' && zone[0] <= 'Z') || 789087719fdSdp (zone[0] >= '0' && zone[0] <= '9'))) 790087719fdSdp return (Z_BOGUS_ZONE_NAME); 791087719fdSdp 792087719fdSdp for (i = 1; zone[i] != '\0'; i++) { 793087719fdSdp if (!((zone[i] >= 'a' && zone[i] <= 'z') || 794087719fdSdp (zone[i] >= 'A' && zone[i] <= 'Z') || 795087719fdSdp (zone[i] >= '0' && zone[i] <= '9') || 796087719fdSdp (zone[i] == '-') || (zone[i] == '_') || (zone[i] == '.'))) 797087719fdSdp return (Z_BOGUS_ZONE_NAME); 798087719fdSdp } 799087719fdSdp 800087719fdSdp return (Z_OK); 801087719fdSdp } 802087719fdSdp 803087719fdSdp /* 804087719fdSdp * Changing the zone name requires us to track both the old and new 805087719fdSdp * name of the zone until commit time. 806087719fdSdp */ 8077c478bd9Sstevel@tonic-gate int 8087c478bd9Sstevel@tonic-gate zonecfg_get_name(zone_dochandle_t handle, char *name, size_t namesize) 8097c478bd9Sstevel@tonic-gate { 810a1be23daSdp return (getrootattr(handle, DTD_ATTR_NAME, name, namesize)); 811a1be23daSdp } 8127c478bd9Sstevel@tonic-gate 813cb8a054bSGlenn Faden static int 814cb8a054bSGlenn Faden insert_admins(zone_dochandle_t handle, char *zonename) 815cb8a054bSGlenn Faden { 816cb8a054bSGlenn Faden int err; 817cb8a054bSGlenn Faden struct zone_admintab admintab; 818cb8a054bSGlenn Faden 819cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 820cb8a054bSGlenn Faden return (err); 821cb8a054bSGlenn Faden } 822cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 823cb8a054bSGlenn Faden err = zonecfg_insert_userauths(handle, 824cb8a054bSGlenn Faden admintab.zone_admin_user, zonename); 825cb8a054bSGlenn Faden if (err != Z_OK) { 826cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 827cb8a054bSGlenn Faden return (err); 828cb8a054bSGlenn Faden } 829cb8a054bSGlenn Faden } 830cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 831cb8a054bSGlenn Faden return (Z_OK); 832cb8a054bSGlenn Faden } 833cb8a054bSGlenn Faden 834a1be23daSdp int 835a1be23daSdp zonecfg_set_name(zone_dochandle_t handle, char *name) 836a1be23daSdp { 837087719fdSdp zone_state_t state; 838087719fdSdp char curname[ZONENAME_MAX], old_delname[ZONENAME_MAX]; 839087719fdSdp int err; 840087719fdSdp 841087719fdSdp if ((err = getrootattr(handle, DTD_ATTR_NAME, curname, 842087719fdSdp sizeof (curname))) != Z_OK) 843087719fdSdp return (err); 844087719fdSdp 845087719fdSdp if (strcmp(name, curname) == 0) 846087719fdSdp return (Z_OK); 847087719fdSdp 848087719fdSdp /* 849087719fdSdp * Switching zone names to one beginning with SUNW is not permitted. 850087719fdSdp */ 851087719fdSdp if (strncmp(name, "SUNW", 4) == 0) 852087719fdSdp return (Z_BOGUS_ZONE_NAME); 853087719fdSdp 854087719fdSdp if ((err = zonecfg_validate_zonename(name)) != Z_OK) 855087719fdSdp return (err); 856087719fdSdp 857087719fdSdp /* 858087719fdSdp * Setting the name back to the original name (effectively a revert of 859087719fdSdp * the name) is fine. But if we carry on, we'll falsely identify the 860087719fdSdp * name as "in use," so special case here. 861087719fdSdp */ 862087719fdSdp if (strcmp(name, handle->zone_dh_delete_name) == 0) { 863087719fdSdp err = setrootattr(handle, DTD_ATTR_NAME, name); 864087719fdSdp handle->zone_dh_delete_name[0] = '\0'; 865087719fdSdp return (err); 866087719fdSdp } 867087719fdSdp 868087719fdSdp /* Check to see if new name chosen is already in use */ 869087719fdSdp if (zone_get_state(name, &state) != Z_NO_ZONE) 870087719fdSdp return (Z_NAME_IN_USE); 871087719fdSdp 872087719fdSdp /* 873087719fdSdp * If this isn't already "new" or in a renaming transition, then 874087719fdSdp * we're initiating a rename here; so stash the "delete name" 875087719fdSdp * (i.e. the name of the zone we'll be removing) for the rename. 876087719fdSdp */ 877087719fdSdp (void) strlcpy(old_delname, handle->zone_dh_delete_name, 878087719fdSdp sizeof (old_delname)); 879087719fdSdp if (!is_new(handle) && !is_renaming(handle)) { 880087719fdSdp /* 881087719fdSdp * Name change is allowed only when the zone we're altering 882087719fdSdp * is not ready or running. 883087719fdSdp */ 884087719fdSdp err = zone_get_state(curname, &state); 885087719fdSdp if (err == Z_OK) { 886087719fdSdp if (state > ZONE_STATE_INSTALLED) 887087719fdSdp return (Z_BAD_ZONE_STATE); 888087719fdSdp } else if (err != Z_NO_ZONE) { 889087719fdSdp return (err); 890087719fdSdp } 891087719fdSdp 892087719fdSdp (void) strlcpy(handle->zone_dh_delete_name, curname, 893087719fdSdp sizeof (handle->zone_dh_delete_name)); 894087719fdSdp assert(is_renaming(handle)); 895087719fdSdp } else if (is_renaming(handle)) { 896087719fdSdp err = zone_get_state(handle->zone_dh_delete_name, &state); 897087719fdSdp if (err == Z_OK) { 898087719fdSdp if (state > ZONE_STATE_INSTALLED) 899087719fdSdp return (Z_BAD_ZONE_STATE); 900087719fdSdp } else if (err != Z_NO_ZONE) { 901087719fdSdp return (err); 902087719fdSdp } 903087719fdSdp } 904087719fdSdp 905087719fdSdp if ((err = setrootattr(handle, DTD_ATTR_NAME, name)) != Z_OK) { 906087719fdSdp /* 907087719fdSdp * Restore the deletename to whatever it was at the 908087719fdSdp * top of the routine, since we've had a failure. 909087719fdSdp */ 910087719fdSdp (void) strlcpy(handle->zone_dh_delete_name, old_delname, 911087719fdSdp sizeof (handle->zone_dh_delete_name)); 912087719fdSdp return (err); 913087719fdSdp } 914087719fdSdp 915cb8a054bSGlenn Faden /* 916cb8a054bSGlenn Faden * Record the old admins from the old zonename 917cb8a054bSGlenn Faden * so that they can be deleted when the operation is committed. 918cb8a054bSGlenn Faden */ 919cb8a054bSGlenn Faden if ((err = insert_admins(handle, curname)) != Z_OK) 920cb8a054bSGlenn Faden return (err); 921cb8a054bSGlenn Faden else 922cb8a054bSGlenn Faden return (Z_OK); 923a1be23daSdp } 9247c478bd9Sstevel@tonic-gate 925a1be23daSdp int 926a1be23daSdp zonecfg_get_zonepath(zone_dochandle_t handle, char *path, size_t pathsize) 927a1be23daSdp { 928108322fbScarlsonj size_t len; 929108322fbScarlsonj 930108322fbScarlsonj if ((len = strlcpy(path, zonecfg_root, pathsize)) >= pathsize) 931108322fbScarlsonj return (Z_TOO_BIG); 932108322fbScarlsonj return (getrootattr(handle, DTD_ATTR_ZONEPATH, path + len, 933108322fbScarlsonj pathsize - len)); 934a1be23daSdp } 9357c478bd9Sstevel@tonic-gate 936a1be23daSdp int 937a1be23daSdp zonecfg_set_zonepath(zone_dochandle_t handle, char *zonepath) 938a1be23daSdp { 939555afedfScarlsonj size_t len; 940555afedfScarlsonj 941555afedfScarlsonj /* 942555afedfScarlsonj * The user deals in absolute paths in the running global zone, but the 943555afedfScarlsonj * internal configuration files deal with boot environment relative 944555afedfScarlsonj * paths. Strip out the alternate root when specified. 945555afedfScarlsonj */ 946555afedfScarlsonj len = strlen(zonecfg_root); 947555afedfScarlsonj if (strncmp(zonepath, zonecfg_root, len) != 0 || zonepath[len] != '/') 948555afedfScarlsonj return (Z_BAD_PROPERTY); 949555afedfScarlsonj zonepath += len; 950a1be23daSdp return (setrootattr(handle, DTD_ATTR_ZONEPATH, zonepath)); 951a1be23daSdp } 952a1be23daSdp 953e5816e35SEdward Pilatowicz static int 954e5816e35SEdward Pilatowicz i_zonecfg_get_brand(zone_dochandle_t handle, char *brand, size_t brandsize, 955e5816e35SEdward Pilatowicz boolean_t default_query) 9569acbbeafSnn { 9579acbbeafSnn int ret, sz; 9589acbbeafSnn 9599acbbeafSnn ret = getrootattr(handle, DTD_ATTR_BRAND, brand, brandsize); 9609acbbeafSnn 961e5816e35SEdward Pilatowicz /* 962e5816e35SEdward Pilatowicz * If the lookup failed, or succeeded in finding a non-null brand 963e5816e35SEdward Pilatowicz * string then return. 964e5816e35SEdward Pilatowicz */ 965e5816e35SEdward Pilatowicz if (ret != Z_OK || brand[0] != '\0') 966e5816e35SEdward Pilatowicz return (ret); 967e5816e35SEdward Pilatowicz 968e5816e35SEdward Pilatowicz if (!default_query) { 969e5816e35SEdward Pilatowicz /* If the zone has no brand, it is the default brand. */ 970b08d9f75SEdward Pilatowicz return (zonecfg_default_brand(brand, brandsize)); 9719acbbeafSnn } 9729acbbeafSnn 973e5816e35SEdward Pilatowicz /* if SUNWdefault didn't specify a brand, fallback to "native" */ 974e5816e35SEdward Pilatowicz sz = strlcpy(brand, NATIVE_BRAND_NAME, brandsize); 975e5816e35SEdward Pilatowicz if (sz >= brandsize) 976e5816e35SEdward Pilatowicz return (Z_TOO_BIG); 977e5816e35SEdward Pilatowicz return (Z_OK); 978e5816e35SEdward Pilatowicz } 979e5816e35SEdward Pilatowicz 980e5816e35SEdward Pilatowicz int 981e5816e35SEdward Pilatowicz zonecfg_get_brand(zone_dochandle_t handle, char *brand, size_t brandsize) 982e5816e35SEdward Pilatowicz { 983e5816e35SEdward Pilatowicz return (i_zonecfg_get_brand(handle, brand, brandsize, B_FALSE)); 9849acbbeafSnn } 9859acbbeafSnn 9869acbbeafSnn int 9879acbbeafSnn zonecfg_set_brand(zone_dochandle_t handle, char *brand) 9889acbbeafSnn { 9899acbbeafSnn return (setrootattr(handle, DTD_ATTR_BRAND, brand)); 9909acbbeafSnn } 9919acbbeafSnn 992a1be23daSdp int 993a1be23daSdp zonecfg_get_autoboot(zone_dochandle_t handle, boolean_t *autoboot) 994a1be23daSdp { 995a1be23daSdp char autobootstr[DTD_ENTITY_BOOL_LEN]; 996a1be23daSdp int ret; 997a1be23daSdp 998a1be23daSdp if ((ret = getrootattr(handle, DTD_ATTR_AUTOBOOT, autobootstr, 999a1be23daSdp sizeof (autobootstr))) != Z_OK) 1000a1be23daSdp return (ret); 1001a1be23daSdp 1002a1be23daSdp if (strcmp(autobootstr, DTD_ENTITY_TRUE) == 0) 1003a1be23daSdp *autoboot = B_TRUE; 1004a1be23daSdp else if (strcmp(autobootstr, DTD_ENTITY_FALSE) == 0) 1005a1be23daSdp *autoboot = B_FALSE; 1006a1be23daSdp else 1007a1be23daSdp ret = Z_BAD_PROPERTY; 1008a1be23daSdp return (ret); 1009a1be23daSdp } 1010a1be23daSdp 1011a1be23daSdp int 1012a1be23daSdp zonecfg_set_autoboot(zone_dochandle_t handle, boolean_t autoboot) 1013a1be23daSdp { 1014a1be23daSdp return (setrootattr(handle, DTD_ATTR_AUTOBOOT, 1015a1be23daSdp autoboot ? DTD_ENTITY_TRUE : DTD_ENTITY_FALSE)); 1016a1be23daSdp } 1017a1be23daSdp 1018a1be23daSdp int 1019a1be23daSdp zonecfg_get_pool(zone_dochandle_t handle, char *pool, size_t poolsize) 1020a1be23daSdp { 1021a1be23daSdp return (getrootattr(handle, DTD_ATTR_POOL, pool, poolsize)); 1022a1be23daSdp } 1023a1be23daSdp 1024a1be23daSdp int 1025a1be23daSdp zonecfg_set_pool(zone_dochandle_t handle, char *pool) 1026a1be23daSdp { 1027a1be23daSdp return (setrootattr(handle, DTD_ATTR_POOL, pool)); 1028a1be23daSdp } 1029a1be23daSdp 1030ffbafc53Scomay int 1031ffbafc53Scomay zonecfg_get_limitpriv(zone_dochandle_t handle, char **limitpriv) 1032ffbafc53Scomay { 1033ffbafc53Scomay return (get_alloc_rootattr(handle, DTD_ATTR_LIMITPRIV, limitpriv)); 1034ffbafc53Scomay } 1035ffbafc53Scomay 1036ffbafc53Scomay int 10373f2f09c1Sdp zonecfg_set_limitpriv(zone_dochandle_t handle, char *limitpriv) 1038ffbafc53Scomay { 10393f2f09c1Sdp return (setrootattr(handle, DTD_ATTR_LIMITPRIV, limitpriv)); 10403f2f09c1Sdp } 10413f2f09c1Sdp 10423f2f09c1Sdp int 10433f2f09c1Sdp zonecfg_get_bootargs(zone_dochandle_t handle, char *bargs, size_t bargssize) 10443f2f09c1Sdp { 10453f2f09c1Sdp return (getrootattr(handle, DTD_ATTR_BOOTARGS, bargs, bargssize)); 10463f2f09c1Sdp } 10473f2f09c1Sdp 10483f2f09c1Sdp int 10493f2f09c1Sdp zonecfg_set_bootargs(zone_dochandle_t handle, char *bargs) 10503f2f09c1Sdp { 10513f2f09c1Sdp return (setrootattr(handle, DTD_ATTR_BOOTARGS, bargs)); 1052ffbafc53Scomay } 1053ffbafc53Scomay 10540209230bSgjelinek int 10550209230bSgjelinek zonecfg_get_sched_class(zone_dochandle_t handle, char *sched, size_t schedsize) 10560209230bSgjelinek { 10570209230bSgjelinek return (getrootattr(handle, DTD_ATTR_SCHED, sched, schedsize)); 10580209230bSgjelinek } 10590209230bSgjelinek 10600209230bSgjelinek int 10610209230bSgjelinek zonecfg_set_sched(zone_dochandle_t handle, char *sched) 10620209230bSgjelinek { 10630209230bSgjelinek return (setrootattr(handle, DTD_ATTR_SCHED, sched)); 10640209230bSgjelinek } 10650209230bSgjelinek 1066a1be23daSdp /* 1067a1be23daSdp * /etc/zones/index caches a vital piece of information which is also 1068a1be23daSdp * in the <zonename>.xml file: the path to the zone. This is for performance, 1069a1be23daSdp * since we need to walk all zonepath's in order to be able to detect conflicts 1070a1be23daSdp * (see crosscheck_zonepaths() in the zoneadm command). 1071087719fdSdp * 1072087719fdSdp * An additional complexity is that when doing a rename, we'd like the entire 1073087719fdSdp * index update operation (rename, and potential state changes) to be atomic. 1074087719fdSdp * In general, the operation of this function should succeed or fail as 1075087719fdSdp * a unit. 1076a1be23daSdp */ 1077a1be23daSdp int 1078a1be23daSdp zonecfg_refresh_index_file(zone_dochandle_t handle) 1079a1be23daSdp { 1080a1be23daSdp char name[ZONENAME_MAX], zonepath[MAXPATHLEN]; 1081a1be23daSdp struct zoneent ze; 1082a1be23daSdp int err; 1083087719fdSdp int opcode; 1084087719fdSdp char *zn; 1085087719fdSdp 1086087719fdSdp bzero(&ze, sizeof (ze)); 1087087719fdSdp ze.zone_state = -1; /* Preserve existing state in index */ 1088a1be23daSdp 1089a1be23daSdp if ((err = zonecfg_get_name(handle, name, sizeof (name))) != Z_OK) 1090a1be23daSdp return (err); 1091087719fdSdp (void) strlcpy(ze.zone_name, name, sizeof (ze.zone_name)); 1092087719fdSdp 1093a1be23daSdp if ((err = zonecfg_get_zonepath(handle, zonepath, 1094a1be23daSdp sizeof (zonepath))) != Z_OK) 1095a1be23daSdp return (err); 1096555afedfScarlsonj (void) strlcpy(ze.zone_path, zonepath + strlen(zonecfg_root), 1097555afedfScarlsonj sizeof (ze.zone_path)); 1098087719fdSdp 1099087719fdSdp if (is_renaming(handle)) { 1100087719fdSdp opcode = PZE_MODIFY; 1101087719fdSdp (void) strlcpy(ze.zone_name, handle->zone_dh_delete_name, 1102087719fdSdp sizeof (ze.zone_name)); 1103087719fdSdp (void) strlcpy(ze.zone_newname, name, sizeof (ze.zone_newname)); 1104087719fdSdp } else if (is_new(handle)) { 1105087719fdSdp FILE *cookie; 1106087719fdSdp /* 1107087719fdSdp * Be tolerant of the zone already existing in the index file, 1108087719fdSdp * since we might be forcibly overwriting an existing 1109087719fdSdp * configuration with a new one (for example 'create -F' 1110087719fdSdp * in zonecfg). 1111087719fdSdp */ 1112087719fdSdp opcode = PZE_ADD; 1113087719fdSdp cookie = setzoneent(); 1114087719fdSdp while ((zn = getzoneent(cookie)) != NULL) { 1115087719fdSdp if (strcmp(zn, name) == 0) { 1116087719fdSdp opcode = PZE_MODIFY; 1117087719fdSdp free(zn); 1118087719fdSdp break; 1119087719fdSdp } 1120087719fdSdp free(zn); 1121087719fdSdp } 1122087719fdSdp endzoneent(cookie); 1123087719fdSdp ze.zone_state = ZONE_STATE_CONFIGURED; 1124087719fdSdp } else { 1125087719fdSdp opcode = PZE_MODIFY; 1126087719fdSdp } 1127087719fdSdp 1128087719fdSdp if ((err = putzoneent(&ze, opcode)) != Z_OK) 1129087719fdSdp return (err); 1130087719fdSdp 1131087719fdSdp return (Z_OK); 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate 1134087719fdSdp /* 1135087719fdSdp * The goal of this routine is to cause the index file update and the 1136087719fdSdp * document save to happen as an atomic operation. We do the document 1137087719fdSdp * first, saving a backup copy using a hard link; if that succeeds, we go 1138087719fdSdp * on to the index. If that fails, we roll the document back into place. 1139087719fdSdp * 1140087719fdSdp * Strategy: 1141087719fdSdp * 1142087719fdSdp * New zone 'foo' configuration: 1143087719fdSdp * Create tmpfile (zonecfg.xxxxxx) 1144087719fdSdp * Write XML to tmpfile 1145087719fdSdp * Rename tmpfile to xmlfile (zonecfg.xxxxxx -> foo.xml) 1146087719fdSdp * Add entry to index file 1147087719fdSdp * If it fails, delete foo.xml, leaving nothing behind. 1148087719fdSdp * 1149087719fdSdp * Save existing zone 'foo': 1150087719fdSdp * Make backup of foo.xml -> .backup 1151087719fdSdp * Create tmpfile (zonecfg.xxxxxx) 1152087719fdSdp * Write XML to tmpfile 1153087719fdSdp * Rename tmpfile to xmlfile (zonecfg.xxxxxx -> foo.xml) 1154087719fdSdp * Modify index file as needed 1155087719fdSdp * If it fails, recover from .backup -> foo.xml 1156087719fdSdp * 1157087719fdSdp * Rename 'foo' to 'bar': 1158087719fdSdp * Create tmpfile (zonecfg.xxxxxx) 1159087719fdSdp * Write XML to tmpfile 1160087719fdSdp * Rename tmpfile to xmlfile (zonecfg.xxxxxx -> bar.xml) 1161087719fdSdp * Add entry for 'bar' to index file, Remove entry for 'foo' (refresh) 1162087719fdSdp * If it fails, delete bar.xml; foo.xml is left behind. 1163087719fdSdp */ 11647c478bd9Sstevel@tonic-gate static int 11657c478bd9Sstevel@tonic-gate zonecfg_save_impl(zone_dochandle_t handle, char *filename) 11667c478bd9Sstevel@tonic-gate { 11677c478bd9Sstevel@tonic-gate char tmpfile[MAXPATHLEN]; 1168087719fdSdp char bakdir[MAXPATHLEN], bakbase[MAXPATHLEN], bakfile[MAXPATHLEN]; 11699acbbeafSnn int tmpfd, err, valid; 11707c478bd9Sstevel@tonic-gate xmlValidCtxt cvp = { NULL }; 1171087719fdSdp boolean_t backup; 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate (void) strlcpy(tmpfile, filename, sizeof (tmpfile)); 11747c478bd9Sstevel@tonic-gate (void) dirname(tmpfile); 11757c478bd9Sstevel@tonic-gate (void) strlcat(tmpfile, _PATH_TMPFILE, sizeof (tmpfile)); 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate tmpfd = mkstemp(tmpfile); 11787c478bd9Sstevel@tonic-gate if (tmpfd == -1) { 11797c478bd9Sstevel@tonic-gate (void) unlink(tmpfile); 11807c478bd9Sstevel@tonic-gate return (Z_TEMP_FILE); 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate (void) close(tmpfd); 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate cvp.error = zonecfg_error_func; 11857c478bd9Sstevel@tonic-gate cvp.warning = zonecfg_error_func; 11867c478bd9Sstevel@tonic-gate 1187087719fdSdp /* 11889acbbeafSnn * We do a final validation of the document. Since the library has 11899acbbeafSnn * malfunctioned if it fails to validate, we follow-up with an 11909acbbeafSnn * assert() that the doc is valid. 1191087719fdSdp */ 11929acbbeafSnn valid = xmlValidateDocument(&cvp, handle->zone_dh_doc); 11939acbbeafSnn assert(valid != 0); 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate if (xmlSaveFormatFile(tmpfile, handle->zone_dh_doc, 1) <= 0) 11967c478bd9Sstevel@tonic-gate goto err; 1197087719fdSdp 11987c478bd9Sstevel@tonic-gate (void) chmod(tmpfile, 0644); 11997c478bd9Sstevel@tonic-gate 1200087719fdSdp /* 1201087719fdSdp * In the event we are doing a standard save, hard link a copy of the 1202087719fdSdp * original file in .backup.<pid>.filename so we can restore it if 1203087719fdSdp * something goes wrong. 1204087719fdSdp */ 1205087719fdSdp if (!is_new(handle) && !is_renaming(handle)) { 1206087719fdSdp backup = B_TRUE; 1207087719fdSdp 1208087719fdSdp (void) strlcpy(bakdir, filename, sizeof (bakdir)); 1209087719fdSdp (void) strlcpy(bakbase, filename, sizeof (bakbase)); 1210087719fdSdp (void) snprintf(bakfile, sizeof (bakfile), "%s/.backup.%d.%s", 1211087719fdSdp dirname(bakdir), getpid(), basename(bakbase)); 1212087719fdSdp 1213087719fdSdp if (link(filename, bakfile) == -1) { 1214087719fdSdp err = errno; 1215087719fdSdp (void) unlink(tmpfile); 1216087719fdSdp if (errno == EACCES) 1217087719fdSdp return (Z_ACCES); 1218087719fdSdp return (Z_MISC_FS); 1219087719fdSdp } 1220087719fdSdp } 1221087719fdSdp 1222087719fdSdp /* 1223087719fdSdp * Move the new document over top of the old. 1224087719fdSdp * i.e.: zonecfg.XXXXXX -> myzone.xml 1225087719fdSdp */ 12267c478bd9Sstevel@tonic-gate if (rename(tmpfile, filename) == -1) { 1227087719fdSdp err = errno; 12287c478bd9Sstevel@tonic-gate (void) unlink(tmpfile); 1229087719fdSdp if (backup) 1230087719fdSdp (void) unlink(bakfile); 1231087719fdSdp if (err == EACCES) 12327c478bd9Sstevel@tonic-gate return (Z_ACCES); 12337c478bd9Sstevel@tonic-gate return (Z_MISC_FS); 12347c478bd9Sstevel@tonic-gate } 1235a1be23daSdp 1236087719fdSdp /* 1237087719fdSdp * If this is a snapshot, we're done-- don't add an index entry. 1238087719fdSdp */ 1239087719fdSdp if (is_snapshot(handle)) 1240087719fdSdp return (Z_OK); 1241087719fdSdp 1242087719fdSdp /* now update the index file to reflect whatever we just did */ 1243087719fdSdp if ((err = zonecfg_refresh_index_file(handle)) != Z_OK) { 1244087719fdSdp if (backup) { 1245087719fdSdp /* 1246087719fdSdp * Try to restore from our backup. 1247087719fdSdp */ 1248087719fdSdp (void) unlink(filename); 1249087719fdSdp (void) rename(bakfile, filename); 1250087719fdSdp } else { 1251087719fdSdp /* 1252087719fdSdp * Either the zone is new, in which case we can delete 1253087719fdSdp * new.xml, or we're doing a rename, so ditto. 1254087719fdSdp */ 1255087719fdSdp assert(is_new(handle) || is_renaming(handle)); 1256087719fdSdp (void) unlink(filename); 1257087719fdSdp } 1258087719fdSdp return (Z_UPDATING_INDEX); 1259087719fdSdp } 1260087719fdSdp 1261087719fdSdp if (backup) 1262087719fdSdp (void) unlink(bakfile); 1263087719fdSdp 1264087719fdSdp return (Z_OK); 12657c478bd9Sstevel@tonic-gate 12667c478bd9Sstevel@tonic-gate err: 12677c478bd9Sstevel@tonic-gate (void) unlink(tmpfile); 12687c478bd9Sstevel@tonic-gate return (Z_SAVING_FILE); 12697c478bd9Sstevel@tonic-gate } 12707c478bd9Sstevel@tonic-gate 12717c478bd9Sstevel@tonic-gate int 12727c478bd9Sstevel@tonic-gate zonecfg_save(zone_dochandle_t handle) 12737c478bd9Sstevel@tonic-gate { 1274087719fdSdp char zname[ZONENAME_MAX], path[MAXPATHLEN]; 1275087719fdSdp char delpath[MAXPATHLEN]; 1276087719fdSdp int err = Z_SAVING_FILE; 1277087719fdSdp 1278087719fdSdp if (zonecfg_check_handle(handle) != Z_OK) 1279087719fdSdp return (Z_BAD_HANDLE); 12807c478bd9Sstevel@tonic-gate 1281087719fdSdp /* 1282ee519a1fSgjelinek * We don't support saving snapshots or a tree containing a sw 1283ee519a1fSgjelinek * inventory at this time. 1284087719fdSdp */ 1285ee519a1fSgjelinek if (handle->zone_dh_snapshot || handle->zone_dh_sw_inv) 1286087719fdSdp return (Z_INVAL); 1287087719fdSdp 1288087719fdSdp if ((err = zonecfg_get_name(handle, zname, sizeof (zname))) != Z_OK) 12897c478bd9Sstevel@tonic-gate return (err); 1290087719fdSdp 1291108322fbScarlsonj if (!config_file_path(zname, path)) 1292108322fbScarlsonj return (Z_MISC_FS); 1293087719fdSdp 1294087719fdSdp addcomment(handle, "\n DO NOT EDIT THIS " 1295087719fdSdp "FILE. Use zonecfg(1M) instead.\n"); 1296087719fdSdp 1297cb8a054bSGlenn Faden /* 1298cb8a054bSGlenn Faden * Update user_attr first so that it will be older 1299cb8a054bSGlenn Faden * than the config file. 1300cb8a054bSGlenn Faden */ 1301cb8a054bSGlenn Faden (void) zonecfg_authorize_users(handle, zname); 1302087719fdSdp err = zonecfg_save_impl(handle, path); 1303087719fdSdp 1304087719fdSdp stripcomments(handle); 1305087719fdSdp 1306087719fdSdp if (err != Z_OK) 1307087719fdSdp return (err); 1308087719fdSdp 1309087719fdSdp handle->zone_dh_newzone = B_FALSE; 1310087719fdSdp 1311087719fdSdp if (is_renaming(handle)) { 1312108322fbScarlsonj if (config_file_path(handle->zone_dh_delete_name, delpath)) 1313108322fbScarlsonj (void) unlink(delpath); 1314087719fdSdp handle->zone_dh_delete_name[0] = '\0'; 1315087719fdSdp } 1316087719fdSdp 1317087719fdSdp return (Z_OK); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate 13209acbbeafSnn int 13219acbbeafSnn zonecfg_verify_save(zone_dochandle_t handle, char *filename) 13229acbbeafSnn { 13239acbbeafSnn int valid; 13249acbbeafSnn 13259acbbeafSnn xmlValidCtxt cvp = { NULL }; 13269acbbeafSnn 13279acbbeafSnn if (zonecfg_check_handle(handle) != Z_OK) 13289acbbeafSnn return (Z_BAD_HANDLE); 13299acbbeafSnn 13309acbbeafSnn cvp.error = zonecfg_error_func; 13319acbbeafSnn cvp.warning = zonecfg_error_func; 13329acbbeafSnn 13339acbbeafSnn /* 13349acbbeafSnn * We do a final validation of the document. Since the library has 13359acbbeafSnn * malfunctioned if it fails to validate, we follow-up with an 13369acbbeafSnn * assert() that the doc is valid. 13379acbbeafSnn */ 13389acbbeafSnn valid = xmlValidateDocument(&cvp, handle->zone_dh_doc); 13399acbbeafSnn assert(valid != 0); 13409acbbeafSnn 13419acbbeafSnn if (xmlSaveFormatFile(filename, handle->zone_dh_doc, 1) <= 0) 13429acbbeafSnn return (Z_SAVING_FILE); 13439acbbeafSnn 13449acbbeafSnn return (Z_OK); 13459acbbeafSnn } 13469acbbeafSnn 1347ee519a1fSgjelinek int 13488cd327d5Sgjelinek zonecfg_detach_save(zone_dochandle_t handle, uint_t flags) 1349ee519a1fSgjelinek { 1350ee519a1fSgjelinek char zname[ZONENAME_MAX]; 1351ee519a1fSgjelinek char path[MAXPATHLEN]; 1352ee519a1fSgjelinek char migpath[MAXPATHLEN]; 1353ee519a1fSgjelinek xmlValidCtxt cvp = { NULL }; 1354ee519a1fSgjelinek int err = Z_SAVING_FILE; 13559acbbeafSnn int valid; 1356ee519a1fSgjelinek 1357ee519a1fSgjelinek if (zonecfg_check_handle(handle) != Z_OK) 1358ee519a1fSgjelinek return (Z_BAD_HANDLE); 1359ee519a1fSgjelinek 13608cd327d5Sgjelinek if (flags & ZONE_DRY_RUN) { 13618cd327d5Sgjelinek (void) strlcpy(migpath, "-", sizeof (migpath)); 13628cd327d5Sgjelinek } else { 13638cd327d5Sgjelinek if ((err = zonecfg_get_name(handle, zname, sizeof (zname))) 13648cd327d5Sgjelinek != Z_OK) 13658cd327d5Sgjelinek return (err); 1366ee519a1fSgjelinek 13678cd327d5Sgjelinek if ((err = zone_get_zonepath(zname, path, sizeof (path))) 13688cd327d5Sgjelinek != Z_OK) 13698cd327d5Sgjelinek return (err); 1370ee519a1fSgjelinek 137116ab8c7bSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/%s", path, 137216ab8c7bSgjelinek ZONE_DETACHED) >= sizeof (migpath)) 13738cd327d5Sgjelinek return (Z_NOMEM); 13748cd327d5Sgjelinek } 1375ee519a1fSgjelinek 1376ee519a1fSgjelinek if ((err = operation_prep(handle)) != Z_OK) 1377ee519a1fSgjelinek return (err); 1378ee519a1fSgjelinek 1379ee519a1fSgjelinek addcomment(handle, "\n DO NOT EDIT THIS FILE. " 1380ee519a1fSgjelinek "Use zonecfg(1M) and zoneadm(1M) attach.\n"); 1381ee519a1fSgjelinek 1382ee519a1fSgjelinek cvp.error = zonecfg_error_func; 1383ee519a1fSgjelinek cvp.warning = zonecfg_error_func; 1384ee519a1fSgjelinek 1385ee519a1fSgjelinek /* 13869acbbeafSnn * We do a final validation of the document. Since the library has 13879acbbeafSnn * malfunctioned if it fails to validate, we follow-up with an 13889acbbeafSnn * assert() that the doc is valid. 1389ee519a1fSgjelinek */ 13909acbbeafSnn valid = xmlValidateDocument(&cvp, handle->zone_dh_doc); 13919acbbeafSnn assert(valid != 0); 1392ee519a1fSgjelinek 1393ee519a1fSgjelinek if (xmlSaveFormatFile(migpath, handle->zone_dh_doc, 1) <= 0) 1394ee519a1fSgjelinek return (Z_SAVING_FILE); 1395ee519a1fSgjelinek 13968cd327d5Sgjelinek if (!(flags & ZONE_DRY_RUN)) 13978cd327d5Sgjelinek (void) chmod(migpath, 0644); 1398ee519a1fSgjelinek 1399ee519a1fSgjelinek stripcomments(handle); 1400ee519a1fSgjelinek 1401ee519a1fSgjelinek handle->zone_dh_newzone = B_FALSE; 1402ee519a1fSgjelinek 1403ee519a1fSgjelinek return (Z_OK); 1404ee519a1fSgjelinek } 1405ee519a1fSgjelinek 1406ee519a1fSgjelinek boolean_t 1407ee519a1fSgjelinek zonecfg_detached(const char *path) 1408ee519a1fSgjelinek { 1409ee519a1fSgjelinek char migpath[MAXPATHLEN]; 1410ee519a1fSgjelinek struct stat buf; 1411ee519a1fSgjelinek 141216ab8c7bSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/%s", path, ZONE_DETACHED) >= 1413ee519a1fSgjelinek sizeof (migpath)) 1414ee519a1fSgjelinek return (B_FALSE); 1415ee519a1fSgjelinek 1416ee519a1fSgjelinek if (stat(migpath, &buf) != -1) 1417ee519a1fSgjelinek return (B_TRUE); 1418ee519a1fSgjelinek 1419ee519a1fSgjelinek return (B_FALSE); 1420ee519a1fSgjelinek } 1421ee519a1fSgjelinek 1422ee519a1fSgjelinek void 1423ee519a1fSgjelinek zonecfg_rm_detached(zone_dochandle_t handle, boolean_t forced) 1424ee519a1fSgjelinek { 1425ee519a1fSgjelinek char zname[ZONENAME_MAX]; 1426ee519a1fSgjelinek char path[MAXPATHLEN]; 1427ee519a1fSgjelinek char detached[MAXPATHLEN]; 1428ee519a1fSgjelinek char attached[MAXPATHLEN]; 1429ee519a1fSgjelinek 1430ee519a1fSgjelinek if (zonecfg_check_handle(handle) != Z_OK) 1431ee519a1fSgjelinek return; 1432ee519a1fSgjelinek 1433ee519a1fSgjelinek if (zonecfg_get_name(handle, zname, sizeof (zname)) != Z_OK) 1434ee519a1fSgjelinek return; 1435ee519a1fSgjelinek 1436ee519a1fSgjelinek if (zone_get_zonepath(zname, path, sizeof (path)) != Z_OK) 1437ee519a1fSgjelinek return; 1438ee519a1fSgjelinek 143916ab8c7bSgjelinek (void) snprintf(detached, sizeof (detached), "%s/%s", path, 144016ab8c7bSgjelinek ZONE_DETACHED); 1441ee519a1fSgjelinek (void) snprintf(attached, sizeof (attached), "%s/%s", path, 1442ee519a1fSgjelinek ATTACH_FORCED); 1443ee519a1fSgjelinek 1444ee519a1fSgjelinek if (forced) { 1445ee519a1fSgjelinek (void) rename(detached, attached); 1446ee519a1fSgjelinek } else { 1447ee519a1fSgjelinek (void) unlink(attached); 1448ee519a1fSgjelinek (void) unlink(detached); 1449ee519a1fSgjelinek } 1450ee519a1fSgjelinek } 1451ee519a1fSgjelinek 14527c478bd9Sstevel@tonic-gate /* 14537c478bd9Sstevel@tonic-gate * Special case: if access(2) fails with ENOENT, then try again using 14547c478bd9Sstevel@tonic-gate * ZONE_CONFIG_ROOT instead of config_file_path(zonename). This is how we 14557c478bd9Sstevel@tonic-gate * work around the case of a config file which has not been created yet: 14567c478bd9Sstevel@tonic-gate * the user will need access to the directory so use that as a heuristic. 14577c478bd9Sstevel@tonic-gate */ 14587c478bd9Sstevel@tonic-gate 14597c478bd9Sstevel@tonic-gate int 14607c478bd9Sstevel@tonic-gate zonecfg_access(const char *zonename, int amode) 14617c478bd9Sstevel@tonic-gate { 14627c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 14637c478bd9Sstevel@tonic-gate 1464108322fbScarlsonj if (!config_file_path(zonename, path)) 1465108322fbScarlsonj return (Z_INVAL); 14667c478bd9Sstevel@tonic-gate if (access(path, amode) == 0) 14677c478bd9Sstevel@tonic-gate return (Z_OK); 1468108322fbScarlsonj if (errno == ENOENT) { 1469108322fbScarlsonj if (snprintf(path, sizeof (path), "%s%s", zonecfg_root, 1470108322fbScarlsonj ZONE_CONFIG_ROOT) >= sizeof (path)) 1471108322fbScarlsonj return (Z_INVAL); 1472108322fbScarlsonj if (access(path, amode) == 0) 1473108322fbScarlsonj return (Z_OK); 1474108322fbScarlsonj } 14757c478bd9Sstevel@tonic-gate if (errno == EACCES) 14767c478bd9Sstevel@tonic-gate return (Z_ACCES); 14777c478bd9Sstevel@tonic-gate if (errno == EINVAL) 14787c478bd9Sstevel@tonic-gate return (Z_INVAL); 14797c478bd9Sstevel@tonic-gate return (Z_MISC_FS); 14807c478bd9Sstevel@tonic-gate } 14817c478bd9Sstevel@tonic-gate 14827c478bd9Sstevel@tonic-gate int 1483108322fbScarlsonj zonecfg_create_snapshot(const char *zonename) 14847c478bd9Sstevel@tonic-gate { 14857c478bd9Sstevel@tonic-gate zone_dochandle_t handle; 14867c478bd9Sstevel@tonic-gate char path[MAXPATHLEN], zonepath[MAXPATHLEN], rpath[MAXPATHLEN]; 14877c478bd9Sstevel@tonic-gate int error = Z_OK, res; 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 14907c478bd9Sstevel@tonic-gate return (Z_NOMEM); 14917c478bd9Sstevel@tonic-gate } 14927c478bd9Sstevel@tonic-gate 1493087719fdSdp handle->zone_dh_newzone = B_TRUE; 1494087719fdSdp handle->zone_dh_snapshot = B_TRUE; 1495087719fdSdp 14967c478bd9Sstevel@tonic-gate if ((error = zonecfg_get_handle(zonename, handle)) != Z_OK) 14977c478bd9Sstevel@tonic-gate goto out; 14987c478bd9Sstevel@tonic-gate if ((error = operation_prep(handle)) != Z_OK) 14997c478bd9Sstevel@tonic-gate goto out; 15007c478bd9Sstevel@tonic-gate error = zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)); 15017c478bd9Sstevel@tonic-gate if (error != Z_OK) 15027c478bd9Sstevel@tonic-gate goto out; 15037c478bd9Sstevel@tonic-gate if ((res = resolvepath(zonepath, rpath, sizeof (rpath))) == -1) { 15047c478bd9Sstevel@tonic-gate error = Z_RESOLVED_PATH; 15057c478bd9Sstevel@tonic-gate goto out; 15067c478bd9Sstevel@tonic-gate } 15077c478bd9Sstevel@tonic-gate /* 15087c478bd9Sstevel@tonic-gate * If the resolved path is not the same as the original path, then 15097c478bd9Sstevel@tonic-gate * save the resolved path in the snapshot, thus preventing any 15107c478bd9Sstevel@tonic-gate * potential problems down the line when zoneadmd goes to unmount 15117c478bd9Sstevel@tonic-gate * file systems and depends on initial string matches with resolved 15127c478bd9Sstevel@tonic-gate * paths. 15137c478bd9Sstevel@tonic-gate */ 15147c478bd9Sstevel@tonic-gate rpath[res] = '\0'; 15157c478bd9Sstevel@tonic-gate if (strcmp(zonepath, rpath) != 0) { 15167c478bd9Sstevel@tonic-gate if ((error = zonecfg_set_zonepath(handle, rpath)) != Z_OK) 15177c478bd9Sstevel@tonic-gate goto out; 15187c478bd9Sstevel@tonic-gate } 1519108322fbScarlsonj if (snprintf(path, sizeof (path), "%s%s", zonecfg_root, 1520108322fbScarlsonj ZONE_SNAPSHOT_ROOT) >= sizeof (path)) { 1521108322fbScarlsonj error = Z_MISC_FS; 1522108322fbScarlsonj goto out; 1523108322fbScarlsonj } 1524108322fbScarlsonj if ((mkdir(path, S_IRWXU) == -1) && (errno != EEXIST)) { 15257c478bd9Sstevel@tonic-gate error = Z_MISC_FS; 15267c478bd9Sstevel@tonic-gate goto out; 15277c478bd9Sstevel@tonic-gate } 15287c478bd9Sstevel@tonic-gate 1529108322fbScarlsonj if (!snap_file_path(zonename, path)) { 1530108322fbScarlsonj error = Z_MISC_FS; 1531108322fbScarlsonj goto out; 1532108322fbScarlsonj } 1533087719fdSdp 1534087719fdSdp addcomment(handle, "\n DO NOT EDIT THIS FILE. " 1535087719fdSdp "It is a snapshot of running zone state.\n"); 1536087719fdSdp 15377c478bd9Sstevel@tonic-gate error = zonecfg_save_impl(handle, path); 15387c478bd9Sstevel@tonic-gate 1539087719fdSdp stripcomments(handle); 1540087719fdSdp 15417c478bd9Sstevel@tonic-gate out: 15427c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 15437c478bd9Sstevel@tonic-gate return (error); 15447c478bd9Sstevel@tonic-gate } 15457c478bd9Sstevel@tonic-gate 1546f4b3ec61Sdh int 1547f4b3ec61Sdh zonecfg_get_iptype(zone_dochandle_t handle, zone_iptype_t *iptypep) 1548f4b3ec61Sdh { 1549f4b3ec61Sdh char property[10]; /* 10 is big enough for "shared"/"exclusive" */ 1550f4b3ec61Sdh int err; 1551f4b3ec61Sdh 1552f4b3ec61Sdh err = getrootattr(handle, DTD_ATTR_IPTYPE, property, sizeof (property)); 1553f4b3ec61Sdh if (err == Z_BAD_PROPERTY) { 1554f4b3ec61Sdh /* Return default value */ 1555f4b3ec61Sdh *iptypep = ZS_SHARED; 1556f4b3ec61Sdh return (Z_OK); 1557f4b3ec61Sdh } else if (err != Z_OK) { 1558f4b3ec61Sdh return (err); 1559f4b3ec61Sdh } 1560f4b3ec61Sdh 1561f4b3ec61Sdh if (strlen(property) == 0 || 1562f4b3ec61Sdh strcmp(property, "shared") == 0) 1563f4b3ec61Sdh *iptypep = ZS_SHARED; 1564f4b3ec61Sdh else if (strcmp(property, "exclusive") == 0) 1565f4b3ec61Sdh *iptypep = ZS_EXCLUSIVE; 1566f4b3ec61Sdh else 1567f4b3ec61Sdh return (Z_INVAL); 1568f4b3ec61Sdh 1569f4b3ec61Sdh return (Z_OK); 1570f4b3ec61Sdh } 1571f4b3ec61Sdh 1572f4b3ec61Sdh int 1573f4b3ec61Sdh zonecfg_set_iptype(zone_dochandle_t handle, zone_iptype_t iptype) 1574f4b3ec61Sdh { 1575f4b3ec61Sdh xmlNodePtr cur; 1576f4b3ec61Sdh 1577f4b3ec61Sdh if (handle == NULL) 1578f4b3ec61Sdh return (Z_INVAL); 1579f4b3ec61Sdh 1580f4b3ec61Sdh cur = xmlDocGetRootElement(handle->zone_dh_doc); 1581f4b3ec61Sdh if (cur == NULL) { 1582f4b3ec61Sdh return (Z_EMPTY_DOCUMENT); 1583f4b3ec61Sdh } 1584f4b3ec61Sdh 1585f4b3ec61Sdh if (xmlStrcmp(cur->name, DTD_ELEM_ZONE) != 0) { 1586f4b3ec61Sdh return (Z_WRONG_DOC_TYPE); 1587f4b3ec61Sdh } 1588f4b3ec61Sdh switch (iptype) { 1589f4b3ec61Sdh case ZS_SHARED: 1590f4b3ec61Sdh /* 1591f4b3ec61Sdh * Since "shared" is the default, we don't write it to the 1592f4b3ec61Sdh * configuration file, so that it's easier to migrate those 1593f4b3ec61Sdh * zones elsewhere, eg., to systems which are not IP-Instances 1594f4b3ec61Sdh * aware. 1595f4b3ec61Sdh * xmlUnsetProp only fails when the attribute doesn't exist, 1596f4b3ec61Sdh * which we don't care. 1597f4b3ec61Sdh */ 1598f4b3ec61Sdh (void) xmlUnsetProp(cur, DTD_ATTR_IPTYPE); 1599f4b3ec61Sdh break; 1600f4b3ec61Sdh case ZS_EXCLUSIVE: 1601f4b3ec61Sdh if (xmlSetProp(cur, DTD_ATTR_IPTYPE, 1602f4b3ec61Sdh (const xmlChar *) "exclusive") == NULL) 1603f4b3ec61Sdh return (Z_INVAL); 1604f4b3ec61Sdh break; 1605f4b3ec61Sdh } 1606f4b3ec61Sdh return (Z_OK); 1607f4b3ec61Sdh } 1608f4b3ec61Sdh 16097c478bd9Sstevel@tonic-gate static int 1610a1be23daSdp newprop(xmlNodePtr node, const xmlChar *attrname, char *src) 16117c478bd9Sstevel@tonic-gate { 16127c478bd9Sstevel@tonic-gate xmlAttrPtr newattr; 16137c478bd9Sstevel@tonic-gate 16147c478bd9Sstevel@tonic-gate newattr = xmlNewProp(node, attrname, (xmlChar *)src); 16157c478bd9Sstevel@tonic-gate if (newattr == NULL) { 16167c478bd9Sstevel@tonic-gate xmlUnlinkNode(node); 16177c478bd9Sstevel@tonic-gate xmlFreeNode(node); 16187c478bd9Sstevel@tonic-gate return (Z_BAD_PROPERTY); 16197c478bd9Sstevel@tonic-gate } 16207c478bd9Sstevel@tonic-gate return (Z_OK); 16217c478bd9Sstevel@tonic-gate } 16227c478bd9Sstevel@tonic-gate 16237c478bd9Sstevel@tonic-gate static int 16247c478bd9Sstevel@tonic-gate zonecfg_add_filesystem_core(zone_dochandle_t handle, struct zone_fstab *tabptr) 16257c478bd9Sstevel@tonic-gate { 16267c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur, options_node; 16277c478bd9Sstevel@tonic-gate zone_fsopt_t *ptr; 16287c478bd9Sstevel@tonic-gate int err; 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_FS, NULL); 1631a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_SPECIAL, 16327c478bd9Sstevel@tonic-gate tabptr->zone_fs_special)) != Z_OK) 16337c478bd9Sstevel@tonic-gate return (err); 16347c478bd9Sstevel@tonic-gate if (tabptr->zone_fs_raw[0] != '\0' && 1635a1be23daSdp (err = newprop(newnode, DTD_ATTR_RAW, tabptr->zone_fs_raw)) != Z_OK) 16367c478bd9Sstevel@tonic-gate return (err); 1637a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_DIR, tabptr->zone_fs_dir)) != Z_OK) 16387c478bd9Sstevel@tonic-gate return (err); 1639a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_TYPE, 16407c478bd9Sstevel@tonic-gate tabptr->zone_fs_type)) != Z_OK) 16417c478bd9Sstevel@tonic-gate return (err); 16427c478bd9Sstevel@tonic-gate if (tabptr->zone_fs_options != NULL) { 16437c478bd9Sstevel@tonic-gate for (ptr = tabptr->zone_fs_options; ptr != NULL; 16447c478bd9Sstevel@tonic-gate ptr = ptr->zone_fsopt_next) { 16457c478bd9Sstevel@tonic-gate options_node = xmlNewTextChild(newnode, NULL, 16467c478bd9Sstevel@tonic-gate DTD_ELEM_FSOPTION, NULL); 1647a1be23daSdp if ((err = newprop(options_node, DTD_ATTR_NAME, 16487c478bd9Sstevel@tonic-gate ptr->zone_fsopt_opt)) != Z_OK) 16497c478bd9Sstevel@tonic-gate return (err); 16507c478bd9Sstevel@tonic-gate } 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate return (Z_OK); 16537c478bd9Sstevel@tonic-gate } 16547c478bd9Sstevel@tonic-gate 16557c478bd9Sstevel@tonic-gate int 16567c478bd9Sstevel@tonic-gate zonecfg_add_filesystem(zone_dochandle_t handle, struct zone_fstab *tabptr) 16577c478bd9Sstevel@tonic-gate { 16587c478bd9Sstevel@tonic-gate int err; 16597c478bd9Sstevel@tonic-gate 16607c478bd9Sstevel@tonic-gate if (tabptr == NULL) 16617c478bd9Sstevel@tonic-gate return (Z_INVAL); 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 16647c478bd9Sstevel@tonic-gate return (err); 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_filesystem_core(handle, tabptr)) != Z_OK) 16677c478bd9Sstevel@tonic-gate return (err); 16687c478bd9Sstevel@tonic-gate 16697c478bd9Sstevel@tonic-gate return (Z_OK); 16707c478bd9Sstevel@tonic-gate } 16717c478bd9Sstevel@tonic-gate 16727c478bd9Sstevel@tonic-gate static int 16737c478bd9Sstevel@tonic-gate zonecfg_add_ipd_core(zone_dochandle_t handle, struct zone_fstab *tabptr) 16747c478bd9Sstevel@tonic-gate { 16757c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 16767c478bd9Sstevel@tonic-gate int err; 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_IPD, NULL); 1679a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_DIR, tabptr->zone_fs_dir)) != Z_OK) 16807c478bd9Sstevel@tonic-gate return (err); 16817c478bd9Sstevel@tonic-gate return (Z_OK); 16827c478bd9Sstevel@tonic-gate } 16837c478bd9Sstevel@tonic-gate 16847c478bd9Sstevel@tonic-gate int 16857c478bd9Sstevel@tonic-gate zonecfg_add_ipd(zone_dochandle_t handle, struct zone_fstab *tabptr) 16867c478bd9Sstevel@tonic-gate { 16877c478bd9Sstevel@tonic-gate int err; 16887c478bd9Sstevel@tonic-gate 16897c478bd9Sstevel@tonic-gate if (tabptr == NULL) 16907c478bd9Sstevel@tonic-gate return (Z_INVAL); 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 16937c478bd9Sstevel@tonic-gate return (err); 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_ipd_core(handle, tabptr)) != Z_OK) 16967c478bd9Sstevel@tonic-gate return (err); 16977c478bd9Sstevel@tonic-gate 16987c478bd9Sstevel@tonic-gate return (Z_OK); 16997c478bd9Sstevel@tonic-gate } 17007c478bd9Sstevel@tonic-gate 17017c478bd9Sstevel@tonic-gate int 17027c478bd9Sstevel@tonic-gate zonecfg_add_fs_option(struct zone_fstab *tabptr, char *option) 17037c478bd9Sstevel@tonic-gate { 17047c478bd9Sstevel@tonic-gate zone_fsopt_t *last, *old, *new; 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate last = tabptr->zone_fs_options; 17077c478bd9Sstevel@tonic-gate for (old = last; old != NULL; old = old->zone_fsopt_next) 17087c478bd9Sstevel@tonic-gate last = old; /* walk to the end of the list */ 17097c478bd9Sstevel@tonic-gate new = (zone_fsopt_t *)malloc(sizeof (zone_fsopt_t)); 17107c478bd9Sstevel@tonic-gate if (new == NULL) 17117c478bd9Sstevel@tonic-gate return (Z_NOMEM); 17127c478bd9Sstevel@tonic-gate (void) strlcpy(new->zone_fsopt_opt, option, 17137c478bd9Sstevel@tonic-gate sizeof (new->zone_fsopt_opt)); 17147c478bd9Sstevel@tonic-gate new->zone_fsopt_next = NULL; 17157c478bd9Sstevel@tonic-gate if (last == NULL) 17167c478bd9Sstevel@tonic-gate tabptr->zone_fs_options = new; 17177c478bd9Sstevel@tonic-gate else 17187c478bd9Sstevel@tonic-gate last->zone_fsopt_next = new; 17197c478bd9Sstevel@tonic-gate return (Z_OK); 17207c478bd9Sstevel@tonic-gate } 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate int 17237c478bd9Sstevel@tonic-gate zonecfg_remove_fs_option(struct zone_fstab *tabptr, char *option) 17247c478bd9Sstevel@tonic-gate { 17257c478bd9Sstevel@tonic-gate zone_fsopt_t *last, *this, *next; 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate last = tabptr->zone_fs_options; 17287c478bd9Sstevel@tonic-gate for (this = last; this != NULL; this = this->zone_fsopt_next) { 17297c478bd9Sstevel@tonic-gate if (strcmp(this->zone_fsopt_opt, option) == 0) { 17307c478bd9Sstevel@tonic-gate next = this->zone_fsopt_next; 17317c478bd9Sstevel@tonic-gate if (this == tabptr->zone_fs_options) 17327c478bd9Sstevel@tonic-gate tabptr->zone_fs_options = next; 17337c478bd9Sstevel@tonic-gate else 17347c478bd9Sstevel@tonic-gate last->zone_fsopt_next = next; 17357c478bd9Sstevel@tonic-gate free(this); 17367c478bd9Sstevel@tonic-gate return (Z_OK); 17377c478bd9Sstevel@tonic-gate } else 17387c478bd9Sstevel@tonic-gate last = this; 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate return (Z_NO_PROPERTY_ID); 17417c478bd9Sstevel@tonic-gate } 17427c478bd9Sstevel@tonic-gate 17437c478bd9Sstevel@tonic-gate void 17447c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(zone_fsopt_t *list) 17457c478bd9Sstevel@tonic-gate { 17467c478bd9Sstevel@tonic-gate zone_fsopt_t *this, *next; 17477c478bd9Sstevel@tonic-gate 17487c478bd9Sstevel@tonic-gate for (this = list; this != NULL; this = next) { 17497c478bd9Sstevel@tonic-gate next = this->zone_fsopt_next; 17507c478bd9Sstevel@tonic-gate free(this); 17517c478bd9Sstevel@tonic-gate } 17527c478bd9Sstevel@tonic-gate } 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate void 17557c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(struct zone_rctlvaltab *valtab) 17567c478bd9Sstevel@tonic-gate { 17577c478bd9Sstevel@tonic-gate if (valtab == NULL) 17587c478bd9Sstevel@tonic-gate return; 17597c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(valtab->zone_rctlval_next); 17607c478bd9Sstevel@tonic-gate free(valtab); 17617c478bd9Sstevel@tonic-gate } 17627c478bd9Sstevel@tonic-gate 17637c478bd9Sstevel@tonic-gate static boolean_t 17647c478bd9Sstevel@tonic-gate match_prop(xmlNodePtr cur, const xmlChar *attr, char *user_prop) 17657c478bd9Sstevel@tonic-gate { 17667c478bd9Sstevel@tonic-gate xmlChar *gotten_prop; 17677c478bd9Sstevel@tonic-gate int prop_result; 17687c478bd9Sstevel@tonic-gate 17697c478bd9Sstevel@tonic-gate gotten_prop = xmlGetProp(cur, attr); 17707c478bd9Sstevel@tonic-gate if (gotten_prop == NULL) /* shouldn't happen */ 17717c478bd9Sstevel@tonic-gate return (B_FALSE); 17727c478bd9Sstevel@tonic-gate prop_result = xmlStrcmp(gotten_prop, (const xmlChar *) user_prop); 17737c478bd9Sstevel@tonic-gate xmlFree(gotten_prop); 17747c478bd9Sstevel@tonic-gate return ((prop_result == 0)); 17757c478bd9Sstevel@tonic-gate } 17767c478bd9Sstevel@tonic-gate 17777c478bd9Sstevel@tonic-gate static int 17787c478bd9Sstevel@tonic-gate zonecfg_delete_filesystem_core(zone_dochandle_t handle, 17797c478bd9Sstevel@tonic-gate struct zone_fstab *tabptr) 17807c478bd9Sstevel@tonic-gate { 17817c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 17827c478bd9Sstevel@tonic-gate boolean_t dir_match, spec_match, raw_match, type_match; 17837c478bd9Sstevel@tonic-gate 17847c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 17857c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_FS)) 17867c478bd9Sstevel@tonic-gate continue; 17877c478bd9Sstevel@tonic-gate dir_match = match_prop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir); 17887c478bd9Sstevel@tonic-gate spec_match = match_prop(cur, DTD_ATTR_SPECIAL, 17897c478bd9Sstevel@tonic-gate tabptr->zone_fs_special); 17907c478bd9Sstevel@tonic-gate raw_match = match_prop(cur, DTD_ATTR_RAW, 17917c478bd9Sstevel@tonic-gate tabptr->zone_fs_raw); 17927c478bd9Sstevel@tonic-gate type_match = match_prop(cur, DTD_ATTR_TYPE, 17937c478bd9Sstevel@tonic-gate tabptr->zone_fs_type); 17947c478bd9Sstevel@tonic-gate if (dir_match && spec_match && raw_match && type_match) { 17957c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 17967c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 17977c478bd9Sstevel@tonic-gate return (Z_OK); 17987c478bd9Sstevel@tonic-gate } 17997c478bd9Sstevel@tonic-gate } 18007c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 18017c478bd9Sstevel@tonic-gate } 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate int 18047c478bd9Sstevel@tonic-gate zonecfg_delete_filesystem(zone_dochandle_t handle, struct zone_fstab *tabptr) 18057c478bd9Sstevel@tonic-gate { 18067c478bd9Sstevel@tonic-gate int err; 18077c478bd9Sstevel@tonic-gate 18087c478bd9Sstevel@tonic-gate if (tabptr == NULL) 18097c478bd9Sstevel@tonic-gate return (Z_INVAL); 18107c478bd9Sstevel@tonic-gate 18117c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18127c478bd9Sstevel@tonic-gate return (err); 18137c478bd9Sstevel@tonic-gate 18147c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem_core(handle, tabptr)) != Z_OK) 18157c478bd9Sstevel@tonic-gate return (err); 18167c478bd9Sstevel@tonic-gate 18177c478bd9Sstevel@tonic-gate return (Z_OK); 18187c478bd9Sstevel@tonic-gate } 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate int 18217c478bd9Sstevel@tonic-gate zonecfg_modify_filesystem( 18227c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 18237c478bd9Sstevel@tonic-gate struct zone_fstab *oldtabptr, 18247c478bd9Sstevel@tonic-gate struct zone_fstab *newtabptr) 18257c478bd9Sstevel@tonic-gate { 18267c478bd9Sstevel@tonic-gate int err; 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 18297c478bd9Sstevel@tonic-gate return (Z_INVAL); 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18327c478bd9Sstevel@tonic-gate return (err); 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem_core(handle, oldtabptr)) != Z_OK) 18357c478bd9Sstevel@tonic-gate return (err); 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_filesystem_core(handle, newtabptr)) != Z_OK) 18387c478bd9Sstevel@tonic-gate return (err); 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate return (Z_OK); 18417c478bd9Sstevel@tonic-gate } 18427c478bd9Sstevel@tonic-gate 18437c478bd9Sstevel@tonic-gate static int 18447c478bd9Sstevel@tonic-gate zonecfg_delete_ipd_core(zone_dochandle_t handle, struct zone_fstab *tabptr) 18457c478bd9Sstevel@tonic-gate { 18467c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 18477c478bd9Sstevel@tonic-gate 18487c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 18497c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_IPD)) 18507c478bd9Sstevel@tonic-gate continue; 18517c478bd9Sstevel@tonic-gate if (match_prop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir)) { 18527c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 18537c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 18547c478bd9Sstevel@tonic-gate return (Z_OK); 18557c478bd9Sstevel@tonic-gate } 18567c478bd9Sstevel@tonic-gate } 18577c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 18587c478bd9Sstevel@tonic-gate } 18597c478bd9Sstevel@tonic-gate 18607c478bd9Sstevel@tonic-gate int 18617c478bd9Sstevel@tonic-gate zonecfg_delete_ipd(zone_dochandle_t handle, struct zone_fstab *tabptr) 18627c478bd9Sstevel@tonic-gate { 18637c478bd9Sstevel@tonic-gate int err; 18647c478bd9Sstevel@tonic-gate 18657c478bd9Sstevel@tonic-gate if (tabptr == NULL) 18667c478bd9Sstevel@tonic-gate return (Z_INVAL); 18677c478bd9Sstevel@tonic-gate 18687c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18697c478bd9Sstevel@tonic-gate return (err); 18707c478bd9Sstevel@tonic-gate 18717c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd_core(handle, tabptr)) != Z_OK) 18727c478bd9Sstevel@tonic-gate return (err); 18737c478bd9Sstevel@tonic-gate 18747c478bd9Sstevel@tonic-gate return (Z_OK); 18757c478bd9Sstevel@tonic-gate } 18767c478bd9Sstevel@tonic-gate 18777c478bd9Sstevel@tonic-gate int 18787c478bd9Sstevel@tonic-gate zonecfg_modify_ipd(zone_dochandle_t handle, struct zone_fstab *oldtabptr, 18797c478bd9Sstevel@tonic-gate struct zone_fstab *newtabptr) 18807c478bd9Sstevel@tonic-gate { 18817c478bd9Sstevel@tonic-gate int err; 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 18847c478bd9Sstevel@tonic-gate return (Z_INVAL); 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18877c478bd9Sstevel@tonic-gate return (err); 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd_core(handle, oldtabptr)) != Z_OK) 18907c478bd9Sstevel@tonic-gate return (err); 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_ipd_core(handle, newtabptr)) != Z_OK) 18937c478bd9Sstevel@tonic-gate return (err); 18947c478bd9Sstevel@tonic-gate 18957c478bd9Sstevel@tonic-gate return (Z_OK); 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate 18987c478bd9Sstevel@tonic-gate int 18997c478bd9Sstevel@tonic-gate zonecfg_lookup_filesystem( 19007c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 19017c478bd9Sstevel@tonic-gate struct zone_fstab *tabptr) 19027c478bd9Sstevel@tonic-gate { 19037c478bd9Sstevel@tonic-gate xmlNodePtr cur, options, firstmatch; 19047c478bd9Sstevel@tonic-gate int err; 19057c478bd9Sstevel@tonic-gate char dirname[MAXPATHLEN], special[MAXPATHLEN], raw[MAXPATHLEN]; 19067c478bd9Sstevel@tonic-gate char type[FSTYPSZ]; 19077c478bd9Sstevel@tonic-gate char options_str[MAX_MNTOPT_STR]; 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate if (tabptr == NULL) 19107c478bd9Sstevel@tonic-gate return (Z_INVAL); 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 19137c478bd9Sstevel@tonic-gate return (err); 19147c478bd9Sstevel@tonic-gate 19157c478bd9Sstevel@tonic-gate /* 19167c478bd9Sstevel@tonic-gate * Walk the list of children looking for matches on any properties 19177c478bd9Sstevel@tonic-gate * specified in the fstab parameter. If more than one resource 19187c478bd9Sstevel@tonic-gate * matches, we return Z_INSUFFICIENT_SPEC; if none match, we return 19197c478bd9Sstevel@tonic-gate * Z_NO_RESOURCE_ID. 19207c478bd9Sstevel@tonic-gate */ 19217c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 19227c478bd9Sstevel@tonic-gate firstmatch = NULL; 19237c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 19247c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_FS)) 19257c478bd9Sstevel@tonic-gate continue; 19267c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_dir) > 0) { 19277c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_DIR, dirname, 19287c478bd9Sstevel@tonic-gate sizeof (dirname)) == Z_OK) && 19297c478bd9Sstevel@tonic-gate (strcmp(tabptr->zone_fs_dir, dirname) == 0)) { 19307c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19317c478bd9Sstevel@tonic-gate firstmatch = cur; 19327c478bd9Sstevel@tonic-gate else 19337c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19347c478bd9Sstevel@tonic-gate } 19357c478bd9Sstevel@tonic-gate } 19367c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_special) > 0) { 19377c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_SPECIAL, special, 19387c478bd9Sstevel@tonic-gate sizeof (special)) == Z_OK)) { 19397c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_fs_special, 19407c478bd9Sstevel@tonic-gate special) == 0) { 19417c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19427c478bd9Sstevel@tonic-gate firstmatch = cur; 19437c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 19447c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19457c478bd9Sstevel@tonic-gate } else { 19467c478bd9Sstevel@tonic-gate /* 19477c478bd9Sstevel@tonic-gate * If another property matched but this 19487c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 19497c478bd9Sstevel@tonic-gate */ 19507c478bd9Sstevel@tonic-gate if (firstmatch == cur) 19517c478bd9Sstevel@tonic-gate firstmatch = NULL; 19527c478bd9Sstevel@tonic-gate } 19537c478bd9Sstevel@tonic-gate } 19547c478bd9Sstevel@tonic-gate } 19557c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_raw) > 0) { 19567c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_RAW, raw, 19577c478bd9Sstevel@tonic-gate sizeof (raw)) == Z_OK)) { 19587c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_fs_raw, raw) == 0) { 19597c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19607c478bd9Sstevel@tonic-gate firstmatch = cur; 19617c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 19627c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19637c478bd9Sstevel@tonic-gate } else { 19647c478bd9Sstevel@tonic-gate /* 19657c478bd9Sstevel@tonic-gate * If another property matched but this 19667c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 19677c478bd9Sstevel@tonic-gate */ 19687c478bd9Sstevel@tonic-gate if (firstmatch == cur) 19697c478bd9Sstevel@tonic-gate firstmatch = NULL; 19707c478bd9Sstevel@tonic-gate } 19717c478bd9Sstevel@tonic-gate } 19727c478bd9Sstevel@tonic-gate } 19737c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_type) > 0) { 19747c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_TYPE, type, 19757c478bd9Sstevel@tonic-gate sizeof (type)) == Z_OK)) { 19767c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_fs_type, type) == 0) { 19777c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19787c478bd9Sstevel@tonic-gate firstmatch = cur; 19797c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 19807c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19817c478bd9Sstevel@tonic-gate } else { 19827c478bd9Sstevel@tonic-gate /* 19837c478bd9Sstevel@tonic-gate * If another property matched but this 19847c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 19857c478bd9Sstevel@tonic-gate */ 19867c478bd9Sstevel@tonic-gate if (firstmatch == cur) 19877c478bd9Sstevel@tonic-gate firstmatch = NULL; 19887c478bd9Sstevel@tonic-gate } 19897c478bd9Sstevel@tonic-gate } 19907c478bd9Sstevel@tonic-gate } 19917c478bd9Sstevel@tonic-gate } 19927c478bd9Sstevel@tonic-gate 19937c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19947c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate cur = firstmatch; 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir, 19997c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_dir))) != Z_OK) 20007c478bd9Sstevel@tonic-gate return (err); 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_SPECIAL, tabptr->zone_fs_special, 20037c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_special))) != Z_OK) 20047c478bd9Sstevel@tonic-gate return (err); 20057c478bd9Sstevel@tonic-gate 20067c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_RAW, tabptr->zone_fs_raw, 20077c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_raw))) != Z_OK) 20087c478bd9Sstevel@tonic-gate return (err); 20097c478bd9Sstevel@tonic-gate 20107c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_fs_type, 20117c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_type))) != Z_OK) 20127c478bd9Sstevel@tonic-gate return (err); 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate /* options are optional */ 20157c478bd9Sstevel@tonic-gate tabptr->zone_fs_options = NULL; 20167c478bd9Sstevel@tonic-gate for (options = cur->xmlChildrenNode; options != NULL; 20177c478bd9Sstevel@tonic-gate options = options->next) { 20187c478bd9Sstevel@tonic-gate if ((fetchprop(options, DTD_ATTR_NAME, options_str, 20197c478bd9Sstevel@tonic-gate sizeof (options_str)) != Z_OK)) 20207c478bd9Sstevel@tonic-gate break; 20217c478bd9Sstevel@tonic-gate if (zonecfg_add_fs_option(tabptr, options_str) != Z_OK) 20227c478bd9Sstevel@tonic-gate break; 20237c478bd9Sstevel@tonic-gate } 20247c478bd9Sstevel@tonic-gate return (Z_OK); 20257c478bd9Sstevel@tonic-gate } 20267c478bd9Sstevel@tonic-gate 20277c478bd9Sstevel@tonic-gate int 20287c478bd9Sstevel@tonic-gate zonecfg_lookup_ipd(zone_dochandle_t handle, struct zone_fstab *tabptr) 20297c478bd9Sstevel@tonic-gate { 20307c478bd9Sstevel@tonic-gate xmlNodePtr cur, match; 20317c478bd9Sstevel@tonic-gate int err; 20327c478bd9Sstevel@tonic-gate char dirname[MAXPATHLEN]; 20337c478bd9Sstevel@tonic-gate 20347c478bd9Sstevel@tonic-gate if (tabptr == NULL) 20357c478bd9Sstevel@tonic-gate return (Z_INVAL); 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 20387c478bd9Sstevel@tonic-gate return (err); 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate /* 20417c478bd9Sstevel@tonic-gate * General algorithm: 20427c478bd9Sstevel@tonic-gate * Walk the list of children looking for matches on any properties 20437c478bd9Sstevel@tonic-gate * specified in the fstab parameter. If more than one resource 20447c478bd9Sstevel@tonic-gate * matches, we return Z_INSUFFICIENT_SPEC; if none match, we return 20457c478bd9Sstevel@tonic-gate * Z_NO_RESOURCE_ID. 20467c478bd9Sstevel@tonic-gate */ 20477c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 20487c478bd9Sstevel@tonic-gate match = NULL; 20497c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 20507c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_IPD)) 20517c478bd9Sstevel@tonic-gate continue; 20527c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_dir) > 0) { 20537c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_DIR, dirname, 20547c478bd9Sstevel@tonic-gate sizeof (dirname)) == Z_OK) && 20557c478bd9Sstevel@tonic-gate (strcmp(tabptr->zone_fs_dir, dirname) == 0)) { 20567c478bd9Sstevel@tonic-gate if (match == NULL) 20577c478bd9Sstevel@tonic-gate match = cur; 20587c478bd9Sstevel@tonic-gate else 20597c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate } 20627c478bd9Sstevel@tonic-gate } 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate if (match == NULL) 20657c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 20667c478bd9Sstevel@tonic-gate 20677c478bd9Sstevel@tonic-gate cur = match; 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir, 20707c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_dir))) != Z_OK) 20717c478bd9Sstevel@tonic-gate return (err); 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate return (Z_OK); 20747c478bd9Sstevel@tonic-gate } 20757c478bd9Sstevel@tonic-gate 20767c478bd9Sstevel@tonic-gate /* 20777c478bd9Sstevel@tonic-gate * Compare two IP addresses in string form. Allow for the possibility that 20787c478bd9Sstevel@tonic-gate * one might have "/<prefix-length>" at the end: allow a match on just the 20797c478bd9Sstevel@tonic-gate * IP address (or host name) part. 20807c478bd9Sstevel@tonic-gate */ 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate boolean_t 20837c478bd9Sstevel@tonic-gate zonecfg_same_net_address(char *a1, char *a2) 20847c478bd9Sstevel@tonic-gate { 20857c478bd9Sstevel@tonic-gate char *slashp, *slashp1, *slashp2; 20867c478bd9Sstevel@tonic-gate int result; 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate if (strcmp(a1, a2) == 0) 20897c478bd9Sstevel@tonic-gate return (B_TRUE); 20907c478bd9Sstevel@tonic-gate 20917c478bd9Sstevel@tonic-gate /* 20927c478bd9Sstevel@tonic-gate * If neither has a slash or both do, they need to match to be 20937c478bd9Sstevel@tonic-gate * considered the same, but they did not match above, so fail. 20947c478bd9Sstevel@tonic-gate */ 20957c478bd9Sstevel@tonic-gate slashp1 = strchr(a1, '/'); 20967c478bd9Sstevel@tonic-gate slashp2 = strchr(a2, '/'); 20977c478bd9Sstevel@tonic-gate if ((slashp1 == NULL && slashp2 == NULL) || 20987c478bd9Sstevel@tonic-gate (slashp1 != NULL && slashp2 != NULL)) 20997c478bd9Sstevel@tonic-gate return (B_FALSE); 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate /* 21027c478bd9Sstevel@tonic-gate * Only one had a slash: pick that one, zero out the slash, compare 21037c478bd9Sstevel@tonic-gate * the "address only" strings, restore the slash, and return the 21047c478bd9Sstevel@tonic-gate * result of the comparison. 21057c478bd9Sstevel@tonic-gate */ 21067c478bd9Sstevel@tonic-gate slashp = (slashp1 == NULL) ? slashp2 : slashp1; 21077c478bd9Sstevel@tonic-gate *slashp = '\0'; 21087c478bd9Sstevel@tonic-gate result = strcmp(a1, a2); 21097c478bd9Sstevel@tonic-gate *slashp = '/'; 21107c478bd9Sstevel@tonic-gate return ((result == 0)); 21117c478bd9Sstevel@tonic-gate } 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate int 21147c478bd9Sstevel@tonic-gate zonecfg_valid_net_address(char *address, struct lifreq *lifr) 21157c478bd9Sstevel@tonic-gate { 21167c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 21177c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 21187c478bd9Sstevel@tonic-gate struct addrinfo hints, *result; 21197c478bd9Sstevel@tonic-gate char *slashp = strchr(address, '/'); 21207c478bd9Sstevel@tonic-gate 21217c478bd9Sstevel@tonic-gate bzero(lifr, sizeof (struct lifreq)); 21227c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)&lifr->lifr_addr; 21237c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)&lifr->lifr_addr; 21247c478bd9Sstevel@tonic-gate if (slashp != NULL) 21257c478bd9Sstevel@tonic-gate *slashp = '\0'; 21267c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, address, &sin4->sin_addr) == 1) { 21277c478bd9Sstevel@tonic-gate sin4->sin_family = AF_INET; 21287c478bd9Sstevel@tonic-gate } else if (inet_pton(AF_INET6, address, &sin6->sin6_addr) == 1) { 21297c478bd9Sstevel@tonic-gate if (slashp == NULL) 21307c478bd9Sstevel@tonic-gate return (Z_IPV6_ADDR_PREFIX_LEN); 21317c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6; 21327c478bd9Sstevel@tonic-gate } else { 21337c478bd9Sstevel@tonic-gate /* "address" may be a host name */ 21347c478bd9Sstevel@tonic-gate (void) memset(&hints, 0, sizeof (hints)); 21357c478bd9Sstevel@tonic-gate hints.ai_family = PF_INET; 21367c478bd9Sstevel@tonic-gate if (getaddrinfo(address, NULL, &hints, &result) != 0) 21377c478bd9Sstevel@tonic-gate return (Z_BOGUS_ADDRESS); 21387c478bd9Sstevel@tonic-gate sin4->sin_family = result->ai_family; 2139a1be23daSdp 21407c478bd9Sstevel@tonic-gate (void) memcpy(&sin4->sin_addr, 21417c478bd9Sstevel@tonic-gate /* LINTED E_BAD_PTR_CAST_ALIGN */ 21427c478bd9Sstevel@tonic-gate &((struct sockaddr_in *)result->ai_addr)->sin_addr, 21437c478bd9Sstevel@tonic-gate sizeof (struct in_addr)); 2144a1be23daSdp 21457c478bd9Sstevel@tonic-gate freeaddrinfo(result); 21467c478bd9Sstevel@tonic-gate } 21477c478bd9Sstevel@tonic-gate return (Z_OK); 21487c478bd9Sstevel@tonic-gate } 21497c478bd9Sstevel@tonic-gate 2150f4b3ec61Sdh boolean_t 2151f4b3ec61Sdh zonecfg_ifname_exists(sa_family_t af, char *ifname) 2152f4b3ec61Sdh { 2153f4b3ec61Sdh struct lifreq lifr; 2154f4b3ec61Sdh int so; 2155f4b3ec61Sdh int save_errno; 2156f4b3ec61Sdh 2157f4b3ec61Sdh (void) memset(&lifr, 0, sizeof (lifr)); 2158f4b3ec61Sdh (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name)); 2159f4b3ec61Sdh lifr.lifr_addr.ss_family = af; 2160f4b3ec61Sdh if ((so = socket(af, SOCK_DGRAM, 0)) < 0) { 2161f4b3ec61Sdh /* Odd - can't tell if the ifname exists */ 2162f4b3ec61Sdh return (B_FALSE); 2163f4b3ec61Sdh } 2164f4b3ec61Sdh if (ioctl(so, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) { 2165f4b3ec61Sdh save_errno = errno; 2166f4b3ec61Sdh (void) close(so); 2167f4b3ec61Sdh errno = save_errno; 2168f4b3ec61Sdh return (B_FALSE); 2169f4b3ec61Sdh } 2170f4b3ec61Sdh (void) close(so); 2171f4b3ec61Sdh return (B_TRUE); 2172f4b3ec61Sdh } 2173f4b3ec61Sdh 2174a8053275Sjv /* 217534eb7836Sjv * Determines whether there is a net resource with the physical interface, IP 217634eb7836Sjv * address, and default router specified by 'tabptr' in the zone configuration 217734eb7836Sjv * to which 'handle' refers. 'tabptr' must have an interface, an address, a 217834eb7836Sjv * default router, or a combination of the three. This function returns Z_OK 217934eb7836Sjv * iff there is exactly one net resource matching the query specified by 218034eb7836Sjv * 'tabptr'. The function returns Z_INSUFFICIENT_SPEC if there are multiple 218134eb7836Sjv * matches or 'tabptr' does not specify a physical interface, address, or 218234eb7836Sjv * default router. The function returns Z_NO_RESOURCE_ID if are no matches. 2183a8053275Sjv * 2184a8053275Sjv * Errors might also be returned if the entry that exactly matches the 2185a8053275Sjv * query lacks critical network resource information. 2186a8053275Sjv * 218734eb7836Sjv * If there is a single match, then the matching entry's physical interface, IP 218834eb7836Sjv * address, and default router information are stored in 'tabptr'. 2189a8053275Sjv */ 21907c478bd9Sstevel@tonic-gate int 21917c478bd9Sstevel@tonic-gate zonecfg_lookup_nwif(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 21927c478bd9Sstevel@tonic-gate { 2193a8053275Sjv xmlNodePtr cur; 2194a8053275Sjv xmlNodePtr firstmatch; 21957c478bd9Sstevel@tonic-gate int err; 2196a8053275Sjv char address[INET6_ADDRSTRLEN]; 2197a8053275Sjv char physical[LIFNAMSIZ]; 2198a8053275Sjv size_t addrspec; /* nonzero if tabptr has IP addr */ 2199a8053275Sjv size_t physspec; /* nonzero if tabptr has interface */ 220034eb7836Sjv size_t defrouterspec; /* nonzero if tabptr has def. router */ 22017c478bd9Sstevel@tonic-gate 22027c478bd9Sstevel@tonic-gate if (tabptr == NULL) 22037c478bd9Sstevel@tonic-gate return (Z_INVAL); 22047c478bd9Sstevel@tonic-gate 2205a8053275Sjv /* 220634eb7836Sjv * Determine the fields that will be searched. There must be at least 220734eb7836Sjv * one. 220834eb7836Sjv * 220934eb7836Sjv * zone_nwif_address, zone_nwif_physical, and zone_nwif_defrouter are 221034eb7836Sjv * arrays, so no NULL checks are necessary. 2211a8053275Sjv */ 2212a8053275Sjv addrspec = strlen(tabptr->zone_nwif_address); 2213a8053275Sjv physspec = strlen(tabptr->zone_nwif_physical); 221434eb7836Sjv defrouterspec = strlen(tabptr->zone_nwif_defrouter); 221534eb7836Sjv if (addrspec == 0 && physspec == 0 && defrouterspec == 0) 221634eb7836Sjv return (Z_INSUFFICIENT_SPEC); 2217a8053275Sjv 22187c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 22197c478bd9Sstevel@tonic-gate return (err); 22207c478bd9Sstevel@tonic-gate 222134eb7836Sjv /* 222234eb7836Sjv * Iterate over the configuration's elements and look for net elements 222334eb7836Sjv * that match the query. 222434eb7836Sjv */ 22257c478bd9Sstevel@tonic-gate firstmatch = NULL; 2226a8053275Sjv cur = handle->zone_dh_cur; 22277c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 2228a8053275Sjv /* Skip non-net elements */ 22297c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_NET)) 22307c478bd9Sstevel@tonic-gate continue; 2231a8053275Sjv 2232a8053275Sjv /* 223334eb7836Sjv * If any relevant fields don't match the query, then skip 223434eb7836Sjv * the current net element. 2235a8053275Sjv */ 223634eb7836Sjv if (physspec != 0 && (fetchprop(cur, DTD_ATTR_PHYSICAL, 223734eb7836Sjv physical, sizeof (physical)) != Z_OK || 223834eb7836Sjv strcmp(tabptr->zone_nwif_physical, physical) != 0)) 223934eb7836Sjv continue; 224034eb7836Sjv if (addrspec != 0 && (fetchprop(cur, DTD_ATTR_ADDRESS, address, 224134eb7836Sjv sizeof (address)) != Z_OK || 224234eb7836Sjv !zonecfg_same_net_address(tabptr->zone_nwif_address, 224334eb7836Sjv address))) 224434eb7836Sjv continue; 224534eb7836Sjv if (defrouterspec != 0 && (fetchprop(cur, DTD_ATTR_DEFROUTER, 224634eb7836Sjv address, sizeof (address)) != Z_OK || 224734eb7836Sjv !zonecfg_same_net_address(tabptr->zone_nwif_defrouter, 224834eb7836Sjv address))) 224934eb7836Sjv continue; 225034eb7836Sjv 225134eb7836Sjv /* 225234eb7836Sjv * The current net element matches the query. Select it if 225334eb7836Sjv * it's the first match; otherwise, abort the search. 225434eb7836Sjv */ 225534eb7836Sjv if (firstmatch == NULL) 225634eb7836Sjv firstmatch = cur; 225734eb7836Sjv else 225834eb7836Sjv return (Z_INSUFFICIENT_SPEC); 22597c478bd9Sstevel@tonic-gate } 22607c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 22617c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate cur = firstmatch; 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_PHYSICAL, tabptr->zone_nwif_physical, 22667c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_nwif_physical))) != Z_OK) 22677c478bd9Sstevel@tonic-gate return (err); 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_ADDRESS, tabptr->zone_nwif_address, 22707c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_nwif_address))) != Z_OK) 22717c478bd9Sstevel@tonic-gate return (err); 22727c478bd9Sstevel@tonic-gate 2273de860bd9Sgfaden if ((err = fetchprop(cur, DTD_ATTR_DEFROUTER, 2274de860bd9Sgfaden tabptr->zone_nwif_defrouter, 2275de860bd9Sgfaden sizeof (tabptr->zone_nwif_defrouter))) != Z_OK) 2276de860bd9Sgfaden return (err); 2277de860bd9Sgfaden 22787c478bd9Sstevel@tonic-gate return (Z_OK); 22797c478bd9Sstevel@tonic-gate } 22807c478bd9Sstevel@tonic-gate 22817c478bd9Sstevel@tonic-gate static int 22827c478bd9Sstevel@tonic-gate zonecfg_add_nwif_core(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 22837c478bd9Sstevel@tonic-gate { 22847c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 22857c478bd9Sstevel@tonic-gate int err; 22867c478bd9Sstevel@tonic-gate 22877c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_NET, NULL); 2288a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_ADDRESS, 22897c478bd9Sstevel@tonic-gate tabptr->zone_nwif_address)) != Z_OK) 22907c478bd9Sstevel@tonic-gate return (err); 2291a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_PHYSICAL, 22927c478bd9Sstevel@tonic-gate tabptr->zone_nwif_physical)) != Z_OK) 22937c478bd9Sstevel@tonic-gate return (err); 229444ce818bSjparcel /* 229544ce818bSjparcel * Do not add this property when it is not set, for backwards 229644ce818bSjparcel * compatibility and because it is optional. 229744ce818bSjparcel */ 229844ce818bSjparcel if ((strlen(tabptr->zone_nwif_defrouter) > 0) && 229944ce818bSjparcel ((err = newprop(newnode, DTD_ATTR_DEFROUTER, 230044ce818bSjparcel tabptr->zone_nwif_defrouter)) != Z_OK)) 2301de860bd9Sgfaden return (err); 23027c478bd9Sstevel@tonic-gate return (Z_OK); 23037c478bd9Sstevel@tonic-gate } 23047c478bd9Sstevel@tonic-gate 23057c478bd9Sstevel@tonic-gate int 23067c478bd9Sstevel@tonic-gate zonecfg_add_nwif(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 23077c478bd9Sstevel@tonic-gate { 23087c478bd9Sstevel@tonic-gate int err; 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate if (tabptr == NULL) 23117c478bd9Sstevel@tonic-gate return (Z_INVAL); 23127c478bd9Sstevel@tonic-gate 23137c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 23147c478bd9Sstevel@tonic-gate return (err); 23157c478bd9Sstevel@tonic-gate 23167c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_nwif_core(handle, tabptr)) != Z_OK) 23177c478bd9Sstevel@tonic-gate return (err); 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate return (Z_OK); 23207c478bd9Sstevel@tonic-gate } 23217c478bd9Sstevel@tonic-gate 23227c478bd9Sstevel@tonic-gate static int 23237c478bd9Sstevel@tonic-gate zonecfg_delete_nwif_core(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 23247c478bd9Sstevel@tonic-gate { 23257c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 23267c478bd9Sstevel@tonic-gate boolean_t addr_match, phys_match; 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 23297c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_NET)) 23307c478bd9Sstevel@tonic-gate continue; 23317c478bd9Sstevel@tonic-gate 23327c478bd9Sstevel@tonic-gate addr_match = match_prop(cur, DTD_ATTR_ADDRESS, 23337c478bd9Sstevel@tonic-gate tabptr->zone_nwif_address); 23347c478bd9Sstevel@tonic-gate phys_match = match_prop(cur, DTD_ATTR_PHYSICAL, 23357c478bd9Sstevel@tonic-gate tabptr->zone_nwif_physical); 23367c478bd9Sstevel@tonic-gate 23377c478bd9Sstevel@tonic-gate if (addr_match && phys_match) { 23387c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 23397c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 23407c478bd9Sstevel@tonic-gate return (Z_OK); 23417c478bd9Sstevel@tonic-gate } 23427c478bd9Sstevel@tonic-gate } 23437c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 23447c478bd9Sstevel@tonic-gate } 23457c478bd9Sstevel@tonic-gate 23467c478bd9Sstevel@tonic-gate int 23477c478bd9Sstevel@tonic-gate zonecfg_delete_nwif(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 23487c478bd9Sstevel@tonic-gate { 23497c478bd9Sstevel@tonic-gate int err; 23507c478bd9Sstevel@tonic-gate 23517c478bd9Sstevel@tonic-gate if (tabptr == NULL) 23527c478bd9Sstevel@tonic-gate return (Z_INVAL); 23537c478bd9Sstevel@tonic-gate 23547c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 23557c478bd9Sstevel@tonic-gate return (err); 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif_core(handle, tabptr)) != Z_OK) 23587c478bd9Sstevel@tonic-gate return (err); 23597c478bd9Sstevel@tonic-gate 23607c478bd9Sstevel@tonic-gate return (Z_OK); 23617c478bd9Sstevel@tonic-gate } 23627c478bd9Sstevel@tonic-gate 23637c478bd9Sstevel@tonic-gate int 23647c478bd9Sstevel@tonic-gate zonecfg_modify_nwif( 23657c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 23667c478bd9Sstevel@tonic-gate struct zone_nwiftab *oldtabptr, 23677c478bd9Sstevel@tonic-gate struct zone_nwiftab *newtabptr) 23687c478bd9Sstevel@tonic-gate { 23697c478bd9Sstevel@tonic-gate int err; 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 23727c478bd9Sstevel@tonic-gate return (Z_INVAL); 23737c478bd9Sstevel@tonic-gate 23747c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 23757c478bd9Sstevel@tonic-gate return (err); 23767c478bd9Sstevel@tonic-gate 23777c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif_core(handle, oldtabptr)) != Z_OK) 23787c478bd9Sstevel@tonic-gate return (err); 23797c478bd9Sstevel@tonic-gate 23807c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_nwif_core(handle, newtabptr)) != Z_OK) 23817c478bd9Sstevel@tonic-gate return (err); 23827c478bd9Sstevel@tonic-gate 23837c478bd9Sstevel@tonic-gate return (Z_OK); 23847c478bd9Sstevel@tonic-gate } 23857c478bd9Sstevel@tonic-gate 23865679c89fSjv /* 23875679c89fSjv * Gets the zone hostid string stored in the specified zone configuration 23885679c89fSjv * document. This function returns Z_OK on success. Z_BAD_PROPERTY is returned 23895679c89fSjv * if the config file doesn't specify a hostid or if the hostid is blank. 23905679c89fSjv * 23915679c89fSjv * Note that buflen should be at least HW_HOSTID_LEN. 23925679c89fSjv */ 23935679c89fSjv int 23945679c89fSjv zonecfg_get_hostid(zone_dochandle_t handle, char *bufp, size_t buflen) 23955679c89fSjv { 23965679c89fSjv int err; 23975679c89fSjv 23985679c89fSjv if ((err = getrootattr(handle, DTD_ATTR_HOSTID, bufp, buflen)) != Z_OK) 23995679c89fSjv return (err); 24005679c89fSjv if (bufp[0] == '\0') 24015679c89fSjv return (Z_BAD_PROPERTY); 24025679c89fSjv return (Z_OK); 24035679c89fSjv } 24045679c89fSjv 24055679c89fSjv /* 24065679c89fSjv * Sets the hostid string in the specified zone config document to the given 24075679c89fSjv * string value. If 'hostidp' is NULL, then the config document's hostid 24085679c89fSjv * attribute is cleared. Non-NULL hostids are validated. This function returns 24095679c89fSjv * Z_OK on success. Any other return value indicates failure. 24105679c89fSjv */ 24115679c89fSjv int 24125679c89fSjv zonecfg_set_hostid(zone_dochandle_t handle, const char *hostidp) 24135679c89fSjv { 24145679c89fSjv int err; 24155679c89fSjv 24165679c89fSjv /* 24175679c89fSjv * A NULL hostid string is interpreted as a request to clear the 24185679c89fSjv * hostid. 24195679c89fSjv */ 24205679c89fSjv if (hostidp == NULL || (err = zonecfg_valid_hostid(hostidp)) == Z_OK) 24215679c89fSjv return (setrootattr(handle, DTD_ATTR_HOSTID, hostidp)); 24225679c89fSjv return (err); 24235679c89fSjv } 24245679c89fSjv 24255679c89fSjv /* 24265679c89fSjv * Determines if the specified string is a valid hostid string. This function 24275679c89fSjv * returns Z_OK if the string is a valid hostid string. It returns Z_INVAL if 24285679c89fSjv * 'hostidp' is NULL, Z_TOO_BIG if 'hostidp' refers to a string buffer 24295679c89fSjv * containing a hex string with more than 8 digits, and Z_HOSTID_FUBAR if the 24305679c89fSjv * string has an invalid format. 24315679c89fSjv */ 24325679c89fSjv int 24335679c89fSjv zonecfg_valid_hostid(const char *hostidp) 24345679c89fSjv { 24355679c89fSjv char *currentp; 24365679c89fSjv u_longlong_t hostidval; 24375679c89fSjv size_t len; 24385679c89fSjv 24395679c89fSjv if (hostidp == NULL) 24405679c89fSjv return (Z_INVAL); 24415679c89fSjv 24425679c89fSjv /* Empty strings and strings with whitespace are invalid. */ 24435679c89fSjv if (*hostidp == '\0') 24445679c89fSjv return (Z_HOSTID_FUBAR); 24455679c89fSjv for (currentp = (char *)hostidp; *currentp != '\0'; ++currentp) { 24465679c89fSjv if (isspace(*currentp)) 24475679c89fSjv return (Z_HOSTID_FUBAR); 24485679c89fSjv } 24495679c89fSjv len = (size_t)(currentp - hostidp); 24505679c89fSjv 24515679c89fSjv /* 24525679c89fSjv * The caller might pass a hostid that is larger than the maximum 24535679c89fSjv * unsigned 32-bit integral value. Check for this! Also, make sure 24545679c89fSjv * that the whole string is converted (this helps us find illegal 24555679c89fSjv * characters) and that the whole string fits within a buffer of size 24565679c89fSjv * HW_HOSTID_LEN. 24575679c89fSjv */ 24585679c89fSjv currentp = (char *)hostidp; 24595679c89fSjv if (strncmp(hostidp, "0x", 2) == 0 || strncmp(hostidp, "0X", 2) == 0) 24605679c89fSjv currentp += 2; 24615679c89fSjv hostidval = strtoull(currentp, ¤tp, 16); 24625679c89fSjv if ((size_t)(currentp - hostidp) >= HW_HOSTID_LEN) 24635679c89fSjv return (Z_TOO_BIG); 24645679c89fSjv if (hostidval > UINT_MAX || hostidval == HW_INVALID_HOSTID || 24655679c89fSjv currentp != hostidp + len) 24665679c89fSjv return (Z_HOSTID_FUBAR); 24675679c89fSjv return (Z_OK); 24685679c89fSjv } 24695679c89fSjv 24707c478bd9Sstevel@tonic-gate int 24717c478bd9Sstevel@tonic-gate zonecfg_lookup_dev(zone_dochandle_t handle, struct zone_devtab *tabptr) 24727c478bd9Sstevel@tonic-gate { 24737c478bd9Sstevel@tonic-gate xmlNodePtr cur, firstmatch; 24747c478bd9Sstevel@tonic-gate int err; 24757c478bd9Sstevel@tonic-gate char match[MAXPATHLEN]; 24767c478bd9Sstevel@tonic-gate 24777c478bd9Sstevel@tonic-gate if (tabptr == NULL) 24787c478bd9Sstevel@tonic-gate return (Z_INVAL); 24797c478bd9Sstevel@tonic-gate 24807c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 24817c478bd9Sstevel@tonic-gate return (err); 24827c478bd9Sstevel@tonic-gate 24837c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 24847c478bd9Sstevel@tonic-gate firstmatch = NULL; 24857c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 24867c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_DEVICE)) 24877c478bd9Sstevel@tonic-gate continue; 24887c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_dev_match) == 0) 24897c478bd9Sstevel@tonic-gate continue; 24907c478bd9Sstevel@tonic-gate 24917c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_MATCH, match, 24927c478bd9Sstevel@tonic-gate sizeof (match)) == Z_OK)) { 24937c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_dev_match, 24947c478bd9Sstevel@tonic-gate match) == 0) { 24957c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 24967c478bd9Sstevel@tonic-gate firstmatch = cur; 24977c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 24987c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24997c478bd9Sstevel@tonic-gate } else { 25007c478bd9Sstevel@tonic-gate /* 25017c478bd9Sstevel@tonic-gate * If another property matched but this 25027c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 25037c478bd9Sstevel@tonic-gate */ 25047c478bd9Sstevel@tonic-gate if (firstmatch == cur) 25057c478bd9Sstevel@tonic-gate firstmatch = NULL; 25067c478bd9Sstevel@tonic-gate } 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate } 25097c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 25107c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate cur = firstmatch; 25137c478bd9Sstevel@tonic-gate 25147c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_MATCH, tabptr->zone_dev_match, 25157c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_dev_match))) != Z_OK) 25167c478bd9Sstevel@tonic-gate return (err); 25177c478bd9Sstevel@tonic-gate 25187c478bd9Sstevel@tonic-gate return (Z_OK); 25197c478bd9Sstevel@tonic-gate } 25207c478bd9Sstevel@tonic-gate 25217c478bd9Sstevel@tonic-gate static int 25227c478bd9Sstevel@tonic-gate zonecfg_add_dev_core(zone_dochandle_t handle, struct zone_devtab *tabptr) 25237c478bd9Sstevel@tonic-gate { 25247c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 25257c478bd9Sstevel@tonic-gate int err; 25267c478bd9Sstevel@tonic-gate 25277c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_DEVICE, NULL); 25287c478bd9Sstevel@tonic-gate 2529a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_MATCH, 25307c478bd9Sstevel@tonic-gate tabptr->zone_dev_match)) != Z_OK) 25317c478bd9Sstevel@tonic-gate return (err); 25327c478bd9Sstevel@tonic-gate 25337c478bd9Sstevel@tonic-gate return (Z_OK); 25347c478bd9Sstevel@tonic-gate } 25357c478bd9Sstevel@tonic-gate 25367c478bd9Sstevel@tonic-gate int 25377c478bd9Sstevel@tonic-gate zonecfg_add_dev(zone_dochandle_t handle, struct zone_devtab *tabptr) 25387c478bd9Sstevel@tonic-gate { 25397c478bd9Sstevel@tonic-gate int err; 25407c478bd9Sstevel@tonic-gate 25417c478bd9Sstevel@tonic-gate if (tabptr == NULL) 25427c478bd9Sstevel@tonic-gate return (Z_INVAL); 25437c478bd9Sstevel@tonic-gate 25447c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 25457c478bd9Sstevel@tonic-gate return (err); 25467c478bd9Sstevel@tonic-gate 25477c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_dev_core(handle, tabptr)) != Z_OK) 25487c478bd9Sstevel@tonic-gate return (err); 25497c478bd9Sstevel@tonic-gate 25507c478bd9Sstevel@tonic-gate return (Z_OK); 25517c478bd9Sstevel@tonic-gate } 25527c478bd9Sstevel@tonic-gate 25537c478bd9Sstevel@tonic-gate static int 25547c478bd9Sstevel@tonic-gate zonecfg_delete_dev_core(zone_dochandle_t handle, struct zone_devtab *tabptr) 25557c478bd9Sstevel@tonic-gate { 2556facf4a8dSllai xmlNodePtr cur = handle->zone_dh_cur; 25577c478bd9Sstevel@tonic-gate int match_match; 25587c478bd9Sstevel@tonic-gate 25597c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 25607c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_DEVICE)) 25617c478bd9Sstevel@tonic-gate continue; 25627c478bd9Sstevel@tonic-gate 25637c478bd9Sstevel@tonic-gate match_match = match_prop(cur, DTD_ATTR_MATCH, 25647c478bd9Sstevel@tonic-gate tabptr->zone_dev_match); 25657c478bd9Sstevel@tonic-gate 25667c478bd9Sstevel@tonic-gate if (match_match) { 25677c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 25687c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 25697c478bd9Sstevel@tonic-gate return (Z_OK); 25707c478bd9Sstevel@tonic-gate } 25717c478bd9Sstevel@tonic-gate } 25727c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 25737c478bd9Sstevel@tonic-gate } 25747c478bd9Sstevel@tonic-gate 25757c478bd9Sstevel@tonic-gate int 25767c478bd9Sstevel@tonic-gate zonecfg_delete_dev(zone_dochandle_t handle, struct zone_devtab *tabptr) 25777c478bd9Sstevel@tonic-gate { 25787c478bd9Sstevel@tonic-gate int err; 25797c478bd9Sstevel@tonic-gate 25807c478bd9Sstevel@tonic-gate if (tabptr == NULL) 25817c478bd9Sstevel@tonic-gate return (Z_INVAL); 25827c478bd9Sstevel@tonic-gate 25837c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 25847c478bd9Sstevel@tonic-gate return (err); 25857c478bd9Sstevel@tonic-gate 25867c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev_core(handle, tabptr)) != Z_OK) 25877c478bd9Sstevel@tonic-gate return (err); 25887c478bd9Sstevel@tonic-gate 25897c478bd9Sstevel@tonic-gate return (Z_OK); 25907c478bd9Sstevel@tonic-gate } 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate int 25937c478bd9Sstevel@tonic-gate zonecfg_modify_dev( 25947c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 25957c478bd9Sstevel@tonic-gate struct zone_devtab *oldtabptr, 25967c478bd9Sstevel@tonic-gate struct zone_devtab *newtabptr) 25977c478bd9Sstevel@tonic-gate { 25987c478bd9Sstevel@tonic-gate int err; 25997c478bd9Sstevel@tonic-gate 26007c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 26017c478bd9Sstevel@tonic-gate return (Z_INVAL); 26027c478bd9Sstevel@tonic-gate 26037c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 26047c478bd9Sstevel@tonic-gate return (err); 26057c478bd9Sstevel@tonic-gate 26067c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev_core(handle, oldtabptr)) != Z_OK) 26077c478bd9Sstevel@tonic-gate return (err); 26087c478bd9Sstevel@tonic-gate 26097c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_dev_core(handle, newtabptr)) != Z_OK) 26107c478bd9Sstevel@tonic-gate return (err); 26117c478bd9Sstevel@tonic-gate 26127c478bd9Sstevel@tonic-gate return (Z_OK); 26137c478bd9Sstevel@tonic-gate } 26147c478bd9Sstevel@tonic-gate 2615cb8a054bSGlenn Faden static int 2616cb8a054bSGlenn Faden zonecfg_add_auth_core(zone_dochandle_t handle, struct zone_admintab *tabptr, 2617cb8a054bSGlenn Faden char *zonename) 2618cb8a054bSGlenn Faden { 2619cb8a054bSGlenn Faden xmlNodePtr newnode, cur = handle->zone_dh_cur; 2620cb8a054bSGlenn Faden int err; 2621cb8a054bSGlenn Faden 2622cb8a054bSGlenn Faden newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_ADMIN, NULL); 2623cb8a054bSGlenn Faden err = newprop(newnode, DTD_ATTR_USER, tabptr->zone_admin_user); 2624cb8a054bSGlenn Faden if (err != Z_OK) 2625cb8a054bSGlenn Faden return (err); 2626cb8a054bSGlenn Faden err = newprop(newnode, DTD_ATTR_AUTHS, tabptr->zone_admin_auths); 2627cb8a054bSGlenn Faden if (err != Z_OK) 2628cb8a054bSGlenn Faden return (err); 2629cb8a054bSGlenn Faden if ((err = zonecfg_remove_userauths( 2630cb8a054bSGlenn Faden handle, tabptr->zone_admin_user, zonename, B_FALSE)) != Z_OK) 2631cb8a054bSGlenn Faden return (err); 2632cb8a054bSGlenn Faden return (Z_OK); 2633cb8a054bSGlenn Faden } 2634cb8a054bSGlenn Faden 2635cb8a054bSGlenn Faden int 2636cb8a054bSGlenn Faden zonecfg_add_admin(zone_dochandle_t handle, struct zone_admintab *tabptr, 2637cb8a054bSGlenn Faden char *zonename) 2638cb8a054bSGlenn Faden { 2639cb8a054bSGlenn Faden int err; 2640cb8a054bSGlenn Faden 2641cb8a054bSGlenn Faden if (tabptr == NULL) 2642cb8a054bSGlenn Faden return (Z_INVAL); 2643cb8a054bSGlenn Faden 2644cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2645cb8a054bSGlenn Faden return (err); 2646cb8a054bSGlenn Faden 2647cb8a054bSGlenn Faden if ((err = zonecfg_add_auth_core(handle, tabptr, 2648cb8a054bSGlenn Faden zonename)) != Z_OK) 2649cb8a054bSGlenn Faden return (err); 2650cb8a054bSGlenn Faden 2651cb8a054bSGlenn Faden return (Z_OK); 2652cb8a054bSGlenn Faden } 2653cb8a054bSGlenn Faden static int 2654cb8a054bSGlenn Faden zonecfg_delete_auth_core(zone_dochandle_t handle, struct zone_admintab *tabptr, 2655cb8a054bSGlenn Faden char *zonename) 2656cb8a054bSGlenn Faden { 2657cb8a054bSGlenn Faden xmlNodePtr cur = handle->zone_dh_cur; 2658cb8a054bSGlenn Faden boolean_t auth_match; 2659cb8a054bSGlenn Faden int err; 2660cb8a054bSGlenn Faden 2661cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 2662cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 2663cb8a054bSGlenn Faden continue; 2664cb8a054bSGlenn Faden auth_match = match_prop(cur, DTD_ATTR_USER, 2665cb8a054bSGlenn Faden tabptr->zone_admin_user); 2666cb8a054bSGlenn Faden if (auth_match) { 2667cb8a054bSGlenn Faden if ((err = zonecfg_insert_userauths( 2668cb8a054bSGlenn Faden handle, tabptr->zone_admin_user, 2669cb8a054bSGlenn Faden zonename)) != Z_OK) 2670cb8a054bSGlenn Faden return (err); 2671cb8a054bSGlenn Faden xmlUnlinkNode(cur); 2672cb8a054bSGlenn Faden xmlFreeNode(cur); 2673cb8a054bSGlenn Faden return (Z_OK); 2674cb8a054bSGlenn Faden } 2675cb8a054bSGlenn Faden } 2676cb8a054bSGlenn Faden return (Z_NO_RESOURCE_ID); 2677cb8a054bSGlenn Faden } 2678cb8a054bSGlenn Faden 2679cb8a054bSGlenn Faden int 2680cb8a054bSGlenn Faden zonecfg_delete_admin(zone_dochandle_t handle, struct zone_admintab *tabptr, 2681cb8a054bSGlenn Faden char *zonename) 2682cb8a054bSGlenn Faden { 2683cb8a054bSGlenn Faden int err; 2684cb8a054bSGlenn Faden 2685cb8a054bSGlenn Faden if (tabptr == NULL) 2686cb8a054bSGlenn Faden return (Z_INVAL); 2687cb8a054bSGlenn Faden 2688cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2689cb8a054bSGlenn Faden return (err); 2690cb8a054bSGlenn Faden 2691cb8a054bSGlenn Faden if ((err = zonecfg_delete_auth_core(handle, tabptr, zonename)) != Z_OK) 2692cb8a054bSGlenn Faden return (err); 2693cb8a054bSGlenn Faden 2694cb8a054bSGlenn Faden return (Z_OK); 2695cb8a054bSGlenn Faden } 2696cb8a054bSGlenn Faden 2697cb8a054bSGlenn Faden int 2698cb8a054bSGlenn Faden zonecfg_modify_admin(zone_dochandle_t handle, struct zone_admintab *oldtabptr, 2699cb8a054bSGlenn Faden struct zone_admintab *newtabptr, char *zonename) 2700cb8a054bSGlenn Faden { 2701cb8a054bSGlenn Faden int err; 2702cb8a054bSGlenn Faden 2703cb8a054bSGlenn Faden if (oldtabptr == NULL || newtabptr == NULL) 2704cb8a054bSGlenn Faden return (Z_INVAL); 2705cb8a054bSGlenn Faden 2706cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2707cb8a054bSGlenn Faden return (err); 2708cb8a054bSGlenn Faden 2709cb8a054bSGlenn Faden if ((err = zonecfg_delete_auth_core(handle, oldtabptr, zonename)) 2710cb8a054bSGlenn Faden != Z_OK) 2711cb8a054bSGlenn Faden return (err); 2712cb8a054bSGlenn Faden 2713cb8a054bSGlenn Faden if ((err = zonecfg_add_auth_core(handle, newtabptr, 2714cb8a054bSGlenn Faden zonename)) != Z_OK) 2715cb8a054bSGlenn Faden return (err); 2716cb8a054bSGlenn Faden 2717cb8a054bSGlenn Faden return (Z_OK); 2718cb8a054bSGlenn Faden } 2719cb8a054bSGlenn Faden 2720cb8a054bSGlenn Faden int 2721cb8a054bSGlenn Faden zonecfg_lookup_admin(zone_dochandle_t handle, struct zone_admintab *tabptr) 2722cb8a054bSGlenn Faden { 2723cb8a054bSGlenn Faden xmlNodePtr cur, firstmatch; 2724cb8a054bSGlenn Faden int err; 2725cb8a054bSGlenn Faden char user[MAXUSERNAME]; 2726cb8a054bSGlenn Faden 2727cb8a054bSGlenn Faden if (tabptr == NULL) 2728cb8a054bSGlenn Faden return (Z_INVAL); 2729cb8a054bSGlenn Faden 2730cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2731cb8a054bSGlenn Faden return (err); 2732cb8a054bSGlenn Faden 2733cb8a054bSGlenn Faden cur = handle->zone_dh_cur; 2734cb8a054bSGlenn Faden firstmatch = NULL; 2735cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 2736cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 2737cb8a054bSGlenn Faden continue; 2738cb8a054bSGlenn Faden if (strlen(tabptr->zone_admin_user) > 0) { 2739cb8a054bSGlenn Faden if ((fetchprop(cur, DTD_ATTR_USER, user, 2740cb8a054bSGlenn Faden sizeof (user)) == Z_OK) && 2741cb8a054bSGlenn Faden (strcmp(tabptr->zone_admin_user, user) == 0)) { 2742cb8a054bSGlenn Faden if (firstmatch == NULL) 2743cb8a054bSGlenn Faden firstmatch = cur; 2744cb8a054bSGlenn Faden else 2745cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2746cb8a054bSGlenn Faden } 2747cb8a054bSGlenn Faden } 2748cb8a054bSGlenn Faden } 2749cb8a054bSGlenn Faden if (firstmatch == NULL) 2750cb8a054bSGlenn Faden return (Z_NO_RESOURCE_ID); 2751cb8a054bSGlenn Faden 2752cb8a054bSGlenn Faden cur = firstmatch; 2753cb8a054bSGlenn Faden 2754cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_USER, tabptr->zone_admin_user, 2755cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_user))) != Z_OK) 2756cb8a054bSGlenn Faden return (err); 2757cb8a054bSGlenn Faden 2758cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_AUTHS, tabptr->zone_admin_auths, 2759cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_auths))) != Z_OK) 2760cb8a054bSGlenn Faden return (err); 2761cb8a054bSGlenn Faden 2762cb8a054bSGlenn Faden return (Z_OK); 2763cb8a054bSGlenn Faden } 2764cb8a054bSGlenn Faden 2765cb8a054bSGlenn Faden 2766ff17c8bfSgjelinek /* Lock to serialize all devwalks */ 2767ee519a1fSgjelinek static pthread_mutex_t zonecfg_devwalk_lock = PTHREAD_MUTEX_INITIALIZER; 2768ee519a1fSgjelinek /* 2769ff17c8bfSgjelinek * Global variables used to pass data from zonecfg_dev_manifest to the nftw 2770ee519a1fSgjelinek * call-back (zonecfg_devwalk_cb). g_devwalk_data is really the void* 2771ff17c8bfSgjelinek * parameter and g_devwalk_cb is really the *cb parameter from 2772ff17c8bfSgjelinek * zonecfg_dev_manifest. 2773ee519a1fSgjelinek */ 2774ff17c8bfSgjelinek typedef struct __g_devwalk_data *g_devwalk_data_t; 2775ff17c8bfSgjelinek static g_devwalk_data_t g_devwalk_data; 2776ee519a1fSgjelinek static int (*g_devwalk_cb)(const char *, uid_t, gid_t, mode_t, const char *, 2777ee519a1fSgjelinek void *); 2778ee519a1fSgjelinek static size_t g_devwalk_skip_prefix; 2779ee519a1fSgjelinek 2780ee519a1fSgjelinek /* 2781ff17c8bfSgjelinek * zonecfg_dev_manifest call-back function used during detach to generate the 2782ff17c8bfSgjelinek * dev info in the manifest. 2783ff17c8bfSgjelinek */ 2784ff17c8bfSgjelinek static int 2785ff17c8bfSgjelinek get_detach_dev_entry(const char *name, uid_t uid, gid_t gid, mode_t mode, 2786ff17c8bfSgjelinek const char *acl, void *hdl) 2787ff17c8bfSgjelinek { 2788ff17c8bfSgjelinek zone_dochandle_t handle = (zone_dochandle_t)hdl; 2789ff17c8bfSgjelinek xmlNodePtr newnode; 2790ff17c8bfSgjelinek xmlNodePtr cur; 2791ff17c8bfSgjelinek int err; 2792ff17c8bfSgjelinek char buf[128]; 2793ff17c8bfSgjelinek 2794ff17c8bfSgjelinek if ((err = operation_prep(handle)) != Z_OK) 2795ff17c8bfSgjelinek return (err); 2796ff17c8bfSgjelinek 2797ff17c8bfSgjelinek cur = handle->zone_dh_cur; 2798ff17c8bfSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_DEV_PERM, NULL); 2799ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_NAME, (char *)name)) != Z_OK) 2800ff17c8bfSgjelinek return (err); 2801ff17c8bfSgjelinek (void) snprintf(buf, sizeof (buf), "%lu", uid); 2802ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_UID, buf)) != Z_OK) 2803ff17c8bfSgjelinek return (err); 2804ff17c8bfSgjelinek (void) snprintf(buf, sizeof (buf), "%lu", gid); 2805ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_GID, buf)) != Z_OK) 2806ff17c8bfSgjelinek return (err); 2807ff17c8bfSgjelinek (void) snprintf(buf, sizeof (buf), "%o", mode); 2808ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_MODE, buf)) != Z_OK) 2809ff17c8bfSgjelinek return (err); 2810ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_ACL, (char *)acl)) != Z_OK) 2811ff17c8bfSgjelinek return (err); 2812ff17c8bfSgjelinek return (Z_OK); 2813ff17c8bfSgjelinek } 2814ff17c8bfSgjelinek 2815ff17c8bfSgjelinek /* 2816ff17c8bfSgjelinek * This is the nftw call-back function used by zonecfg_dev_manifest. It is 2817ff17c8bfSgjelinek * responsible for calling the actual call-back. 2818ee519a1fSgjelinek */ 2819ee519a1fSgjelinek /* ARGSUSED2 */ 2820ee519a1fSgjelinek static int 2821ee519a1fSgjelinek zonecfg_devwalk_cb(const char *path, const struct stat *st, int f, 2822ee519a1fSgjelinek struct FTW *ftw) 2823ee519a1fSgjelinek { 2824ee519a1fSgjelinek acl_t *acl; 2825ee519a1fSgjelinek char *acl_txt = NULL; 2826ee519a1fSgjelinek 2827ee519a1fSgjelinek /* skip all but character and block devices */ 2828ee519a1fSgjelinek if (!S_ISBLK(st->st_mode) && !S_ISCHR(st->st_mode)) 2829ee519a1fSgjelinek return (0); 2830ee519a1fSgjelinek 2831ee519a1fSgjelinek if ((acl_get(path, ACL_NO_TRIVIAL, &acl) == 0) && 2832ee519a1fSgjelinek acl != NULL) { 2833ee519a1fSgjelinek acl_txt = acl_totext(acl, ACL_NORESOLVE); 2834ee519a1fSgjelinek acl_free(acl); 2835ee519a1fSgjelinek } 2836ee519a1fSgjelinek 2837ee519a1fSgjelinek if (strlen(path) <= g_devwalk_skip_prefix) 2838ee519a1fSgjelinek return (0); 2839ee519a1fSgjelinek 2840ee519a1fSgjelinek g_devwalk_cb(path + g_devwalk_skip_prefix, st->st_uid, st->st_gid, 2841ee519a1fSgjelinek st->st_mode & S_IAMB, acl_txt != NULL ? acl_txt : "", 2842ee519a1fSgjelinek g_devwalk_data); 2843ee519a1fSgjelinek free(acl_txt); 2844ee519a1fSgjelinek return (0); 2845ee519a1fSgjelinek } 2846ee519a1fSgjelinek 2847ee519a1fSgjelinek /* 2848ff17c8bfSgjelinek * Walk the dev tree for the zone specified by hdl and call the 2849ff17c8bfSgjelinek * get_detach_dev_entry call-back function for each entry in the tree. The 2850ff17c8bfSgjelinek * call-back will be passed the name, uid, gid, mode, acl string and the 2851ff17c8bfSgjelinek * handle input parameter for each dev entry. 2852ee519a1fSgjelinek * 2853ff17c8bfSgjelinek * Data is passed to get_detach_dev_entry through the global variables 2854ee519a1fSgjelinek * g_devwalk_data, *g_devwalk_cb, and g_devwalk_skip_prefix. The 2855ff17c8bfSgjelinek * zonecfg_devwalk_cb function will actually call get_detach_dev_entry. 2856ee519a1fSgjelinek */ 2857ee519a1fSgjelinek int 2858ff17c8bfSgjelinek zonecfg_dev_manifest(zone_dochandle_t hdl) 2859ee519a1fSgjelinek { 2860ee519a1fSgjelinek char path[MAXPATHLEN]; 2861ee519a1fSgjelinek int ret; 2862ee519a1fSgjelinek 2863ee519a1fSgjelinek if ((ret = zonecfg_get_zonepath(hdl, path, sizeof (path))) != Z_OK) 2864ee519a1fSgjelinek return (ret); 2865ee519a1fSgjelinek 2866ee519a1fSgjelinek if (strlcat(path, "/dev", sizeof (path)) >= sizeof (path)) 2867ee519a1fSgjelinek return (Z_TOO_BIG); 2868ee519a1fSgjelinek 2869ee519a1fSgjelinek /* 2870ff17c8bfSgjelinek * We have to serialize all devwalks in the same process 2871ee519a1fSgjelinek * (which should be fine), since nftw() is so badly designed. 2872ee519a1fSgjelinek */ 2873ee519a1fSgjelinek (void) pthread_mutex_lock(&zonecfg_devwalk_lock); 2874ee519a1fSgjelinek 2875ff17c8bfSgjelinek g_devwalk_skip_prefix = strlen(path) + 1; 2876ff17c8bfSgjelinek g_devwalk_data = (g_devwalk_data_t)hdl; 2877ff17c8bfSgjelinek g_devwalk_cb = get_detach_dev_entry; 2878ee519a1fSgjelinek (void) nftw(path, zonecfg_devwalk_cb, 0, FTW_PHYS); 2879ee519a1fSgjelinek 2880ee519a1fSgjelinek (void) pthread_mutex_unlock(&zonecfg_devwalk_lock); 2881ee519a1fSgjelinek return (Z_OK); 2882ee519a1fSgjelinek } 2883ee519a1fSgjelinek 2884ee519a1fSgjelinek /* 2885ee519a1fSgjelinek * Update the owner, group, mode and acl on the specified dev (inpath) for 2886ee519a1fSgjelinek * the zone (hdl). This function can be used to fix up the dev tree after 2887ee519a1fSgjelinek * attaching a migrated zone. 2888ee519a1fSgjelinek */ 2889ee519a1fSgjelinek int 2890ee519a1fSgjelinek zonecfg_devperms_apply(zone_dochandle_t hdl, const char *inpath, uid_t owner, 2891ee519a1fSgjelinek gid_t group, mode_t mode, const char *acltxt) 2892ee519a1fSgjelinek { 2893ee519a1fSgjelinek int ret; 2894ee519a1fSgjelinek char path[MAXPATHLEN]; 2895ee519a1fSgjelinek struct stat st; 2896ee519a1fSgjelinek acl_t *aclp; 2897ee519a1fSgjelinek 2898ee519a1fSgjelinek if ((ret = zonecfg_get_zonepath(hdl, path, sizeof (path))) != Z_OK) 2899ee519a1fSgjelinek return (ret); 2900ee519a1fSgjelinek 2901ee519a1fSgjelinek if (strlcat(path, "/dev/", sizeof (path)) >= sizeof (path)) 2902ee519a1fSgjelinek return (Z_TOO_BIG); 2903ee519a1fSgjelinek if (strlcat(path, inpath, sizeof (path)) >= sizeof (path)) 2904ee519a1fSgjelinek return (Z_TOO_BIG); 2905ee519a1fSgjelinek 2906ee519a1fSgjelinek if (stat(path, &st) == -1) 2907ee519a1fSgjelinek return (Z_INVAL); 2908ee519a1fSgjelinek 2909ee519a1fSgjelinek /* make sure we're only touching device nodes */ 2910ee519a1fSgjelinek if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) 2911ee519a1fSgjelinek return (Z_INVAL); 2912ee519a1fSgjelinek 2913ee519a1fSgjelinek if (chown(path, owner, group) == -1) 2914ee519a1fSgjelinek return (Z_SYSTEM); 2915ee519a1fSgjelinek 2916ee519a1fSgjelinek if (chmod(path, mode) == -1) 2917ee519a1fSgjelinek return (Z_SYSTEM); 2918ee519a1fSgjelinek 2919ee519a1fSgjelinek if ((acltxt == NULL) || (strcmp(acltxt, "") == 0)) 2920ee519a1fSgjelinek return (Z_OK); 2921ee519a1fSgjelinek 29222ad45a84Sjv if (acl_fromtext(acltxt, &aclp) != 0) { 29232ad45a84Sjv errno = EINVAL; 2924ee519a1fSgjelinek return (Z_SYSTEM); 29252ad45a84Sjv } 2926ee519a1fSgjelinek 2927ee519a1fSgjelinek errno = 0; 2928ee519a1fSgjelinek if (acl_set(path, aclp) == -1) { 2929ee519a1fSgjelinek free(aclp); 2930ee519a1fSgjelinek return (Z_SYSTEM); 2931ee519a1fSgjelinek } 2932ee519a1fSgjelinek 2933ee519a1fSgjelinek free(aclp); 2934ee519a1fSgjelinek return (Z_OK); 2935ee519a1fSgjelinek } 2936ee519a1fSgjelinek 29377c478bd9Sstevel@tonic-gate /* 29387c478bd9Sstevel@tonic-gate * This function finds everything mounted under a zone's rootpath. 29397c478bd9Sstevel@tonic-gate * This returns the number of mounts under rootpath, or -1 on error. 29407c478bd9Sstevel@tonic-gate * callback is called once per mount found with the first argument 29410094b373Sjv * pointing to a mnttab structure containing the mount's information. 29427c478bd9Sstevel@tonic-gate * 29437c478bd9Sstevel@tonic-gate * If the callback function returns non-zero zonecfg_find_mounts 29447c478bd9Sstevel@tonic-gate * aborts with an error. 29457c478bd9Sstevel@tonic-gate */ 29467c478bd9Sstevel@tonic-gate int 29470094b373Sjv zonecfg_find_mounts(char *rootpath, int (*callback)(const struct mnttab *, 29480094b373Sjv void *), void *priv) { 29497c478bd9Sstevel@tonic-gate FILE *mnttab; 29507c478bd9Sstevel@tonic-gate struct mnttab m; 29517c478bd9Sstevel@tonic-gate size_t l; 295207b574eeSgjelinek int zfsl; 29537c478bd9Sstevel@tonic-gate int rv = 0; 295407b574eeSgjelinek char zfs_path[MAXPATHLEN]; 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate assert(rootpath != NULL); 29577c478bd9Sstevel@tonic-gate 295807b574eeSgjelinek if ((zfsl = snprintf(zfs_path, sizeof (zfs_path), "%s/.zfs/", rootpath)) 295907b574eeSgjelinek >= sizeof (zfs_path)) 296007b574eeSgjelinek return (-1); 296107b574eeSgjelinek 29627c478bd9Sstevel@tonic-gate l = strlen(rootpath); 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate mnttab = fopen("/etc/mnttab", "r"); 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate if (mnttab == NULL) 29677c478bd9Sstevel@tonic-gate return (-1); 29687c478bd9Sstevel@tonic-gate 29697c478bd9Sstevel@tonic-gate if (ioctl(fileno(mnttab), MNTIOC_SHOWHIDDEN, NULL) < 0) { 29707c478bd9Sstevel@tonic-gate rv = -1; 29717c478bd9Sstevel@tonic-gate goto out; 29727c478bd9Sstevel@tonic-gate } 29737c478bd9Sstevel@tonic-gate 29747c478bd9Sstevel@tonic-gate while (!getmntent(mnttab, &m)) { 29757c478bd9Sstevel@tonic-gate if ((strncmp(rootpath, m.mnt_mountp, l) == 0) && 297607b574eeSgjelinek (m.mnt_mountp[l] == '/') && 297707b574eeSgjelinek (strncmp(zfs_path, m.mnt_mountp, zfsl) != 0)) { 29787c478bd9Sstevel@tonic-gate rv++; 29797c478bd9Sstevel@tonic-gate if (callback == NULL) 29807c478bd9Sstevel@tonic-gate continue; 29810094b373Sjv if (callback(&m, priv)) { 29827c478bd9Sstevel@tonic-gate rv = -1; 29837c478bd9Sstevel@tonic-gate goto out; 29847c478bd9Sstevel@tonic-gate 29857c478bd9Sstevel@tonic-gate } 29867c478bd9Sstevel@tonic-gate } 29877c478bd9Sstevel@tonic-gate } 29887c478bd9Sstevel@tonic-gate 29897c478bd9Sstevel@tonic-gate out: 29907c478bd9Sstevel@tonic-gate (void) fclose(mnttab); 29917c478bd9Sstevel@tonic-gate return (rv); 29927c478bd9Sstevel@tonic-gate } 29937c478bd9Sstevel@tonic-gate 29947c478bd9Sstevel@tonic-gate int 29957c478bd9Sstevel@tonic-gate zonecfg_lookup_attr(zone_dochandle_t handle, struct zone_attrtab *tabptr) 29967c478bd9Sstevel@tonic-gate { 29977c478bd9Sstevel@tonic-gate xmlNodePtr cur, firstmatch; 29987c478bd9Sstevel@tonic-gate int err; 29997c478bd9Sstevel@tonic-gate char name[MAXNAMELEN], type[MAXNAMELEN], value[MAXNAMELEN]; 30007c478bd9Sstevel@tonic-gate 30017c478bd9Sstevel@tonic-gate if (tabptr == NULL) 30027c478bd9Sstevel@tonic-gate return (Z_INVAL); 30037c478bd9Sstevel@tonic-gate 30047c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 30057c478bd9Sstevel@tonic-gate return (err); 30067c478bd9Sstevel@tonic-gate 30077c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 30087c478bd9Sstevel@tonic-gate firstmatch = NULL; 30097c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 30107c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_ATTR)) 30117c478bd9Sstevel@tonic-gate continue; 30127c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_attr_name) > 0) { 30137c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_NAME, name, 30147c478bd9Sstevel@tonic-gate sizeof (name)) == Z_OK) && 30157c478bd9Sstevel@tonic-gate (strcmp(tabptr->zone_attr_name, name) == 0)) { 30167c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30177c478bd9Sstevel@tonic-gate firstmatch = cur; 30187c478bd9Sstevel@tonic-gate else 30197c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 30207c478bd9Sstevel@tonic-gate } 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_attr_type) > 0) { 30237c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_TYPE, type, 30247c478bd9Sstevel@tonic-gate sizeof (type)) == Z_OK)) { 30257c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_attr_type, type) == 0) { 30267c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30277c478bd9Sstevel@tonic-gate firstmatch = cur; 30287c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 30297c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 30307c478bd9Sstevel@tonic-gate } else { 30317c478bd9Sstevel@tonic-gate /* 30327c478bd9Sstevel@tonic-gate * If another property matched but this 30337c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 30347c478bd9Sstevel@tonic-gate */ 30357c478bd9Sstevel@tonic-gate if (firstmatch == cur) 30367c478bd9Sstevel@tonic-gate firstmatch = NULL; 30377c478bd9Sstevel@tonic-gate } 30387c478bd9Sstevel@tonic-gate } 30397c478bd9Sstevel@tonic-gate } 30407c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_attr_value) > 0) { 30417c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_VALUE, value, 30427c478bd9Sstevel@tonic-gate sizeof (value)) == Z_OK)) { 30437c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_attr_value, value) == 30447c478bd9Sstevel@tonic-gate 0) { 30457c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30467c478bd9Sstevel@tonic-gate firstmatch = cur; 30477c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 30487c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 30497c478bd9Sstevel@tonic-gate } else { 30507c478bd9Sstevel@tonic-gate /* 30517c478bd9Sstevel@tonic-gate * If another property matched but this 30527c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 30537c478bd9Sstevel@tonic-gate */ 30547c478bd9Sstevel@tonic-gate if (firstmatch == cur) 30557c478bd9Sstevel@tonic-gate firstmatch = NULL; 30567c478bd9Sstevel@tonic-gate } 30577c478bd9Sstevel@tonic-gate } 30587c478bd9Sstevel@tonic-gate } 30597c478bd9Sstevel@tonic-gate } 30607c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30617c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 30627c478bd9Sstevel@tonic-gate 30637c478bd9Sstevel@tonic-gate cur = firstmatch; 30647c478bd9Sstevel@tonic-gate 30657c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_attr_name, 30667c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_attr_name))) != Z_OK) 30677c478bd9Sstevel@tonic-gate return (err); 30687c478bd9Sstevel@tonic-gate 30697c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_attr_type, 30707c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_attr_type))) != Z_OK) 30717c478bd9Sstevel@tonic-gate return (err); 30727c478bd9Sstevel@tonic-gate 30737c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_VALUE, tabptr->zone_attr_value, 30747c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_attr_value))) != Z_OK) 30757c478bd9Sstevel@tonic-gate return (err); 30767c478bd9Sstevel@tonic-gate 30777c478bd9Sstevel@tonic-gate return (Z_OK); 30787c478bd9Sstevel@tonic-gate } 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate static int 30817c478bd9Sstevel@tonic-gate zonecfg_add_attr_core(zone_dochandle_t handle, struct zone_attrtab *tabptr) 30827c478bd9Sstevel@tonic-gate { 30837c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 30847c478bd9Sstevel@tonic-gate int err; 30857c478bd9Sstevel@tonic-gate 30867c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_ATTR, NULL); 3087a1be23daSdp err = newprop(newnode, DTD_ATTR_NAME, tabptr->zone_attr_name); 30887c478bd9Sstevel@tonic-gate if (err != Z_OK) 30897c478bd9Sstevel@tonic-gate return (err); 3090a1be23daSdp err = newprop(newnode, DTD_ATTR_TYPE, tabptr->zone_attr_type); 30917c478bd9Sstevel@tonic-gate if (err != Z_OK) 30927c478bd9Sstevel@tonic-gate return (err); 3093a1be23daSdp err = newprop(newnode, DTD_ATTR_VALUE, tabptr->zone_attr_value); 30947c478bd9Sstevel@tonic-gate if (err != Z_OK) 30957c478bd9Sstevel@tonic-gate return (err); 30967c478bd9Sstevel@tonic-gate return (Z_OK); 30977c478bd9Sstevel@tonic-gate } 30987c478bd9Sstevel@tonic-gate 30997c478bd9Sstevel@tonic-gate int 31007c478bd9Sstevel@tonic-gate zonecfg_add_attr(zone_dochandle_t handle, struct zone_attrtab *tabptr) 31017c478bd9Sstevel@tonic-gate { 31027c478bd9Sstevel@tonic-gate int err; 31037c478bd9Sstevel@tonic-gate 31047c478bd9Sstevel@tonic-gate if (tabptr == NULL) 31057c478bd9Sstevel@tonic-gate return (Z_INVAL); 31067c478bd9Sstevel@tonic-gate 31077c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 31087c478bd9Sstevel@tonic-gate return (err); 31097c478bd9Sstevel@tonic-gate 31107c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_attr_core(handle, tabptr)) != Z_OK) 31117c478bd9Sstevel@tonic-gate return (err); 31127c478bd9Sstevel@tonic-gate 31137c478bd9Sstevel@tonic-gate return (Z_OK); 31147c478bd9Sstevel@tonic-gate } 31157c478bd9Sstevel@tonic-gate 31167c478bd9Sstevel@tonic-gate static int 31177c478bd9Sstevel@tonic-gate zonecfg_delete_attr_core(zone_dochandle_t handle, struct zone_attrtab *tabptr) 31187c478bd9Sstevel@tonic-gate { 31197c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 31207c478bd9Sstevel@tonic-gate int name_match, type_match, value_match; 31217c478bd9Sstevel@tonic-gate 31227c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 31237c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_ATTR)) 31247c478bd9Sstevel@tonic-gate continue; 31257c478bd9Sstevel@tonic-gate 31267c478bd9Sstevel@tonic-gate name_match = match_prop(cur, DTD_ATTR_NAME, 31277c478bd9Sstevel@tonic-gate tabptr->zone_attr_name); 31287c478bd9Sstevel@tonic-gate type_match = match_prop(cur, DTD_ATTR_TYPE, 31297c478bd9Sstevel@tonic-gate tabptr->zone_attr_type); 31307c478bd9Sstevel@tonic-gate value_match = match_prop(cur, DTD_ATTR_VALUE, 31317c478bd9Sstevel@tonic-gate tabptr->zone_attr_value); 31327c478bd9Sstevel@tonic-gate 31337c478bd9Sstevel@tonic-gate if (name_match && type_match && value_match) { 31347c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 31357c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 31367c478bd9Sstevel@tonic-gate return (Z_OK); 31377c478bd9Sstevel@tonic-gate } 31387c478bd9Sstevel@tonic-gate } 31397c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 31407c478bd9Sstevel@tonic-gate } 31417c478bd9Sstevel@tonic-gate 31427c478bd9Sstevel@tonic-gate int 31437c478bd9Sstevel@tonic-gate zonecfg_delete_attr(zone_dochandle_t handle, struct zone_attrtab *tabptr) 31447c478bd9Sstevel@tonic-gate { 31457c478bd9Sstevel@tonic-gate int err; 31467c478bd9Sstevel@tonic-gate 31477c478bd9Sstevel@tonic-gate if (tabptr == NULL) 31487c478bd9Sstevel@tonic-gate return (Z_INVAL); 31497c478bd9Sstevel@tonic-gate 31507c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 31517c478bd9Sstevel@tonic-gate return (err); 31527c478bd9Sstevel@tonic-gate 31537c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr_core(handle, tabptr)) != Z_OK) 31547c478bd9Sstevel@tonic-gate return (err); 31557c478bd9Sstevel@tonic-gate 31567c478bd9Sstevel@tonic-gate return (Z_OK); 31577c478bd9Sstevel@tonic-gate } 31587c478bd9Sstevel@tonic-gate 31597c478bd9Sstevel@tonic-gate int 31607c478bd9Sstevel@tonic-gate zonecfg_modify_attr( 31617c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 31627c478bd9Sstevel@tonic-gate struct zone_attrtab *oldtabptr, 31637c478bd9Sstevel@tonic-gate struct zone_attrtab *newtabptr) 31647c478bd9Sstevel@tonic-gate { 31657c478bd9Sstevel@tonic-gate int err; 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 31687c478bd9Sstevel@tonic-gate return (Z_INVAL); 31697c478bd9Sstevel@tonic-gate 31707c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 31717c478bd9Sstevel@tonic-gate return (err); 31727c478bd9Sstevel@tonic-gate 31737c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr_core(handle, oldtabptr)) != Z_OK) 31747c478bd9Sstevel@tonic-gate return (err); 31757c478bd9Sstevel@tonic-gate 31767c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_attr_core(handle, newtabptr)) != Z_OK) 31777c478bd9Sstevel@tonic-gate return (err); 31787c478bd9Sstevel@tonic-gate 31797c478bd9Sstevel@tonic-gate return (Z_OK); 31807c478bd9Sstevel@tonic-gate } 31817c478bd9Sstevel@tonic-gate 31827c478bd9Sstevel@tonic-gate int 31837c478bd9Sstevel@tonic-gate zonecfg_get_attr_boolean(const struct zone_attrtab *attr, boolean_t *value) 31847c478bd9Sstevel@tonic-gate { 31857c478bd9Sstevel@tonic-gate if (attr == NULL) 31867c478bd9Sstevel@tonic-gate return (Z_INVAL); 31877c478bd9Sstevel@tonic-gate 31887c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_BOOLEAN) != 0) 31897c478bd9Sstevel@tonic-gate return (Z_INVAL); 31907c478bd9Sstevel@tonic-gate 31917c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_value, DTD_ENTITY_TRUE) == 0) { 31927c478bd9Sstevel@tonic-gate *value = B_TRUE; 31937c478bd9Sstevel@tonic-gate return (Z_OK); 31947c478bd9Sstevel@tonic-gate } 31957c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_value, DTD_ENTITY_FALSE) == 0) { 31967c478bd9Sstevel@tonic-gate *value = B_FALSE; 31977c478bd9Sstevel@tonic-gate return (Z_OK); 31987c478bd9Sstevel@tonic-gate } 31997c478bd9Sstevel@tonic-gate return (Z_INVAL); 32007c478bd9Sstevel@tonic-gate } 32017c478bd9Sstevel@tonic-gate 32027c478bd9Sstevel@tonic-gate int 32037c478bd9Sstevel@tonic-gate zonecfg_get_attr_int(const struct zone_attrtab *attr, int64_t *value) 32047c478bd9Sstevel@tonic-gate { 32057c478bd9Sstevel@tonic-gate long long result; 32067c478bd9Sstevel@tonic-gate char *endptr; 32077c478bd9Sstevel@tonic-gate 32087c478bd9Sstevel@tonic-gate if (attr == NULL) 32097c478bd9Sstevel@tonic-gate return (Z_INVAL); 32107c478bd9Sstevel@tonic-gate 32117c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_INT) != 0) 32127c478bd9Sstevel@tonic-gate return (Z_INVAL); 32137c478bd9Sstevel@tonic-gate 32147c478bd9Sstevel@tonic-gate errno = 0; 32157c478bd9Sstevel@tonic-gate result = strtoll(attr->zone_attr_value, &endptr, 10); 32167c478bd9Sstevel@tonic-gate if (errno != 0 || *endptr != '\0') 32177c478bd9Sstevel@tonic-gate return (Z_INVAL); 32187c478bd9Sstevel@tonic-gate *value = result; 32197c478bd9Sstevel@tonic-gate return (Z_OK); 32207c478bd9Sstevel@tonic-gate } 32217c478bd9Sstevel@tonic-gate 32227c478bd9Sstevel@tonic-gate int 32237c478bd9Sstevel@tonic-gate zonecfg_get_attr_string(const struct zone_attrtab *attr, char *value, 32247c478bd9Sstevel@tonic-gate size_t val_sz) 32257c478bd9Sstevel@tonic-gate { 32267c478bd9Sstevel@tonic-gate if (attr == NULL) 32277c478bd9Sstevel@tonic-gate return (Z_INVAL); 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_STRING) != 0) 32307c478bd9Sstevel@tonic-gate return (Z_INVAL); 32317c478bd9Sstevel@tonic-gate 32327c478bd9Sstevel@tonic-gate if (strlcpy(value, attr->zone_attr_value, val_sz) >= val_sz) 32337c478bd9Sstevel@tonic-gate return (Z_TOO_BIG); 32347c478bd9Sstevel@tonic-gate return (Z_OK); 32357c478bd9Sstevel@tonic-gate } 32367c478bd9Sstevel@tonic-gate 32377c478bd9Sstevel@tonic-gate int 32387c478bd9Sstevel@tonic-gate zonecfg_get_attr_uint(const struct zone_attrtab *attr, uint64_t *value) 32397c478bd9Sstevel@tonic-gate { 32407c478bd9Sstevel@tonic-gate unsigned long long result; 32417c478bd9Sstevel@tonic-gate long long neg_result; 32427c478bd9Sstevel@tonic-gate char *endptr; 32437c478bd9Sstevel@tonic-gate 32447c478bd9Sstevel@tonic-gate if (attr == NULL) 32457c478bd9Sstevel@tonic-gate return (Z_INVAL); 32467c478bd9Sstevel@tonic-gate 32477c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_UINT) != 0) 32487c478bd9Sstevel@tonic-gate return (Z_INVAL); 32497c478bd9Sstevel@tonic-gate 32507c478bd9Sstevel@tonic-gate errno = 0; 32517c478bd9Sstevel@tonic-gate result = strtoull(attr->zone_attr_value, &endptr, 10); 32527c478bd9Sstevel@tonic-gate if (errno != 0 || *endptr != '\0') 32537c478bd9Sstevel@tonic-gate return (Z_INVAL); 32547c478bd9Sstevel@tonic-gate errno = 0; 32557c478bd9Sstevel@tonic-gate neg_result = strtoll(attr->zone_attr_value, &endptr, 10); 32567c478bd9Sstevel@tonic-gate /* 32577c478bd9Sstevel@tonic-gate * Incredibly, strtoull("<negative number>", ...) will not fail but 32587c478bd9Sstevel@tonic-gate * return whatever (negative) number cast as a u_longlong_t, so we 32597c478bd9Sstevel@tonic-gate * need to look for this here. 32607c478bd9Sstevel@tonic-gate */ 32617c478bd9Sstevel@tonic-gate if (errno == 0 && neg_result < 0) 32627c478bd9Sstevel@tonic-gate return (Z_INVAL); 32637c478bd9Sstevel@tonic-gate *value = result; 32647c478bd9Sstevel@tonic-gate return (Z_OK); 32657c478bd9Sstevel@tonic-gate } 32667c478bd9Sstevel@tonic-gate 32677c478bd9Sstevel@tonic-gate int 32687c478bd9Sstevel@tonic-gate zonecfg_lookup_rctl(zone_dochandle_t handle, struct zone_rctltab *tabptr) 32697c478bd9Sstevel@tonic-gate { 32707c478bd9Sstevel@tonic-gate xmlNodePtr cur, val; 32717c478bd9Sstevel@tonic-gate char savedname[MAXNAMELEN]; 32727c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 32737c478bd9Sstevel@tonic-gate int err; 32747c478bd9Sstevel@tonic-gate 32752ad45a84Sjv if (strlen(tabptr->zone_rctl_name) == 0) 32767c478bd9Sstevel@tonic-gate return (Z_INVAL); 32777c478bd9Sstevel@tonic-gate 32787c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 32797c478bd9Sstevel@tonic-gate return (err); 32807c478bd9Sstevel@tonic-gate 32817c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 32827c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 32837c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_RCTL)) 32847c478bd9Sstevel@tonic-gate continue; 32857c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_NAME, savedname, 32867c478bd9Sstevel@tonic-gate sizeof (savedname)) == Z_OK) && 32877c478bd9Sstevel@tonic-gate (strcmp(savedname, tabptr->zone_rctl_name) == 0)) { 32887c478bd9Sstevel@tonic-gate tabptr->zone_rctl_valptr = NULL; 32897c478bd9Sstevel@tonic-gate for (val = cur->xmlChildrenNode; val != NULL; 32907c478bd9Sstevel@tonic-gate val = val->next) { 32917c478bd9Sstevel@tonic-gate valptr = (struct zone_rctlvaltab *)malloc( 32927c478bd9Sstevel@tonic-gate sizeof (struct zone_rctlvaltab)); 32937c478bd9Sstevel@tonic-gate if (valptr == NULL) 32947c478bd9Sstevel@tonic-gate return (Z_NOMEM); 32957c478bd9Sstevel@tonic-gate if ((fetchprop(val, DTD_ATTR_PRIV, 32967c478bd9Sstevel@tonic-gate valptr->zone_rctlval_priv, 32977c478bd9Sstevel@tonic-gate sizeof (valptr->zone_rctlval_priv)) != 32987c478bd9Sstevel@tonic-gate Z_OK)) 32997c478bd9Sstevel@tonic-gate break; 33007c478bd9Sstevel@tonic-gate if ((fetchprop(val, DTD_ATTR_LIMIT, 33017c478bd9Sstevel@tonic-gate valptr->zone_rctlval_limit, 33027c478bd9Sstevel@tonic-gate sizeof (valptr->zone_rctlval_limit)) != 33037c478bd9Sstevel@tonic-gate Z_OK)) 33047c478bd9Sstevel@tonic-gate break; 33057c478bd9Sstevel@tonic-gate if ((fetchprop(val, DTD_ATTR_ACTION, 33067c478bd9Sstevel@tonic-gate valptr->zone_rctlval_action, 33077c478bd9Sstevel@tonic-gate sizeof (valptr->zone_rctlval_action)) != 33087c478bd9Sstevel@tonic-gate Z_OK)) 33097c478bd9Sstevel@tonic-gate break; 33107c478bd9Sstevel@tonic-gate if (zonecfg_add_rctl_value(tabptr, valptr) != 33117c478bd9Sstevel@tonic-gate Z_OK) 33127c478bd9Sstevel@tonic-gate break; 33137c478bd9Sstevel@tonic-gate } 33147c478bd9Sstevel@tonic-gate return (Z_OK); 33157c478bd9Sstevel@tonic-gate } 33167c478bd9Sstevel@tonic-gate } 33177c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 33187c478bd9Sstevel@tonic-gate } 33197c478bd9Sstevel@tonic-gate 33207c478bd9Sstevel@tonic-gate static int 33217c478bd9Sstevel@tonic-gate zonecfg_add_rctl_core(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33227c478bd9Sstevel@tonic-gate { 33237c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur, valnode; 33247c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 33257c478bd9Sstevel@tonic-gate int err; 33267c478bd9Sstevel@tonic-gate 33277c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_RCTL, NULL); 3328a1be23daSdp err = newprop(newnode, DTD_ATTR_NAME, tabptr->zone_rctl_name); 33297c478bd9Sstevel@tonic-gate if (err != Z_OK) 33307c478bd9Sstevel@tonic-gate return (err); 33317c478bd9Sstevel@tonic-gate for (valptr = tabptr->zone_rctl_valptr; valptr != NULL; 33327c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 33337c478bd9Sstevel@tonic-gate valnode = xmlNewTextChild(newnode, NULL, 33347c478bd9Sstevel@tonic-gate DTD_ELEM_RCTLVALUE, NULL); 3335a1be23daSdp err = newprop(valnode, DTD_ATTR_PRIV, 33367c478bd9Sstevel@tonic-gate valptr->zone_rctlval_priv); 33377c478bd9Sstevel@tonic-gate if (err != Z_OK) 33387c478bd9Sstevel@tonic-gate return (err); 3339a1be23daSdp err = newprop(valnode, DTD_ATTR_LIMIT, 33407c478bd9Sstevel@tonic-gate valptr->zone_rctlval_limit); 33417c478bd9Sstevel@tonic-gate if (err != Z_OK) 33427c478bd9Sstevel@tonic-gate return (err); 3343a1be23daSdp err = newprop(valnode, DTD_ATTR_ACTION, 33447c478bd9Sstevel@tonic-gate valptr->zone_rctlval_action); 33457c478bd9Sstevel@tonic-gate if (err != Z_OK) 33467c478bd9Sstevel@tonic-gate return (err); 33477c478bd9Sstevel@tonic-gate } 33487c478bd9Sstevel@tonic-gate return (Z_OK); 33497c478bd9Sstevel@tonic-gate } 33507c478bd9Sstevel@tonic-gate 33517c478bd9Sstevel@tonic-gate int 33527c478bd9Sstevel@tonic-gate zonecfg_add_rctl(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33537c478bd9Sstevel@tonic-gate { 33547c478bd9Sstevel@tonic-gate int err; 33557c478bd9Sstevel@tonic-gate 33562ad45a84Sjv if (tabptr == NULL) 33577c478bd9Sstevel@tonic-gate return (Z_INVAL); 33587c478bd9Sstevel@tonic-gate 33597c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 33607c478bd9Sstevel@tonic-gate return (err); 33617c478bd9Sstevel@tonic-gate 33627c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_rctl_core(handle, tabptr)) != Z_OK) 33637c478bd9Sstevel@tonic-gate return (err); 33647c478bd9Sstevel@tonic-gate 33657c478bd9Sstevel@tonic-gate return (Z_OK); 33667c478bd9Sstevel@tonic-gate } 33677c478bd9Sstevel@tonic-gate 33687c478bd9Sstevel@tonic-gate static int 33697c478bd9Sstevel@tonic-gate zonecfg_delete_rctl_core(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33707c478bd9Sstevel@tonic-gate { 33717c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 33727c478bd9Sstevel@tonic-gate xmlChar *savedname; 33737c478bd9Sstevel@tonic-gate int name_result; 33747c478bd9Sstevel@tonic-gate 33757c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 33767c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_RCTL)) 33777c478bd9Sstevel@tonic-gate continue; 33787c478bd9Sstevel@tonic-gate 33797c478bd9Sstevel@tonic-gate savedname = xmlGetProp(cur, DTD_ATTR_NAME); 33807c478bd9Sstevel@tonic-gate if (savedname == NULL) /* shouldn't happen */ 33817c478bd9Sstevel@tonic-gate continue; 33827c478bd9Sstevel@tonic-gate name_result = xmlStrcmp(savedname, 33837c478bd9Sstevel@tonic-gate (const xmlChar *) tabptr->zone_rctl_name); 33847c478bd9Sstevel@tonic-gate xmlFree(savedname); 33857c478bd9Sstevel@tonic-gate 33867c478bd9Sstevel@tonic-gate if (name_result == 0) { 33877c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 33887c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 33897c478bd9Sstevel@tonic-gate return (Z_OK); 33907c478bd9Sstevel@tonic-gate } 33917c478bd9Sstevel@tonic-gate } 33927c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 33937c478bd9Sstevel@tonic-gate } 33947c478bd9Sstevel@tonic-gate 33957c478bd9Sstevel@tonic-gate int 33967c478bd9Sstevel@tonic-gate zonecfg_delete_rctl(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33977c478bd9Sstevel@tonic-gate { 33987c478bd9Sstevel@tonic-gate int err; 33997c478bd9Sstevel@tonic-gate 34002ad45a84Sjv if (tabptr == NULL) 34017c478bd9Sstevel@tonic-gate return (Z_INVAL); 34027c478bd9Sstevel@tonic-gate 34037c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 34047c478bd9Sstevel@tonic-gate return (err); 34057c478bd9Sstevel@tonic-gate 34067c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl_core(handle, tabptr)) != Z_OK) 34077c478bd9Sstevel@tonic-gate return (err); 34087c478bd9Sstevel@tonic-gate 34097c478bd9Sstevel@tonic-gate return (Z_OK); 34107c478bd9Sstevel@tonic-gate } 34117c478bd9Sstevel@tonic-gate 34127c478bd9Sstevel@tonic-gate int 34137c478bd9Sstevel@tonic-gate zonecfg_modify_rctl( 34147c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 34157c478bd9Sstevel@tonic-gate struct zone_rctltab *oldtabptr, 34167c478bd9Sstevel@tonic-gate struct zone_rctltab *newtabptr) 34177c478bd9Sstevel@tonic-gate { 34187c478bd9Sstevel@tonic-gate int err; 34197c478bd9Sstevel@tonic-gate 34202ad45a84Sjv if (oldtabptr == NULL || newtabptr == NULL) 34217c478bd9Sstevel@tonic-gate return (Z_INVAL); 34227c478bd9Sstevel@tonic-gate 34237c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 34247c478bd9Sstevel@tonic-gate return (err); 34257c478bd9Sstevel@tonic-gate 34267c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl_core(handle, oldtabptr)) != Z_OK) 34277c478bd9Sstevel@tonic-gate return (err); 34287c478bd9Sstevel@tonic-gate 34297c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_rctl_core(handle, newtabptr)) != Z_OK) 34307c478bd9Sstevel@tonic-gate return (err); 34317c478bd9Sstevel@tonic-gate 34327c478bd9Sstevel@tonic-gate return (Z_OK); 34337c478bd9Sstevel@tonic-gate } 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate int 34367c478bd9Sstevel@tonic-gate zonecfg_add_rctl_value( 34377c478bd9Sstevel@tonic-gate struct zone_rctltab *tabptr, 34387c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valtabptr) 34397c478bd9Sstevel@tonic-gate { 34407c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *last, *old, *new; 34417c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk = alloca(rctlblk_size()); 34427c478bd9Sstevel@tonic-gate 34437c478bd9Sstevel@tonic-gate last = tabptr->zone_rctl_valptr; 34447c478bd9Sstevel@tonic-gate for (old = last; old != NULL; old = old->zone_rctlval_next) 34457c478bd9Sstevel@tonic-gate last = old; /* walk to the end of the list */ 34467c478bd9Sstevel@tonic-gate new = valtabptr; /* alloc'd by caller */ 34477c478bd9Sstevel@tonic-gate new->zone_rctlval_next = NULL; 34487c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(valtabptr, rctlblk) != Z_OK) 34497c478bd9Sstevel@tonic-gate return (Z_INVAL); 34507c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlblk(rctlblk)) 34517c478bd9Sstevel@tonic-gate return (Z_INVAL); 34527c478bd9Sstevel@tonic-gate if (last == NULL) 34537c478bd9Sstevel@tonic-gate tabptr->zone_rctl_valptr = new; 34547c478bd9Sstevel@tonic-gate else 34557c478bd9Sstevel@tonic-gate last->zone_rctlval_next = new; 34567c478bd9Sstevel@tonic-gate return (Z_OK); 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate 34597c478bd9Sstevel@tonic-gate int 34607c478bd9Sstevel@tonic-gate zonecfg_remove_rctl_value( 34617c478bd9Sstevel@tonic-gate struct zone_rctltab *tabptr, 34627c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valtabptr) 34637c478bd9Sstevel@tonic-gate { 34647c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *last, *this, *next; 34657c478bd9Sstevel@tonic-gate 34667c478bd9Sstevel@tonic-gate last = tabptr->zone_rctl_valptr; 34677c478bd9Sstevel@tonic-gate for (this = last; this != NULL; this = this->zone_rctlval_next) { 34687c478bd9Sstevel@tonic-gate if (strcmp(this->zone_rctlval_priv, 34697c478bd9Sstevel@tonic-gate valtabptr->zone_rctlval_priv) == 0 && 34707c478bd9Sstevel@tonic-gate strcmp(this->zone_rctlval_limit, 34717c478bd9Sstevel@tonic-gate valtabptr->zone_rctlval_limit) == 0 && 34727c478bd9Sstevel@tonic-gate strcmp(this->zone_rctlval_action, 34737c478bd9Sstevel@tonic-gate valtabptr->zone_rctlval_action) == 0) { 34747c478bd9Sstevel@tonic-gate next = this->zone_rctlval_next; 34757c478bd9Sstevel@tonic-gate if (this == tabptr->zone_rctl_valptr) 34767c478bd9Sstevel@tonic-gate tabptr->zone_rctl_valptr = next; 34777c478bd9Sstevel@tonic-gate else 34787c478bd9Sstevel@tonic-gate last->zone_rctlval_next = next; 34797c478bd9Sstevel@tonic-gate free(this); 34807c478bd9Sstevel@tonic-gate return (Z_OK); 34817c478bd9Sstevel@tonic-gate } else 34827c478bd9Sstevel@tonic-gate last = this; 34837c478bd9Sstevel@tonic-gate } 34847c478bd9Sstevel@tonic-gate return (Z_NO_PROPERTY_ID); 34857c478bd9Sstevel@tonic-gate } 34867c478bd9Sstevel@tonic-gate 3487ff17c8bfSgjelinek void 3488ff17c8bfSgjelinek zonecfg_set_swinv(zone_dochandle_t handle) 3489ff17c8bfSgjelinek { 3490ff17c8bfSgjelinek handle->zone_dh_sw_inv = B_TRUE; 3491ff17c8bfSgjelinek } 3492ff17c8bfSgjelinek 3493ff17c8bfSgjelinek /* 3494ff17c8bfSgjelinek * Add the pkg to the sw inventory on the handle. 3495ff17c8bfSgjelinek */ 3496ff17c8bfSgjelinek int 3497ff17c8bfSgjelinek zonecfg_add_pkg(zone_dochandle_t handle, char *name, char *version) 3498ff17c8bfSgjelinek { 3499ff17c8bfSgjelinek xmlNodePtr newnode; 3500ff17c8bfSgjelinek xmlNodePtr cur; 3501ff17c8bfSgjelinek int err; 3502ff17c8bfSgjelinek 3503ff17c8bfSgjelinek if ((err = operation_prep(handle)) != Z_OK) 3504ff17c8bfSgjelinek return (err); 3505ff17c8bfSgjelinek 3506ff17c8bfSgjelinek cur = handle->zone_dh_cur; 3507ff17c8bfSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_PACKAGE, NULL); 3508ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_NAME, name)) != Z_OK) 3509ff17c8bfSgjelinek return (err); 3510ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_VERSION, version)) != Z_OK) 3511ff17c8bfSgjelinek return (err); 3512ff17c8bfSgjelinek return (Z_OK); 3513ff17c8bfSgjelinek } 3514ff17c8bfSgjelinek 3515ff17c8bfSgjelinek int 3516ff17c8bfSgjelinek zonecfg_add_patch(zone_dochandle_t handle, char *id, void **pnode) 3517ff17c8bfSgjelinek { 3518ff17c8bfSgjelinek xmlNodePtr node = (xmlNodePtr)*pnode; 3519ff17c8bfSgjelinek xmlNodePtr cur; 3520ff17c8bfSgjelinek int err; 3521ff17c8bfSgjelinek 3522ff17c8bfSgjelinek if ((err = operation_prep(handle)) != Z_OK) 3523ff17c8bfSgjelinek return (err); 3524ff17c8bfSgjelinek 3525ff17c8bfSgjelinek cur = handle->zone_dh_cur; 3526ff17c8bfSgjelinek node = xmlNewTextChild(cur, NULL, DTD_ELEM_PATCH, NULL); 3527ff17c8bfSgjelinek if ((err = newprop(node, DTD_ATTR_ID, id)) != Z_OK) 3528ff17c8bfSgjelinek return (err); 3529ff17c8bfSgjelinek *pnode = (void *)node; 3530ff17c8bfSgjelinek return (Z_OK); 3531ff17c8bfSgjelinek } 3532ff17c8bfSgjelinek 3533ff17c8bfSgjelinek int 3534ff17c8bfSgjelinek zonecfg_add_patch_obs(char *id, void *cur) 3535ff17c8bfSgjelinek { 3536ff17c8bfSgjelinek xmlNodePtr node; 3537ff17c8bfSgjelinek int err; 3538ff17c8bfSgjelinek 3539ff17c8bfSgjelinek node = xmlNewTextChild((xmlNodePtr)cur, NULL, DTD_ELEM_OBSOLETES, NULL); 3540ff17c8bfSgjelinek if ((err = newprop(node, DTD_ATTR_ID, id)) != Z_OK) 3541ff17c8bfSgjelinek return (err); 3542ff17c8bfSgjelinek return (Z_OK); 3543ff17c8bfSgjelinek } 3544ff17c8bfSgjelinek 35457c478bd9Sstevel@tonic-gate char * 35467c478bd9Sstevel@tonic-gate zonecfg_strerror(int errnum) 35477c478bd9Sstevel@tonic-gate { 35487c478bd9Sstevel@tonic-gate switch (errnum) { 35497c478bd9Sstevel@tonic-gate case Z_OK: 35507c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "OK")); 35517c478bd9Sstevel@tonic-gate case Z_EMPTY_DOCUMENT: 35527c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Empty document")); 35537c478bd9Sstevel@tonic-gate case Z_WRONG_DOC_TYPE: 35547c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Wrong document type")); 35557c478bd9Sstevel@tonic-gate case Z_BAD_PROPERTY: 35567c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Bad document property")); 35577c478bd9Sstevel@tonic-gate case Z_TEMP_FILE: 35587c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 35597c478bd9Sstevel@tonic-gate "Problem creating temporary file")); 35607c478bd9Sstevel@tonic-gate case Z_SAVING_FILE: 35617c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Problem saving file")); 35627c478bd9Sstevel@tonic-gate case Z_NO_ENTRY: 35637c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such entry")); 35647c478bd9Sstevel@tonic-gate case Z_BOGUS_ZONE_NAME: 35657c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Bogus zone name")); 35667c478bd9Sstevel@tonic-gate case Z_REQD_RESOURCE_MISSING: 35677c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Required resource missing")); 35687c478bd9Sstevel@tonic-gate case Z_REQD_PROPERTY_MISSING: 35697c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Required property missing")); 35707c478bd9Sstevel@tonic-gate case Z_BAD_HANDLE: 35717c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Bad handle")); 35727c478bd9Sstevel@tonic-gate case Z_NOMEM: 35737c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Out of memory")); 35747c478bd9Sstevel@tonic-gate case Z_INVAL: 35757c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Invalid argument")); 35767c478bd9Sstevel@tonic-gate case Z_ACCES: 35777c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Permission denied")); 35787c478bd9Sstevel@tonic-gate case Z_TOO_BIG: 35797c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Argument list too long")); 35807c478bd9Sstevel@tonic-gate case Z_MISC_FS: 35817c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 35827c478bd9Sstevel@tonic-gate "Miscellaneous file system error")); 35837c478bd9Sstevel@tonic-gate case Z_NO_ZONE: 35847c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such zone configured")); 35857c478bd9Sstevel@tonic-gate case Z_NO_RESOURCE_TYPE: 35867c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such resource type")); 35877c478bd9Sstevel@tonic-gate case Z_NO_RESOURCE_ID: 35887c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such resource with that id")); 35897c478bd9Sstevel@tonic-gate case Z_NO_PROPERTY_TYPE: 35907c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such property type")); 35917c478bd9Sstevel@tonic-gate case Z_NO_PROPERTY_ID: 35927c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such property with that id")); 3593087719fdSdp case Z_BAD_ZONE_STATE: 35947c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 3595087719fdSdp "Zone state is invalid for the requested operation")); 35967c478bd9Sstevel@tonic-gate case Z_INVALID_DOCUMENT: 35977c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Invalid document")); 3598087719fdSdp case Z_NAME_IN_USE: 3599087719fdSdp return (dgettext(TEXT_DOMAIN, "Zone name already in use")); 36007c478bd9Sstevel@tonic-gate case Z_NO_SUCH_ID: 36017c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such zone ID")); 36027c478bd9Sstevel@tonic-gate case Z_UPDATING_INDEX: 36037c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Problem updating index file")); 36047c478bd9Sstevel@tonic-gate case Z_LOCKING_FILE: 36057c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Locking index file")); 36067c478bd9Sstevel@tonic-gate case Z_UNLOCKING_FILE: 36077c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Unlocking index file")); 36087c478bd9Sstevel@tonic-gate case Z_INSUFFICIENT_SPEC: 36097c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Insufficient specification")); 36107c478bd9Sstevel@tonic-gate case Z_RESOLVED_PATH: 36117c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Resolved path mismatch")); 36127c478bd9Sstevel@tonic-gate case Z_IPV6_ADDR_PREFIX_LEN: 36137c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 36147c478bd9Sstevel@tonic-gate "IPv6 address missing required prefix length")); 36157c478bd9Sstevel@tonic-gate case Z_BOGUS_ADDRESS: 36167c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 36177c478bd9Sstevel@tonic-gate "Neither an IPv4 nor an IPv6 address nor a host name")); 3618ffbafc53Scomay case Z_PRIV_PROHIBITED: 3619ffbafc53Scomay return (dgettext(TEXT_DOMAIN, 3620ffbafc53Scomay "Specified privilege is prohibited")); 3621ffbafc53Scomay case Z_PRIV_REQUIRED: 3622ffbafc53Scomay return (dgettext(TEXT_DOMAIN, 3623ffbafc53Scomay "Required privilege is missing")); 3624ffbafc53Scomay case Z_PRIV_UNKNOWN: 3625ffbafc53Scomay return (dgettext(TEXT_DOMAIN, 3626ffbafc53Scomay "Specified privilege is unknown")); 36279acbbeafSnn case Z_BRAND_ERROR: 36289acbbeafSnn return (dgettext(TEXT_DOMAIN, 36299acbbeafSnn "Brand-specific error")); 36300209230bSgjelinek case Z_INCOMPATIBLE: 36310209230bSgjelinek return (dgettext(TEXT_DOMAIN, "Incompatible settings")); 36320209230bSgjelinek case Z_ALIAS_DISALLOW: 36330209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36340209230bSgjelinek "An incompatible rctl already exists for this property")); 36350209230bSgjelinek case Z_CLEAR_DISALLOW: 36360209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36370209230bSgjelinek "Clearing this property is not allowed")); 36380209230bSgjelinek case Z_POOL: 36390209230bSgjelinek return (dgettext(TEXT_DOMAIN, "libpool(3LIB) error")); 36400209230bSgjelinek case Z_POOLS_NOT_ACTIVE: 36410209230bSgjelinek return (dgettext(TEXT_DOMAIN, "Pools facility not active; " 36420209230bSgjelinek "zone will not be bound to pool")); 36430209230bSgjelinek case Z_POOL_ENABLE: 36440209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36450209230bSgjelinek "Could not enable pools facility")); 36460209230bSgjelinek case Z_NO_POOL: 36470209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36480209230bSgjelinek "Pool not found; using default pool")); 36490209230bSgjelinek case Z_POOL_CREATE: 36500209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36510209230bSgjelinek "Could not create a temporary pool")); 36520209230bSgjelinek case Z_POOL_BIND: 36530209230bSgjelinek return (dgettext(TEXT_DOMAIN, "Could not bind zone to pool")); 36545679c89fSjv case Z_HOSTID_FUBAR: 36555679c89fSjv return (dgettext(TEXT_DOMAIN, "Specified hostid is invalid")); 36562ad45a84Sjv case Z_SYSTEM: 36572ad45a84Sjv return (strerror(errno)); 36587c478bd9Sstevel@tonic-gate default: 36597c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Unknown error")); 36607c478bd9Sstevel@tonic-gate } 36617c478bd9Sstevel@tonic-gate } 36627c478bd9Sstevel@tonic-gate 36637c478bd9Sstevel@tonic-gate /* 36647c478bd9Sstevel@tonic-gate * Note that the zonecfg_setXent() and zonecfg_endXent() calls are all the 36657c478bd9Sstevel@tonic-gate * same, as they just turn around and call zonecfg_setent() / zonecfg_endent(). 36667c478bd9Sstevel@tonic-gate */ 36677c478bd9Sstevel@tonic-gate 36687c478bd9Sstevel@tonic-gate static int 36697c478bd9Sstevel@tonic-gate zonecfg_setent(zone_dochandle_t handle) 36707c478bd9Sstevel@tonic-gate { 36717c478bd9Sstevel@tonic-gate xmlNodePtr cur; 36727c478bd9Sstevel@tonic-gate int err; 36737c478bd9Sstevel@tonic-gate 36747c478bd9Sstevel@tonic-gate if (handle == NULL) 36757c478bd9Sstevel@tonic-gate return (Z_INVAL); 36767c478bd9Sstevel@tonic-gate 36777c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) { 36787c478bd9Sstevel@tonic-gate handle->zone_dh_cur = NULL; 36797c478bd9Sstevel@tonic-gate return (err); 36807c478bd9Sstevel@tonic-gate } 36817c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 36827c478bd9Sstevel@tonic-gate cur = cur->xmlChildrenNode; 36837c478bd9Sstevel@tonic-gate handle->zone_dh_cur = cur; 36847c478bd9Sstevel@tonic-gate return (Z_OK); 36857c478bd9Sstevel@tonic-gate } 36867c478bd9Sstevel@tonic-gate 36877c478bd9Sstevel@tonic-gate static int 36887c478bd9Sstevel@tonic-gate zonecfg_endent(zone_dochandle_t handle) 36897c478bd9Sstevel@tonic-gate { 36907c478bd9Sstevel@tonic-gate if (handle == NULL) 36917c478bd9Sstevel@tonic-gate return (Z_INVAL); 36927c478bd9Sstevel@tonic-gate 36937c478bd9Sstevel@tonic-gate handle->zone_dh_cur = handle->zone_dh_top; 36947c478bd9Sstevel@tonic-gate return (Z_OK); 36957c478bd9Sstevel@tonic-gate } 36967c478bd9Sstevel@tonic-gate 36970209230bSgjelinek /* 36980209230bSgjelinek * Do the work required to manipulate a process through libproc. 36990209230bSgjelinek * If grab_process() returns no errors (0), then release_process() 37000209230bSgjelinek * must eventually be called. 37010209230bSgjelinek * 37020209230bSgjelinek * Return values: 37030209230bSgjelinek * 0 Successful creation of agent thread 37040209230bSgjelinek * 1 Error grabbing 37050209230bSgjelinek * 2 Error creating agent 37060209230bSgjelinek */ 37070209230bSgjelinek static int 37080209230bSgjelinek grab_process(pr_info_handle_t *p) 37097c478bd9Sstevel@tonic-gate { 37100209230bSgjelinek int ret; 37110209230bSgjelinek 37120209230bSgjelinek if ((p->pr = Pgrab(p->pid, 0, &ret)) != NULL) { 37130209230bSgjelinek 37140209230bSgjelinek if (Psetflags(p->pr, PR_RLC) != 0) { 37150209230bSgjelinek Prelease(p->pr, 0); 37160209230bSgjelinek return (1); 37170209230bSgjelinek } 37180209230bSgjelinek if (Pcreate_agent(p->pr) == 0) { 37190209230bSgjelinek return (0); 37200209230bSgjelinek 37210209230bSgjelinek } else { 37220209230bSgjelinek Prelease(p->pr, 0); 37230209230bSgjelinek return (2); 37240209230bSgjelinek } 37250209230bSgjelinek } else { 37260209230bSgjelinek return (1); 37270209230bSgjelinek } 37287c478bd9Sstevel@tonic-gate } 37297c478bd9Sstevel@tonic-gate 37300209230bSgjelinek /* 37310209230bSgjelinek * Release the specified process. This destroys the agent 37320209230bSgjelinek * and releases the process. If the process is NULL, nothing 37330209230bSgjelinek * is done. This function should only be called if grab_process() 37340209230bSgjelinek * has previously been called and returned success. 37350209230bSgjelinek * 37360209230bSgjelinek * This function is Pgrab-safe. 37370209230bSgjelinek */ 37380209230bSgjelinek static void 37390209230bSgjelinek release_process(struct ps_prochandle *Pr) 37407c478bd9Sstevel@tonic-gate { 37410209230bSgjelinek if (Pr == NULL) 37420209230bSgjelinek return; 37437c478bd9Sstevel@tonic-gate 37440209230bSgjelinek Pdestroy_agent(Pr); 37450209230bSgjelinek Prelease(Pr, 0); 37460209230bSgjelinek } 37477c478bd9Sstevel@tonic-gate 37480209230bSgjelinek static boolean_t 37490209230bSgjelinek grab_zone_proc(char *zonename, pr_info_handle_t *p) 37500209230bSgjelinek { 37510209230bSgjelinek DIR *dirp; 37520209230bSgjelinek struct dirent *dentp; 37530209230bSgjelinek zoneid_t zoneid; 37540209230bSgjelinek int pid_self; 37550209230bSgjelinek psinfo_t psinfo; 37567c478bd9Sstevel@tonic-gate 37570209230bSgjelinek if (zone_get_id(zonename, &zoneid) != 0) 37580209230bSgjelinek return (B_FALSE); 37597c478bd9Sstevel@tonic-gate 37600209230bSgjelinek pid_self = getpid(); 37617c478bd9Sstevel@tonic-gate 37620209230bSgjelinek if ((dirp = opendir("/proc")) == NULL) 37630209230bSgjelinek return (B_FALSE); 37647c478bd9Sstevel@tonic-gate 37650209230bSgjelinek while (dentp = readdir(dirp)) { 37660209230bSgjelinek p->pid = atoi(dentp->d_name); 37677c478bd9Sstevel@tonic-gate 37680209230bSgjelinek /* Skip self */ 37690209230bSgjelinek if (p->pid == pid_self) 37700209230bSgjelinek continue; 37717c478bd9Sstevel@tonic-gate 37720209230bSgjelinek if (proc_get_psinfo(p->pid, &psinfo) != 0) 37730209230bSgjelinek continue; 37740209230bSgjelinek 37750209230bSgjelinek if (psinfo.pr_zoneid != zoneid) 37760209230bSgjelinek continue; 37770209230bSgjelinek 37780209230bSgjelinek /* attempt to grab process */ 37790209230bSgjelinek if (grab_process(p) != 0) 37800209230bSgjelinek continue; 37810209230bSgjelinek 37820209230bSgjelinek if (pr_getzoneid(p->pr) != zoneid) { 37830209230bSgjelinek release_process(p->pr); 37840209230bSgjelinek continue; 37850209230bSgjelinek } 37860209230bSgjelinek 37870209230bSgjelinek (void) closedir(dirp); 37880209230bSgjelinek return (B_TRUE); 37897c478bd9Sstevel@tonic-gate } 37907c478bd9Sstevel@tonic-gate 37910209230bSgjelinek (void) closedir(dirp); 37920209230bSgjelinek return (B_FALSE); 37937c478bd9Sstevel@tonic-gate } 37947c478bd9Sstevel@tonic-gate 37950209230bSgjelinek static boolean_t 37960209230bSgjelinek get_priv_rctl(struct ps_prochandle *pr, char *name, rctlblk_t *rblk) 37977c478bd9Sstevel@tonic-gate { 37980209230bSgjelinek if (pr_getrctl(pr, name, NULL, rblk, RCTL_FIRST)) 37990209230bSgjelinek return (B_FALSE); 38007c478bd9Sstevel@tonic-gate 38010209230bSgjelinek if (rctlblk_get_privilege(rblk) == RCPRIV_PRIVILEGED) 38020209230bSgjelinek return (B_TRUE); 38030209230bSgjelinek 38040209230bSgjelinek while (pr_getrctl(pr, name, rblk, rblk, RCTL_NEXT) == 0) { 38050209230bSgjelinek if (rctlblk_get_privilege(rblk) == RCPRIV_PRIVILEGED) 38060209230bSgjelinek return (B_TRUE); 38070209230bSgjelinek } 38080209230bSgjelinek 38090209230bSgjelinek return (B_FALSE); 38107c478bd9Sstevel@tonic-gate } 38117c478bd9Sstevel@tonic-gate 38120209230bSgjelinek /* 38130209230bSgjelinek * Apply the current rctl settings to the specified, running zone. 38140209230bSgjelinek */ 38157c478bd9Sstevel@tonic-gate int 38160209230bSgjelinek zonecfg_apply_rctls(char *zone_name, zone_dochandle_t handle) 38177c478bd9Sstevel@tonic-gate { 38187c478bd9Sstevel@tonic-gate int err; 38190209230bSgjelinek int res = Z_OK; 38200209230bSgjelinek rctlblk_t *rblk; 38210209230bSgjelinek pr_info_handle_t p; 38220209230bSgjelinek struct zone_rctltab rctl; 38237c478bd9Sstevel@tonic-gate 38240209230bSgjelinek if ((err = zonecfg_setrctlent(handle)) != Z_OK) 38250209230bSgjelinek return (err); 38267c478bd9Sstevel@tonic-gate 38270209230bSgjelinek if ((rblk = (rctlblk_t *)malloc(rctlblk_size())) == NULL) { 38280209230bSgjelinek (void) zonecfg_endrctlent(handle); 38290209230bSgjelinek return (Z_NOMEM); 38300209230bSgjelinek } 38317c478bd9Sstevel@tonic-gate 38320209230bSgjelinek if (!grab_zone_proc(zone_name, &p)) { 38330209230bSgjelinek (void) zonecfg_endrctlent(handle); 38340209230bSgjelinek free(rblk); 38350209230bSgjelinek return (Z_SYSTEM); 38367c478bd9Sstevel@tonic-gate } 38377c478bd9Sstevel@tonic-gate 38380209230bSgjelinek while (zonecfg_getrctlent(handle, &rctl) == Z_OK) { 38390209230bSgjelinek char *rname; 38400209230bSgjelinek struct zone_rctlvaltab *valptr; 38410209230bSgjelinek 38420209230bSgjelinek rname = rctl.zone_rctl_name; 38430209230bSgjelinek 38440209230bSgjelinek /* first delete all current privileged settings for this rctl */ 38450209230bSgjelinek while (get_priv_rctl(p.pr, rname, rblk)) { 38460209230bSgjelinek if (pr_setrctl(p.pr, rname, NULL, rblk, RCTL_DELETE) != 38470209230bSgjelinek 0) { 38480209230bSgjelinek res = Z_SYSTEM; 38490209230bSgjelinek goto done; 38500209230bSgjelinek } 38510209230bSgjelinek } 38520209230bSgjelinek 38530209230bSgjelinek /* now set each new value for the rctl */ 38540209230bSgjelinek for (valptr = rctl.zone_rctl_valptr; valptr != NULL; 38550209230bSgjelinek valptr = valptr->zone_rctlval_next) { 38560209230bSgjelinek if ((err = zonecfg_construct_rctlblk(valptr, rblk)) 38570209230bSgjelinek != Z_OK) { 38580209230bSgjelinek res = errno = err; 38590209230bSgjelinek goto done; 38600209230bSgjelinek } 38610209230bSgjelinek 38620209230bSgjelinek if (pr_setrctl(p.pr, rname, NULL, rblk, RCTL_INSERT)) { 38630209230bSgjelinek res = Z_SYSTEM; 38640209230bSgjelinek goto done; 38650209230bSgjelinek } 38660209230bSgjelinek } 38677c478bd9Sstevel@tonic-gate } 38687c478bd9Sstevel@tonic-gate 38690209230bSgjelinek done: 38700209230bSgjelinek release_process(p.pr); 38710209230bSgjelinek free(rblk); 38720209230bSgjelinek (void) zonecfg_endrctlent(handle); 38730209230bSgjelinek 38740209230bSgjelinek return (res); 38757c478bd9Sstevel@tonic-gate } 38767c478bd9Sstevel@tonic-gate 38770209230bSgjelinek static const xmlChar * 38780209230bSgjelinek nm_to_dtd(char *nm) 38797c478bd9Sstevel@tonic-gate { 38800209230bSgjelinek if (strcmp(nm, "device") == 0) 38810209230bSgjelinek return (DTD_ELEM_DEVICE); 38820209230bSgjelinek if (strcmp(nm, "fs") == 0) 38830209230bSgjelinek return (DTD_ELEM_FS); 38840209230bSgjelinek if (strcmp(nm, "inherit-pkg-dir") == 0) 38850209230bSgjelinek return (DTD_ELEM_IPD); 38860209230bSgjelinek if (strcmp(nm, "net") == 0) 38870209230bSgjelinek return (DTD_ELEM_NET); 38880209230bSgjelinek if (strcmp(nm, "attr") == 0) 38890209230bSgjelinek return (DTD_ELEM_ATTR); 38900209230bSgjelinek if (strcmp(nm, "rctl") == 0) 38910209230bSgjelinek return (DTD_ELEM_RCTL); 38920209230bSgjelinek if (strcmp(nm, "dataset") == 0) 38930209230bSgjelinek return (DTD_ELEM_DATASET); 3894cb8a054bSGlenn Faden if (strcmp(nm, "admin") == 0) 3895cb8a054bSGlenn Faden return (DTD_ELEM_ADMIN); 38960209230bSgjelinek 38970209230bSgjelinek return (NULL); 38987c478bd9Sstevel@tonic-gate } 38997c478bd9Sstevel@tonic-gate 39007c478bd9Sstevel@tonic-gate int 39010209230bSgjelinek zonecfg_num_resources(zone_dochandle_t handle, char *rsrc) 39027c478bd9Sstevel@tonic-gate { 39030209230bSgjelinek int num = 0; 39040209230bSgjelinek const xmlChar *dtd; 39050209230bSgjelinek xmlNodePtr cur; 39060209230bSgjelinek 39070209230bSgjelinek if ((dtd = nm_to_dtd(rsrc)) == NULL) 39080209230bSgjelinek return (num); 39090209230bSgjelinek 39100209230bSgjelinek if (zonecfg_setent(handle) != Z_OK) 39110209230bSgjelinek return (num); 39120209230bSgjelinek 39130209230bSgjelinek for (cur = handle->zone_dh_cur; cur != NULL; cur = cur->next) 39140209230bSgjelinek if (xmlStrcmp(cur->name, dtd) == 0) 39150209230bSgjelinek num++; 39160209230bSgjelinek 39170209230bSgjelinek (void) zonecfg_endent(handle); 39180209230bSgjelinek 39190209230bSgjelinek return (num); 39207c478bd9Sstevel@tonic-gate } 39217c478bd9Sstevel@tonic-gate 39227c478bd9Sstevel@tonic-gate int 39230209230bSgjelinek zonecfg_del_all_resources(zone_dochandle_t handle, char *rsrc) 39247c478bd9Sstevel@tonic-gate { 39257c478bd9Sstevel@tonic-gate int err; 39260209230bSgjelinek const xmlChar *dtd; 39270209230bSgjelinek xmlNodePtr cur; 39287c478bd9Sstevel@tonic-gate 39290209230bSgjelinek if ((dtd = nm_to_dtd(rsrc)) == NULL) 39300209230bSgjelinek return (Z_NO_RESOURCE_TYPE); 39317c478bd9Sstevel@tonic-gate 39320209230bSgjelinek if ((err = zonecfg_setent(handle)) != Z_OK) 39330209230bSgjelinek return (err); 39347c478bd9Sstevel@tonic-gate 39350209230bSgjelinek cur = handle->zone_dh_cur; 39360209230bSgjelinek while (cur != NULL) { 39370209230bSgjelinek xmlNodePtr tmp; 39387c478bd9Sstevel@tonic-gate 39390209230bSgjelinek if (xmlStrcmp(cur->name, dtd)) { 39400209230bSgjelinek cur = cur->next; 39410209230bSgjelinek continue; 39420209230bSgjelinek } 39437c478bd9Sstevel@tonic-gate 39440209230bSgjelinek tmp = cur->next; 39450209230bSgjelinek xmlUnlinkNode(cur); 39460209230bSgjelinek xmlFreeNode(cur); 39470209230bSgjelinek cur = tmp; 39487c478bd9Sstevel@tonic-gate } 39497c478bd9Sstevel@tonic-gate 39500209230bSgjelinek (void) zonecfg_endent(handle); 39517c478bd9Sstevel@tonic-gate return (Z_OK); 39527c478bd9Sstevel@tonic-gate } 39537c478bd9Sstevel@tonic-gate 39540209230bSgjelinek static boolean_t 39550209230bSgjelinek valid_uint(char *s, uint64_t *n) 39567c478bd9Sstevel@tonic-gate { 39570209230bSgjelinek char *endp; 39587c478bd9Sstevel@tonic-gate 39590209230bSgjelinek /* strtoull accepts '-'?! so we want to flag that as an error */ 39600209230bSgjelinek if (strchr(s, '-') != NULL) 39610209230bSgjelinek return (B_FALSE); 39620209230bSgjelinek 39630209230bSgjelinek errno = 0; 39640209230bSgjelinek *n = strtoull(s, &endp, 10); 39650209230bSgjelinek 39660209230bSgjelinek if (errno != 0 || *endp != '\0') 39670209230bSgjelinek return (B_FALSE); 39680209230bSgjelinek return (B_TRUE); 39697c478bd9Sstevel@tonic-gate } 39707c478bd9Sstevel@tonic-gate 39710209230bSgjelinek /* 39720209230bSgjelinek * Convert a string representing a number (possibly a fraction) into an integer. 39730209230bSgjelinek * The string can have a modifier (K, M, G or T). The modifiers are treated 39740209230bSgjelinek * as powers of two (not 10). 39750209230bSgjelinek */ 39767c478bd9Sstevel@tonic-gate int 39770209230bSgjelinek zonecfg_str_to_bytes(char *str, uint64_t *bytes) 39787c478bd9Sstevel@tonic-gate { 39790209230bSgjelinek long double val; 39800209230bSgjelinek char *unitp; 39810209230bSgjelinek uint64_t scale; 39827c478bd9Sstevel@tonic-gate 39830209230bSgjelinek if ((val = strtold(str, &unitp)) < 0) 39840209230bSgjelinek return (-1); 39857c478bd9Sstevel@tonic-gate 39860209230bSgjelinek /* remove any leading white space from units string */ 39870209230bSgjelinek while (isspace(*unitp) != 0) 39880209230bSgjelinek ++unitp; 39897c478bd9Sstevel@tonic-gate 39900209230bSgjelinek /* if no units explicitly set, error */ 39910209230bSgjelinek if (unitp == NULL || *unitp == '\0') { 39920209230bSgjelinek scale = 1; 39930209230bSgjelinek } else { 39940209230bSgjelinek int i; 39950209230bSgjelinek char *units[] = {"K", "M", "G", "T", NULL}; 39967c478bd9Sstevel@tonic-gate 39970209230bSgjelinek scale = 1024; 39980209230bSgjelinek 39990209230bSgjelinek /* update scale based on units */ 40000209230bSgjelinek for (i = 0; units[i] != NULL; i++) { 40010209230bSgjelinek if (strcasecmp(unitp, units[i]) == 0) 40020209230bSgjelinek break; 40030209230bSgjelinek scale <<= 10; 40040209230bSgjelinek } 40050209230bSgjelinek 40060209230bSgjelinek if (units[i] == NULL) 40070209230bSgjelinek return (-1); 40087c478bd9Sstevel@tonic-gate } 40097c478bd9Sstevel@tonic-gate 40100209230bSgjelinek *bytes = (uint64_t)(val * scale); 40110209230bSgjelinek return (0); 40127c478bd9Sstevel@tonic-gate } 40137c478bd9Sstevel@tonic-gate 40140209230bSgjelinek boolean_t 40150209230bSgjelinek zonecfg_valid_ncpus(char *lowstr, char *highstr) 40167c478bd9Sstevel@tonic-gate { 40170209230bSgjelinek uint64_t low, high; 40187c478bd9Sstevel@tonic-gate 40190209230bSgjelinek if (!valid_uint(lowstr, &low) || !valid_uint(highstr, &high) || 40200209230bSgjelinek low < 1 || low > high) 40210209230bSgjelinek return (B_FALSE); 40220209230bSgjelinek 40230209230bSgjelinek return (B_TRUE); 40247c478bd9Sstevel@tonic-gate } 40257c478bd9Sstevel@tonic-gate 40260209230bSgjelinek boolean_t 40270209230bSgjelinek zonecfg_valid_importance(char *impstr) 40287c478bd9Sstevel@tonic-gate { 40290209230bSgjelinek uint64_t num; 40307c478bd9Sstevel@tonic-gate 40310209230bSgjelinek if (!valid_uint(impstr, &num)) 40320209230bSgjelinek return (B_FALSE); 40337c478bd9Sstevel@tonic-gate 40340209230bSgjelinek return (B_TRUE); 40350209230bSgjelinek } 40367c478bd9Sstevel@tonic-gate 40370209230bSgjelinek boolean_t 40380209230bSgjelinek zonecfg_valid_alias_limit(char *name, char *limitstr, uint64_t *limit) 40390209230bSgjelinek { 40400209230bSgjelinek int i; 40410209230bSgjelinek 40420209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 40430209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 40447c478bd9Sstevel@tonic-gate break; 40457c478bd9Sstevel@tonic-gate 40460209230bSgjelinek if (aliases[i].shortname == NULL) 40470209230bSgjelinek return (B_FALSE); 40487c478bd9Sstevel@tonic-gate 40490209230bSgjelinek if (!valid_uint(limitstr, limit) || *limit < aliases[i].low_limit) 40500209230bSgjelinek return (B_FALSE); 40517c478bd9Sstevel@tonic-gate 40520209230bSgjelinek return (B_TRUE); 40537c478bd9Sstevel@tonic-gate } 40547c478bd9Sstevel@tonic-gate 40550209230bSgjelinek boolean_t 40560209230bSgjelinek zonecfg_valid_memlimit(char *memstr, uint64_t *mem_val) 40577c478bd9Sstevel@tonic-gate { 40580209230bSgjelinek if (zonecfg_str_to_bytes(memstr, mem_val) != 0) 40590209230bSgjelinek return (B_FALSE); 40600209230bSgjelinek 40610209230bSgjelinek return (B_TRUE); 40627c478bd9Sstevel@tonic-gate } 40637c478bd9Sstevel@tonic-gate 40640209230bSgjelinek static int 40650209230bSgjelinek zerr_pool(char *pool_err, int err_size, int res) 40667c478bd9Sstevel@tonic-gate { 40670209230bSgjelinek (void) strlcpy(pool_err, pool_strerror(pool_error()), err_size); 40680209230bSgjelinek return (res); 40697c478bd9Sstevel@tonic-gate } 40707c478bd9Sstevel@tonic-gate 40710209230bSgjelinek static int 40720209230bSgjelinek create_tmp_pset(char *pool_err, int err_size, pool_conf_t *pconf, pool_t *pool, 40730209230bSgjelinek char *name, int min, int max) 40747c478bd9Sstevel@tonic-gate { 40750209230bSgjelinek pool_resource_t *res; 40760209230bSgjelinek pool_elem_t *elem; 40770209230bSgjelinek pool_value_t *val; 40787c478bd9Sstevel@tonic-gate 40790209230bSgjelinek if ((res = pool_resource_create(pconf, "pset", name)) == NULL) 40800209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40817c478bd9Sstevel@tonic-gate 40820209230bSgjelinek if (pool_associate(pconf, pool, res) != PO_SUCCESS) 40830209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40847c478bd9Sstevel@tonic-gate 40850209230bSgjelinek if ((elem = pool_resource_to_elem(pconf, res)) == NULL) 40860209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40877c478bd9Sstevel@tonic-gate 40880209230bSgjelinek if ((val = pool_value_alloc()) == NULL) 40890209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40907c478bd9Sstevel@tonic-gate 40910209230bSgjelinek /* set the maximum number of cpus for the pset */ 40920209230bSgjelinek pool_value_set_uint64(val, (uint64_t)max); 40930209230bSgjelinek 40940209230bSgjelinek if (pool_put_property(pconf, elem, "pset.max", val) != PO_SUCCESS) { 40950209230bSgjelinek pool_value_free(val); 40960209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40977c478bd9Sstevel@tonic-gate } 40987c478bd9Sstevel@tonic-gate 40990209230bSgjelinek /* set the minimum number of cpus for the pset */ 41000209230bSgjelinek pool_value_set_uint64(val, (uint64_t)min); 41010209230bSgjelinek 41020209230bSgjelinek if (pool_put_property(pconf, elem, "pset.min", val) != PO_SUCCESS) { 41030209230bSgjelinek pool_value_free(val); 41040209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 41057c478bd9Sstevel@tonic-gate } 41067c478bd9Sstevel@tonic-gate 41070209230bSgjelinek pool_value_free(val); 41080209230bSgjelinek 41097c478bd9Sstevel@tonic-gate return (Z_OK); 41107c478bd9Sstevel@tonic-gate } 41117c478bd9Sstevel@tonic-gate 41120209230bSgjelinek static int 41130209230bSgjelinek create_tmp_pool(char *pool_err, int err_size, pool_conf_t *pconf, char *name, 41140209230bSgjelinek struct zone_psettab *pset_tab) 41157c478bd9Sstevel@tonic-gate { 41160209230bSgjelinek pool_t *pool; 41170209230bSgjelinek int res = Z_OK; 41187c478bd9Sstevel@tonic-gate 41190209230bSgjelinek /* create a temporary pool configuration */ 41200209230bSgjelinek if (pool_conf_open(pconf, NULL, PO_TEMP) != PO_SUCCESS) { 41210209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41220209230bSgjelinek return (res); 41230209230bSgjelinek } 4124ffbafc53Scomay 41250209230bSgjelinek if ((pool = pool_create(pconf, name)) == NULL) { 41260209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL_CREATE); 41270209230bSgjelinek goto done; 41280209230bSgjelinek } 4129ffbafc53Scomay 41300209230bSgjelinek /* set pool importance */ 41310209230bSgjelinek if (pset_tab->zone_importance[0] != '\0') { 41320209230bSgjelinek pool_elem_t *elem; 41330209230bSgjelinek pool_value_t *val; 41349acbbeafSnn 41350209230bSgjelinek if ((elem = pool_to_elem(pconf, pool)) == NULL) { 41360209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41370209230bSgjelinek goto done; 41380209230bSgjelinek } 41399acbbeafSnn 41400209230bSgjelinek if ((val = pool_value_alloc()) == NULL) { 41410209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41420209230bSgjelinek goto done; 41430209230bSgjelinek } 41449acbbeafSnn 41450209230bSgjelinek pool_value_set_int64(val, 41460209230bSgjelinek (int64_t)atoi(pset_tab->zone_importance)); 41479acbbeafSnn 41480209230bSgjelinek if (pool_put_property(pconf, elem, "pool.importance", val) 41490209230bSgjelinek != PO_SUCCESS) { 41500209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41510209230bSgjelinek pool_value_free(val); 41520209230bSgjelinek goto done; 41530209230bSgjelinek } 41549acbbeafSnn 41550209230bSgjelinek pool_value_free(val); 41569acbbeafSnn } 41579acbbeafSnn 41580209230bSgjelinek if ((res = create_tmp_pset(pool_err, err_size, pconf, pool, name, 41590209230bSgjelinek atoi(pset_tab->zone_ncpu_min), 41600209230bSgjelinek atoi(pset_tab->zone_ncpu_max))) != Z_OK) 41610209230bSgjelinek goto done; 41620209230bSgjelinek 41630209230bSgjelinek /* validation */ 41640209230bSgjelinek if (pool_conf_status(pconf) == POF_INVALID) { 41650209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41660209230bSgjelinek goto done; 41679acbbeafSnn } 41689acbbeafSnn 41690209230bSgjelinek /* 41700209230bSgjelinek * This validation is the one we expect to fail if the user specified 41710209230bSgjelinek * an invalid configuration (too many cpus) for this system. 41720209230bSgjelinek */ 41730209230bSgjelinek if (pool_conf_validate(pconf, POV_RUNTIME) != PO_SUCCESS) { 41740209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL_CREATE); 41750209230bSgjelinek goto done; 41760209230bSgjelinek } 41779acbbeafSnn 41780209230bSgjelinek /* 41790209230bSgjelinek * Commit the dynamic configuration but not the pool configuration 41800209230bSgjelinek * file. 41810209230bSgjelinek */ 41820209230bSgjelinek if (pool_conf_commit(pconf, 1) != PO_SUCCESS) 41830209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41849acbbeafSnn 41850209230bSgjelinek done: 41860209230bSgjelinek (void) pool_conf_close(pconf); 41870209230bSgjelinek return (res); 41889acbbeafSnn } 41899acbbeafSnn 41909acbbeafSnn static int 41910209230bSgjelinek get_running_tmp_pset(pool_conf_t *pconf, pool_t *pool, pool_resource_t *pset, 41920209230bSgjelinek struct zone_psettab *pset_tab) 41930209230bSgjelinek { 41940209230bSgjelinek int nfound = 0; 41950209230bSgjelinek pool_elem_t *pe; 41960209230bSgjelinek pool_value_t *pv = pool_value_alloc(); 41970209230bSgjelinek uint64_t val_uint; 41980209230bSgjelinek 41990209230bSgjelinek if (pool != NULL) { 42000209230bSgjelinek pe = pool_to_elem(pconf, pool); 42010209230bSgjelinek if (pool_get_property(pconf, pe, "pool.importance", pv) 42020209230bSgjelinek != POC_INVAL) { 42030209230bSgjelinek int64_t val_int; 42040209230bSgjelinek 42050209230bSgjelinek (void) pool_value_get_int64(pv, &val_int); 42060209230bSgjelinek (void) snprintf(pset_tab->zone_importance, 42070209230bSgjelinek sizeof (pset_tab->zone_importance), "%d", val_int); 42080209230bSgjelinek nfound++; 42090209230bSgjelinek } 42109acbbeafSnn } 42119acbbeafSnn 42120209230bSgjelinek if (pset != NULL) { 42130209230bSgjelinek pe = pool_resource_to_elem(pconf, pset); 42140209230bSgjelinek if (pool_get_property(pconf, pe, "pset.min", pv) != POC_INVAL) { 42150209230bSgjelinek (void) pool_value_get_uint64(pv, &val_uint); 42160209230bSgjelinek (void) snprintf(pset_tab->zone_ncpu_min, 42170209230bSgjelinek sizeof (pset_tab->zone_ncpu_min), "%u", val_uint); 42180209230bSgjelinek nfound++; 42190209230bSgjelinek } 42209acbbeafSnn 42210209230bSgjelinek if (pool_get_property(pconf, pe, "pset.max", pv) != POC_INVAL) { 42220209230bSgjelinek (void) pool_value_get_uint64(pv, &val_uint); 42230209230bSgjelinek (void) snprintf(pset_tab->zone_ncpu_max, 42240209230bSgjelinek sizeof (pset_tab->zone_ncpu_max), "%u", val_uint); 42250209230bSgjelinek nfound++; 42260209230bSgjelinek } 42279acbbeafSnn } 42289acbbeafSnn 42290209230bSgjelinek pool_value_free(pv); 42309acbbeafSnn 42310209230bSgjelinek if (nfound == 3) 42320209230bSgjelinek return (PO_SUCCESS); 42330209230bSgjelinek 42340209230bSgjelinek return (PO_FAIL); 42359acbbeafSnn } 42369acbbeafSnn 42370209230bSgjelinek /* 42380209230bSgjelinek * Determine if a tmp pool is configured and if so, if the configuration is 42390209230bSgjelinek * still valid or if it has been changed since the tmp pool was created. 42400209230bSgjelinek * If the tmp pool configuration is no longer valid, delete the tmp pool. 42410209230bSgjelinek * 42420209230bSgjelinek * Set *valid=B_TRUE if there is an existing, valid tmp pool configuration. 42430209230bSgjelinek */ 42449acbbeafSnn static int 42450209230bSgjelinek verify_del_tmp_pool(pool_conf_t *pconf, char *tmp_name, char *pool_err, 42460209230bSgjelinek int err_size, struct zone_psettab *pset_tab, boolean_t *exists) 42479acbbeafSnn { 42480209230bSgjelinek int res = Z_OK; 42490209230bSgjelinek pool_t *pool; 42500209230bSgjelinek pool_resource_t *pset; 42510209230bSgjelinek struct zone_psettab pset_current; 42527c478bd9Sstevel@tonic-gate 42530209230bSgjelinek *exists = B_FALSE; 42547c478bd9Sstevel@tonic-gate 42550209230bSgjelinek if (pool_conf_open(pconf, pool_dynamic_location(), PO_RDWR) 42560209230bSgjelinek != PO_SUCCESS) { 42570209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42580209230bSgjelinek return (res); 42590209230bSgjelinek } 42607c478bd9Sstevel@tonic-gate 42610209230bSgjelinek pool = pool_get_pool(pconf, tmp_name); 42620209230bSgjelinek pset = pool_get_resource(pconf, "pset", tmp_name); 42630209230bSgjelinek 42640209230bSgjelinek if (pool == NULL && pset == NULL) { 42650209230bSgjelinek /* no tmp pool configured */ 42660209230bSgjelinek goto done; 42677c478bd9Sstevel@tonic-gate } 42689acbbeafSnn 42690209230bSgjelinek /* 42700209230bSgjelinek * If an existing tmp pool for this zone is configured with the proper 42710209230bSgjelinek * settings, then the tmp pool is valid. 42720209230bSgjelinek */ 42730209230bSgjelinek if (get_running_tmp_pset(pconf, pool, pset, &pset_current) 42740209230bSgjelinek == PO_SUCCESS && 42750209230bSgjelinek strcmp(pset_tab->zone_ncpu_min, 42760209230bSgjelinek pset_current.zone_ncpu_min) == 0 && 42770209230bSgjelinek strcmp(pset_tab->zone_ncpu_max, 42780209230bSgjelinek pset_current.zone_ncpu_max) == 0 && 42790209230bSgjelinek strcmp(pset_tab->zone_importance, 42800209230bSgjelinek pset_current.zone_importance) == 0) { 42810209230bSgjelinek *exists = B_TRUE; 42827c478bd9Sstevel@tonic-gate 42830209230bSgjelinek } else { 42840209230bSgjelinek /* 42850209230bSgjelinek * An out-of-date tmp pool configuration exists. Delete it 42860209230bSgjelinek * so that we can create the correct tmp pool config. 42870209230bSgjelinek */ 42880209230bSgjelinek if (pset != NULL && 42890209230bSgjelinek pool_resource_destroy(pconf, pset) != PO_SUCCESS) { 42900209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42910209230bSgjelinek goto done; 42920209230bSgjelinek } 42939acbbeafSnn 42940209230bSgjelinek if (pool != NULL && 42950209230bSgjelinek pool_destroy(pconf, pool) != PO_SUCCESS) { 42960209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42970209230bSgjelinek goto done; 42980209230bSgjelinek } 42999acbbeafSnn 43000209230bSgjelinek /* commit dynamic config */ 43010209230bSgjelinek if (pool_conf_commit(pconf, 0) != PO_SUCCESS) 43020209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43030209230bSgjelinek } 43040209230bSgjelinek 43050209230bSgjelinek done: 43060209230bSgjelinek (void) pool_conf_close(pconf); 43070209230bSgjelinek 43080209230bSgjelinek return (res); 4309ffbafc53Scomay } 4310ffbafc53Scomay 4311ffbafc53Scomay /* 43120209230bSgjelinek * Destroy any existing tmp pool. 4313ffbafc53Scomay */ 43140209230bSgjelinek int 43150209230bSgjelinek zonecfg_destroy_tmp_pool(char *zone_name, char *pool_err, int err_size) 4316ffbafc53Scomay { 43170209230bSgjelinek int status; 43180209230bSgjelinek int res = Z_OK; 43190209230bSgjelinek pool_conf_t *pconf; 43200209230bSgjelinek pool_t *pool; 43210209230bSgjelinek pool_resource_t *pset; 43220209230bSgjelinek char tmp_name[MAX_TMP_POOL_NAME]; 4323ffbafc53Scomay 43240209230bSgjelinek /* if pools not enabled then nothing to do */ 43250209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) 43260209230bSgjelinek return (Z_OK); 4327ffbafc53Scomay 43280209230bSgjelinek if ((pconf = pool_conf_alloc()) == NULL) 43290209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 43309acbbeafSnn 43310209230bSgjelinek (void) snprintf(tmp_name, sizeof (tmp_name), TMP_POOL_NAME, zone_name); 4332ffbafc53Scomay 43330209230bSgjelinek if (pool_conf_open(pconf, pool_dynamic_location(), PO_RDWR) 43340209230bSgjelinek != PO_SUCCESS) { 43350209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43360209230bSgjelinek pool_conf_free(pconf); 43370209230bSgjelinek return (res); 4338ffbafc53Scomay } 4339ffbafc53Scomay 43400209230bSgjelinek pool = pool_get_pool(pconf, tmp_name); 43410209230bSgjelinek pset = pool_get_resource(pconf, "pset", tmp_name); 4342ffbafc53Scomay 43430209230bSgjelinek if (pool == NULL && pset == NULL) { 43440209230bSgjelinek /* nothing to destroy, we're done */ 43450209230bSgjelinek goto done; 4346ffbafc53Scomay } 4347ffbafc53Scomay 43480209230bSgjelinek if (pset != NULL && pool_resource_destroy(pconf, pset) != PO_SUCCESS) { 43490209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43500209230bSgjelinek goto done; 4351ffbafc53Scomay } 4352ffbafc53Scomay 43530209230bSgjelinek if (pool != NULL && pool_destroy(pconf, pool) != PO_SUCCESS) { 43540209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43550209230bSgjelinek goto done; 4356ffbafc53Scomay } 4357ffbafc53Scomay 43580209230bSgjelinek /* commit dynamic config */ 43590209230bSgjelinek if (pool_conf_commit(pconf, 0) != PO_SUCCESS) 43600209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43610209230bSgjelinek 43620209230bSgjelinek done: 43630209230bSgjelinek (void) pool_conf_close(pconf); 43640209230bSgjelinek pool_conf_free(pconf); 43650209230bSgjelinek 43660209230bSgjelinek return (res); 4367ffbafc53Scomay } 4368ffbafc53Scomay 4369ffbafc53Scomay /* 43700209230bSgjelinek * Attempt to bind to a tmp pool for this zone. If there is no tmp pool 43710209230bSgjelinek * configured, we just return Z_OK. 4372ffbafc53Scomay * 43730209230bSgjelinek * We either attempt to create the tmp pool for this zone or rebind to an 43740209230bSgjelinek * existing tmp pool for this zone. 43750209230bSgjelinek * 43760209230bSgjelinek * Rebinding is used when a zone with a tmp pool reboots so that we don't have 43770209230bSgjelinek * to recreate the tmp pool. To do this we need to be sure we work correctly 43780209230bSgjelinek * for the following cases: 43790209230bSgjelinek * 43800209230bSgjelinek * - there is an existing, properly configured tmp pool. 43810209230bSgjelinek * - zonecfg added tmp pool after zone was booted, must now create. 43820209230bSgjelinek * - zonecfg updated tmp pool config after zone was booted, in this case 43830209230bSgjelinek * we destroy the old tmp pool and create a new one. 4384ffbafc53Scomay */ 4385ffbafc53Scomay int 43860209230bSgjelinek zonecfg_bind_tmp_pool(zone_dochandle_t handle, zoneid_t zoneid, char *pool_err, 43870209230bSgjelinek int err_size) 4388ffbafc53Scomay { 43890209230bSgjelinek struct zone_psettab pset_tab; 43900209230bSgjelinek int err; 43910209230bSgjelinek int status; 43920209230bSgjelinek pool_conf_t *pconf; 43930209230bSgjelinek boolean_t exists; 43940209230bSgjelinek char zone_name[ZONENAME_MAX]; 43950209230bSgjelinek char tmp_name[MAX_TMP_POOL_NAME]; 43960209230bSgjelinek 43970209230bSgjelinek (void) getzonenamebyid(zoneid, zone_name, sizeof (zone_name)); 43980209230bSgjelinek 43990209230bSgjelinek err = zonecfg_lookup_pset(handle, &pset_tab); 44000209230bSgjelinek 44010209230bSgjelinek /* if no temporary pool configured, we're done */ 44020209230bSgjelinek if (err == Z_NO_ENTRY) 44030209230bSgjelinek return (Z_OK); 4404ffbafc53Scomay 4405ffbafc53Scomay /* 44060209230bSgjelinek * importance might not have a value but we need to validate it here, 44070209230bSgjelinek * so set the default. 4408ffbafc53Scomay */ 44090209230bSgjelinek if (pset_tab.zone_importance[0] == '\0') 44100209230bSgjelinek (void) strlcpy(pset_tab.zone_importance, "1", 44110209230bSgjelinek sizeof (pset_tab.zone_importance)); 44129acbbeafSnn 44130209230bSgjelinek /* if pools not enabled, enable them now */ 44140209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) { 44150209230bSgjelinek if (pool_set_status(POOL_ENABLED) != PO_SUCCESS) 44160209230bSgjelinek return (Z_POOL_ENABLE); 4417ffbafc53Scomay } 4418ffbafc53Scomay 44190209230bSgjelinek if ((pconf = pool_conf_alloc()) == NULL) 44200209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 44210209230bSgjelinek 44220209230bSgjelinek (void) snprintf(tmp_name, sizeof (tmp_name), TMP_POOL_NAME, zone_name); 44230209230bSgjelinek 4424ffbafc53Scomay /* 44250209230bSgjelinek * Check if a valid tmp pool/pset already exists. If so, we just 44260209230bSgjelinek * reuse it. 4427ffbafc53Scomay */ 44280209230bSgjelinek if ((err = verify_del_tmp_pool(pconf, tmp_name, pool_err, err_size, 44290209230bSgjelinek &pset_tab, &exists)) != Z_OK) { 44300209230bSgjelinek pool_conf_free(pconf); 44310209230bSgjelinek return (err); 44320209230bSgjelinek } 4433ffbafc53Scomay 44340209230bSgjelinek if (!exists) 44350209230bSgjelinek err = create_tmp_pool(pool_err, err_size, pconf, tmp_name, 44360209230bSgjelinek &pset_tab); 44370209230bSgjelinek 44380209230bSgjelinek pool_conf_free(pconf); 44390209230bSgjelinek 44400209230bSgjelinek if (err != Z_OK) 44410209230bSgjelinek return (err); 44420209230bSgjelinek 44430209230bSgjelinek /* Bind the zone to the pool. */ 44440209230bSgjelinek if (pool_set_binding(tmp_name, P_ZONEID, zoneid) != PO_SUCCESS) 44450209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL_BIND)); 44460209230bSgjelinek 44470209230bSgjelinek return (Z_OK); 4448ffbafc53Scomay } 4449ffbafc53Scomay 44500209230bSgjelinek /* 44510209230bSgjelinek * Attempt to bind to a permanent pool for this zone. If there is no 44520209230bSgjelinek * permanent pool configured, we just return Z_OK. 44530209230bSgjelinek */ 44547c478bd9Sstevel@tonic-gate int 44550209230bSgjelinek zonecfg_bind_pool(zone_dochandle_t handle, zoneid_t zoneid, char *pool_err, 44560209230bSgjelinek int err_size) 44577c478bd9Sstevel@tonic-gate { 44580209230bSgjelinek pool_conf_t *poolconf; 44590209230bSgjelinek pool_t *pool; 44600209230bSgjelinek char poolname[MAXPATHLEN]; 44610209230bSgjelinek int status; 44620209230bSgjelinek int error; 4463108322fbScarlsonj 44640209230bSgjelinek /* 44650209230bSgjelinek * Find the pool mentioned in the zone configuration, and bind to it. 44660209230bSgjelinek */ 44670209230bSgjelinek error = zonecfg_get_pool(handle, poolname, sizeof (poolname)); 44680209230bSgjelinek if (error == Z_NO_ENTRY || (error == Z_OK && strlen(poolname) == 0)) { 44690209230bSgjelinek /* 44700209230bSgjelinek * The property is not set on the zone, so the pool 44710209230bSgjelinek * should be bound to the default pool. But that's 44720209230bSgjelinek * already done by the kernel, so we can just return. 44730209230bSgjelinek */ 44747c478bd9Sstevel@tonic-gate return (Z_OK); 44757c478bd9Sstevel@tonic-gate } 44760209230bSgjelinek if (error != Z_OK) { 44770209230bSgjelinek /* 44780209230bSgjelinek * Not an error, even though it shouldn't be happening. 44790209230bSgjelinek */ 44800209230bSgjelinek return (Z_OK); 44810209230bSgjelinek } 44820209230bSgjelinek /* 44830209230bSgjelinek * Don't do anything if pools aren't enabled. 44840209230bSgjelinek */ 44850209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) 44860209230bSgjelinek return (Z_POOLS_NOT_ACTIVE); 44877c478bd9Sstevel@tonic-gate 44887c478bd9Sstevel@tonic-gate /* 44890209230bSgjelinek * Try to provide a sane error message if the requested pool doesn't 44900209230bSgjelinek * exist. 44917c478bd9Sstevel@tonic-gate */ 44920209230bSgjelinek if ((poolconf = pool_conf_alloc()) == NULL) 44930209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 44947c478bd9Sstevel@tonic-gate 44950209230bSgjelinek if (pool_conf_open(poolconf, pool_dynamic_location(), PO_RDONLY) != 44960209230bSgjelinek PO_SUCCESS) { 44970209230bSgjelinek pool_conf_free(poolconf); 44980209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 44990209230bSgjelinek } 45000209230bSgjelinek pool = pool_get_pool(poolconf, poolname); 45010209230bSgjelinek (void) pool_conf_close(poolconf); 45020209230bSgjelinek pool_conf_free(poolconf); 45030209230bSgjelinek if (pool == NULL) 45040209230bSgjelinek return (Z_NO_POOL); 45057c478bd9Sstevel@tonic-gate 45067c478bd9Sstevel@tonic-gate /* 45070209230bSgjelinek * Bind the zone to the pool. 45087c478bd9Sstevel@tonic-gate */ 45090209230bSgjelinek if (pool_set_binding(poolname, P_ZONEID, zoneid) != PO_SUCCESS) { 45100209230bSgjelinek /* if bind fails, return poolname for the error msg */ 45110209230bSgjelinek (void) strlcpy(pool_err, poolname, err_size); 45120209230bSgjelinek return (Z_POOL_BIND); 45137c478bd9Sstevel@tonic-gate } 45140209230bSgjelinek 45150209230bSgjelinek return (Z_OK); 45160209230bSgjelinek } 45170209230bSgjelinek 45180dc2366fSVenugopal Iyer int 45190dc2366fSVenugopal Iyer zonecfg_get_poolname(zone_dochandle_t handle, char *zone, char *pool, 45200dc2366fSVenugopal Iyer size_t poolsize) 45210dc2366fSVenugopal Iyer { 45220dc2366fSVenugopal Iyer int err; 45230dc2366fSVenugopal Iyer struct zone_psettab pset_tab; 45240dc2366fSVenugopal Iyer 45250dc2366fSVenugopal Iyer err = zonecfg_lookup_pset(handle, &pset_tab); 45260dc2366fSVenugopal Iyer if ((err != Z_NO_ENTRY) && (err != Z_OK)) 45270dc2366fSVenugopal Iyer return (err); 45280dc2366fSVenugopal Iyer 45290dc2366fSVenugopal Iyer /* pset was found so a temporary pool was created */ 45300dc2366fSVenugopal Iyer if (err == Z_OK) { 45310dc2366fSVenugopal Iyer (void) snprintf(pool, poolsize, TMP_POOL_NAME, zone); 45320dc2366fSVenugopal Iyer return (Z_OK); 45330dc2366fSVenugopal Iyer } 45340dc2366fSVenugopal Iyer 45350dc2366fSVenugopal Iyer /* lookup the poolname in zonecfg */ 45360dc2366fSVenugopal Iyer return (zonecfg_get_pool(handle, pool, poolsize)); 45370dc2366fSVenugopal Iyer } 45380209230bSgjelinek 45390209230bSgjelinek static boolean_t 45400209230bSgjelinek svc_enabled(char *svc_name) 45410209230bSgjelinek { 45420209230bSgjelinek scf_simple_prop_t *prop; 45430209230bSgjelinek boolean_t found = B_FALSE; 45440209230bSgjelinek 45450209230bSgjelinek prop = scf_simple_prop_get(NULL, svc_name, SCF_PG_GENERAL, 45460209230bSgjelinek SCF_PROPERTY_ENABLED); 45470209230bSgjelinek 45480209230bSgjelinek if (scf_simple_prop_numvalues(prop) == 1 && 45490209230bSgjelinek *scf_simple_prop_next_boolean(prop) != 0) 45500209230bSgjelinek found = B_TRUE; 45510209230bSgjelinek 45520209230bSgjelinek scf_simple_prop_free(prop); 45530209230bSgjelinek 45540209230bSgjelinek return (found); 45557c478bd9Sstevel@tonic-gate } 45567c478bd9Sstevel@tonic-gate 45570209230bSgjelinek /* 45580209230bSgjelinek * If the zone has capped-memory, make sure the rcap service is enabled. 45590209230bSgjelinek */ 45607c478bd9Sstevel@tonic-gate int 45610209230bSgjelinek zonecfg_enable_rcapd(char *err, int size) 45627c478bd9Sstevel@tonic-gate { 45630209230bSgjelinek if (!svc_enabled(RCAP_SERVICE) && 45640209230bSgjelinek smf_enable_instance(RCAP_SERVICE, 0) == -1) { 45650209230bSgjelinek (void) strlcpy(err, scf_strerror(scf_error()), size); 45660209230bSgjelinek return (Z_SYSTEM); 45670209230bSgjelinek } 45687c478bd9Sstevel@tonic-gate 45697c478bd9Sstevel@tonic-gate return (Z_OK); 45707c478bd9Sstevel@tonic-gate } 45717c478bd9Sstevel@tonic-gate 45720209230bSgjelinek /* 45730209230bSgjelinek * Return true if pset has cpu range specified and poold is not enabled. 45740209230bSgjelinek */ 45750209230bSgjelinek boolean_t 45760209230bSgjelinek zonecfg_warn_poold(zone_dochandle_t handle) 45779acbbeafSnn { 45780209230bSgjelinek struct zone_psettab pset_tab; 45790209230bSgjelinek int min, max; 45809acbbeafSnn int err; 45819acbbeafSnn 45820209230bSgjelinek err = zonecfg_lookup_pset(handle, &pset_tab); 45830209230bSgjelinek 45840209230bSgjelinek /* if no temporary pool configured, we're done */ 45850209230bSgjelinek if (err == Z_NO_ENTRY) 45860209230bSgjelinek return (B_FALSE); 45870209230bSgjelinek 45880209230bSgjelinek min = atoi(pset_tab.zone_ncpu_min); 45890209230bSgjelinek max = atoi(pset_tab.zone_ncpu_max); 45900209230bSgjelinek 45910209230bSgjelinek /* range not specified, no need for poold */ 45920209230bSgjelinek if (min == max) 45930209230bSgjelinek return (B_FALSE); 45940209230bSgjelinek 45950209230bSgjelinek /* we have a range, check if poold service is enabled */ 45960209230bSgjelinek if (svc_enabled(POOLD_SERVICE)) 45970209230bSgjelinek return (B_FALSE); 45980209230bSgjelinek 45990209230bSgjelinek return (B_TRUE); 46000209230bSgjelinek } 46010209230bSgjelinek 460234eb7836Sjv /* 460334eb7836Sjv * Retrieve the specified pool's thread scheduling class. 'poolname' must 460434eb7836Sjv * refer to the name of a configured resource pool. The thread scheduling 460534eb7836Sjv * class specified by the pool will be stored in the buffer to which 'class' 460634eb7836Sjv * points. 'clsize' is the byte size of the buffer to which 'class' points. 460734eb7836Sjv * 460834eb7836Sjv * This function returns Z_OK if it successfully stored the specified pool's 460934eb7836Sjv * thread scheduling class into the buffer to which 'class' points. It returns 461034eb7836Sjv * Z_NO_POOL if resource pools are not enabled, the function is unable to 461134eb7836Sjv * access the system's resource pools configuration, or the specified pool 461234eb7836Sjv * does not exist. The function returns Z_TOO_BIG if the buffer to which 461334eb7836Sjv * 'class' points is not large enough to contain the thread scheduling class' 461434eb7836Sjv * name. The function returns Z_NO_ENTRY if the pool does not specify a thread 461534eb7836Sjv * scheduling class. 461634eb7836Sjv */ 46170209230bSgjelinek static int 46180209230bSgjelinek get_pool_sched_class(char *poolname, char *class, int clsize) 46190209230bSgjelinek { 46200209230bSgjelinek int status; 46210209230bSgjelinek pool_conf_t *poolconf; 46220209230bSgjelinek pool_t *pool; 46230209230bSgjelinek pool_elem_t *pe; 46240209230bSgjelinek pool_value_t *pv = pool_value_alloc(); 46250209230bSgjelinek const char *sched_str; 46260209230bSgjelinek 46270209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) 46280209230bSgjelinek return (Z_NO_POOL); 46290209230bSgjelinek 46300209230bSgjelinek if ((poolconf = pool_conf_alloc()) == NULL) 46310209230bSgjelinek return (Z_NO_POOL); 46320209230bSgjelinek 46330209230bSgjelinek if (pool_conf_open(poolconf, pool_dynamic_location(), PO_RDONLY) != 46340209230bSgjelinek PO_SUCCESS) { 46350209230bSgjelinek pool_conf_free(poolconf); 46360209230bSgjelinek return (Z_NO_POOL); 46379acbbeafSnn } 46389acbbeafSnn 46390209230bSgjelinek if ((pool = pool_get_pool(poolconf, poolname)) == NULL) { 46400209230bSgjelinek (void) pool_conf_close(poolconf); 46410209230bSgjelinek pool_conf_free(poolconf); 46420209230bSgjelinek return (Z_NO_POOL); 46439acbbeafSnn } 46449acbbeafSnn 46450209230bSgjelinek pe = pool_to_elem(poolconf, pool); 464634eb7836Sjv if (pool_get_property(poolconf, pe, "pool.scheduler", pv) != 464734eb7836Sjv POC_STRING) { 464834eb7836Sjv (void) pool_conf_close(poolconf); 464934eb7836Sjv pool_conf_free(poolconf); 465034eb7836Sjv return (Z_NO_ENTRY); 46510209230bSgjelinek } 465234eb7836Sjv (void) pool_value_get_string(pv, &sched_str); 46530209230bSgjelinek (void) pool_conf_close(poolconf); 46540209230bSgjelinek pool_conf_free(poolconf); 465534eb7836Sjv if (strlcpy(class, sched_str, clsize) >= clsize) 465634eb7836Sjv return (Z_TOO_BIG); 46570209230bSgjelinek return (Z_OK); 46589acbbeafSnn } 46599acbbeafSnn 4660facf4a8dSllai /* 46610209230bSgjelinek * Get the default scheduling class for the zone. This will either be the 46620209230bSgjelinek * class set on the zone's pool or the system default scheduling class. 4663facf4a8dSllai */ 4664facf4a8dSllai int 46650209230bSgjelinek zonecfg_get_dflt_sched_class(zone_dochandle_t handle, char *class, int clsize) 4666facf4a8dSllai { 46670209230bSgjelinek char poolname[MAXPATHLEN]; 4668facf4a8dSllai 46690209230bSgjelinek if (zonecfg_get_pool(handle, poolname, sizeof (poolname)) == Z_OK) { 46700209230bSgjelinek /* check if the zone's pool specified a sched class */ 46710209230bSgjelinek if (get_pool_sched_class(poolname, class, clsize) == Z_OK) 46720209230bSgjelinek return (Z_OK); 46730209230bSgjelinek } 4674facf4a8dSllai 46750209230bSgjelinek if (priocntl(0, 0, PC_GETDFLCL, class, (uint64_t)clsize) == -1) 4676facf4a8dSllai return (Z_TOO_BIG); 46770209230bSgjelinek 4678facf4a8dSllai return (Z_OK); 4679facf4a8dSllai } 4680facf4a8dSllai 46810209230bSgjelinek int 46820209230bSgjelinek zonecfg_setfsent(zone_dochandle_t handle) 46837c478bd9Sstevel@tonic-gate { 46840209230bSgjelinek return (zonecfg_setent(handle)); 46857c478bd9Sstevel@tonic-gate } 46867c478bd9Sstevel@tonic-gate 46877c478bd9Sstevel@tonic-gate int 46880209230bSgjelinek zonecfg_getfsent(zone_dochandle_t handle, struct zone_fstab *tabptr) 46897c478bd9Sstevel@tonic-gate { 46900209230bSgjelinek xmlNodePtr cur, options; 46910209230bSgjelinek char options_str[MAX_MNTOPT_STR]; 46920209230bSgjelinek int err; 46937c478bd9Sstevel@tonic-gate 46940209230bSgjelinek if (handle == NULL) 46957c478bd9Sstevel@tonic-gate return (Z_INVAL); 46967c478bd9Sstevel@tonic-gate 46970209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 46980209230bSgjelinek return (Z_NO_ENTRY); 46990209230bSgjelinek 47000209230bSgjelinek for (; cur != NULL; cur = cur->next) 47010209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_FS)) 47020209230bSgjelinek break; 47030209230bSgjelinek if (cur == NULL) { 47040209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47050209230bSgjelinek return (Z_NO_ENTRY); 4706108322fbScarlsonj } 4707108322fbScarlsonj 47080209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_SPECIAL, tabptr->zone_fs_special, 47090209230bSgjelinek sizeof (tabptr->zone_fs_special))) != Z_OK) { 47100209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47110209230bSgjelinek return (err); 47127c478bd9Sstevel@tonic-gate } 47137c478bd9Sstevel@tonic-gate 47140209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_RAW, tabptr->zone_fs_raw, 47150209230bSgjelinek sizeof (tabptr->zone_fs_raw))) != Z_OK) { 47160209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47170209230bSgjelinek return (err); 47180209230bSgjelinek } 47190209230bSgjelinek 47200209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir, 47210209230bSgjelinek sizeof (tabptr->zone_fs_dir))) != Z_OK) { 47220209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47230209230bSgjelinek return (err); 47240209230bSgjelinek } 47250209230bSgjelinek 47260209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_fs_type, 47270209230bSgjelinek sizeof (tabptr->zone_fs_type))) != Z_OK) { 47280209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47290209230bSgjelinek return (err); 47300209230bSgjelinek } 47310209230bSgjelinek 47320209230bSgjelinek /* OK for options to be NULL */ 47330209230bSgjelinek tabptr->zone_fs_options = NULL; 47340209230bSgjelinek for (options = cur->xmlChildrenNode; options != NULL; 47350209230bSgjelinek options = options->next) { 47360209230bSgjelinek if (fetchprop(options, DTD_ATTR_NAME, options_str, 47370209230bSgjelinek sizeof (options_str)) != Z_OK) 47380209230bSgjelinek break; 47390209230bSgjelinek if (zonecfg_add_fs_option(tabptr, options_str) != Z_OK) 47407c478bd9Sstevel@tonic-gate break; 47417c478bd9Sstevel@tonic-gate } 47420209230bSgjelinek 47430209230bSgjelinek handle->zone_dh_cur = cur->next; 47440209230bSgjelinek return (Z_OK); 47457c478bd9Sstevel@tonic-gate } 47467c478bd9Sstevel@tonic-gate 47477c478bd9Sstevel@tonic-gate int 47480209230bSgjelinek zonecfg_endfsent(zone_dochandle_t handle) 47497c478bd9Sstevel@tonic-gate { 47500209230bSgjelinek return (zonecfg_endent(handle)); 47517c478bd9Sstevel@tonic-gate } 47527c478bd9Sstevel@tonic-gate 47537c478bd9Sstevel@tonic-gate int 47540209230bSgjelinek zonecfg_setipdent(zone_dochandle_t handle) 47557c478bd9Sstevel@tonic-gate { 47560209230bSgjelinek return (zonecfg_setent(handle)); 47570209230bSgjelinek } 47580209230bSgjelinek 47590209230bSgjelinek int 47600209230bSgjelinek zonecfg_getipdent(zone_dochandle_t handle, struct zone_fstab *tabptr) 47610209230bSgjelinek { 47620209230bSgjelinek xmlNodePtr cur; 47637c478bd9Sstevel@tonic-gate int err; 47647c478bd9Sstevel@tonic-gate 47650209230bSgjelinek if (handle == NULL) 47660209230bSgjelinek return (Z_INVAL); 47677c478bd9Sstevel@tonic-gate 47680209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 47690209230bSgjelinek return (Z_NO_ENTRY); 47707c478bd9Sstevel@tonic-gate 47710209230bSgjelinek for (; cur != NULL; cur = cur->next) 47720209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_IPD)) 47730209230bSgjelinek break; 47740209230bSgjelinek if (cur == NULL) { 47750209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47760209230bSgjelinek return (Z_NO_ENTRY); 47770209230bSgjelinek } 47787c478bd9Sstevel@tonic-gate 47790209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir, 47800209230bSgjelinek sizeof (tabptr->zone_fs_dir))) != Z_OK) { 47810209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47820209230bSgjelinek return (err); 47837c478bd9Sstevel@tonic-gate } 47847c478bd9Sstevel@tonic-gate 47850209230bSgjelinek handle->zone_dh_cur = cur->next; 47860209230bSgjelinek return (Z_OK); 47877c478bd9Sstevel@tonic-gate } 47887c478bd9Sstevel@tonic-gate 47890209230bSgjelinek int 47900209230bSgjelinek zonecfg_endipdent(zone_dochandle_t handle) 47917c478bd9Sstevel@tonic-gate { 47920209230bSgjelinek return (zonecfg_endent(handle)); 47937c478bd9Sstevel@tonic-gate } 47947c478bd9Sstevel@tonic-gate 4795108322fbScarlsonj int 47960209230bSgjelinek zonecfg_setnwifent(zone_dochandle_t handle) 4797108322fbScarlsonj { 47980209230bSgjelinek return (zonecfg_setent(handle)); 4799108322fbScarlsonj } 4800108322fbScarlsonj 4801108322fbScarlsonj int 48020209230bSgjelinek zonecfg_getnwifent(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 4803108322fbScarlsonj { 48040209230bSgjelinek xmlNodePtr cur; 48050209230bSgjelinek int err; 4806108322fbScarlsonj 48070209230bSgjelinek if (handle == NULL) 48080209230bSgjelinek return (Z_INVAL); 48090209230bSgjelinek 48100209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 48110209230bSgjelinek return (Z_NO_ENTRY); 48120209230bSgjelinek 48130209230bSgjelinek for (; cur != NULL; cur = cur->next) 48140209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_NET)) 4815108322fbScarlsonj break; 48160209230bSgjelinek if (cur == NULL) { 48170209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48180209230bSgjelinek return (Z_NO_ENTRY); 4819108322fbScarlsonj } 48200209230bSgjelinek 48210209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_ADDRESS, tabptr->zone_nwif_address, 48220209230bSgjelinek sizeof (tabptr->zone_nwif_address))) != Z_OK) { 48230209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48240209230bSgjelinek return (err); 48250209230bSgjelinek } 48260209230bSgjelinek 48270209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_PHYSICAL, tabptr->zone_nwif_physical, 48280209230bSgjelinek sizeof (tabptr->zone_nwif_physical))) != Z_OK) { 48290209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 4830de860bd9Sgfaden return (err); 4831de860bd9Sgfaden } 4832de860bd9Sgfaden 4833de860bd9Sgfaden if ((err = fetchprop(cur, DTD_ATTR_DEFROUTER, 4834de860bd9Sgfaden tabptr->zone_nwif_defrouter, 4835de860bd9Sgfaden sizeof (tabptr->zone_nwif_defrouter))) != Z_OK) { 4836de860bd9Sgfaden handle->zone_dh_cur = handle->zone_dh_top; 48370209230bSgjelinek return (err); 4838108322fbScarlsonj } 48390209230bSgjelinek 48400209230bSgjelinek handle->zone_dh_cur = cur->next; 48410209230bSgjelinek return (Z_OK); 4842108322fbScarlsonj } 4843108322fbScarlsonj 48440209230bSgjelinek int 48450209230bSgjelinek zonecfg_endnwifent(zone_dochandle_t handle) 48467c478bd9Sstevel@tonic-gate { 48470209230bSgjelinek return (zonecfg_endent(handle)); 48487c478bd9Sstevel@tonic-gate } 48497c478bd9Sstevel@tonic-gate 48500209230bSgjelinek int 48510209230bSgjelinek zonecfg_setdevent(zone_dochandle_t handle) 48520209230bSgjelinek { 48530209230bSgjelinek return (zonecfg_setent(handle)); 48540209230bSgjelinek } 48557c478bd9Sstevel@tonic-gate 48567c478bd9Sstevel@tonic-gate int 48570209230bSgjelinek zonecfg_getdevent(zone_dochandle_t handle, struct zone_devtab *tabptr) 48587c478bd9Sstevel@tonic-gate { 48590209230bSgjelinek xmlNodePtr cur; 48600209230bSgjelinek int err; 48617c478bd9Sstevel@tonic-gate 48620209230bSgjelinek if (handle == NULL) 48637c478bd9Sstevel@tonic-gate return (Z_INVAL); 48647c478bd9Sstevel@tonic-gate 48650209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 48660209230bSgjelinek return (Z_NO_ENTRY); 48670209230bSgjelinek 48680209230bSgjelinek for (; cur != NULL; cur = cur->next) 48690209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_DEVICE)) 48700209230bSgjelinek break; 48710209230bSgjelinek if (cur == NULL) { 48720209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48730209230bSgjelinek return (Z_NO_ENTRY); 48747c478bd9Sstevel@tonic-gate } 48757c478bd9Sstevel@tonic-gate 48760209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_MATCH, tabptr->zone_dev_match, 48770209230bSgjelinek sizeof (tabptr->zone_dev_match))) != Z_OK) { 48780209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48790209230bSgjelinek return (err); 48807c478bd9Sstevel@tonic-gate } 48810209230bSgjelinek 48820209230bSgjelinek handle->zone_dh_cur = cur->next; 48837c478bd9Sstevel@tonic-gate return (Z_OK); 48847c478bd9Sstevel@tonic-gate } 48857c478bd9Sstevel@tonic-gate 48860209230bSgjelinek int 48870209230bSgjelinek zonecfg_enddevent(zone_dochandle_t handle) 48887c478bd9Sstevel@tonic-gate { 48890209230bSgjelinek return (zonecfg_endent(handle)); 48900209230bSgjelinek } 48917c478bd9Sstevel@tonic-gate 48920209230bSgjelinek int 48930209230bSgjelinek zonecfg_setrctlent(zone_dochandle_t handle) 48940209230bSgjelinek { 48950209230bSgjelinek return (zonecfg_setent(handle)); 48960209230bSgjelinek } 48970209230bSgjelinek 48980209230bSgjelinek int 48990209230bSgjelinek zonecfg_getrctlent(zone_dochandle_t handle, struct zone_rctltab *tabptr) 49000209230bSgjelinek { 49010209230bSgjelinek xmlNodePtr cur, val; 49020209230bSgjelinek struct zone_rctlvaltab *valptr; 49030209230bSgjelinek int err; 49040209230bSgjelinek 49050209230bSgjelinek if (handle == NULL) 49060209230bSgjelinek return (Z_INVAL); 49070209230bSgjelinek 49080209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 49090209230bSgjelinek return (Z_NO_ENTRY); 49100209230bSgjelinek 49110209230bSgjelinek for (; cur != NULL; cur = cur->next) 49120209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_RCTL)) 49130209230bSgjelinek break; 49140209230bSgjelinek if (cur == NULL) { 49150209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49160209230bSgjelinek return (Z_NO_ENTRY); 49170209230bSgjelinek } 49180209230bSgjelinek 49190209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_rctl_name, 49200209230bSgjelinek sizeof (tabptr->zone_rctl_name))) != Z_OK) { 49210209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49220209230bSgjelinek return (err); 49230209230bSgjelinek } 49240209230bSgjelinek 49250209230bSgjelinek tabptr->zone_rctl_valptr = NULL; 49260209230bSgjelinek for (val = cur->xmlChildrenNode; val != NULL; val = val->next) { 49270209230bSgjelinek valptr = (struct zone_rctlvaltab *)malloc( 49280209230bSgjelinek sizeof (struct zone_rctlvaltab)); 49290209230bSgjelinek if (valptr == NULL) 49300209230bSgjelinek return (Z_NOMEM); 49310209230bSgjelinek if (fetchprop(val, DTD_ATTR_PRIV, valptr->zone_rctlval_priv, 49320209230bSgjelinek sizeof (valptr->zone_rctlval_priv)) != Z_OK) 49330209230bSgjelinek break; 49340209230bSgjelinek if (fetchprop(val, DTD_ATTR_LIMIT, valptr->zone_rctlval_limit, 49350209230bSgjelinek sizeof (valptr->zone_rctlval_limit)) != Z_OK) 49360209230bSgjelinek break; 49370209230bSgjelinek if (fetchprop(val, DTD_ATTR_ACTION, valptr->zone_rctlval_action, 49380209230bSgjelinek sizeof (valptr->zone_rctlval_action)) != Z_OK) 49390209230bSgjelinek break; 49400209230bSgjelinek if (zonecfg_add_rctl_value(tabptr, valptr) != Z_OK) 49410209230bSgjelinek break; 49420209230bSgjelinek } 49430209230bSgjelinek 49440209230bSgjelinek handle->zone_dh_cur = cur->next; 49450209230bSgjelinek return (Z_OK); 49460209230bSgjelinek } 49470209230bSgjelinek 49480209230bSgjelinek int 49490209230bSgjelinek zonecfg_endrctlent(zone_dochandle_t handle) 49500209230bSgjelinek { 49510209230bSgjelinek return (zonecfg_endent(handle)); 49520209230bSgjelinek } 49530209230bSgjelinek 49540209230bSgjelinek int 49550209230bSgjelinek zonecfg_setattrent(zone_dochandle_t handle) 49560209230bSgjelinek { 49570209230bSgjelinek return (zonecfg_setent(handle)); 49580209230bSgjelinek } 49590209230bSgjelinek 49600209230bSgjelinek int 49610209230bSgjelinek zonecfg_getattrent(zone_dochandle_t handle, struct zone_attrtab *tabptr) 49620209230bSgjelinek { 49630209230bSgjelinek xmlNodePtr cur; 49640209230bSgjelinek int err; 49650209230bSgjelinek 49660209230bSgjelinek if (handle == NULL) 49670209230bSgjelinek return (Z_INVAL); 49680209230bSgjelinek 49690209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 49700209230bSgjelinek return (Z_NO_ENTRY); 49710209230bSgjelinek 49720209230bSgjelinek for (; cur != NULL; cur = cur->next) 49730209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_ATTR)) 49740209230bSgjelinek break; 49750209230bSgjelinek if (cur == NULL) { 49760209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49770209230bSgjelinek return (Z_NO_ENTRY); 49780209230bSgjelinek } 49790209230bSgjelinek 49800209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_attr_name, 49810209230bSgjelinek sizeof (tabptr->zone_attr_name))) != Z_OK) { 49820209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49830209230bSgjelinek return (err); 49840209230bSgjelinek } 49850209230bSgjelinek 49860209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_attr_type, 49870209230bSgjelinek sizeof (tabptr->zone_attr_type))) != Z_OK) { 49880209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49890209230bSgjelinek return (err); 49900209230bSgjelinek } 49910209230bSgjelinek 49920209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_VALUE, tabptr->zone_attr_value, 49930209230bSgjelinek sizeof (tabptr->zone_attr_value))) != Z_OK) { 49940209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49950209230bSgjelinek return (err); 49960209230bSgjelinek } 49970209230bSgjelinek 49980209230bSgjelinek handle->zone_dh_cur = cur->next; 49990209230bSgjelinek return (Z_OK); 50000209230bSgjelinek } 50010209230bSgjelinek 50020209230bSgjelinek int 50030209230bSgjelinek zonecfg_endattrent(zone_dochandle_t handle) 50040209230bSgjelinek { 50050209230bSgjelinek return (zonecfg_endent(handle)); 50060209230bSgjelinek } 50070209230bSgjelinek 5008cb8a054bSGlenn Faden int 5009cb8a054bSGlenn Faden zonecfg_setadminent(zone_dochandle_t handle) 5010cb8a054bSGlenn Faden { 5011cb8a054bSGlenn Faden return (zonecfg_setent(handle)); 5012cb8a054bSGlenn Faden } 5013cb8a054bSGlenn Faden 5014cb8a054bSGlenn Faden int 5015cb8a054bSGlenn Faden zonecfg_getadminent(zone_dochandle_t handle, struct zone_admintab *tabptr) 5016cb8a054bSGlenn Faden { 5017cb8a054bSGlenn Faden xmlNodePtr cur; 5018cb8a054bSGlenn Faden int err; 5019cb8a054bSGlenn Faden 5020cb8a054bSGlenn Faden if (handle == NULL) 5021cb8a054bSGlenn Faden return (Z_INVAL); 5022cb8a054bSGlenn Faden 5023cb8a054bSGlenn Faden if ((cur = handle->zone_dh_cur) == NULL) 5024cb8a054bSGlenn Faden return (Z_NO_ENTRY); 5025cb8a054bSGlenn Faden 5026cb8a054bSGlenn Faden for (; cur != NULL; cur = cur->next) 5027cb8a054bSGlenn Faden if (!xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 5028cb8a054bSGlenn Faden break; 5029cb8a054bSGlenn Faden if (cur == NULL) { 5030cb8a054bSGlenn Faden handle->zone_dh_cur = handle->zone_dh_top; 5031cb8a054bSGlenn Faden return (Z_NO_ENTRY); 5032cb8a054bSGlenn Faden } 5033cb8a054bSGlenn Faden 5034cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_USER, tabptr->zone_admin_user, 5035cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_user))) != Z_OK) { 5036cb8a054bSGlenn Faden handle->zone_dh_cur = handle->zone_dh_top; 5037cb8a054bSGlenn Faden return (err); 5038cb8a054bSGlenn Faden } 5039cb8a054bSGlenn Faden 5040cb8a054bSGlenn Faden 5041cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_AUTHS, tabptr->zone_admin_auths, 5042cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_auths))) != Z_OK) { 5043cb8a054bSGlenn Faden handle->zone_dh_cur = handle->zone_dh_top; 5044cb8a054bSGlenn Faden return (err); 5045cb8a054bSGlenn Faden } 5046cb8a054bSGlenn Faden 5047cb8a054bSGlenn Faden handle->zone_dh_cur = cur->next; 5048cb8a054bSGlenn Faden return (Z_OK); 5049cb8a054bSGlenn Faden } 5050cb8a054bSGlenn Faden 5051cb8a054bSGlenn Faden int 5052cb8a054bSGlenn Faden zonecfg_endadminent(zone_dochandle_t handle) 5053cb8a054bSGlenn Faden { 5054cb8a054bSGlenn Faden return (zonecfg_endent(handle)); 5055cb8a054bSGlenn Faden } 5056cb8a054bSGlenn Faden 50570209230bSgjelinek /* 50580209230bSgjelinek * The privileges available on the system and described in privileges(5) 50590209230bSgjelinek * fall into four categories with respect to non-global zones: 50600209230bSgjelinek * 50610209230bSgjelinek * Default set of privileges considered safe for all non-global 50620209230bSgjelinek * zones. These privileges are "safe" in the sense that a 50630209230bSgjelinek * privileged process in the zone cannot affect processes in any 50640209230bSgjelinek * other zone on the system. 50650209230bSgjelinek * 50660209230bSgjelinek * Set of privileges not currently permitted within a non-global 50670209230bSgjelinek * zone. These privileges are considered by default, "unsafe," 50680209230bSgjelinek * and include ones which affect global resources (such as the 50690209230bSgjelinek * system clock or physical memory) or are overly broad and cover 50700209230bSgjelinek * more than one mechanism in the system. In other cases, there 50710209230bSgjelinek * has not been sufficient virtualization in the parts of the 50720209230bSgjelinek * system the privilege covers to allow its use within a 50730209230bSgjelinek * non-global zone. 50740209230bSgjelinek * 50750209230bSgjelinek * Set of privileges required in order to get a zone booted and 50760209230bSgjelinek * init(1M) started. These cannot be removed from the zone's 50770209230bSgjelinek * privilege set. 50780209230bSgjelinek * 50790209230bSgjelinek * All other privileges are optional and are potentially useful for 50800209230bSgjelinek * processes executing inside a non-global zone. 50810209230bSgjelinek * 50820209230bSgjelinek * When privileges are added to the system, a determination needs to be 50830209230bSgjelinek * made as to which category the privilege belongs to. Ideally, 50840209230bSgjelinek * privileges should be fine-grained enough and the mechanisms they cover 50850209230bSgjelinek * virtualized enough so that they can be made available to non-global 50860209230bSgjelinek * zones. 50870209230bSgjelinek */ 50880209230bSgjelinek 50890209230bSgjelinek /* 50900209230bSgjelinek * Define some of the tokens that priv_str_to_set(3C) recognizes. Since 50910209230bSgjelinek * the privilege string separator can be any character, although it is 50920209230bSgjelinek * usually a comma character, define these here as well in the event that 50930209230bSgjelinek * they change or are augmented in the future. 50940209230bSgjelinek */ 50950209230bSgjelinek #define BASIC_TOKEN "basic" 50960209230bSgjelinek #define DEFAULT_TOKEN "default" 50970209230bSgjelinek #define ZONE_TOKEN "zone" 50980209230bSgjelinek #define TOKEN_PRIV_CHAR ',' 50990209230bSgjelinek #define TOKEN_PRIV_STR "," 51000209230bSgjelinek 51010209230bSgjelinek typedef struct priv_node { 51020209230bSgjelinek struct priv_node *pn_next; /* Next privilege */ 51030209230bSgjelinek char *pn_priv; /* Privileges name */ 51040209230bSgjelinek } priv_node_t; 51050209230bSgjelinek 51060209230bSgjelinek /* Privileges lists can differ across brands */ 51070209230bSgjelinek typedef struct priv_lists { 51080209230bSgjelinek /* Privileges considered safe for all non-global zones of a brand */ 51090209230bSgjelinek struct priv_node *pl_default; 51100209230bSgjelinek 51110209230bSgjelinek /* Privileges not permitted for all non-global zones of a brand */ 51120209230bSgjelinek struct priv_node *pl_prohibited; 51130209230bSgjelinek 51140209230bSgjelinek /* Privileges required for all non-global zones of a brand */ 51150209230bSgjelinek struct priv_node *pl_required; 5116bf1d7e28Sdh 5117bf1d7e28Sdh /* 5118bf1d7e28Sdh * ip-type of the zone these privileges lists apply to. 5119bf1d7e28Sdh * It is used to pass ip-type to the callback function, 5120bf1d7e28Sdh * priv_lists_cb, which has no way of getting the ip-type. 5121bf1d7e28Sdh */ 5122bf1d7e28Sdh const char *pl_iptype; 51230209230bSgjelinek } priv_lists_t; 51240209230bSgjelinek 51250209230bSgjelinek static int 5126bf1d7e28Sdh priv_lists_cb(void *data, priv_iter_t *priv_iter) 51270209230bSgjelinek { 51280209230bSgjelinek priv_lists_t *plp = (priv_lists_t *)data; 51290209230bSgjelinek priv_node_t *pnp; 51300209230bSgjelinek 5131bf1d7e28Sdh /* Skip this privilege if ip-type does not match */ 5132bf1d7e28Sdh if ((strcmp(priv_iter->pi_iptype, "all") != 0) && 5133bf1d7e28Sdh (strcmp(priv_iter->pi_iptype, plp->pl_iptype) != 0)) 5134bf1d7e28Sdh return (0); 5135bf1d7e28Sdh 51360209230bSgjelinek /* Allocate a new priv list node. */ 51370209230bSgjelinek if ((pnp = malloc(sizeof (*pnp))) == NULL) 51380209230bSgjelinek return (-1); 5139bf1d7e28Sdh if ((pnp->pn_priv = strdup(priv_iter->pi_name)) == NULL) { 51400209230bSgjelinek free(pnp); 51410209230bSgjelinek return (-1); 51420209230bSgjelinek } 51430209230bSgjelinek 51440209230bSgjelinek /* Insert the new priv list node into the right list */ 5145bf1d7e28Sdh if (strcmp(priv_iter->pi_set, "default") == 0) { 51460209230bSgjelinek pnp->pn_next = plp->pl_default; 51470209230bSgjelinek plp->pl_default = pnp; 5148bf1d7e28Sdh } else if (strcmp(priv_iter->pi_set, "prohibited") == 0) { 51490209230bSgjelinek pnp->pn_next = plp->pl_prohibited; 51500209230bSgjelinek plp->pl_prohibited = pnp; 5151bf1d7e28Sdh } else if (strcmp(priv_iter->pi_set, "required") == 0) { 51520209230bSgjelinek pnp->pn_next = plp->pl_required; 51530209230bSgjelinek plp->pl_required = pnp; 51540209230bSgjelinek } else { 51550209230bSgjelinek free(pnp->pn_priv); 51560209230bSgjelinek free(pnp); 51570209230bSgjelinek return (-1); 51580209230bSgjelinek } 51590209230bSgjelinek return (0); 51600209230bSgjelinek } 51610209230bSgjelinek 51620209230bSgjelinek static void 51630209230bSgjelinek priv_lists_destroy(priv_lists_t *plp) 51640209230bSgjelinek { 51650209230bSgjelinek priv_node_t *pnp; 51660209230bSgjelinek 51670209230bSgjelinek assert(plp != NULL); 51680209230bSgjelinek 51690209230bSgjelinek while ((pnp = plp->pl_default) != NULL) { 51700209230bSgjelinek plp->pl_default = pnp->pn_next; 51710209230bSgjelinek free(pnp->pn_priv); 51720209230bSgjelinek free(pnp); 51730209230bSgjelinek } 51740209230bSgjelinek while ((pnp = plp->pl_prohibited) != NULL) { 51750209230bSgjelinek plp->pl_prohibited = pnp->pn_next; 51760209230bSgjelinek free(pnp->pn_priv); 51770209230bSgjelinek free(pnp); 51780209230bSgjelinek } 51790209230bSgjelinek while ((pnp = plp->pl_required) != NULL) { 51800209230bSgjelinek plp->pl_required = pnp->pn_next; 51810209230bSgjelinek free(pnp->pn_priv); 51820209230bSgjelinek free(pnp); 51830209230bSgjelinek } 51840209230bSgjelinek free(plp); 51850209230bSgjelinek } 51860209230bSgjelinek 51870209230bSgjelinek static int 5188e5816e35SEdward Pilatowicz priv_lists_create(zone_dochandle_t handle, char *brand, priv_lists_t **plpp, 5189bf1d7e28Sdh const char *curr_iptype) 51900209230bSgjelinek { 51910209230bSgjelinek priv_lists_t *plp; 51920209230bSgjelinek brand_handle_t bh; 5193e5816e35SEdward Pilatowicz char brand_str[MAXNAMELEN]; 5194e5816e35SEdward Pilatowicz 5195e5816e35SEdward Pilatowicz /* handle or brand must be set, but never both */ 5196e5816e35SEdward Pilatowicz assert((handle != NULL) || (brand != NULL)); 5197e5816e35SEdward Pilatowicz assert((handle == NULL) || (brand == NULL)); 51980209230bSgjelinek 51990209230bSgjelinek if (handle != NULL) { 5200e5816e35SEdward Pilatowicz brand = brand_str; 5201e5816e35SEdward Pilatowicz if (zonecfg_get_brand(handle, brand, sizeof (brand_str)) != 0) 52020209230bSgjelinek return (Z_BRAND_ERROR); 52030209230bSgjelinek } 52040209230bSgjelinek 52050209230bSgjelinek if ((bh = brand_open(brand)) == NULL) 52060209230bSgjelinek return (Z_BRAND_ERROR); 52070209230bSgjelinek 52080209230bSgjelinek if ((plp = calloc(1, sizeof (priv_lists_t))) == NULL) { 52090209230bSgjelinek brand_close(bh); 52100209230bSgjelinek return (Z_NOMEM); 52110209230bSgjelinek } 52120209230bSgjelinek 5213bf1d7e28Sdh plp->pl_iptype = curr_iptype; 5214bf1d7e28Sdh 52150209230bSgjelinek /* construct the privilege lists */ 52160209230bSgjelinek if (brand_config_iter_privilege(bh, priv_lists_cb, plp) != 0) { 52170209230bSgjelinek priv_lists_destroy(plp); 52180209230bSgjelinek brand_close(bh); 52190209230bSgjelinek return (Z_BRAND_ERROR); 52200209230bSgjelinek } 52210209230bSgjelinek 52220209230bSgjelinek brand_close(bh); 52230209230bSgjelinek *plpp = plp; 52240209230bSgjelinek return (Z_OK); 52250209230bSgjelinek } 52260209230bSgjelinek 52270209230bSgjelinek static int 52280209230bSgjelinek get_default_privset(priv_set_t *privs, priv_lists_t *plp) 52290209230bSgjelinek { 52300209230bSgjelinek priv_node_t *pnp; 52310209230bSgjelinek priv_set_t *basic; 52320209230bSgjelinek 52330209230bSgjelinek basic = priv_str_to_set(BASIC_TOKEN, TOKEN_PRIV_STR, NULL); 52340209230bSgjelinek if (basic == NULL) 52350209230bSgjelinek return (errno == ENOMEM ? Z_NOMEM : Z_INVAL); 52360209230bSgjelinek 52370209230bSgjelinek priv_union(basic, privs); 52380209230bSgjelinek priv_freeset(basic); 52390209230bSgjelinek 52400209230bSgjelinek for (pnp = plp->pl_default; pnp != NULL; pnp = pnp->pn_next) { 52410209230bSgjelinek if (priv_addset(privs, pnp->pn_priv) != 0) 52420209230bSgjelinek return (Z_INVAL); 52430209230bSgjelinek } 52440209230bSgjelinek 52450209230bSgjelinek return (Z_OK); 52460209230bSgjelinek } 52470209230bSgjelinek 5248e5816e35SEdward Pilatowicz int 5249e5816e35SEdward Pilatowicz zonecfg_default_brand(char *brand, size_t brandsize) 5250e5816e35SEdward Pilatowicz { 5251e5816e35SEdward Pilatowicz zone_dochandle_t handle; 52527522f2fcSEdward Pilatowicz int myzoneid = getzoneid(); 5253e5816e35SEdward Pilatowicz int ret; 5254e5816e35SEdward Pilatowicz 52557522f2fcSEdward Pilatowicz /* 52567522f2fcSEdward Pilatowicz * If we're running within a zone, then the default brand is the 52577522f2fcSEdward Pilatowicz * current zone's brand. 52587522f2fcSEdward Pilatowicz */ 52597522f2fcSEdward Pilatowicz if (myzoneid != GLOBAL_ZONEID) { 52607522f2fcSEdward Pilatowicz ret = zone_getattr(myzoneid, ZONE_ATTR_BRAND, brand, brandsize); 52617522f2fcSEdward Pilatowicz if (ret < 0) 52627522f2fcSEdward Pilatowicz return ((errno == EFAULT) ? Z_TOO_BIG : Z_INVAL); 52637522f2fcSEdward Pilatowicz return (Z_OK); 52647522f2fcSEdward Pilatowicz } 52657522f2fcSEdward Pilatowicz 5266e5816e35SEdward Pilatowicz if ((handle = zonecfg_init_handle()) == NULL) 5267e5816e35SEdward Pilatowicz return (Z_NOMEM); 5268e5816e35SEdward Pilatowicz if ((ret = zonecfg_get_handle("SUNWdefault", handle)) == Z_OK) { 5269e5816e35SEdward Pilatowicz ret = i_zonecfg_get_brand(handle, brand, brandsize, B_TRUE); 5270e5816e35SEdward Pilatowicz zonecfg_fini_handle(handle); 5271e5816e35SEdward Pilatowicz return (ret); 5272e5816e35SEdward Pilatowicz } 5273e5816e35SEdward Pilatowicz return (ret); 5274e5816e35SEdward Pilatowicz } 5275e5816e35SEdward Pilatowicz 52760209230bSgjelinek int 5277bf1d7e28Sdh zonecfg_default_privset(priv_set_t *privs, const char *curr_iptype) 52780209230bSgjelinek { 52790209230bSgjelinek priv_lists_t *plp; 5280e5816e35SEdward Pilatowicz char buf[MAXNAMELEN]; 52810209230bSgjelinek int ret; 52820209230bSgjelinek 5283e5816e35SEdward Pilatowicz if ((ret = zonecfg_default_brand(buf, sizeof (buf))) != Z_OK) 5284e5816e35SEdward Pilatowicz return (ret); 5285e5816e35SEdward Pilatowicz if ((ret = priv_lists_create(NULL, buf, &plp, curr_iptype)) != Z_OK) 52860209230bSgjelinek return (ret); 52870209230bSgjelinek ret = get_default_privset(privs, plp); 52880209230bSgjelinek priv_lists_destroy(plp); 52890209230bSgjelinek return (ret); 52900209230bSgjelinek } 52910209230bSgjelinek 52920209230bSgjelinek void 52930209230bSgjelinek append_priv_token(char *priv, char *str, size_t strlen) 52940209230bSgjelinek { 52950209230bSgjelinek if (*str != '\0') 52960209230bSgjelinek (void) strlcat(str, TOKEN_PRIV_STR, strlen); 52970209230bSgjelinek (void) strlcat(str, priv, strlen); 52980209230bSgjelinek } 52990209230bSgjelinek 53000209230bSgjelinek /* 53010209230bSgjelinek * Verify that the supplied string is a valid privilege limit set for a 53020209230bSgjelinek * non-global zone. This string must not only be acceptable to 53030209230bSgjelinek * priv_str_to_set(3C) which parses it, but it also must resolve to a 53040209230bSgjelinek * privilege set that includes certain required privileges and lacks 53050209230bSgjelinek * certain prohibited privileges. 53060209230bSgjelinek */ 53070209230bSgjelinek static int 53080209230bSgjelinek verify_privset(char *privbuf, priv_set_t *privs, char **privname, 53090209230bSgjelinek boolean_t add_default, priv_lists_t *plp) 53100209230bSgjelinek { 53110209230bSgjelinek priv_node_t *pnp; 53120209230bSgjelinek char *tmp, *cp, *lasts; 53130209230bSgjelinek size_t len; 53140209230bSgjelinek priv_set_t *mergeset; 53150209230bSgjelinek const char *token; 53160209230bSgjelinek 53170209230bSgjelinek /* 53180209230bSgjelinek * The verification of the privilege string occurs in several 53190209230bSgjelinek * phases. In the first phase, the supplied string is scanned for 53200209230bSgjelinek * the ZONE_TOKEN token which is not support as part of the 53210209230bSgjelinek * "limitpriv" property. 53220209230bSgjelinek * 53230209230bSgjelinek * Duplicate the supplied privilege string since strtok_r(3C) 53240209230bSgjelinek * tokenizes its input by null-terminating the tokens. 53250209230bSgjelinek */ 53260209230bSgjelinek if ((tmp = strdup(privbuf)) == NULL) 53270209230bSgjelinek return (Z_NOMEM); 53280209230bSgjelinek for (cp = strtok_r(tmp, TOKEN_PRIV_STR, &lasts); cp != NULL; 53290209230bSgjelinek cp = strtok_r(NULL, TOKEN_PRIV_STR, &lasts)) { 53300209230bSgjelinek if (strcmp(cp, ZONE_TOKEN) == 0) { 53310209230bSgjelinek free(tmp); 53320209230bSgjelinek if ((*privname = strdup(ZONE_TOKEN)) == NULL) 53330209230bSgjelinek return (Z_NOMEM); 53340209230bSgjelinek else 53350209230bSgjelinek return (Z_PRIV_UNKNOWN); 53360209230bSgjelinek } 53370209230bSgjelinek } 53380209230bSgjelinek free(tmp); 53390209230bSgjelinek 53400209230bSgjelinek if (add_default) { 53410209230bSgjelinek /* 53420209230bSgjelinek * If DEFAULT_TOKEN was specified, a string needs to be 53430209230bSgjelinek * built containing the privileges from the default, safe 53440209230bSgjelinek * set along with those of the "limitpriv" property. 53450209230bSgjelinek */ 53460209230bSgjelinek len = strlen(privbuf) + sizeof (BASIC_TOKEN) + 2; 53470209230bSgjelinek 53480209230bSgjelinek for (pnp = plp->pl_default; pnp != NULL; pnp = pnp->pn_next) 53490209230bSgjelinek len += strlen(pnp->pn_priv) + 1; 53500209230bSgjelinek tmp = alloca(len); 53510209230bSgjelinek *tmp = '\0'; 53520209230bSgjelinek 53530209230bSgjelinek append_priv_token(BASIC_TOKEN, tmp, len); 53540209230bSgjelinek for (pnp = plp->pl_default; pnp != NULL; pnp = pnp->pn_next) 53550209230bSgjelinek append_priv_token(pnp->pn_priv, tmp, len); 53560209230bSgjelinek (void) strlcat(tmp, TOKEN_PRIV_STR, len); 53570209230bSgjelinek (void) strlcat(tmp, privbuf, len); 53580209230bSgjelinek } else { 53590209230bSgjelinek tmp = privbuf; 53600209230bSgjelinek } 53610209230bSgjelinek 53620209230bSgjelinek 53630209230bSgjelinek /* 53640209230bSgjelinek * In the next phase, attempt to convert the merged privilege 53650209230bSgjelinek * string into a privilege set. In the case of an error, either 53660209230bSgjelinek * there was a memory allocation failure or there was an invalid 53670209230bSgjelinek * privilege token in the string. In either case, return an 53680209230bSgjelinek * appropriate error code but in the event of an invalid token, 53690209230bSgjelinek * allocate a string containing its name and return that back to 53700209230bSgjelinek * the caller. 53710209230bSgjelinek */ 53720209230bSgjelinek mergeset = priv_str_to_set(tmp, TOKEN_PRIV_STR, &token); 53730209230bSgjelinek if (mergeset == NULL) { 53740209230bSgjelinek if (token == NULL) 53750209230bSgjelinek return (Z_NOMEM); 53760209230bSgjelinek if ((cp = strchr(token, TOKEN_PRIV_CHAR)) != NULL) 53770209230bSgjelinek *cp = '\0'; 53780209230bSgjelinek if ((*privname = strdup(token)) == NULL) 53790209230bSgjelinek return (Z_NOMEM); 53800209230bSgjelinek else 53810209230bSgjelinek return (Z_PRIV_UNKNOWN); 53820209230bSgjelinek } 53830209230bSgjelinek 53840209230bSgjelinek /* 53850209230bSgjelinek * Next, verify that none of the prohibited zone privileges are 53860209230bSgjelinek * present in the merged privilege set. 53870209230bSgjelinek */ 53880209230bSgjelinek for (pnp = plp->pl_prohibited; pnp != NULL; pnp = pnp->pn_next) { 53890209230bSgjelinek if (priv_ismember(mergeset, pnp->pn_priv)) { 53900209230bSgjelinek priv_freeset(mergeset); 53910209230bSgjelinek if ((*privname = strdup(pnp->pn_priv)) == NULL) 53920209230bSgjelinek return (Z_NOMEM); 53930209230bSgjelinek else 53940209230bSgjelinek return (Z_PRIV_PROHIBITED); 53950209230bSgjelinek } 53960209230bSgjelinek } 53970209230bSgjelinek 53980209230bSgjelinek /* 53990209230bSgjelinek * Finally, verify that all of the required zone privileges are 54000209230bSgjelinek * present in the merged privilege set. 54010209230bSgjelinek */ 54020209230bSgjelinek for (pnp = plp->pl_required; pnp != NULL; pnp = pnp->pn_next) { 54030209230bSgjelinek if (!priv_ismember(mergeset, pnp->pn_priv)) { 54040209230bSgjelinek priv_freeset(mergeset); 54050209230bSgjelinek if ((*privname = strdup(pnp->pn_priv)) == NULL) 54060209230bSgjelinek return (Z_NOMEM); 54070209230bSgjelinek else 54080209230bSgjelinek return (Z_PRIV_REQUIRED); 54090209230bSgjelinek } 54100209230bSgjelinek } 54110209230bSgjelinek 54120209230bSgjelinek priv_copyset(mergeset, privs); 54130209230bSgjelinek priv_freeset(mergeset); 54140209230bSgjelinek return (Z_OK); 54150209230bSgjelinek } 54160209230bSgjelinek 54170209230bSgjelinek /* 54180209230bSgjelinek * Fill in the supplied privilege set with either the default, safe set of 54190209230bSgjelinek * privileges suitable for a non-global zone, or one based on the 54200209230bSgjelinek * "limitpriv" property in the zone's configuration. 54210209230bSgjelinek * 54220209230bSgjelinek * In the event of an invalid privilege specification in the 54230209230bSgjelinek * configuration, a string is allocated and returned containing the 54240209230bSgjelinek * "privilege" causing the issue. It is the caller's responsibility to 54250209230bSgjelinek * free this memory when it is done with it. 54260209230bSgjelinek */ 54270209230bSgjelinek int 54280209230bSgjelinek zonecfg_get_privset(zone_dochandle_t handle, priv_set_t *privs, 54290209230bSgjelinek char **privname) 54300209230bSgjelinek { 54310209230bSgjelinek priv_lists_t *plp; 54320209230bSgjelinek char *cp, *limitpriv = NULL; 54330209230bSgjelinek int err, limitlen; 5434bf1d7e28Sdh zone_iptype_t iptype; 5435bf1d7e28Sdh const char *curr_iptype; 54360209230bSgjelinek 54370209230bSgjelinek /* 54380209230bSgjelinek * Attempt to lookup the "limitpriv" property. If it does not 54390209230bSgjelinek * exist or matches the string DEFAULT_TOKEN exactly, then the 54400209230bSgjelinek * default, safe privilege set is returned. 54410209230bSgjelinek */ 54420209230bSgjelinek if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) != Z_OK) 54430209230bSgjelinek return (err); 54440209230bSgjelinek 5445bf1d7e28Sdh if ((err = zonecfg_get_iptype(handle, &iptype)) != Z_OK) 5446bf1d7e28Sdh return (err); 5447bf1d7e28Sdh 5448bf1d7e28Sdh switch (iptype) { 5449bf1d7e28Sdh case ZS_SHARED: 5450bf1d7e28Sdh curr_iptype = "shared"; 5451bf1d7e28Sdh break; 5452bf1d7e28Sdh case ZS_EXCLUSIVE: 5453bf1d7e28Sdh curr_iptype = "exclusive"; 5454bf1d7e28Sdh break; 5455bf1d7e28Sdh } 5456bf1d7e28Sdh 5457e5816e35SEdward Pilatowicz if ((err = priv_lists_create(handle, NULL, &plp, curr_iptype)) != Z_OK) 54580209230bSgjelinek return (err); 54590209230bSgjelinek 54600209230bSgjelinek limitlen = strlen(limitpriv); 54610209230bSgjelinek if (limitlen == 0 || strcmp(limitpriv, DEFAULT_TOKEN) == 0) { 54620209230bSgjelinek free(limitpriv); 54630209230bSgjelinek err = get_default_privset(privs, plp); 54640209230bSgjelinek priv_lists_destroy(plp); 54650209230bSgjelinek return (err); 54660209230bSgjelinek } 54670209230bSgjelinek 54680209230bSgjelinek /* 54690209230bSgjelinek * Check if the string DEFAULT_TOKEN is the first token in a list 54700209230bSgjelinek * of privileges. 54710209230bSgjelinek */ 54720209230bSgjelinek cp = strchr(limitpriv, TOKEN_PRIV_CHAR); 54730209230bSgjelinek if (cp != NULL && 54740209230bSgjelinek strncmp(limitpriv, DEFAULT_TOKEN, cp - limitpriv) == 0) 54750209230bSgjelinek err = verify_privset(cp + 1, privs, privname, B_TRUE, plp); 54760209230bSgjelinek else 54770209230bSgjelinek err = verify_privset(limitpriv, privs, privname, B_FALSE, plp); 54780209230bSgjelinek 54790209230bSgjelinek free(limitpriv); 54800209230bSgjelinek priv_lists_destroy(plp); 54810209230bSgjelinek return (err); 54820209230bSgjelinek } 54830209230bSgjelinek 54840209230bSgjelinek int 54850209230bSgjelinek zone_get_zonepath(char *zone_name, char *zonepath, size_t rp_sz) 54860209230bSgjelinek { 54870209230bSgjelinek zone_dochandle_t handle; 54880209230bSgjelinek boolean_t found = B_FALSE; 54890209230bSgjelinek struct zoneent *ze; 54900209230bSgjelinek FILE *cookie; 54910209230bSgjelinek int err; 54920209230bSgjelinek char *cp; 54930209230bSgjelinek 54940209230bSgjelinek if (zone_name == NULL) 54950209230bSgjelinek return (Z_INVAL); 54960209230bSgjelinek 54970209230bSgjelinek (void) strlcpy(zonepath, zonecfg_root, rp_sz); 54980209230bSgjelinek cp = zonepath + strlen(zonepath); 54990209230bSgjelinek while (cp > zonepath && cp[-1] == '/') 55000209230bSgjelinek *--cp = '\0'; 55010209230bSgjelinek 55020209230bSgjelinek if (strcmp(zone_name, GLOBAL_ZONENAME) == 0) { 55030209230bSgjelinek if (zonepath[0] == '\0') 55040209230bSgjelinek (void) strlcpy(zonepath, "/", rp_sz); 55050209230bSgjelinek return (Z_OK); 55060209230bSgjelinek } 55070209230bSgjelinek 55080209230bSgjelinek /* 55090209230bSgjelinek * First check the index file. Because older versions did not have 55100209230bSgjelinek * a copy of the zone path, allow for it to be zero length, in which 55110209230bSgjelinek * case we ignore this result and fall back to the XML files. 55120209230bSgjelinek */ 55130209230bSgjelinek cookie = setzoneent(); 55140209230bSgjelinek while ((ze = getzoneent_private(cookie)) != NULL) { 55150209230bSgjelinek if (strcmp(ze->zone_name, zone_name) == 0) { 55160209230bSgjelinek found = B_TRUE; 55170209230bSgjelinek if (ze->zone_path[0] != '\0') 55180209230bSgjelinek (void) strlcpy(cp, ze->zone_path, 55190209230bSgjelinek rp_sz - (cp - zonepath)); 55200209230bSgjelinek } 55210209230bSgjelinek free(ze); 55220209230bSgjelinek if (found) 55230209230bSgjelinek break; 55240209230bSgjelinek } 55250209230bSgjelinek endzoneent(cookie); 55260209230bSgjelinek if (found && *cp != '\0') 55270209230bSgjelinek return (Z_OK); 55280209230bSgjelinek 55290209230bSgjelinek /* Fall back to the XML files. */ 55300209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) 55310209230bSgjelinek return (Z_NOMEM); 55320209230bSgjelinek 55330209230bSgjelinek /* 55340209230bSgjelinek * Check the snapshot first: if a zone is running, its zonepath 55350209230bSgjelinek * may have changed. 55360209230bSgjelinek */ 55370209230bSgjelinek if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 5538e767a340Sgjelinek if ((err = zonecfg_get_handle(zone_name, handle)) != Z_OK) { 5539e767a340Sgjelinek zonecfg_fini_handle(handle); 55400209230bSgjelinek return (err); 5541e767a340Sgjelinek } 55420209230bSgjelinek } 55430209230bSgjelinek err = zonecfg_get_zonepath(handle, zonepath, rp_sz); 55440209230bSgjelinek zonecfg_fini_handle(handle); 55450209230bSgjelinek return (err); 55460209230bSgjelinek } 55470209230bSgjelinek 55480209230bSgjelinek int 55490209230bSgjelinek zone_get_rootpath(char *zone_name, char *rootpath, size_t rp_sz) 55500209230bSgjelinek { 55510209230bSgjelinek int err; 55520209230bSgjelinek 55530209230bSgjelinek /* This function makes sense for non-global zones only. */ 55540209230bSgjelinek if (strcmp(zone_name, GLOBAL_ZONENAME) == 0) 55550209230bSgjelinek return (Z_BOGUS_ZONE_NAME); 55560209230bSgjelinek if ((err = zone_get_zonepath(zone_name, rootpath, rp_sz)) != Z_OK) 55570209230bSgjelinek return (err); 55580209230bSgjelinek if (strlcat(rootpath, "/root", rp_sz) >= rp_sz) 55590209230bSgjelinek return (Z_TOO_BIG); 55600209230bSgjelinek return (Z_OK); 55610209230bSgjelinek } 55620209230bSgjelinek 55630209230bSgjelinek int 55640209230bSgjelinek zone_get_brand(char *zone_name, char *brandname, size_t rp_sz) 55650209230bSgjelinek { 55660209230bSgjelinek int err; 55670209230bSgjelinek zone_dochandle_t handle; 55680209230bSgjelinek char myzone[MAXNAMELEN]; 55690209230bSgjelinek int myzoneid = getzoneid(); 55700209230bSgjelinek 55710209230bSgjelinek /* 55720209230bSgjelinek * If we are not in the global zone, then we don't have the zone 55730209230bSgjelinek * .xml files with the brand name available. Thus, we are going to 55740209230bSgjelinek * have to ask the kernel for the information. 55750209230bSgjelinek */ 55760209230bSgjelinek if (myzoneid != GLOBAL_ZONEID) { 55772ec67e04Sgjelinek if (is_system_labeled()) { 55782ec67e04Sgjelinek (void) strlcpy(brandname, NATIVE_BRAND_NAME, rp_sz); 55792ec67e04Sgjelinek return (Z_OK); 55802ec67e04Sgjelinek } 55810209230bSgjelinek if (zone_getattr(myzoneid, ZONE_ATTR_NAME, myzone, 55820209230bSgjelinek sizeof (myzone)) < 0) 55830209230bSgjelinek return (Z_NO_ZONE); 55841d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India if (!zonecfg_is_scratch(myzone)) { 55851d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India if (strncmp(zone_name, myzone, MAXNAMELEN) != 0) 55861d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India return (Z_NO_ZONE); 55871d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India } 55880209230bSgjelinek err = zone_getattr(myzoneid, ZONE_ATTR_BRAND, brandname, rp_sz); 55890209230bSgjelinek if (err < 0) 55900209230bSgjelinek return ((errno == EFAULT) ? Z_TOO_BIG : Z_INVAL); 55911d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India 55920209230bSgjelinek return (Z_OK); 55930209230bSgjelinek } 55940209230bSgjelinek 5595e5816e35SEdward Pilatowicz if (strcmp(zone_name, "global") == 0) 5596e5816e35SEdward Pilatowicz return (zonecfg_default_brand(brandname, rp_sz)); 5597e5816e35SEdward Pilatowicz 55980209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) 55990209230bSgjelinek return (Z_NOMEM); 56000209230bSgjelinek 56010209230bSgjelinek err = zonecfg_get_handle((char *)zone_name, handle); 56020209230bSgjelinek if (err == Z_OK) 56030209230bSgjelinek err = zonecfg_get_brand(handle, brandname, rp_sz); 56040209230bSgjelinek 56050209230bSgjelinek zonecfg_fini_handle(handle); 56060209230bSgjelinek return (err); 56070209230bSgjelinek } 56080209230bSgjelinek 56090209230bSgjelinek /* 56100209230bSgjelinek * Return the appropriate root for the active /dev. 56110209230bSgjelinek * For normal zone, the path is $ZONEPATH/root; 56120209230bSgjelinek * for scratch zone, the dev path is $ZONEPATH/lu. 56130209230bSgjelinek */ 56140209230bSgjelinek int 56150209230bSgjelinek zone_get_devroot(char *zone_name, char *devroot, size_t rp_sz) 56160209230bSgjelinek { 56170209230bSgjelinek int err; 56180209230bSgjelinek char *suffix; 56190209230bSgjelinek zone_state_t state; 56200209230bSgjelinek 56210209230bSgjelinek /* This function makes sense for non-global zones only. */ 56220209230bSgjelinek if (strcmp(zone_name, GLOBAL_ZONENAME) == 0) 56230209230bSgjelinek return (Z_BOGUS_ZONE_NAME); 56240209230bSgjelinek if ((err = zone_get_zonepath(zone_name, devroot, rp_sz)) != Z_OK) 56250209230bSgjelinek return (err); 56260209230bSgjelinek 56270209230bSgjelinek if (zone_get_state(zone_name, &state) == Z_OK && 56280209230bSgjelinek state == ZONE_STATE_MOUNTED) 56290209230bSgjelinek suffix = "/lu"; 56300209230bSgjelinek else 56310209230bSgjelinek suffix = "/root"; 56320209230bSgjelinek if (strlcat(devroot, suffix, rp_sz) >= rp_sz) 56330209230bSgjelinek return (Z_TOO_BIG); 56340209230bSgjelinek return (Z_OK); 56350209230bSgjelinek } 56360209230bSgjelinek 56370209230bSgjelinek static zone_state_t 56380209230bSgjelinek kernel_state_to_user_state(zoneid_t zoneid, zone_status_t kernel_state) 56390209230bSgjelinek { 56400209230bSgjelinek char zoneroot[MAXPATHLEN]; 56410209230bSgjelinek size_t zlen; 56420209230bSgjelinek 56430209230bSgjelinek assert(kernel_state <= ZONE_MAX_STATE); 56440209230bSgjelinek switch (kernel_state) { 56450209230bSgjelinek case ZONE_IS_UNINITIALIZED: 5646bd41d0a8Snordmark case ZONE_IS_INITIALIZED: 5647bd41d0a8Snordmark /* The kernel will not return these two states */ 56480209230bSgjelinek return (ZONE_STATE_READY); 56490209230bSgjelinek case ZONE_IS_READY: 56500209230bSgjelinek /* 56510209230bSgjelinek * If the zone's root is mounted on $ZONEPATH/lu, then 56520209230bSgjelinek * it's a mounted scratch zone. 56530209230bSgjelinek */ 56540209230bSgjelinek if (zone_getattr(zoneid, ZONE_ATTR_ROOT, zoneroot, 56550209230bSgjelinek sizeof (zoneroot)) >= 0) { 56560209230bSgjelinek zlen = strlen(zoneroot); 56570209230bSgjelinek if (zlen > 3 && 56580209230bSgjelinek strcmp(zoneroot + zlen - 3, "/lu") == 0) 56590209230bSgjelinek return (ZONE_STATE_MOUNTED); 56600209230bSgjelinek } 56610209230bSgjelinek return (ZONE_STATE_READY); 56620209230bSgjelinek case ZONE_IS_BOOTING: 56630209230bSgjelinek case ZONE_IS_RUNNING: 56640209230bSgjelinek return (ZONE_STATE_RUNNING); 56650209230bSgjelinek case ZONE_IS_SHUTTING_DOWN: 56660209230bSgjelinek case ZONE_IS_EMPTY: 56670209230bSgjelinek return (ZONE_STATE_SHUTTING_DOWN); 56680209230bSgjelinek case ZONE_IS_DOWN: 56690209230bSgjelinek case ZONE_IS_DYING: 56700209230bSgjelinek case ZONE_IS_DEAD: 56710209230bSgjelinek default: 56720209230bSgjelinek return (ZONE_STATE_DOWN); 56730209230bSgjelinek } 56740209230bSgjelinek /* NOTREACHED */ 56750209230bSgjelinek } 56760209230bSgjelinek 56770209230bSgjelinek int 56780209230bSgjelinek zone_get_state(char *zone_name, zone_state_t *state_num) 56790209230bSgjelinek { 56800209230bSgjelinek zone_status_t status; 56810209230bSgjelinek zoneid_t zone_id; 56820209230bSgjelinek struct zoneent *ze; 56830209230bSgjelinek boolean_t found = B_FALSE; 56840209230bSgjelinek FILE *cookie; 56850209230bSgjelinek char kernzone[ZONENAME_MAX]; 56860209230bSgjelinek FILE *fp; 56870209230bSgjelinek 56880209230bSgjelinek if (zone_name == NULL) 56890209230bSgjelinek return (Z_INVAL); 56900209230bSgjelinek 56910209230bSgjelinek /* 56920209230bSgjelinek * If we're looking at an alternate root, then we need to query the 56930209230bSgjelinek * kernel using the scratch zone name. 56940209230bSgjelinek */ 56950209230bSgjelinek zone_id = -1; 56960209230bSgjelinek if (*zonecfg_root != '\0' && !zonecfg_is_scratch(zone_name)) { 56970209230bSgjelinek if ((fp = zonecfg_open_scratch("", B_FALSE)) != NULL) { 56980209230bSgjelinek if (zonecfg_find_scratch(fp, zone_name, zonecfg_root, 56990209230bSgjelinek kernzone, sizeof (kernzone)) == 0) 57000209230bSgjelinek zone_id = getzoneidbyname(kernzone); 57010209230bSgjelinek zonecfg_close_scratch(fp); 57020209230bSgjelinek } 57030209230bSgjelinek } else { 57040209230bSgjelinek zone_id = getzoneidbyname(zone_name); 57050209230bSgjelinek } 57060209230bSgjelinek 57070209230bSgjelinek /* check to see if zone is running */ 57080209230bSgjelinek if (zone_id != -1 && 57090209230bSgjelinek zone_getattr(zone_id, ZONE_ATTR_STATUS, &status, 57100209230bSgjelinek sizeof (status)) >= 0) { 57110209230bSgjelinek *state_num = kernel_state_to_user_state(zone_id, status); 57120209230bSgjelinek return (Z_OK); 57130209230bSgjelinek } 57140209230bSgjelinek 57150209230bSgjelinek cookie = setzoneent(); 57160209230bSgjelinek while ((ze = getzoneent_private(cookie)) != NULL) { 57170209230bSgjelinek if (strcmp(ze->zone_name, zone_name) == 0) { 57180209230bSgjelinek found = B_TRUE; 57190209230bSgjelinek *state_num = ze->zone_state; 57200209230bSgjelinek } 57210209230bSgjelinek free(ze); 57220209230bSgjelinek if (found) 57230209230bSgjelinek break; 57240209230bSgjelinek } 57250209230bSgjelinek endzoneent(cookie); 57260209230bSgjelinek return ((found) ? Z_OK : Z_NO_ZONE); 57270209230bSgjelinek } 57280209230bSgjelinek 57290209230bSgjelinek int 57300209230bSgjelinek zone_set_state(char *zone, zone_state_t state) 57310209230bSgjelinek { 57320209230bSgjelinek struct zoneent ze; 57330209230bSgjelinek 57340209230bSgjelinek if (state != ZONE_STATE_CONFIGURED && state != ZONE_STATE_INSTALLED && 57350209230bSgjelinek state != ZONE_STATE_INCOMPLETE) 57360209230bSgjelinek return (Z_INVAL); 57370209230bSgjelinek 57380209230bSgjelinek bzero(&ze, sizeof (ze)); 57390209230bSgjelinek (void) strlcpy(ze.zone_name, zone, sizeof (ze.zone_name)); 57400209230bSgjelinek ze.zone_state = state; 57410209230bSgjelinek (void) strlcpy(ze.zone_path, "", sizeof (ze.zone_path)); 57420209230bSgjelinek return (putzoneent(&ze, PZE_MODIFY)); 57430209230bSgjelinek } 57440209230bSgjelinek 57450209230bSgjelinek /* 57460209230bSgjelinek * Get id (if any) for specified zone. There are four possible outcomes: 57470209230bSgjelinek * - If the string corresponds to the numeric id of an active (booted) 57480209230bSgjelinek * zone, sets *zip to the zone id and returns 0. 57490209230bSgjelinek * - If the string corresponds to the name of an active (booted) zone, 57500209230bSgjelinek * sets *zip to the zone id and returns 0. 57510209230bSgjelinek * - If the string is a name in the configuration but is not booted, 57520209230bSgjelinek * sets *zip to ZONE_ID_UNDEFINED and returns 0. 57530209230bSgjelinek * - Otherwise, leaves *zip unchanged and returns -1. 57540209230bSgjelinek * 57550209230bSgjelinek * This function acts as an auxiliary filter on the function of the same 57560209230bSgjelinek * name in libc; the linker binds to this version if libzonecfg exists, 57570209230bSgjelinek * and the libc version if it doesn't. Any changes to this version of 57580209230bSgjelinek * the function should probably be reflected in the libc version as well. 57590209230bSgjelinek */ 57600209230bSgjelinek int 57610209230bSgjelinek zone_get_id(const char *str, zoneid_t *zip) 57620209230bSgjelinek { 57630209230bSgjelinek zone_dochandle_t hdl; 57640209230bSgjelinek zoneid_t zoneid; 57650209230bSgjelinek char *cp; 57660209230bSgjelinek int err; 57670209230bSgjelinek 57680209230bSgjelinek /* first try looking for active zone by id */ 57690209230bSgjelinek errno = 0; 57700209230bSgjelinek zoneid = (zoneid_t)strtol(str, &cp, 0); 57710209230bSgjelinek if (errno == 0 && cp != str && *cp == '\0' && 57720209230bSgjelinek getzonenamebyid(zoneid, NULL, 0) != -1) { 57730209230bSgjelinek *zip = zoneid; 57740209230bSgjelinek return (0); 57750209230bSgjelinek } 57760209230bSgjelinek 57770209230bSgjelinek /* then look for active zone by name */ 57780209230bSgjelinek if ((zoneid = getzoneidbyname(str)) != -1) { 57790209230bSgjelinek *zip = zoneid; 57800209230bSgjelinek return (0); 57810209230bSgjelinek } 57820209230bSgjelinek 57830209230bSgjelinek /* if in global zone, try looking up name in configuration database */ 57840209230bSgjelinek if (getzoneid() != GLOBAL_ZONEID || 57850209230bSgjelinek (hdl = zonecfg_init_handle()) == NULL) 57860209230bSgjelinek return (-1); 57870209230bSgjelinek 57880209230bSgjelinek if (zonecfg_get_handle(str, hdl) == Z_OK) { 57890209230bSgjelinek /* zone exists but isn't active */ 57900209230bSgjelinek *zip = ZONE_ID_UNDEFINED; 57910209230bSgjelinek err = 0; 57920209230bSgjelinek } else { 57930209230bSgjelinek err = -1; 57940209230bSgjelinek } 57950209230bSgjelinek 57960209230bSgjelinek zonecfg_fini_handle(hdl); 57970209230bSgjelinek return (err); 57980209230bSgjelinek } 57990209230bSgjelinek 58000209230bSgjelinek char * 58010209230bSgjelinek zone_state_str(zone_state_t state_num) 58020209230bSgjelinek { 58030209230bSgjelinek switch (state_num) { 58040209230bSgjelinek case ZONE_STATE_CONFIGURED: 58050209230bSgjelinek return (ZONE_STATE_STR_CONFIGURED); 58060209230bSgjelinek case ZONE_STATE_INCOMPLETE: 58070209230bSgjelinek return (ZONE_STATE_STR_INCOMPLETE); 58080209230bSgjelinek case ZONE_STATE_INSTALLED: 58090209230bSgjelinek return (ZONE_STATE_STR_INSTALLED); 58100209230bSgjelinek case ZONE_STATE_READY: 58110209230bSgjelinek return (ZONE_STATE_STR_READY); 58120209230bSgjelinek case ZONE_STATE_MOUNTED: 58130209230bSgjelinek return (ZONE_STATE_STR_MOUNTED); 58140209230bSgjelinek case ZONE_STATE_RUNNING: 58150209230bSgjelinek return (ZONE_STATE_STR_RUNNING); 58160209230bSgjelinek case ZONE_STATE_SHUTTING_DOWN: 58170209230bSgjelinek return (ZONE_STATE_STR_SHUTTING_DOWN); 58180209230bSgjelinek case ZONE_STATE_DOWN: 58190209230bSgjelinek return (ZONE_STATE_STR_DOWN); 58200209230bSgjelinek default: 58210209230bSgjelinek return ("unknown"); 58220209230bSgjelinek } 58230209230bSgjelinek } 58240209230bSgjelinek 58250209230bSgjelinek /* 58260209230bSgjelinek * Given a UUID value, find an associated zone name. This is intended to be 58270209230bSgjelinek * used by callers who set up some 'default' name (corresponding to the 58280209230bSgjelinek * expected name for the zone) in the zonename buffer, and thus the function 58290209230bSgjelinek * doesn't touch this buffer on failure. 58300209230bSgjelinek */ 58310209230bSgjelinek int 58320209230bSgjelinek zonecfg_get_name_by_uuid(const uuid_t uuidin, char *zonename, size_t namelen) 58330209230bSgjelinek { 58340209230bSgjelinek FILE *fp; 58350209230bSgjelinek struct zoneent *ze; 58360209230bSgjelinek uchar_t *uuid; 58370209230bSgjelinek 58380209230bSgjelinek /* 58390209230bSgjelinek * A small amount of subterfuge via casts is necessary here because 58400209230bSgjelinek * libuuid doesn't use const correctly, but we don't want to export 58410209230bSgjelinek * this brokenness to our clients. 58420209230bSgjelinek */ 58430209230bSgjelinek uuid = (uchar_t *)uuidin; 58440209230bSgjelinek if (uuid_is_null(uuid)) 58450209230bSgjelinek return (Z_NO_ZONE); 58460209230bSgjelinek if ((fp = setzoneent()) == NULL) 58470209230bSgjelinek return (Z_NO_ZONE); 58480209230bSgjelinek while ((ze = getzoneent_private(fp)) != NULL) { 58490209230bSgjelinek if (uuid_compare(uuid, ze->zone_uuid) == 0) 58500209230bSgjelinek break; 58510209230bSgjelinek free(ze); 58520209230bSgjelinek } 58530209230bSgjelinek endzoneent(fp); 58540209230bSgjelinek if (ze != NULL) { 58550209230bSgjelinek (void) strlcpy(zonename, ze->zone_name, namelen); 58560209230bSgjelinek free(ze); 58570209230bSgjelinek return (Z_OK); 58580209230bSgjelinek } else { 58590209230bSgjelinek return (Z_NO_ZONE); 58600209230bSgjelinek } 58610209230bSgjelinek } 58620209230bSgjelinek 58630209230bSgjelinek /* 58640209230bSgjelinek * Given a zone name, get its UUID. Returns a "NULL" UUID value if the zone 58650209230bSgjelinek * exists but the file doesn't have a value set yet. Returns an error if the 58660209230bSgjelinek * zone cannot be located. 58670209230bSgjelinek */ 58680209230bSgjelinek int 58690209230bSgjelinek zonecfg_get_uuid(const char *zonename, uuid_t uuid) 58700209230bSgjelinek { 58710209230bSgjelinek FILE *fp; 58720209230bSgjelinek struct zoneent *ze; 58730209230bSgjelinek 58740209230bSgjelinek if ((fp = setzoneent()) == NULL) 58750209230bSgjelinek return (Z_NO_ZONE); 58760209230bSgjelinek while ((ze = getzoneent_private(fp)) != NULL) { 58770209230bSgjelinek if (strcmp(ze->zone_name, zonename) == 0) 58780209230bSgjelinek break; 58790209230bSgjelinek free(ze); 58800209230bSgjelinek } 58810209230bSgjelinek endzoneent(fp); 58820209230bSgjelinek if (ze != NULL) { 58830209230bSgjelinek uuid_copy(uuid, ze->zone_uuid); 58840209230bSgjelinek free(ze); 58850209230bSgjelinek return (Z_OK); 58860209230bSgjelinek } else { 58870209230bSgjelinek return (Z_NO_ZONE); 58880209230bSgjelinek } 58890209230bSgjelinek } 58900209230bSgjelinek 58910209230bSgjelinek /* 58920209230bSgjelinek * File-system convenience functions. 58930209230bSgjelinek */ 58940209230bSgjelinek boolean_t 58950209230bSgjelinek zonecfg_valid_fs_type(const char *type) 58960209230bSgjelinek { 58970209230bSgjelinek /* 58980209230bSgjelinek * We already know which FS types don't work. 58990209230bSgjelinek */ 59000209230bSgjelinek if (strcmp(type, "proc") == 0 || 59010209230bSgjelinek strcmp(type, "mntfs") == 0 || 59020209230bSgjelinek strcmp(type, "autofs") == 0 || 59030209230bSgjelinek strncmp(type, "nfs", sizeof ("nfs") - 1) == 0 || 59040209230bSgjelinek strcmp(type, "cachefs") == 0) 59050209230bSgjelinek return (B_FALSE); 59060209230bSgjelinek /* 59070209230bSgjelinek * The caller may do more detailed verification to make sure other 59080209230bSgjelinek * aspects of this filesystem type make sense. 59090209230bSgjelinek */ 59100209230bSgjelinek return (B_TRUE); 59110209230bSgjelinek } 59120209230bSgjelinek 59130209230bSgjelinek /* 59140209230bSgjelinek * Generally uninteresting rctl convenience functions. 59150209230bSgjelinek */ 59160209230bSgjelinek 59170209230bSgjelinek int 59180209230bSgjelinek zonecfg_construct_rctlblk(const struct zone_rctlvaltab *rctlval, 59190209230bSgjelinek rctlblk_t *rctlblk) 59200209230bSgjelinek { 59210209230bSgjelinek unsigned long long ull; 59220209230bSgjelinek char *endp; 59230209230bSgjelinek rctl_priv_t priv; 59240209230bSgjelinek rctl_qty_t limit; 59250209230bSgjelinek uint_t action; 59260209230bSgjelinek 59270209230bSgjelinek /* Get the privilege */ 59280209230bSgjelinek if (strcmp(rctlval->zone_rctlval_priv, "basic") == 0) { 59290209230bSgjelinek priv = RCPRIV_BASIC; 59300209230bSgjelinek } else if (strcmp(rctlval->zone_rctlval_priv, "privileged") == 0) { 59310209230bSgjelinek priv = RCPRIV_PRIVILEGED; 59320209230bSgjelinek } else { 59330209230bSgjelinek /* Invalid privilege */ 59340209230bSgjelinek return (Z_INVAL); 59350209230bSgjelinek } 59360209230bSgjelinek 59370209230bSgjelinek /* deal with negative input; strtoull(3c) doesn't do what we want */ 59380209230bSgjelinek if (rctlval->zone_rctlval_limit[0] == '-') 59390209230bSgjelinek return (Z_INVAL); 59400209230bSgjelinek /* Get the limit */ 59410209230bSgjelinek errno = 0; 59420209230bSgjelinek ull = strtoull(rctlval->zone_rctlval_limit, &endp, 0); 59430209230bSgjelinek if (errno != 0 || *endp != '\0') { 59440209230bSgjelinek /* parse failed */ 59450209230bSgjelinek return (Z_INVAL); 59460209230bSgjelinek } 59470209230bSgjelinek limit = (rctl_qty_t)ull; 59480209230bSgjelinek 59490209230bSgjelinek /* Get the action */ 59500209230bSgjelinek if (strcmp(rctlval->zone_rctlval_action, "none") == 0) { 59510209230bSgjelinek action = RCTL_LOCAL_NOACTION; 59520209230bSgjelinek } else if (strcmp(rctlval->zone_rctlval_action, "signal") == 0) { 59530209230bSgjelinek action = RCTL_LOCAL_SIGNAL; 59540209230bSgjelinek } else if (strcmp(rctlval->zone_rctlval_action, "deny") == 0) { 59550209230bSgjelinek action = RCTL_LOCAL_DENY; 59560209230bSgjelinek } else { 59570209230bSgjelinek /* Invalid Action */ 59580209230bSgjelinek return (Z_INVAL); 59590209230bSgjelinek } 59600209230bSgjelinek rctlblk_set_local_action(rctlblk, action, 0); 59610209230bSgjelinek rctlblk_set_privilege(rctlblk, priv); 59620209230bSgjelinek rctlblk_set_value(rctlblk, limit); 59630209230bSgjelinek return (Z_OK); 59640209230bSgjelinek } 59650209230bSgjelinek 59660209230bSgjelinek static int 59670209230bSgjelinek rctl_check(const char *rctlname, void *arg) 59680209230bSgjelinek { 59690209230bSgjelinek const char *attrname = arg; 59700209230bSgjelinek 59710209230bSgjelinek /* 59720209230bSgjelinek * Returning 1 here is our signal to zonecfg_is_rctl() that it is 59737c478bd9Sstevel@tonic-gate * indeed an rctl name recognized by the system. 59747c478bd9Sstevel@tonic-gate */ 59750209230bSgjelinek return (strcmp(rctlname, attrname) == 0 ? 1 : 0); 59760209230bSgjelinek } 59770209230bSgjelinek 59780209230bSgjelinek boolean_t 59790209230bSgjelinek zonecfg_is_rctl(const char *name) 59800209230bSgjelinek { 59810209230bSgjelinek return (rctl_walk(rctl_check, (void *)name) == 1); 59820209230bSgjelinek } 59830209230bSgjelinek 59840209230bSgjelinek boolean_t 59850209230bSgjelinek zonecfg_valid_rctlname(const char *name) 59860209230bSgjelinek { 59870209230bSgjelinek const char *c; 59880209230bSgjelinek 59890209230bSgjelinek if (strncmp(name, "zone.", sizeof ("zone.") - 1) != 0) 59900209230bSgjelinek return (B_FALSE); 59910209230bSgjelinek if (strlen(name) == sizeof ("zone.") - 1) 59920209230bSgjelinek return (B_FALSE); 59930209230bSgjelinek for (c = name + sizeof ("zone.") - 1; *c != '\0'; c++) { 59940209230bSgjelinek if (!isalpha(*c) && *c != '-') 59950209230bSgjelinek return (B_FALSE); 59960209230bSgjelinek } 59970209230bSgjelinek return (B_TRUE); 59980209230bSgjelinek } 59990209230bSgjelinek 60000209230bSgjelinek boolean_t 60010209230bSgjelinek zonecfg_valid_rctlblk(const rctlblk_t *rctlblk) 60020209230bSgjelinek { 60030209230bSgjelinek rctl_priv_t priv = rctlblk_get_privilege((rctlblk_t *)rctlblk); 60040209230bSgjelinek uint_t action = rctlblk_get_local_action((rctlblk_t *)rctlblk, NULL); 60050209230bSgjelinek 60060209230bSgjelinek if (priv != RCPRIV_PRIVILEGED) 60070209230bSgjelinek return (B_FALSE); 60080209230bSgjelinek if (action != RCTL_LOCAL_NOACTION && action != RCTL_LOCAL_DENY) 60090209230bSgjelinek return (B_FALSE); 60100209230bSgjelinek return (B_TRUE); 60110209230bSgjelinek } 60120209230bSgjelinek 60130209230bSgjelinek boolean_t 60140209230bSgjelinek zonecfg_valid_rctl(const char *name, const rctlblk_t *rctlblk) 60150209230bSgjelinek { 60160209230bSgjelinek rctlblk_t *current, *next; 60170209230bSgjelinek rctl_qty_t limit = rctlblk_get_value((rctlblk_t *)rctlblk); 60180209230bSgjelinek uint_t action = rctlblk_get_local_action((rctlblk_t *)rctlblk, NULL); 60190209230bSgjelinek uint_t global_flags; 60200209230bSgjelinek 60210209230bSgjelinek if (!zonecfg_valid_rctlblk(rctlblk)) 60220209230bSgjelinek return (B_FALSE); 60230209230bSgjelinek if (!zonecfg_valid_rctlname(name)) 60240209230bSgjelinek return (B_FALSE); 60250209230bSgjelinek 60260209230bSgjelinek current = alloca(rctlblk_size()); 60270209230bSgjelinek if (getrctl(name, NULL, current, RCTL_FIRST) != 0) 60280209230bSgjelinek return (B_TRUE); /* not an rctl on this system */ 60290209230bSgjelinek /* 60300209230bSgjelinek * Make sure the proposed value isn't greater than the current system 60310209230bSgjelinek * value. 60320209230bSgjelinek */ 60330209230bSgjelinek next = alloca(rctlblk_size()); 60340209230bSgjelinek while (rctlblk_get_privilege(current) != RCPRIV_SYSTEM) { 60350209230bSgjelinek rctlblk_t *tmp; 60360209230bSgjelinek 60370209230bSgjelinek if (getrctl(name, current, next, RCTL_NEXT) != 0) 60380209230bSgjelinek return (B_FALSE); /* shouldn't happen */ 60390209230bSgjelinek tmp = current; 60400209230bSgjelinek current = next; 60410209230bSgjelinek next = tmp; 60420209230bSgjelinek } 60430209230bSgjelinek if (limit > rctlblk_get_value(current)) 60440209230bSgjelinek return (B_FALSE); 60450209230bSgjelinek 60460209230bSgjelinek /* 60470209230bSgjelinek * Make sure the proposed action is allowed. 60480209230bSgjelinek */ 60490209230bSgjelinek global_flags = rctlblk_get_global_flags(current); 60500209230bSgjelinek if ((global_flags & RCTL_GLOBAL_DENY_NEVER) && 60510209230bSgjelinek action == RCTL_LOCAL_DENY) 60520209230bSgjelinek return (B_FALSE); 60530209230bSgjelinek if ((global_flags & RCTL_GLOBAL_DENY_ALWAYS) && 60540209230bSgjelinek action == RCTL_LOCAL_NOACTION) 60550209230bSgjelinek return (B_FALSE); 60560209230bSgjelinek 60570209230bSgjelinek return (B_TRUE); 60580209230bSgjelinek } 60590209230bSgjelinek 60600209230bSgjelinek /* 60610209230bSgjelinek * There is always a race condition between reading the initial copy of 60620209230bSgjelinek * a zones state and its state changing. We address this by providing 60630209230bSgjelinek * zonecfg_notify_critical_enter and zonecfg_noticy_critical_exit functions. 60640209230bSgjelinek * When zonecfg_critical_enter is called, sets the state field to LOCKED 60650209230bSgjelinek * and aquires biglock. Biglock protects against other threads executing 60660209230bSgjelinek * critical_enter and the state field protects against state changes during 60670209230bSgjelinek * the critical period. 60680209230bSgjelinek * 60690209230bSgjelinek * If any state changes occur, zn_cb will set the failed field of the znotify 60700209230bSgjelinek * structure. This will cause the critical_exit function to re-lock the 60710209230bSgjelinek * channel and return an error. Since evsnts may be delayed, the critical_exit 60720209230bSgjelinek * function "flushes" the queue by putting an event on the queue and waiting for 60730209230bSgjelinek * zn_cb to notify critical_exit that it received the ping event. 60740209230bSgjelinek */ 60750209230bSgjelinek static const char * 60760209230bSgjelinek string_get_tok(const char *in, char delim, int num) 60770209230bSgjelinek { 60780209230bSgjelinek int i = 0; 60790209230bSgjelinek 60800209230bSgjelinek for (; i < num; in++) { 60810209230bSgjelinek if (*in == delim) 60820209230bSgjelinek i++; 60830209230bSgjelinek if (*in == 0) 60840209230bSgjelinek return (NULL); 60850209230bSgjelinek } 60860209230bSgjelinek return (in); 60870209230bSgjelinek } 60880209230bSgjelinek 60890209230bSgjelinek static boolean_t 60900209230bSgjelinek is_ping(sysevent_t *ev) 60910209230bSgjelinek { 60920209230bSgjelinek if (strcmp(sysevent_get_subclass_name(ev), 60930209230bSgjelinek ZONE_EVENT_PING_SUBCLASS) == 0) { 60940209230bSgjelinek return (B_TRUE); 60950209230bSgjelinek } else { 60960209230bSgjelinek return (B_FALSE); 60970209230bSgjelinek } 60980209230bSgjelinek } 60990209230bSgjelinek 61000209230bSgjelinek static boolean_t 61010209230bSgjelinek is_my_ping(sysevent_t *ev) 61020209230bSgjelinek { 61030209230bSgjelinek const char *sender; 61040209230bSgjelinek char mypid[sizeof (pid_t) * 3 + 1]; 61050209230bSgjelinek 61060209230bSgjelinek (void) snprintf(mypid, sizeof (mypid), "%i", getpid()); 61070209230bSgjelinek sender = string_get_tok(sysevent_get_pub(ev), ':', 3); 61080209230bSgjelinek if (sender == NULL) 61090209230bSgjelinek return (B_FALSE); 61100209230bSgjelinek if (strcmp(sender, mypid) != 0) 61110209230bSgjelinek return (B_FALSE); 61120209230bSgjelinek return (B_TRUE); 61130209230bSgjelinek } 61140209230bSgjelinek 61150209230bSgjelinek static int 61160209230bSgjelinek do_callback(struct znotify *zevtchan, sysevent_t *ev) 61170209230bSgjelinek { 61180209230bSgjelinek nvlist_t *l; 61190209230bSgjelinek int zid; 61200209230bSgjelinek char *zonename; 61210209230bSgjelinek char *newstate; 61220209230bSgjelinek char *oldstate; 61230209230bSgjelinek int ret; 61240209230bSgjelinek hrtime_t when; 61250209230bSgjelinek 61260209230bSgjelinek if (strcmp(sysevent_get_subclass_name(ev), 61270209230bSgjelinek ZONE_EVENT_STATUS_SUBCLASS) == 0) { 61280209230bSgjelinek 61290209230bSgjelinek if (sysevent_get_attr_list(ev, &l) != 0) { 61300209230bSgjelinek if (errno == ENOMEM) { 61310209230bSgjelinek zevtchan->zn_failure_count++; 61320209230bSgjelinek return (EAGAIN); 61330209230bSgjelinek } 61340209230bSgjelinek return (0); 61350209230bSgjelinek } 61360209230bSgjelinek ret = 0; 61370209230bSgjelinek 61380209230bSgjelinek if ((nvlist_lookup_string(l, ZONE_CB_NAME, &zonename) == 0) && 61390209230bSgjelinek (nvlist_lookup_string(l, ZONE_CB_NEWSTATE, &newstate) 61400209230bSgjelinek == 0) && 61410209230bSgjelinek (nvlist_lookup_string(l, ZONE_CB_OLDSTATE, &oldstate) 61420209230bSgjelinek == 0) && 61430209230bSgjelinek (nvlist_lookup_uint64(l, ZONE_CB_TIMESTAMP, 61440209230bSgjelinek (uint64_t *)&when) == 0) && 61450209230bSgjelinek (nvlist_lookup_int32(l, ZONE_CB_ZONEID, &zid) == 0)) { 61460209230bSgjelinek ret = zevtchan->zn_callback(zonename, zid, newstate, 61470209230bSgjelinek oldstate, when, zevtchan->zn_private); 61480209230bSgjelinek } 61490209230bSgjelinek 61500209230bSgjelinek zevtchan->zn_failure_count = 0; 61510209230bSgjelinek nvlist_free(l); 61520209230bSgjelinek return (ret); 61530209230bSgjelinek } else { 61540209230bSgjelinek /* 61550209230bSgjelinek * We have received an event in an unknown subclass. Ignore. 61560209230bSgjelinek */ 61570209230bSgjelinek zevtchan->zn_failure_count = 0; 61580209230bSgjelinek return (0); 61590209230bSgjelinek } 61600209230bSgjelinek } 61610209230bSgjelinek 61620209230bSgjelinek static int 61630209230bSgjelinek zn_cb(sysevent_t *ev, void *p) 61640209230bSgjelinek { 61650209230bSgjelinek struct znotify *zevtchan = p; 61660209230bSgjelinek int error; 61670209230bSgjelinek 61680209230bSgjelinek (void) pthread_mutex_lock(&(zevtchan->zn_mutex)); 61690209230bSgjelinek 61700209230bSgjelinek if (is_ping(ev) && !is_my_ping(ev)) { 61710209230bSgjelinek (void) pthread_mutex_unlock((&zevtchan->zn_mutex)); 61720209230bSgjelinek return (0); 61730209230bSgjelinek } 61740209230bSgjelinek 61750209230bSgjelinek if (zevtchan->zn_state == ZN_LOCKED) { 61760209230bSgjelinek assert(!is_ping(ev)); 61770209230bSgjelinek zevtchan->zn_failed = B_TRUE; 61780209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61790209230bSgjelinek return (0); 61800209230bSgjelinek } 61810209230bSgjelinek 61820209230bSgjelinek if (zevtchan->zn_state == ZN_PING_INFLIGHT) { 61830209230bSgjelinek if (is_ping(ev)) { 61840209230bSgjelinek zevtchan->zn_state = ZN_PING_RECEIVED; 61850209230bSgjelinek (void) pthread_cond_signal(&(zevtchan->zn_cond)); 61860209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61870209230bSgjelinek return (0); 61880209230bSgjelinek } else { 61890209230bSgjelinek zevtchan->zn_failed = B_TRUE; 61900209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61910209230bSgjelinek return (0); 61920209230bSgjelinek } 61930209230bSgjelinek } 61940209230bSgjelinek 61950209230bSgjelinek if (zevtchan->zn_state == ZN_UNLOCKED) { 61960209230bSgjelinek 61970209230bSgjelinek error = do_callback(zevtchan, ev); 61980209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61990209230bSgjelinek /* 62000209230bSgjelinek * Every ENOMEM failure causes do_callback to increment 62010209230bSgjelinek * zn_failure_count and every success causes it to 62020209230bSgjelinek * set zn_failure_count to zero. If we got EAGAIN, 62030209230bSgjelinek * we will sleep for zn_failure_count seconds and return 62040209230bSgjelinek * EAGAIN to gpec to try again. 62050209230bSgjelinek * 62060209230bSgjelinek * After 55 seconds, or 10 try's we give up and drop the 62070209230bSgjelinek * event. 62080209230bSgjelinek */ 62090209230bSgjelinek if (error == EAGAIN) { 62100209230bSgjelinek if (zevtchan->zn_failure_count > ZONE_CB_RETRY_COUNT) { 62110209230bSgjelinek return (0); 62120209230bSgjelinek } 62130209230bSgjelinek (void) sleep(zevtchan->zn_failure_count); 62140209230bSgjelinek } 62150209230bSgjelinek return (error); 62160209230bSgjelinek } 62170209230bSgjelinek 62180209230bSgjelinek if (zevtchan->zn_state == ZN_PING_RECEIVED) { 62190209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 62200209230bSgjelinek return (0); 62210209230bSgjelinek } 62220209230bSgjelinek 62230209230bSgjelinek abort(); 62240209230bSgjelinek return (0); 62250209230bSgjelinek } 62260209230bSgjelinek 62270209230bSgjelinek void 62280209230bSgjelinek zonecfg_notify_critical_enter(void *h) 62290209230bSgjelinek { 62300209230bSgjelinek struct znotify *zevtchan = h; 62310209230bSgjelinek 62320209230bSgjelinek (void) pthread_mutex_lock(&(zevtchan->zn_bigmutex)); 62330209230bSgjelinek zevtchan->zn_state = ZN_LOCKED; 62340209230bSgjelinek } 62350209230bSgjelinek 62360209230bSgjelinek int 62370209230bSgjelinek zonecfg_notify_critical_exit(void * h) 62380209230bSgjelinek { 62390209230bSgjelinek 62400209230bSgjelinek struct znotify *zevtchan = h; 62410209230bSgjelinek 62420209230bSgjelinek if (zevtchan->zn_state == ZN_UNLOCKED) 62430209230bSgjelinek return (0); 62440209230bSgjelinek 62450209230bSgjelinek (void) pthread_mutex_lock(&(zevtchan->zn_mutex)); 62460209230bSgjelinek zevtchan->zn_state = ZN_PING_INFLIGHT; 62470209230bSgjelinek 62480209230bSgjelinek (void) sysevent_evc_publish(zevtchan->zn_eventchan, 62490209230bSgjelinek ZONE_EVENT_STATUS_CLASS, 62500209230bSgjelinek ZONE_EVENT_PING_SUBCLASS, ZONE_EVENT_PING_PUBLISHER, 62510209230bSgjelinek zevtchan->zn_subscriber_id, NULL, EVCH_SLEEP); 62520209230bSgjelinek 62530209230bSgjelinek while (zevtchan->zn_state != ZN_PING_RECEIVED) { 62540209230bSgjelinek (void) pthread_cond_wait(&(zevtchan->zn_cond), 62550209230bSgjelinek &(zevtchan->zn_mutex)); 62560209230bSgjelinek } 62570209230bSgjelinek 62580209230bSgjelinek if (zevtchan->zn_failed == B_TRUE) { 62590209230bSgjelinek zevtchan->zn_state = ZN_LOCKED; 62600209230bSgjelinek zevtchan->zn_failed = B_FALSE; 62610209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 62620209230bSgjelinek return (1); 62630209230bSgjelinek } 62640209230bSgjelinek 62650209230bSgjelinek zevtchan->zn_state = ZN_UNLOCKED; 62660209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 62670209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_bigmutex)); 62680209230bSgjelinek return (0); 62697c478bd9Sstevel@tonic-gate } 62707c478bd9Sstevel@tonic-gate 62710209230bSgjelinek void 62720209230bSgjelinek zonecfg_notify_critical_abort(void *h) 62737c478bd9Sstevel@tonic-gate { 62740209230bSgjelinek struct znotify *zevtchan = h; 62750209230bSgjelinek 62760209230bSgjelinek zevtchan->zn_state = ZN_UNLOCKED; 62770209230bSgjelinek zevtchan->zn_failed = B_FALSE; 62780209230bSgjelinek /* 62790209230bSgjelinek * Don't do anything about zn_lock. If it is held, it could only be 62800209230bSgjelinek * held by zn_cb and it will be unlocked soon. 62810209230bSgjelinek */ 62820209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_bigmutex)); 62837c478bd9Sstevel@tonic-gate } 62847c478bd9Sstevel@tonic-gate 62850209230bSgjelinek void * 62860209230bSgjelinek zonecfg_notify_bind(int(*func)(const char *zonename, zoneid_t zid, 62870209230bSgjelinek const char *newstate, const char *oldstate, hrtime_t when, void *p), 62880209230bSgjelinek void *p) 62897c478bd9Sstevel@tonic-gate { 62900209230bSgjelinek struct znotify *zevtchan; 62910209230bSgjelinek int i = 1; 62920209230bSgjelinek int r; 62937c478bd9Sstevel@tonic-gate 62940209230bSgjelinek zevtchan = malloc(sizeof (struct znotify)); 62950209230bSgjelinek 62960209230bSgjelinek if (zevtchan == NULL) 62970209230bSgjelinek return (NULL); 62980209230bSgjelinek 62990209230bSgjelinek zevtchan->zn_private = p; 63000209230bSgjelinek zevtchan->zn_callback = func; 63010209230bSgjelinek zevtchan->zn_state = ZN_UNLOCKED; 63020209230bSgjelinek zevtchan->zn_failed = B_FALSE; 63030209230bSgjelinek 63040209230bSgjelinek if (pthread_mutex_init(&(zevtchan->zn_mutex), NULL)) 63050209230bSgjelinek goto out3; 63060209230bSgjelinek if (pthread_cond_init(&(zevtchan->zn_cond), NULL)) { 63070209230bSgjelinek (void) pthread_mutex_destroy(&(zevtchan->zn_mutex)); 63080209230bSgjelinek goto out3; 63090209230bSgjelinek } 63100209230bSgjelinek if (pthread_mutex_init(&(zevtchan->zn_bigmutex), NULL)) { 63110209230bSgjelinek (void) pthread_mutex_destroy(&(zevtchan->zn_mutex)); 63120209230bSgjelinek (void) pthread_cond_destroy(&(zevtchan->zn_cond)); 63130209230bSgjelinek goto out3; 63147c478bd9Sstevel@tonic-gate } 63157c478bd9Sstevel@tonic-gate 63160209230bSgjelinek if (sysevent_evc_bind(ZONE_EVENT_CHANNEL, &(zevtchan->zn_eventchan), 63170209230bSgjelinek 0) != 0) 63180209230bSgjelinek goto out2; 63197c478bd9Sstevel@tonic-gate 63200209230bSgjelinek do { 63210209230bSgjelinek /* 63220209230bSgjelinek * At 4 digits the subscriber ID gets too long and we have 63230209230bSgjelinek * no chance of successfully registering. 63240209230bSgjelinek */ 63250209230bSgjelinek if (i > 999) 63260209230bSgjelinek goto out1; 63270209230bSgjelinek 63280209230bSgjelinek (void) sprintf(zevtchan->zn_subscriber_id, "zone_%li_%i", 63290209230bSgjelinek getpid() % 999999l, i); 63300209230bSgjelinek 63310209230bSgjelinek r = sysevent_evc_subscribe(zevtchan->zn_eventchan, 63320209230bSgjelinek zevtchan->zn_subscriber_id, ZONE_EVENT_STATUS_CLASS, zn_cb, 63330209230bSgjelinek zevtchan, 0); 63340209230bSgjelinek 63350209230bSgjelinek i++; 63360209230bSgjelinek 63370209230bSgjelinek } while (r); 63380209230bSgjelinek 63390209230bSgjelinek return (zevtchan); 63400209230bSgjelinek out1: 634149b225e1SGavin Maltby (void) sysevent_evc_unbind(zevtchan->zn_eventchan); 63420209230bSgjelinek out2: 63430209230bSgjelinek (void) pthread_mutex_destroy(&zevtchan->zn_mutex); 63440209230bSgjelinek (void) pthread_cond_destroy(&zevtchan->zn_cond); 63450209230bSgjelinek (void) pthread_mutex_destroy(&(zevtchan->zn_bigmutex)); 63460209230bSgjelinek out3: 63470209230bSgjelinek free(zevtchan); 63480209230bSgjelinek 63490209230bSgjelinek return (NULL); 63507c478bd9Sstevel@tonic-gate } 63517c478bd9Sstevel@tonic-gate 63520209230bSgjelinek void 63530209230bSgjelinek zonecfg_notify_unbind(void *handle) 63547c478bd9Sstevel@tonic-gate { 63557c478bd9Sstevel@tonic-gate 63560209230bSgjelinek int ret; 63577c478bd9Sstevel@tonic-gate 635849b225e1SGavin Maltby (void) sysevent_evc_unbind(((struct znotify *)handle)->zn_eventchan); 63597c478bd9Sstevel@tonic-gate /* 63600209230bSgjelinek * Check that all evc threads have gone away. This should be 63610209230bSgjelinek * enforced by sysevent_evc_unbind. 63627c478bd9Sstevel@tonic-gate */ 63630209230bSgjelinek ret = pthread_mutex_trylock(&((struct znotify *)handle)->zn_mutex); 63647c478bd9Sstevel@tonic-gate 63650209230bSgjelinek if (ret) 63660209230bSgjelinek abort(); 63677c478bd9Sstevel@tonic-gate 63680209230bSgjelinek (void) pthread_mutex_unlock(&((struct znotify *)handle)->zn_mutex); 63690209230bSgjelinek (void) pthread_mutex_destroy(&((struct znotify *)handle)->zn_mutex); 63700209230bSgjelinek (void) pthread_cond_destroy(&((struct znotify *)handle)->zn_cond); 63710209230bSgjelinek (void) pthread_mutex_destroy(&((struct znotify *)handle)->zn_bigmutex); 63727c478bd9Sstevel@tonic-gate 63730209230bSgjelinek free(handle); 63747c478bd9Sstevel@tonic-gate } 6375fa9e4066Sahrens 63760209230bSgjelinek static int 63770209230bSgjelinek zonecfg_add_ds_core(zone_dochandle_t handle, struct zone_dstab *tabptr) 6378cf8f45c7Sdstaff { 63790209230bSgjelinek xmlNodePtr newnode, cur = handle->zone_dh_cur; 63800209230bSgjelinek int err; 6381cf8f45c7Sdstaff 63820209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_DATASET, NULL); 63830209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_NAME, 63840209230bSgjelinek tabptr->zone_dataset_name)) != Z_OK) 63850209230bSgjelinek return (err); 63860209230bSgjelinek return (Z_OK); 6387cf8f45c7Sdstaff } 6388cf8f45c7Sdstaff 63890209230bSgjelinek int 63900209230bSgjelinek zonecfg_add_ds(zone_dochandle_t handle, struct zone_dstab *tabptr) 6391cf8f45c7Sdstaff { 63920209230bSgjelinek int err; 63930209230bSgjelinek 63940209230bSgjelinek if (tabptr == NULL) 63950209230bSgjelinek return (Z_INVAL); 63960209230bSgjelinek 63970209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 63980209230bSgjelinek return (err); 63990209230bSgjelinek 64000209230bSgjelinek if ((err = zonecfg_add_ds_core(handle, tabptr)) != Z_OK) 64010209230bSgjelinek return (err); 64020209230bSgjelinek 64030209230bSgjelinek return (Z_OK); 64040209230bSgjelinek } 64050209230bSgjelinek 64060209230bSgjelinek static int 64070209230bSgjelinek zonecfg_delete_ds_core(zone_dochandle_t handle, struct zone_dstab *tabptr) 64080209230bSgjelinek { 64090209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 64100209230bSgjelinek 64110209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 64120209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_DATASET)) 64130209230bSgjelinek continue; 64140209230bSgjelinek 64150209230bSgjelinek if (match_prop(cur, DTD_ATTR_NAME, 64160209230bSgjelinek tabptr->zone_dataset_name)) { 64170209230bSgjelinek xmlUnlinkNode(cur); 64180209230bSgjelinek xmlFreeNode(cur); 64190209230bSgjelinek return (Z_OK); 64200209230bSgjelinek } 6421cf8f45c7Sdstaff } 64220209230bSgjelinek return (Z_NO_RESOURCE_ID); 64230209230bSgjelinek } 64240209230bSgjelinek 64250209230bSgjelinek int 64260209230bSgjelinek zonecfg_delete_ds(zone_dochandle_t handle, struct zone_dstab *tabptr) 64270209230bSgjelinek { 64280209230bSgjelinek int err; 64290209230bSgjelinek 64300209230bSgjelinek if (tabptr == NULL) 64310209230bSgjelinek return (Z_INVAL); 64320209230bSgjelinek 64330209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 64340209230bSgjelinek return (err); 64350209230bSgjelinek 64360209230bSgjelinek if ((err = zonecfg_delete_ds_core(handle, tabptr)) != Z_OK) 64370209230bSgjelinek return (err); 64380209230bSgjelinek 64390209230bSgjelinek return (Z_OK); 6440cf8f45c7Sdstaff } 6441cf8f45c7Sdstaff 64420209230bSgjelinek int 64430209230bSgjelinek zonecfg_modify_ds( 64440209230bSgjelinek zone_dochandle_t handle, 64450209230bSgjelinek struct zone_dstab *oldtabptr, 64460209230bSgjelinek struct zone_dstab *newtabptr) 64470209230bSgjelinek { 64480209230bSgjelinek int err; 64490209230bSgjelinek 64500209230bSgjelinek if (oldtabptr == NULL || newtabptr == NULL) 64510209230bSgjelinek return (Z_INVAL); 64520209230bSgjelinek 64530209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 64540209230bSgjelinek return (err); 6455cf8f45c7Sdstaff 64560209230bSgjelinek if ((err = zonecfg_delete_ds_core(handle, oldtabptr)) != Z_OK) 64570209230bSgjelinek return (err); 64580209230bSgjelinek 64590209230bSgjelinek if ((err = zonecfg_add_ds_core(handle, newtabptr)) != Z_OK) 64600209230bSgjelinek return (err); 64610209230bSgjelinek 64620209230bSgjelinek return (Z_OK); 6463cf8f45c7Sdstaff } 6464cf8f45c7Sdstaff 64650209230bSgjelinek int 64660209230bSgjelinek zonecfg_lookup_ds(zone_dochandle_t handle, struct zone_dstab *tabptr) 6467cf8f45c7Sdstaff { 64680209230bSgjelinek xmlNodePtr cur, firstmatch; 64690209230bSgjelinek int err; 64700209230bSgjelinek char dataset[MAXNAMELEN]; 6471cf8f45c7Sdstaff 64720209230bSgjelinek if (tabptr == NULL) 64730209230bSgjelinek return (Z_INVAL); 6474cf8f45c7Sdstaff 64750209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 64760209230bSgjelinek return (err); 64770209230bSgjelinek 64780209230bSgjelinek cur = handle->zone_dh_cur; 64790209230bSgjelinek firstmatch = NULL; 64800209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 64810209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_DATASET)) 64820209230bSgjelinek continue; 64830209230bSgjelinek if (strlen(tabptr->zone_dataset_name) > 0) { 64840209230bSgjelinek if ((fetchprop(cur, DTD_ATTR_NAME, dataset, 64850209230bSgjelinek sizeof (dataset)) == Z_OK) && 64860209230bSgjelinek (strcmp(tabptr->zone_dataset_name, 64870209230bSgjelinek dataset) == 0)) { 64880209230bSgjelinek if (firstmatch == NULL) 64890209230bSgjelinek firstmatch = cur; 64900209230bSgjelinek else 64910209230bSgjelinek return (Z_INSUFFICIENT_SPEC); 6492cf8f45c7Sdstaff } 6493cf8f45c7Sdstaff } 64940209230bSgjelinek } 64950209230bSgjelinek if (firstmatch == NULL) 64960209230bSgjelinek return (Z_NO_RESOURCE_ID); 6497cf8f45c7Sdstaff 64980209230bSgjelinek cur = firstmatch; 6499cf8f45c7Sdstaff 65000209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_dataset_name, 65010209230bSgjelinek sizeof (tabptr->zone_dataset_name))) != Z_OK) 65020209230bSgjelinek return (err); 65030209230bSgjelinek 65040209230bSgjelinek return (Z_OK); 6505cf8f45c7Sdstaff } 6506cf8f45c7Sdstaff 65070209230bSgjelinek int 65080209230bSgjelinek zonecfg_setdsent(zone_dochandle_t handle) 6509cf8f45c7Sdstaff { 65100209230bSgjelinek return (zonecfg_setent(handle)); 65110209230bSgjelinek } 6512cf8f45c7Sdstaff 65130209230bSgjelinek int 65140209230bSgjelinek zonecfg_getdsent(zone_dochandle_t handle, struct zone_dstab *tabptr) 65150209230bSgjelinek { 65160209230bSgjelinek xmlNodePtr cur; 65170209230bSgjelinek int err; 6518cf8f45c7Sdstaff 65190209230bSgjelinek if (handle == NULL) 65200209230bSgjelinek return (Z_INVAL); 6521cf8f45c7Sdstaff 65220209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 65230209230bSgjelinek return (Z_NO_ENTRY); 6524cf8f45c7Sdstaff 65250209230bSgjelinek for (; cur != NULL; cur = cur->next) 65260209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_DATASET)) 65270209230bSgjelinek break; 65280209230bSgjelinek if (cur == NULL) { 65290209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 65300209230bSgjelinek return (Z_NO_ENTRY); 6531cf8f45c7Sdstaff } 6532cf8f45c7Sdstaff 65330209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_dataset_name, 65340209230bSgjelinek sizeof (tabptr->zone_dataset_name))) != Z_OK) { 65350209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 65360209230bSgjelinek return (err); 6537cf8f45c7Sdstaff } 6538cf8f45c7Sdstaff 65390209230bSgjelinek handle->zone_dh_cur = cur->next; 65400209230bSgjelinek return (Z_OK); 6541cf8f45c7Sdstaff } 6542cf8f45c7Sdstaff 65430209230bSgjelinek int 65440209230bSgjelinek zonecfg_enddsent(zone_dochandle_t handle) 6545cf8f45c7Sdstaff { 65460209230bSgjelinek return (zonecfg_endent(handle)); 6547cf8f45c7Sdstaff } 6548cf8f45c7Sdstaff 65490209230bSgjelinek /* 65500209230bSgjelinek * Support for aliased rctls; that is, rctls that have simplified names in 65510209230bSgjelinek * zonecfg. For example, max-lwps is an alias for a well defined zone.max-lwps 65520209230bSgjelinek * rctl. If there are multiple existing values for one of these rctls or if 65530209230bSgjelinek * there is a single value that does not match the well defined template (i.e. 65540209230bSgjelinek * it has a different action) then we cannot treat the rctl as having an alias 65550209230bSgjelinek * so we return Z_ALIAS_DISALLOW. That means that the rctl cannot be 65560209230bSgjelinek * managed in zonecfg via an alias and that the standard rctl syntax must be 65570209230bSgjelinek * used. 65580209230bSgjelinek * 65590209230bSgjelinek * The possible return values are: 65600209230bSgjelinek * Z_NO_PROPERTY_ID - invalid alias name 65610209230bSgjelinek * Z_ALIAS_DISALLOW - pre-existing, incompatible rctl definition 65620209230bSgjelinek * Z_NO_ENTRY - no rctl is configured for this alias 65630209230bSgjelinek * Z_OK - we got a valid rctl for the specified alias 65640209230bSgjelinek */ 6565cf8f45c7Sdstaff int 65660209230bSgjelinek zonecfg_get_aliased_rctl(zone_dochandle_t handle, char *name, uint64_t *rval) 6567cf8f45c7Sdstaff { 65680209230bSgjelinek boolean_t found = B_FALSE; 65690209230bSgjelinek boolean_t found_val = B_FALSE; 65700209230bSgjelinek xmlNodePtr cur, val; 65710209230bSgjelinek char savedname[MAXNAMELEN]; 65720209230bSgjelinek struct zone_rctlvaltab rctl; 65730209230bSgjelinek int i; 65740209230bSgjelinek int err; 6575cf8f45c7Sdstaff 65760209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 65770209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 65780209230bSgjelinek break; 6579cf8f45c7Sdstaff 65800209230bSgjelinek if (aliases[i].shortname == NULL) 65810209230bSgjelinek return (Z_NO_PROPERTY_ID); 6582cf8f45c7Sdstaff 65830209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 65840209230bSgjelinek return (err); 6585cf8f45c7Sdstaff 65860209230bSgjelinek cur = handle->zone_dh_cur; 65870209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 65880209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_RCTL) != 0) 65890209230bSgjelinek continue; 65900209230bSgjelinek if ((fetchprop(cur, DTD_ATTR_NAME, savedname, 65910209230bSgjelinek sizeof (savedname)) == Z_OK) && 65920209230bSgjelinek (strcmp(savedname, aliases[i].realname) == 0)) { 6593cf8f45c7Sdstaff 65940209230bSgjelinek /* 65950209230bSgjelinek * If we already saw one of these, we can't have an 65960209230bSgjelinek * alias since we just found another. 65970209230bSgjelinek */ 65980209230bSgjelinek if (found) 65990209230bSgjelinek return (Z_ALIAS_DISALLOW); 66000209230bSgjelinek found = B_TRUE; 66010209230bSgjelinek 66020209230bSgjelinek for (val = cur->xmlChildrenNode; val != NULL; 66030209230bSgjelinek val = val->next) { 66040209230bSgjelinek /* 66050209230bSgjelinek * If we already have one value, we can't have 66060209230bSgjelinek * an alias since we just found another. 66070209230bSgjelinek */ 66080209230bSgjelinek if (found_val) 66090209230bSgjelinek return (Z_ALIAS_DISALLOW); 66100209230bSgjelinek found_val = B_TRUE; 66110209230bSgjelinek 66120209230bSgjelinek if ((fetchprop(val, DTD_ATTR_PRIV, 66130209230bSgjelinek rctl.zone_rctlval_priv, 66140209230bSgjelinek sizeof (rctl.zone_rctlval_priv)) != Z_OK)) 66150209230bSgjelinek break; 66160209230bSgjelinek if ((fetchprop(val, DTD_ATTR_LIMIT, 66170209230bSgjelinek rctl.zone_rctlval_limit, 66180209230bSgjelinek sizeof (rctl.zone_rctlval_limit)) != Z_OK)) 66190209230bSgjelinek break; 66200209230bSgjelinek if ((fetchprop(val, DTD_ATTR_ACTION, 66210209230bSgjelinek rctl.zone_rctlval_action, 66220209230bSgjelinek sizeof (rctl.zone_rctlval_action)) != Z_OK)) 66230209230bSgjelinek break; 66240209230bSgjelinek } 66250209230bSgjelinek 66260209230bSgjelinek /* check priv and action match the expected vals */ 66270209230bSgjelinek if (strcmp(rctl.zone_rctlval_priv, 66280209230bSgjelinek aliases[i].priv) != 0 || 66290209230bSgjelinek strcmp(rctl.zone_rctlval_action, 66300209230bSgjelinek aliases[i].action) != 0) 66310209230bSgjelinek return (Z_ALIAS_DISALLOW); 66320209230bSgjelinek } 6633cf8f45c7Sdstaff } 6634cf8f45c7Sdstaff 66350209230bSgjelinek if (found) { 66360209230bSgjelinek *rval = strtoull(rctl.zone_rctlval_limit, NULL, 10); 66370209230bSgjelinek return (Z_OK); 6638cf8f45c7Sdstaff } 6639cf8f45c7Sdstaff 66400209230bSgjelinek return (Z_NO_ENTRY); 6641cf8f45c7Sdstaff } 6642cf8f45c7Sdstaff 66430209230bSgjelinek int 66440209230bSgjelinek zonecfg_rm_aliased_rctl(zone_dochandle_t handle, char *name) 6645cf8f45c7Sdstaff { 66460209230bSgjelinek int i; 66470209230bSgjelinek uint64_t val; 66480209230bSgjelinek struct zone_rctltab rctltab; 6649cf8f45c7Sdstaff 6650cf8f45c7Sdstaff /* 66510209230bSgjelinek * First check that we have a valid aliased rctl to remove. 66520209230bSgjelinek * This will catch an rctl entry with non-standard values or 66530209230bSgjelinek * multiple rctl values for this name. We need to ignore those 66540209230bSgjelinek * rctl entries. 6655cf8f45c7Sdstaff */ 66560209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, name, &val) != Z_OK) 66570209230bSgjelinek return (Z_OK); 66580209230bSgjelinek 66590209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 66600209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 66610209230bSgjelinek break; 66620209230bSgjelinek 66630209230bSgjelinek if (aliases[i].shortname == NULL) 66640209230bSgjelinek return (Z_NO_RESOURCE_ID); 66650209230bSgjelinek 66660209230bSgjelinek (void) strlcpy(rctltab.zone_rctl_name, aliases[i].realname, 66670209230bSgjelinek sizeof (rctltab.zone_rctl_name)); 66680209230bSgjelinek 66690209230bSgjelinek return (zonecfg_delete_rctl(handle, &rctltab)); 66700209230bSgjelinek } 66710209230bSgjelinek 66720209230bSgjelinek boolean_t 66730209230bSgjelinek zonecfg_aliased_rctl_ok(zone_dochandle_t handle, char *name) 66740209230bSgjelinek { 66750209230bSgjelinek uint64_t tmp_val; 66760209230bSgjelinek 66770209230bSgjelinek switch (zonecfg_get_aliased_rctl(handle, name, &tmp_val)) { 66780209230bSgjelinek case Z_OK: 66790209230bSgjelinek /*FALLTHRU*/ 66800209230bSgjelinek case Z_NO_ENTRY: 66810209230bSgjelinek return (B_TRUE); 66820209230bSgjelinek default: 66830209230bSgjelinek return (B_FALSE); 66840209230bSgjelinek } 6685cf8f45c7Sdstaff } 6686cf8f45c7Sdstaff 66870209230bSgjelinek int 66880209230bSgjelinek zonecfg_set_aliased_rctl(zone_dochandle_t handle, char *name, uint64_t val) 6689cf8f45c7Sdstaff { 66900209230bSgjelinek int i; 66910209230bSgjelinek int err; 66920209230bSgjelinek struct zone_rctltab rctltab; 66930209230bSgjelinek struct zone_rctlvaltab *rctlvaltab; 66940209230bSgjelinek char buf[128]; 6695cf8f45c7Sdstaff 66960209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, name)) 66970209230bSgjelinek return (Z_ALIAS_DISALLOW); 6698cf8f45c7Sdstaff 66990209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 67000209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 67010209230bSgjelinek break; 6702cf8f45c7Sdstaff 67030209230bSgjelinek if (aliases[i].shortname == NULL) 67040209230bSgjelinek return (Z_NO_RESOURCE_ID); 6705cf8f45c7Sdstaff 67060209230bSgjelinek /* remove any pre-existing definition for this rctl */ 67070209230bSgjelinek (void) zonecfg_rm_aliased_rctl(handle, name); 6708cf8f45c7Sdstaff 67090209230bSgjelinek (void) strlcpy(rctltab.zone_rctl_name, aliases[i].realname, 67100209230bSgjelinek sizeof (rctltab.zone_rctl_name)); 6711cf8f45c7Sdstaff 67120209230bSgjelinek rctltab.zone_rctl_valptr = NULL; 6713cf8f45c7Sdstaff 67140209230bSgjelinek if ((rctlvaltab = calloc(1, sizeof (struct zone_rctlvaltab))) == NULL) 67150209230bSgjelinek return (Z_NOMEM); 6716cf8f45c7Sdstaff 67170209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", (long long)val); 6718cf8f45c7Sdstaff 67190209230bSgjelinek (void) strlcpy(rctlvaltab->zone_rctlval_priv, aliases[i].priv, 67200209230bSgjelinek sizeof (rctlvaltab->zone_rctlval_priv)); 67210209230bSgjelinek (void) strlcpy(rctlvaltab->zone_rctlval_limit, buf, 67220209230bSgjelinek sizeof (rctlvaltab->zone_rctlval_limit)); 67230209230bSgjelinek (void) strlcpy(rctlvaltab->zone_rctlval_action, aliases[i].action, 67240209230bSgjelinek sizeof (rctlvaltab->zone_rctlval_action)); 6725cf8f45c7Sdstaff 67260209230bSgjelinek rctlvaltab->zone_rctlval_next = NULL; 6727cf8f45c7Sdstaff 67280209230bSgjelinek if ((err = zonecfg_add_rctl_value(&rctltab, rctlvaltab)) != Z_OK) 67290209230bSgjelinek return (err); 6730cf8f45c7Sdstaff 67310209230bSgjelinek return (zonecfg_add_rctl(handle, &rctltab)); 6732cf8f45c7Sdstaff } 6733cf8f45c7Sdstaff 67340209230bSgjelinek static int 67350209230bSgjelinek delete_tmp_pool(zone_dochandle_t handle) 6736cf8f45c7Sdstaff { 67370209230bSgjelinek int err; 67380209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 6739cf8f45c7Sdstaff 67400209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 67410209230bSgjelinek return (err); 6742cf8f45c7Sdstaff 67430209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 67440209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_TMPPOOL) == 0) { 67450209230bSgjelinek xmlUnlinkNode(cur); 67460209230bSgjelinek xmlFreeNode(cur); 67470209230bSgjelinek return (Z_OK); 67480209230bSgjelinek } 67490209230bSgjelinek } 6750cf8f45c7Sdstaff 67510209230bSgjelinek return (Z_NO_RESOURCE_ID); 67520209230bSgjelinek } 6753cf8f45c7Sdstaff 67540209230bSgjelinek static int 67550209230bSgjelinek modify_tmp_pool(zone_dochandle_t handle, char *pool_importance) 67560209230bSgjelinek { 67570209230bSgjelinek int err; 67580209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 67590209230bSgjelinek xmlNodePtr newnode; 6760cf8f45c7Sdstaff 67610209230bSgjelinek err = delete_tmp_pool(handle); 67620209230bSgjelinek if (err != Z_OK && err != Z_NO_RESOURCE_ID) 67630209230bSgjelinek return (err); 67640209230bSgjelinek 67650209230bSgjelinek if (*pool_importance != '\0') { 67660209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 67670209230bSgjelinek return (err); 67680209230bSgjelinek 67690209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_TMPPOOL, NULL); 67700209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_IMPORTANCE, 67710209230bSgjelinek pool_importance)) != Z_OK) 67720209230bSgjelinek return (err); 67730209230bSgjelinek } 67740209230bSgjelinek 67750209230bSgjelinek return (Z_OK); 6776cf8f45c7Sdstaff } 6777cf8f45c7Sdstaff 6778fa9e4066Sahrens static int 67790209230bSgjelinek add_pset_core(zone_dochandle_t handle, struct zone_psettab *tabptr) 6780fa9e4066Sahrens { 6781fa9e4066Sahrens xmlNodePtr newnode, cur = handle->zone_dh_cur; 6782fa9e4066Sahrens int err; 6783fa9e4066Sahrens 67840209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_PSET, NULL); 67850209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_NCPU_MIN, 67860209230bSgjelinek tabptr->zone_ncpu_min)) != Z_OK) 67870209230bSgjelinek return (err); 67880209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_NCPU_MAX, 67890209230bSgjelinek tabptr->zone_ncpu_max)) != Z_OK) 67900209230bSgjelinek return (err); 67910209230bSgjelinek 67920209230bSgjelinek if ((err = modify_tmp_pool(handle, tabptr->zone_importance)) != Z_OK) 6793fa9e4066Sahrens return (err); 67940209230bSgjelinek 6795fa9e4066Sahrens return (Z_OK); 6796fa9e4066Sahrens } 6797fa9e4066Sahrens 6798fa9e4066Sahrens int 67990209230bSgjelinek zonecfg_add_pset(zone_dochandle_t handle, struct zone_psettab *tabptr) 6800fa9e4066Sahrens { 6801fa9e4066Sahrens int err; 6802fa9e4066Sahrens 6803fa9e4066Sahrens if (tabptr == NULL) 6804fa9e4066Sahrens return (Z_INVAL); 6805fa9e4066Sahrens 6806fa9e4066Sahrens if ((err = operation_prep(handle)) != Z_OK) 6807fa9e4066Sahrens return (err); 6808fa9e4066Sahrens 68090209230bSgjelinek if ((err = add_pset_core(handle, tabptr)) != Z_OK) 6810fa9e4066Sahrens return (err); 6811fa9e4066Sahrens 6812fa9e4066Sahrens return (Z_OK); 6813fa9e4066Sahrens } 6814fa9e4066Sahrens 68150209230bSgjelinek int 68160209230bSgjelinek zonecfg_delete_pset(zone_dochandle_t handle) 6817fa9e4066Sahrens { 68180209230bSgjelinek int err; 68190209230bSgjelinek int res = Z_NO_RESOURCE_ID; 6820fa9e4066Sahrens xmlNodePtr cur = handle->zone_dh_cur; 6821fa9e4066Sahrens 68220209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 68230209230bSgjelinek return (err); 6824fa9e4066Sahrens 68250209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 68260209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_PSET) == 0) { 6827fa9e4066Sahrens xmlUnlinkNode(cur); 6828fa9e4066Sahrens xmlFreeNode(cur); 68290209230bSgjelinek res = Z_OK; 68300209230bSgjelinek break; 6831fa9e4066Sahrens } 6832fa9e4066Sahrens } 68330209230bSgjelinek 68340209230bSgjelinek /* 68350209230bSgjelinek * Once we have msets, we should check that a mset 68360209230bSgjelinek * do not exist before we delete the tmp_pool data. 68370209230bSgjelinek */ 68380209230bSgjelinek err = delete_tmp_pool(handle); 68390209230bSgjelinek if (err != Z_OK && err != Z_NO_RESOURCE_ID) 68400209230bSgjelinek return (err); 68410209230bSgjelinek 68420209230bSgjelinek return (res); 6843fa9e4066Sahrens } 6844fa9e4066Sahrens 6845fa9e4066Sahrens int 68460209230bSgjelinek zonecfg_modify_pset(zone_dochandle_t handle, struct zone_psettab *tabptr) 6847fa9e4066Sahrens { 6848fa9e4066Sahrens int err; 6849fa9e4066Sahrens 6850fa9e4066Sahrens if (tabptr == NULL) 6851fa9e4066Sahrens return (Z_INVAL); 6852fa9e4066Sahrens 68530209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 6854fa9e4066Sahrens return (err); 6855fa9e4066Sahrens 68560209230bSgjelinek if ((err = add_pset_core(handle, tabptr)) != Z_OK) 6857fa9e4066Sahrens return (err); 6858fa9e4066Sahrens 6859fa9e4066Sahrens return (Z_OK); 6860fa9e4066Sahrens } 6861fa9e4066Sahrens 6862fa9e4066Sahrens int 68630209230bSgjelinek zonecfg_lookup_pset(zone_dochandle_t handle, struct zone_psettab *tabptr) 6864fa9e4066Sahrens { 68650209230bSgjelinek xmlNodePtr cur; 6866fa9e4066Sahrens int err; 68670209230bSgjelinek int res = Z_NO_ENTRY; 6868fa9e4066Sahrens 68690209230bSgjelinek if (tabptr == NULL) 6870fa9e4066Sahrens return (Z_INVAL); 6871fa9e4066Sahrens 6872fa9e4066Sahrens if ((err = operation_prep(handle)) != Z_OK) 6873fa9e4066Sahrens return (err); 6874fa9e4066Sahrens 68750209230bSgjelinek /* this is an optional component */ 68760209230bSgjelinek tabptr->zone_importance[0] = '\0'; 68770209230bSgjelinek 68780209230bSgjelinek cur = handle->zone_dh_cur; 68790209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 68800209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_PSET) == 0) { 68810209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NCPU_MIN, 68820209230bSgjelinek tabptr->zone_ncpu_min, 68830209230bSgjelinek sizeof (tabptr->zone_ncpu_min))) != Z_OK) { 68840209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 68850209230bSgjelinek return (err); 68860209230bSgjelinek } 68870209230bSgjelinek 68880209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NCPU_MAX, 68890209230bSgjelinek tabptr->zone_ncpu_max, 68900209230bSgjelinek sizeof (tabptr->zone_ncpu_max))) != Z_OK) { 68910209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 68920209230bSgjelinek return (err); 68930209230bSgjelinek } 68940209230bSgjelinek 68950209230bSgjelinek res = Z_OK; 68960209230bSgjelinek 68970209230bSgjelinek } else if (xmlStrcmp(cur->name, DTD_ELEM_TMPPOOL) == 0) { 68980209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_IMPORTANCE, 68990209230bSgjelinek tabptr->zone_importance, 69000209230bSgjelinek sizeof (tabptr->zone_importance))) != Z_OK) { 69010209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 69020209230bSgjelinek return (err); 69030209230bSgjelinek } 69040209230bSgjelinek } 69050209230bSgjelinek } 69060209230bSgjelinek 69070209230bSgjelinek return (res); 69080209230bSgjelinek } 69090209230bSgjelinek 69100209230bSgjelinek int 69110209230bSgjelinek zonecfg_getpsetent(zone_dochandle_t handle, struct zone_psettab *tabptr) 69120209230bSgjelinek { 69130209230bSgjelinek int err; 69140209230bSgjelinek 69150209230bSgjelinek if ((err = zonecfg_setent(handle)) != Z_OK) 6916fa9e4066Sahrens return (err); 6917fa9e4066Sahrens 69180209230bSgjelinek err = zonecfg_lookup_pset(handle, tabptr); 69190209230bSgjelinek 69200209230bSgjelinek (void) zonecfg_endent(handle); 69210209230bSgjelinek 69220209230bSgjelinek return (err); 69230209230bSgjelinek } 69240209230bSgjelinek 69250209230bSgjelinek static int 69260209230bSgjelinek add_mcap(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 69270209230bSgjelinek { 69280209230bSgjelinek xmlNodePtr newnode, cur = handle->zone_dh_cur; 69290209230bSgjelinek int err; 69300209230bSgjelinek 69310209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_MCAP, NULL); 69320209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_PHYSCAP, tabptr->zone_physmem_cap)) 69330209230bSgjelinek != Z_OK) 6934fa9e4066Sahrens return (err); 6935fa9e4066Sahrens 6936fa9e4066Sahrens return (Z_OK); 6937fa9e4066Sahrens } 6938fa9e4066Sahrens 6939fa9e4066Sahrens int 69400209230bSgjelinek zonecfg_delete_mcap(zone_dochandle_t handle) 6941fa9e4066Sahrens { 6942fa9e4066Sahrens int err; 69430209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 6944fa9e4066Sahrens 6945fa9e4066Sahrens if ((err = operation_prep(handle)) != Z_OK) 6946fa9e4066Sahrens return (err); 6947fa9e4066Sahrens 6948fa9e4066Sahrens for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 69490209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_MCAP) != 0) 6950fa9e4066Sahrens continue; 69510209230bSgjelinek 69520209230bSgjelinek xmlUnlinkNode(cur); 69530209230bSgjelinek xmlFreeNode(cur); 69540209230bSgjelinek return (Z_OK); 6955fa9e4066Sahrens } 69560209230bSgjelinek return (Z_NO_RESOURCE_ID); 69570209230bSgjelinek } 6958fa9e4066Sahrens 69590209230bSgjelinek int 69600209230bSgjelinek zonecfg_modify_mcap(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 69610209230bSgjelinek { 69620209230bSgjelinek int err; 6963fa9e4066Sahrens 69640209230bSgjelinek if (tabptr == NULL) 69650209230bSgjelinek return (Z_INVAL); 69660209230bSgjelinek 69670209230bSgjelinek err = zonecfg_delete_mcap(handle); 69680209230bSgjelinek /* it is ok if there is no mcap entry */ 69690209230bSgjelinek if (err != Z_OK && err != Z_NO_RESOURCE_ID) 69700209230bSgjelinek return (err); 69710209230bSgjelinek 69720209230bSgjelinek if ((err = add_mcap(handle, tabptr)) != Z_OK) 6973fa9e4066Sahrens return (err); 6974fa9e4066Sahrens 6975fa9e4066Sahrens return (Z_OK); 6976fa9e4066Sahrens } 6977fa9e4066Sahrens 6978fa9e4066Sahrens int 69790209230bSgjelinek zonecfg_lookup_mcap(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 6980fa9e4066Sahrens { 69810209230bSgjelinek xmlNodePtr cur; 69820209230bSgjelinek int err; 69830209230bSgjelinek 69840209230bSgjelinek if (tabptr == NULL) 69850209230bSgjelinek return (Z_INVAL); 69860209230bSgjelinek 69870209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 69880209230bSgjelinek return (err); 69890209230bSgjelinek 69900209230bSgjelinek cur = handle->zone_dh_cur; 69910209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 69920209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_MCAP) != 0) 69930209230bSgjelinek continue; 69940209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_PHYSCAP, 69950209230bSgjelinek tabptr->zone_physmem_cap, 69960209230bSgjelinek sizeof (tabptr->zone_physmem_cap))) != Z_OK) { 69970209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 69980209230bSgjelinek return (err); 69990209230bSgjelinek } 70000209230bSgjelinek 70010209230bSgjelinek return (Z_OK); 70020209230bSgjelinek } 70030209230bSgjelinek 70040209230bSgjelinek return (Z_NO_ENTRY); 7005fa9e4066Sahrens } 7006fa9e4066Sahrens 70070209230bSgjelinek static int 70080209230bSgjelinek getmcapent_core(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 7009fa9e4066Sahrens { 7010fa9e4066Sahrens xmlNodePtr cur; 7011fa9e4066Sahrens int err; 7012fa9e4066Sahrens 7013fa9e4066Sahrens if (handle == NULL) 7014fa9e4066Sahrens return (Z_INVAL); 7015fa9e4066Sahrens 7016fa9e4066Sahrens if ((cur = handle->zone_dh_cur) == NULL) 7017fa9e4066Sahrens return (Z_NO_ENTRY); 7018fa9e4066Sahrens 7019fa9e4066Sahrens for (; cur != NULL; cur = cur->next) 70200209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_MCAP) == 0) 7021fa9e4066Sahrens break; 7022fa9e4066Sahrens if (cur == NULL) { 7023fa9e4066Sahrens handle->zone_dh_cur = handle->zone_dh_top; 7024fa9e4066Sahrens return (Z_NO_ENTRY); 7025fa9e4066Sahrens } 7026fa9e4066Sahrens 70270209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_PHYSCAP, tabptr->zone_physmem_cap, 70280209230bSgjelinek sizeof (tabptr->zone_physmem_cap))) != Z_OK) { 7029fa9e4066Sahrens handle->zone_dh_cur = handle->zone_dh_top; 7030fa9e4066Sahrens return (err); 7031fa9e4066Sahrens } 7032fa9e4066Sahrens 7033fa9e4066Sahrens handle->zone_dh_cur = cur->next; 7034fa9e4066Sahrens return (Z_OK); 7035fa9e4066Sahrens } 7036fa9e4066Sahrens 7037fa9e4066Sahrens int 70380209230bSgjelinek zonecfg_getmcapent(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 7039fa9e4066Sahrens { 70400209230bSgjelinek int err; 70410209230bSgjelinek 70420209230bSgjelinek if ((err = zonecfg_setent(handle)) != Z_OK) 70430209230bSgjelinek return (err); 70440209230bSgjelinek 70450209230bSgjelinek err = getmcapent_core(handle, tabptr); 70460209230bSgjelinek 70470209230bSgjelinek (void) zonecfg_endent(handle); 70480209230bSgjelinek 70490209230bSgjelinek return (err); 7050fa9e4066Sahrens } 7051ee519a1fSgjelinek 70526cfd72c6Sgjelinek /* 70536cfd72c6Sgjelinek * Get the full tree of pkg/patch metadata in a set of nested AVL trees. 70546cfd72c6Sgjelinek * pkgs_avl is an AVL tree of pkgs. Each pkg element contains a 70556cfd72c6Sgjelinek * zpe_patches_avl member which holds an AVL tree of patches for that pkg. 70566cfd72c6Sgjelinek * The patch elements have the same zpe_patches_avl member, each of which can 70576cfd72c6Sgjelinek * hold an AVL tree of patches that are obsoleted by the patch. 70586cfd72c6Sgjelinek * 70596cfd72c6Sgjelinek * The zone xml data contains DTD_ELEM_PACKAGE elements, followed by 70606cfd72c6Sgjelinek * DTD_ELEM_PATCH elements. The DTD_ELEM_PATCH patch element applies to the 70616cfd72c6Sgjelinek * DTD_ELEM_PACKAGE that precedes it. The DTD_ELEM_PATCH element may have 70626cfd72c6Sgjelinek * child DTD_ELEM_OBSOLETES nodes associated with it. The DTD_ELEM_PACKAGE 70636cfd72c6Sgjelinek * really should have had the DTD_ELEM_PATCH elements as children but it 70646cfd72c6Sgjelinek * was not defined that way initially so we are stuck with the DTD definition 70656cfd72c6Sgjelinek * now. However, we can safely assume the ordering for compatibility. 70666cfd72c6Sgjelinek */ 7067ee519a1fSgjelinek int 70686cfd72c6Sgjelinek zonecfg_getpkgdata(zone_dochandle_t handle, uu_avl_pool_t *pkg_pool, 70696cfd72c6Sgjelinek uu_avl_t *pkgs_avl) 7070ee519a1fSgjelinek { 7071ee519a1fSgjelinek xmlNodePtr cur; 70726cfd72c6Sgjelinek int res; 70736cfd72c6Sgjelinek zone_pkg_entry_t *pkg; 70746cfd72c6Sgjelinek char name[MAXNAMELEN]; 70756cfd72c6Sgjelinek char version[ZONE_PKG_VERSMAX]; 7076ee519a1fSgjelinek 7077ee519a1fSgjelinek if (handle == NULL) 7078ee519a1fSgjelinek return (Z_INVAL); 7079ee519a1fSgjelinek 70806cfd72c6Sgjelinek if ((res = zonecfg_setent(handle)) != Z_OK) 70816cfd72c6Sgjelinek return (res); 7082ee519a1fSgjelinek 70836cfd72c6Sgjelinek if ((cur = handle->zone_dh_cur) == NULL) { 70846cfd72c6Sgjelinek res = Z_NO_ENTRY; 70856cfd72c6Sgjelinek goto done; 7086ee519a1fSgjelinek } 7087ee519a1fSgjelinek 70886cfd72c6Sgjelinek for (; cur != NULL; cur = cur->next) { 70896cfd72c6Sgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_PACKAGE) == 0) { 70906cfd72c6Sgjelinek uu_avl_index_t where; 7091ee519a1fSgjelinek 70926cfd72c6Sgjelinek if ((res = fetchprop(cur, DTD_ATTR_NAME, name, 70936cfd72c6Sgjelinek sizeof (name))) != Z_OK) 70946cfd72c6Sgjelinek goto done; 7095ee519a1fSgjelinek 70966cfd72c6Sgjelinek if ((res = fetchprop(cur, DTD_ATTR_VERSION, version, 70976cfd72c6Sgjelinek sizeof (version))) != Z_OK) 70986cfd72c6Sgjelinek goto done; 7099ee519a1fSgjelinek 71006cfd72c6Sgjelinek if ((pkg = (zone_pkg_entry_t *) 71016cfd72c6Sgjelinek malloc(sizeof (zone_pkg_entry_t))) == NULL) { 71026cfd72c6Sgjelinek res = Z_NOMEM; 71036cfd72c6Sgjelinek goto done; 71046cfd72c6Sgjelinek } 7105ee519a1fSgjelinek 71066cfd72c6Sgjelinek if ((pkg->zpe_name = strdup(name)) == NULL) { 71076cfd72c6Sgjelinek free(pkg); 71086cfd72c6Sgjelinek res = Z_NOMEM; 71096cfd72c6Sgjelinek goto done; 71106cfd72c6Sgjelinek } 7111ee519a1fSgjelinek 71126cfd72c6Sgjelinek if ((pkg->zpe_vers = strdup(version)) == NULL) { 71136cfd72c6Sgjelinek free(pkg->zpe_name); 71146cfd72c6Sgjelinek free(pkg); 71156cfd72c6Sgjelinek res = Z_NOMEM; 71166cfd72c6Sgjelinek goto done; 71176cfd72c6Sgjelinek } 7118ee519a1fSgjelinek 71196cfd72c6Sgjelinek pkg->zpe_patches_avl = NULL; 7120ee519a1fSgjelinek 71216cfd72c6Sgjelinek uu_avl_node_init(pkg, &pkg->zpe_entry, pkg_pool); 71226cfd72c6Sgjelinek if (uu_avl_find(pkgs_avl, pkg, NULL, &where) != NULL) { 71236cfd72c6Sgjelinek free(pkg->zpe_name); 71246cfd72c6Sgjelinek free(pkg->zpe_vers); 71256cfd72c6Sgjelinek free(pkg); 71266cfd72c6Sgjelinek } else { 71276cfd72c6Sgjelinek uu_avl_insert(pkgs_avl, pkg, where); 71286cfd72c6Sgjelinek } 7129ee519a1fSgjelinek 71306cfd72c6Sgjelinek } else if (xmlStrcmp(cur->name, DTD_ELEM_PATCH) == 0) { 71316cfd72c6Sgjelinek zone_pkg_entry_t *patch; 71326cfd72c6Sgjelinek uu_avl_index_t where; 71336cfd72c6Sgjelinek char *p; 71346cfd72c6Sgjelinek char *dashp = NULL; 71356cfd72c6Sgjelinek xmlNodePtr child; 7136ee519a1fSgjelinek 71376cfd72c6Sgjelinek if ((res = fetchprop(cur, DTD_ATTR_ID, name, 71386cfd72c6Sgjelinek sizeof (name))) != Z_OK) 71396cfd72c6Sgjelinek goto done; 7140ee519a1fSgjelinek 71416cfd72c6Sgjelinek if ((patch = (zone_pkg_entry_t *) 71426cfd72c6Sgjelinek malloc(sizeof (zone_pkg_entry_t))) == NULL) { 71436cfd72c6Sgjelinek res = Z_NOMEM; 71446cfd72c6Sgjelinek goto done; 71456cfd72c6Sgjelinek } 7146ee519a1fSgjelinek 71476cfd72c6Sgjelinek if ((p = strchr(name, '-')) != NULL) { 71486cfd72c6Sgjelinek dashp = p; 71496cfd72c6Sgjelinek *p++ = '\0'; 71506cfd72c6Sgjelinek } else { 71516cfd72c6Sgjelinek p = ""; 71526cfd72c6Sgjelinek } 71536cfd72c6Sgjelinek 71546cfd72c6Sgjelinek if ((patch->zpe_name = strdup(name)) == NULL) { 71556cfd72c6Sgjelinek free(patch); 71566cfd72c6Sgjelinek res = Z_NOMEM; 71576cfd72c6Sgjelinek goto done; 71586cfd72c6Sgjelinek } 71596cfd72c6Sgjelinek 71606cfd72c6Sgjelinek if ((patch->zpe_vers = strdup(p)) == NULL) { 71616cfd72c6Sgjelinek free(patch->zpe_name); 71626cfd72c6Sgjelinek free(patch); 71636cfd72c6Sgjelinek res = Z_NOMEM; 71646cfd72c6Sgjelinek goto done; 71656cfd72c6Sgjelinek } 71666cfd72c6Sgjelinek 71676cfd72c6Sgjelinek if (dashp != NULL) 71686cfd72c6Sgjelinek *dashp = '-'; 71696cfd72c6Sgjelinek 71706cfd72c6Sgjelinek patch->zpe_patches_avl = NULL; 71716cfd72c6Sgjelinek 71726cfd72c6Sgjelinek if (pkg->zpe_patches_avl == NULL) { 71736cfd72c6Sgjelinek pkg->zpe_patches_avl = uu_avl_create(pkg_pool, 71746cfd72c6Sgjelinek NULL, UU_DEFAULT); 71756cfd72c6Sgjelinek if (pkg->zpe_patches_avl == NULL) { 71766cfd72c6Sgjelinek free(patch->zpe_name); 71776cfd72c6Sgjelinek free(patch->zpe_vers); 71786cfd72c6Sgjelinek free(patch); 71796cfd72c6Sgjelinek res = Z_NOMEM; 71806cfd72c6Sgjelinek goto done; 71816cfd72c6Sgjelinek } 71826cfd72c6Sgjelinek } 71836cfd72c6Sgjelinek 71846cfd72c6Sgjelinek uu_avl_node_init(patch, &patch->zpe_entry, pkg_pool); 71856cfd72c6Sgjelinek if (uu_avl_find(pkg->zpe_patches_avl, patch, NULL, 71866cfd72c6Sgjelinek &where) != NULL) { 71876cfd72c6Sgjelinek free(patch->zpe_name); 71886cfd72c6Sgjelinek free(patch->zpe_vers); 71896cfd72c6Sgjelinek free(patch); 71906cfd72c6Sgjelinek } else { 71916cfd72c6Sgjelinek uu_avl_insert(pkg->zpe_patches_avl, patch, 71926cfd72c6Sgjelinek where); 71936cfd72c6Sgjelinek } 71946cfd72c6Sgjelinek 71956cfd72c6Sgjelinek /* Add any patches this patch obsoletes. */ 71966cfd72c6Sgjelinek for (child = cur->xmlChildrenNode; child != NULL; 71976cfd72c6Sgjelinek child = child->next) { 71986cfd72c6Sgjelinek zone_pkg_entry_t *obs; 71996cfd72c6Sgjelinek 72006cfd72c6Sgjelinek if (xmlStrcmp(child->name, DTD_ELEM_OBSOLETES) 72016cfd72c6Sgjelinek != 0) 72026cfd72c6Sgjelinek continue; 72036cfd72c6Sgjelinek 72046cfd72c6Sgjelinek if ((res = fetchprop(child, DTD_ATTR_ID, 72056cfd72c6Sgjelinek name, sizeof (name))) != Z_OK) 72066cfd72c6Sgjelinek goto done; 72076cfd72c6Sgjelinek 72086cfd72c6Sgjelinek if ((obs = (zone_pkg_entry_t *)malloc( 72096cfd72c6Sgjelinek sizeof (zone_pkg_entry_t))) == NULL) { 72106cfd72c6Sgjelinek res = Z_NOMEM; 72116cfd72c6Sgjelinek goto done; 72126cfd72c6Sgjelinek } 72136cfd72c6Sgjelinek 72146cfd72c6Sgjelinek if ((obs->zpe_name = strdup(name)) == NULL) { 72156cfd72c6Sgjelinek free(obs); 72166cfd72c6Sgjelinek res = Z_NOMEM; 72176cfd72c6Sgjelinek goto done; 72186cfd72c6Sgjelinek } 72196cfd72c6Sgjelinek /* 72206cfd72c6Sgjelinek * The version doesn't matter for obsoleted 72216cfd72c6Sgjelinek * patches. 72226cfd72c6Sgjelinek */ 72236cfd72c6Sgjelinek obs->zpe_vers = NULL; 72246cfd72c6Sgjelinek obs->zpe_patches_avl = NULL; 72256cfd72c6Sgjelinek 72266cfd72c6Sgjelinek /* 72276cfd72c6Sgjelinek * If this is the first obsolete patch, add an 72286cfd72c6Sgjelinek * AVL tree to the parent patch element. 72296cfd72c6Sgjelinek */ 72306cfd72c6Sgjelinek if (patch->zpe_patches_avl == NULL) { 72316cfd72c6Sgjelinek patch->zpe_patches_avl = 72326cfd72c6Sgjelinek uu_avl_create(pkg_pool, NULL, 72336cfd72c6Sgjelinek UU_DEFAULT); 72346cfd72c6Sgjelinek if (patch->zpe_patches_avl == NULL) { 72356cfd72c6Sgjelinek free(obs->zpe_name); 72366cfd72c6Sgjelinek free(obs); 72376cfd72c6Sgjelinek res = Z_NOMEM; 72386cfd72c6Sgjelinek goto done; 72396cfd72c6Sgjelinek } 72406cfd72c6Sgjelinek } 72416cfd72c6Sgjelinek 72426cfd72c6Sgjelinek /* Insert obsolete patch into the AVL tree. */ 72436cfd72c6Sgjelinek uu_avl_node_init(obs, &obs->zpe_entry, 72446cfd72c6Sgjelinek pkg_pool); 72456cfd72c6Sgjelinek if (uu_avl_find(patch->zpe_patches_avl, obs, 72466cfd72c6Sgjelinek NULL, &where) != NULL) { 72476cfd72c6Sgjelinek free(obs->zpe_name); 72486cfd72c6Sgjelinek free(obs); 72496cfd72c6Sgjelinek } else { 72506cfd72c6Sgjelinek uu_avl_insert(patch->zpe_patches_avl, 72516cfd72c6Sgjelinek obs, where); 72526cfd72c6Sgjelinek } 72536cfd72c6Sgjelinek } 72546cfd72c6Sgjelinek } 72556cfd72c6Sgjelinek } 72566cfd72c6Sgjelinek 72576cfd72c6Sgjelinek done: 72586cfd72c6Sgjelinek (void) zonecfg_endent(handle); 72596cfd72c6Sgjelinek return (res); 7260ee519a1fSgjelinek } 7261ee519a1fSgjelinek 7262ee519a1fSgjelinek int 7263ee519a1fSgjelinek zonecfg_setdevperment(zone_dochandle_t handle) 7264ee519a1fSgjelinek { 7265ee519a1fSgjelinek return (zonecfg_setent(handle)); 7266ee519a1fSgjelinek } 7267ee519a1fSgjelinek 7268ee519a1fSgjelinek int 7269ee519a1fSgjelinek zonecfg_getdevperment(zone_dochandle_t handle, struct zone_devpermtab *tabptr) 7270ee519a1fSgjelinek { 7271ee519a1fSgjelinek xmlNodePtr cur; 7272ee519a1fSgjelinek int err; 7273ee519a1fSgjelinek char buf[128]; 7274ee519a1fSgjelinek 7275ee519a1fSgjelinek tabptr->zone_devperm_acl = NULL; 7276ee519a1fSgjelinek 7277ee519a1fSgjelinek if (handle == NULL) 7278ee519a1fSgjelinek return (Z_INVAL); 7279ee519a1fSgjelinek 7280ee519a1fSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 7281ee519a1fSgjelinek return (Z_NO_ENTRY); 7282ee519a1fSgjelinek 7283ee519a1fSgjelinek for (; cur != NULL; cur = cur->next) 7284ee519a1fSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_DEV_PERM)) 7285ee519a1fSgjelinek break; 7286ee519a1fSgjelinek if (cur == NULL) { 7287ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7288ee519a1fSgjelinek return (Z_NO_ENTRY); 7289ee519a1fSgjelinek } 7290ee519a1fSgjelinek 7291ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_devperm_name, 7292ee519a1fSgjelinek sizeof (tabptr->zone_devperm_name))) != Z_OK) { 7293ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7294ee519a1fSgjelinek return (err); 7295ee519a1fSgjelinek } 7296ee519a1fSgjelinek 7297ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_UID, buf, sizeof (buf))) != Z_OK) { 7298ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7299ee519a1fSgjelinek return (err); 7300ee519a1fSgjelinek } 7301ee519a1fSgjelinek tabptr->zone_devperm_uid = (uid_t)atol(buf); 7302ee519a1fSgjelinek 7303ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_GID, buf, sizeof (buf))) != Z_OK) { 7304ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7305ee519a1fSgjelinek return (err); 7306ee519a1fSgjelinek } 7307ee519a1fSgjelinek tabptr->zone_devperm_gid = (gid_t)atol(buf); 7308ee519a1fSgjelinek 7309ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_MODE, buf, sizeof (buf))) != Z_OK) { 7310ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7311ee519a1fSgjelinek return (err); 7312ee519a1fSgjelinek } 7313ee519a1fSgjelinek tabptr->zone_devperm_mode = (mode_t)strtol(buf, (char **)NULL, 8); 7314ee519a1fSgjelinek 7315ee519a1fSgjelinek if ((err = fetch_alloc_prop(cur, DTD_ATTR_ACL, 7316ee519a1fSgjelinek &(tabptr->zone_devperm_acl))) != Z_OK) { 7317ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7318ee519a1fSgjelinek return (err); 7319ee519a1fSgjelinek } 7320ee519a1fSgjelinek 7321ee519a1fSgjelinek handle->zone_dh_cur = cur->next; 7322ee519a1fSgjelinek return (Z_OK); 7323ee519a1fSgjelinek } 7324ee519a1fSgjelinek 7325ee519a1fSgjelinek int 7326ee519a1fSgjelinek zonecfg_enddevperment(zone_dochandle_t handle) 7327ee519a1fSgjelinek { 7328ee519a1fSgjelinek return (zonecfg_endent(handle)); 7329ee519a1fSgjelinek } 7330ee519a1fSgjelinek 7331ff17c8bfSgjelinek /* PRINTFLIKE1 */ 7332ff17c8bfSgjelinek static void 7333ff17c8bfSgjelinek zerror(const char *zone_name, const char *fmt, ...) 733439935be5Sgjelinek { 7335ff17c8bfSgjelinek va_list alist; 733639935be5Sgjelinek 7337ff17c8bfSgjelinek va_start(alist, fmt); 7338ff17c8bfSgjelinek (void) fprintf(stderr, "zone '%s': ", zone_name); 7339ff17c8bfSgjelinek (void) vfprintf(stderr, fmt, alist); 7340ff17c8bfSgjelinek (void) fprintf(stderr, "\n"); 7341ff17c8bfSgjelinek va_end(alist); 7342ff17c8bfSgjelinek } 734339935be5Sgjelinek 7344ff17c8bfSgjelinek static void 7345ff17c8bfSgjelinek zperror(const char *str) 7346ff17c8bfSgjelinek { 7347ff17c8bfSgjelinek (void) fprintf(stderr, "%s: %s\n", str, strerror(errno)); 734839935be5Sgjelinek } 734939935be5Sgjelinek 7350ee519a1fSgjelinek /* 7351ff17c8bfSgjelinek * The following three routines implement a simple locking mechanism to 7352ff17c8bfSgjelinek * ensure that only one instance of zoneadm at a time is able to manipulate 7353ff17c8bfSgjelinek * a given zone. The lock is built on top of an fcntl(2) lock of 7354ff17c8bfSgjelinek * [<altroot>]/var/run/zones/<zonename>.zoneadm.lock. If a zoneadm instance 7355ff17c8bfSgjelinek * can grab that lock, it is allowed to manipulate the zone. 7356ff17c8bfSgjelinek * 7357ff17c8bfSgjelinek * Since zoneadm may call external applications which in turn invoke 7358ff17c8bfSgjelinek * zoneadm again, we introduce the notion of "lock inheritance". Any 7359ff17c8bfSgjelinek * instance of zoneadm that has another instance in its ancestry is assumed 7360ff17c8bfSgjelinek * to be acting on behalf of the original zoneadm, and is thus allowed to 7361ff17c8bfSgjelinek * manipulate its zone. 7362ee519a1fSgjelinek * 7363ff17c8bfSgjelinek * This inheritance is implemented via the _ZONEADM_LOCK_HELD environment 7364ff17c8bfSgjelinek * variable. When zoneadm is granted a lock on its zone, this environment 7365ff17c8bfSgjelinek * variable is set to 1. When it releases the lock, the variable is set to 7366ff17c8bfSgjelinek * 0. Since a child process inherits its parent's environment, checking 7367ff17c8bfSgjelinek * the state of this variable indicates whether or not any ancestor owns 7368ff17c8bfSgjelinek * the lock. 7369ee519a1fSgjelinek */ 7370ff17c8bfSgjelinek void 7371ff17c8bfSgjelinek zonecfg_init_lock_file(const char *zone_name, char **lock_env) 7372ff17c8bfSgjelinek { 7373ff17c8bfSgjelinek *lock_env = getenv(LOCK_ENV_VAR); 7374ff17c8bfSgjelinek if (*lock_env == NULL) { 7375ff17c8bfSgjelinek if (putenv(zoneadm_lock_not_held) != 0) { 7376ff17c8bfSgjelinek zerror(zone_name, gettext("could not set env: %s"), 7377ff17c8bfSgjelinek strerror(errno)); 7378ff17c8bfSgjelinek exit(1); 7379ee519a1fSgjelinek } 7380ff17c8bfSgjelinek } else { 7381ff17c8bfSgjelinek if (atoi(*lock_env) == 1) 7382ff17c8bfSgjelinek zone_lock_cnt = 1; 7383ff17c8bfSgjelinek } 7384ff17c8bfSgjelinek } 7385ee519a1fSgjelinek 7386ff17c8bfSgjelinek void 7387ff17c8bfSgjelinek zonecfg_release_lock_file(const char *zone_name, int lockfd) 7388ff17c8bfSgjelinek { 7389ff17c8bfSgjelinek /* 7390ff17c8bfSgjelinek * If we are cleaning up from a failed attempt to lock the zone for 7391ff17c8bfSgjelinek * the first time, we might have a zone_lock_cnt of 0. In that 7392ff17c8bfSgjelinek * error case, we don't want to do anything but close the lock 7393ff17c8bfSgjelinek * file. 7394ff17c8bfSgjelinek */ 7395ff17c8bfSgjelinek assert(zone_lock_cnt >= 0); 7396ff17c8bfSgjelinek if (zone_lock_cnt > 0) { 7397ff17c8bfSgjelinek assert(getenv(LOCK_ENV_VAR) != NULL); 7398ff17c8bfSgjelinek assert(atoi(getenv(LOCK_ENV_VAR)) == 1); 7399ff17c8bfSgjelinek if (--zone_lock_cnt > 0) { 7400ff17c8bfSgjelinek assert(lockfd == -1); 7401ff17c8bfSgjelinek return; 7402ee519a1fSgjelinek } 7403ff17c8bfSgjelinek if (putenv(zoneadm_lock_not_held) != 0) { 7404ff17c8bfSgjelinek zerror(zone_name, gettext("could not set env: %s"), 7405ff17c8bfSgjelinek strerror(errno)); 7406ff17c8bfSgjelinek exit(1); 7407ee519a1fSgjelinek } 7408ee519a1fSgjelinek } 7409ff17c8bfSgjelinek assert(lockfd >= 0); 7410ff17c8bfSgjelinek (void) close(lockfd); 7411ee519a1fSgjelinek } 7412ee519a1fSgjelinek 7413ff17c8bfSgjelinek int 7414ff17c8bfSgjelinek zonecfg_grab_lock_file(const char *zone_name, int *lockfd) 7415ee519a1fSgjelinek { 7416ff17c8bfSgjelinek char pathbuf[PATH_MAX]; 7417ff17c8bfSgjelinek struct flock flock; 7418ee519a1fSgjelinek 7419ff17c8bfSgjelinek /* 7420ff17c8bfSgjelinek * If we already have the lock, we can skip this expensive song 7421ff17c8bfSgjelinek * and dance. 7422ff17c8bfSgjelinek */ 7423ff17c8bfSgjelinek assert(zone_lock_cnt >= 0); 7424ff17c8bfSgjelinek assert(getenv(LOCK_ENV_VAR) != NULL); 7425ff17c8bfSgjelinek if (zone_lock_cnt > 0) { 7426ff17c8bfSgjelinek assert(atoi(getenv(LOCK_ENV_VAR)) == 1); 7427ff17c8bfSgjelinek zone_lock_cnt++; 7428ff17c8bfSgjelinek *lockfd = -1; 7429ee519a1fSgjelinek return (Z_OK); 743039935be5Sgjelinek } 7431ff17c8bfSgjelinek assert(getenv(LOCK_ENV_VAR) != NULL); 7432ff17c8bfSgjelinek assert(atoi(getenv(LOCK_ENV_VAR)) == 0); 7433ee519a1fSgjelinek 7434ff17c8bfSgjelinek if (snprintf(pathbuf, sizeof (pathbuf), "%s%s", zonecfg_get_root(), 7435ff17c8bfSgjelinek ZONES_TMPDIR) >= sizeof (pathbuf)) { 7436ff17c8bfSgjelinek zerror(zone_name, gettext("alternate root path is too long")); 7437ff17c8bfSgjelinek return (-1); 7438ff17c8bfSgjelinek } 7439ff17c8bfSgjelinek if (mkdir(pathbuf, S_IRWXU) < 0 && errno != EEXIST) { 7440ff17c8bfSgjelinek zerror(zone_name, gettext("could not mkdir %s: %s"), pathbuf, 7441ff17c8bfSgjelinek strerror(errno)); 7442ff17c8bfSgjelinek return (-1); 7443ff17c8bfSgjelinek } 7444ff17c8bfSgjelinek (void) chmod(pathbuf, S_IRWXU); 744507b574eeSgjelinek 744639935be5Sgjelinek /* 7447ff17c8bfSgjelinek * One of these lock files is created for each zone (when needed). 7448ff17c8bfSgjelinek * The lock files are not cleaned up (except on system reboot), 7449ff17c8bfSgjelinek * but since there is only one per zone, there is no resource 7450ff17c8bfSgjelinek * starvation issue. 745139935be5Sgjelinek */ 7452ff17c8bfSgjelinek if (snprintf(pathbuf, sizeof (pathbuf), "%s%s/%s.zoneadm.lock", 7453ff17c8bfSgjelinek zonecfg_get_root(), ZONES_TMPDIR, zone_name) >= sizeof (pathbuf)) { 7454ff17c8bfSgjelinek zerror(zone_name, gettext("alternate root path is too long")); 7455ff17c8bfSgjelinek return (-1); 7456ff17c8bfSgjelinek } 7457ff17c8bfSgjelinek if ((*lockfd = open(pathbuf, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR)) < 0) { 7458ff17c8bfSgjelinek zerror(zone_name, gettext("could not open %s: %s"), pathbuf, 7459ff17c8bfSgjelinek strerror(errno)); 7460ff17c8bfSgjelinek return (-1); 7461ee519a1fSgjelinek } 746239935be5Sgjelinek /* 7463ff17c8bfSgjelinek * Lock the file to synchronize with other zoneadmds 746439935be5Sgjelinek */ 7465ff17c8bfSgjelinek flock.l_type = F_WRLCK; 7466ff17c8bfSgjelinek flock.l_whence = SEEK_SET; 7467ff17c8bfSgjelinek flock.l_start = (off_t)0; 7468ff17c8bfSgjelinek flock.l_len = (off_t)0; 7469ff17c8bfSgjelinek if ((fcntl(*lockfd, F_SETLKW, &flock) < 0) || 7470ff17c8bfSgjelinek (putenv(zoneadm_lock_held) != 0)) { 7471ff17c8bfSgjelinek zerror(zone_name, gettext("unable to lock %s: %s"), pathbuf, 7472ff17c8bfSgjelinek strerror(errno)); 7473ff17c8bfSgjelinek zonecfg_release_lock_file(zone_name, *lockfd); 7474ff17c8bfSgjelinek return (-1); 7475ff17c8bfSgjelinek } 7476ff17c8bfSgjelinek zone_lock_cnt = 1; 7477ff17c8bfSgjelinek return (Z_OK); 7478ff17c8bfSgjelinek } 747939935be5Sgjelinek 7480edfa49ffS boolean_t 7481edfa49ffS zonecfg_lock_file_held(int *lockfd) 7482edfa49ffS { 7483edfa49ffS if (*lockfd >= 0 || zone_lock_cnt > 0) 7484edfa49ffS return (B_TRUE); 7485edfa49ffS return (B_FALSE); 7486edfa49ffS } 7487edfa49ffS 7488ff17c8bfSgjelinek static boolean_t 7489ff17c8bfSgjelinek get_doorname(const char *zone_name, char *buffer) 7490ff17c8bfSgjelinek { 7491ff17c8bfSgjelinek return (snprintf(buffer, PATH_MAX, "%s" ZONE_DOOR_PATH, 7492ff17c8bfSgjelinek zonecfg_get_root(), zone_name) < PATH_MAX); 7493ee519a1fSgjelinek } 7494ee519a1fSgjelinek 7495ee519a1fSgjelinek /* 7496ff17c8bfSgjelinek * system daemons are not audited. For the global zone, this occurs 7497ff17c8bfSgjelinek * "naturally" since init is started with the default audit 7498ff17c8bfSgjelinek * characteristics. Since zoneadmd is a system daemon and it starts 7499ff17c8bfSgjelinek * init for a zone, it is necessary to clear out the audit 7500ff17c8bfSgjelinek * characteristics inherited from whomever started zoneadmd. This is 7501ff17c8bfSgjelinek * indicated by the audit id, which is set from the ruid parameter of 7502ff17c8bfSgjelinek * adt_set_user(), below. 7503ee519a1fSgjelinek */ 7504ee519a1fSgjelinek 7505ff17c8bfSgjelinek static void 7506ff17c8bfSgjelinek prepare_audit_context(const char *zone_name) 7507ff17c8bfSgjelinek { 7508ff17c8bfSgjelinek adt_session_data_t *ah; 7509ff17c8bfSgjelinek char *failure = gettext("audit failure: %s"); 7510ee519a1fSgjelinek 7511ff17c8bfSgjelinek if (adt_start_session(&ah, NULL, 0)) { 7512ff17c8bfSgjelinek zerror(zone_name, failure, strerror(errno)); 7513ff17c8bfSgjelinek return; 7514ee519a1fSgjelinek } 7515ff17c8bfSgjelinek if (adt_set_user(ah, ADT_NO_AUDIT, ADT_NO_AUDIT, 7516ff17c8bfSgjelinek ADT_NO_AUDIT, ADT_NO_AUDIT, NULL, ADT_NEW)) { 7517ff17c8bfSgjelinek zerror(zone_name, failure, strerror(errno)); 7518ff17c8bfSgjelinek (void) adt_end_session(ah); 7519ff17c8bfSgjelinek return; 7520ee519a1fSgjelinek } 7521ff17c8bfSgjelinek if (adt_set_proc(ah)) 7522ff17c8bfSgjelinek zerror(zone_name, failure, strerror(errno)); 7523ee519a1fSgjelinek 7524ff17c8bfSgjelinek (void) adt_end_session(ah); 7525ee519a1fSgjelinek } 7526ee519a1fSgjelinek 7527ee519a1fSgjelinek static int 7528ff17c8bfSgjelinek start_zoneadmd(const char *zone_name, boolean_t lock) 7529ff17c8bfSgjelinek { 7530ff17c8bfSgjelinek char doorpath[PATH_MAX]; 7531ff17c8bfSgjelinek pid_t child_pid; 7532ff17c8bfSgjelinek int error = -1; 7533ff17c8bfSgjelinek int doorfd, lockfd; 7534ff17c8bfSgjelinek struct door_info info; 7535ee519a1fSgjelinek 7536ff17c8bfSgjelinek if (!get_doorname(zone_name, doorpath)) 7537ff17c8bfSgjelinek return (-1); 7538ee519a1fSgjelinek 7539ff17c8bfSgjelinek if (lock) 7540ff17c8bfSgjelinek if (zonecfg_grab_lock_file(zone_name, &lockfd) != Z_OK) 7541ff17c8bfSgjelinek return (-1); 7542ee519a1fSgjelinek 7543ff17c8bfSgjelinek /* 7544ff17c8bfSgjelinek * Now that we have the lock, re-confirm that the daemon is 7545ff17c8bfSgjelinek * *not* up and working fine. If it is still down, we have a green 7546ff17c8bfSgjelinek * light to start it. 7547ff17c8bfSgjelinek */ 7548ff17c8bfSgjelinek if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 7549ff17c8bfSgjelinek if (errno != ENOENT) { 7550ff17c8bfSgjelinek zperror(doorpath); 7551ff17c8bfSgjelinek goto out; 7552ee519a1fSgjelinek } 7553ff17c8bfSgjelinek } else { 7554ff17c8bfSgjelinek if (door_info(doorfd, &info) == 0 && 7555ff17c8bfSgjelinek ((info.di_attributes & DOOR_REVOKED) == 0)) { 7556ff17c8bfSgjelinek error = Z_OK; 7557ff17c8bfSgjelinek (void) close(doorfd); 7558ff17c8bfSgjelinek goto out; 7559ee519a1fSgjelinek } 7560ff17c8bfSgjelinek (void) close(doorfd); 7561ff17c8bfSgjelinek } 7562ee519a1fSgjelinek 7563ff17c8bfSgjelinek if ((child_pid = fork()) == -1) { 7564ff17c8bfSgjelinek zperror(gettext("could not fork")); 7565ff17c8bfSgjelinek goto out; 756639935be5Sgjelinek } 756739935be5Sgjelinek 7568ff17c8bfSgjelinek if (child_pid == 0) { 7569ff17c8bfSgjelinek const char *argv[6], **ap; 757039935be5Sgjelinek 7571ff17c8bfSgjelinek /* child process */ 7572ff17c8bfSgjelinek prepare_audit_context(zone_name); 757339935be5Sgjelinek 7574ff17c8bfSgjelinek ap = argv; 7575ff17c8bfSgjelinek *ap++ = "zoneadmd"; 7576ff17c8bfSgjelinek *ap++ = "-z"; 7577ff17c8bfSgjelinek *ap++ = zone_name; 7578ff17c8bfSgjelinek if (zonecfg_in_alt_root()) { 7579ff17c8bfSgjelinek *ap++ = "-R"; 7580ff17c8bfSgjelinek *ap++ = zonecfg_get_root(); 7581ee519a1fSgjelinek } 7582ff17c8bfSgjelinek *ap = NULL; 7583ee519a1fSgjelinek 7584ff17c8bfSgjelinek (void) execv("/usr/lib/zones/zoneadmd", (char * const *)argv); 7585ff17c8bfSgjelinek /* 7586ff17c8bfSgjelinek * TRANSLATION_NOTE 7587ff17c8bfSgjelinek * zoneadmd is a literal that should not be translated. 7588ff17c8bfSgjelinek */ 7589ff17c8bfSgjelinek zperror(gettext("could not exec zoneadmd")); 7590ff17c8bfSgjelinek _exit(1); 7591ff17c8bfSgjelinek } else { 7592ff17c8bfSgjelinek /* parent process */ 7593ff17c8bfSgjelinek pid_t retval; 7594ff17c8bfSgjelinek int pstatus = 0; 7595ff17c8bfSgjelinek 7596ff17c8bfSgjelinek do { 7597ff17c8bfSgjelinek retval = waitpid(child_pid, &pstatus, 0); 7598ff17c8bfSgjelinek } while (retval != child_pid); 7599ff17c8bfSgjelinek if (WIFSIGNALED(pstatus) || (WIFEXITED(pstatus) && 7600ff17c8bfSgjelinek WEXITSTATUS(pstatus) != 0)) { 7601ff17c8bfSgjelinek zerror(zone_name, gettext("could not start %s"), 7602ff17c8bfSgjelinek "zoneadmd"); 7603ff17c8bfSgjelinek goto out; 760439935be5Sgjelinek } 7605ee519a1fSgjelinek } 7606ff17c8bfSgjelinek error = Z_OK; 7607ff17c8bfSgjelinek out: 7608ff17c8bfSgjelinek if (lock) 7609ff17c8bfSgjelinek zonecfg_release_lock_file(zone_name, lockfd); 7610ff17c8bfSgjelinek return (error); 761139935be5Sgjelinek } 7612ee519a1fSgjelinek 7613ff17c8bfSgjelinek int 7614ff17c8bfSgjelinek zonecfg_ping_zoneadmd(const char *zone_name) 761539935be5Sgjelinek { 7616ff17c8bfSgjelinek char doorpath[PATH_MAX]; 7617ff17c8bfSgjelinek int doorfd; 7618ff17c8bfSgjelinek struct door_info info; 761939935be5Sgjelinek 7620ff17c8bfSgjelinek if (!get_doorname(zone_name, doorpath)) 7621ff17c8bfSgjelinek return (-1); 762239935be5Sgjelinek 7623ff17c8bfSgjelinek if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 7624ff17c8bfSgjelinek return (-1); 7625ff17c8bfSgjelinek } 7626ff17c8bfSgjelinek if (door_info(doorfd, &info) == 0 && 7627ff17c8bfSgjelinek ((info.di_attributes & DOOR_REVOKED) == 0)) { 7628ff17c8bfSgjelinek (void) close(doorfd); 7629ff17c8bfSgjelinek return (Z_OK); 7630ee519a1fSgjelinek } 7631ff17c8bfSgjelinek (void) close(doorfd); 7632ff17c8bfSgjelinek return (-1); 7633ff17c8bfSgjelinek } 7634ee519a1fSgjelinek 7635ff17c8bfSgjelinek int 7636ff17c8bfSgjelinek zonecfg_call_zoneadmd(const char *zone_name, zone_cmd_arg_t *arg, char *locale, 7637ff17c8bfSgjelinek boolean_t lock) 7638ff17c8bfSgjelinek { 7639ff17c8bfSgjelinek char doorpath[PATH_MAX]; 7640ff17c8bfSgjelinek int doorfd, result; 7641ff17c8bfSgjelinek door_arg_t darg; 7642ee519a1fSgjelinek 7643ff17c8bfSgjelinek zoneid_t zoneid; 7644ff17c8bfSgjelinek uint64_t uniqid = 0; 7645ee519a1fSgjelinek 7646ff17c8bfSgjelinek zone_cmd_rval_t *rvalp; 7647ff17c8bfSgjelinek size_t rlen; 7648ff17c8bfSgjelinek char *cp, *errbuf; 7649ee519a1fSgjelinek 7650ff17c8bfSgjelinek rlen = getpagesize(); 7651ff17c8bfSgjelinek if ((rvalp = malloc(rlen)) == NULL) { 7652ff17c8bfSgjelinek zerror(zone_name, gettext("failed to allocate %lu bytes: %s"), 7653ff17c8bfSgjelinek rlen, strerror(errno)); 7654ff17c8bfSgjelinek return (-1); 7655ff17c8bfSgjelinek } 765639935be5Sgjelinek 7657ff17c8bfSgjelinek if ((zoneid = getzoneidbyname(zone_name)) != ZONE_ID_UNDEFINED) { 7658ff17c8bfSgjelinek (void) zone_getattr(zoneid, ZONE_ATTR_UNIQID, &uniqid, 7659ff17c8bfSgjelinek sizeof (uniqid)); 7660ff17c8bfSgjelinek } 7661ff17c8bfSgjelinek arg->uniqid = uniqid; 7662ff17c8bfSgjelinek (void) strlcpy(arg->locale, locale, sizeof (arg->locale)); 7663ff17c8bfSgjelinek if (!get_doorname(zone_name, doorpath)) { 7664ff17c8bfSgjelinek zerror(zone_name, gettext("alternate root path is too long")); 7665ff17c8bfSgjelinek free(rvalp); 7666ff17c8bfSgjelinek return (-1); 7667ee519a1fSgjelinek } 7668ee519a1fSgjelinek 7669ff17c8bfSgjelinek /* 7670ff17c8bfSgjelinek * Loop trying to start zoneadmd; if something goes seriously 7671ff17c8bfSgjelinek * wrong we break out and fail. 7672ff17c8bfSgjelinek */ 7673ff17c8bfSgjelinek for (;;) { 7674ff17c8bfSgjelinek if (start_zoneadmd(zone_name, lock) != Z_OK) 7675ff17c8bfSgjelinek break; 7676ee519a1fSgjelinek 7677ff17c8bfSgjelinek if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 7678ff17c8bfSgjelinek zperror(gettext("failed to open zone door")); 7679ff17c8bfSgjelinek break; 7680ff17c8bfSgjelinek } 768139935be5Sgjelinek 7682ff17c8bfSgjelinek darg.data_ptr = (char *)arg; 7683ff17c8bfSgjelinek darg.data_size = sizeof (*arg); 7684ff17c8bfSgjelinek darg.desc_ptr = NULL; 7685ff17c8bfSgjelinek darg.desc_num = 0; 7686ff17c8bfSgjelinek darg.rbuf = (char *)rvalp; 7687ff17c8bfSgjelinek darg.rsize = rlen; 7688ff17c8bfSgjelinek if (door_call(doorfd, &darg) != 0) { 7689ff17c8bfSgjelinek (void) close(doorfd); 7690ff17c8bfSgjelinek /* 7691ff17c8bfSgjelinek * We'll get EBADF if the door has been revoked. 7692ff17c8bfSgjelinek */ 7693ff17c8bfSgjelinek if (errno != EBADF) { 7694ff17c8bfSgjelinek zperror(gettext("door_call failed")); 7695ff17c8bfSgjelinek break; 7696ff17c8bfSgjelinek } 7697ff17c8bfSgjelinek continue; /* take another lap */ 7698ff17c8bfSgjelinek } 7699ff17c8bfSgjelinek (void) close(doorfd); 7700ee519a1fSgjelinek 7701ff17c8bfSgjelinek if (darg.data_size == 0) { 7702ff17c8bfSgjelinek /* Door server is going away; kick it again. */ 77036cfd72c6Sgjelinek continue; 77046cfd72c6Sgjelinek } 77056cfd72c6Sgjelinek 7706ff17c8bfSgjelinek errbuf = rvalp->errbuf; 7707ff17c8bfSgjelinek while (*errbuf != '\0') { 77086cfd72c6Sgjelinek /* 7709ff17c8bfSgjelinek * Remove any newlines since zerror() 7710ff17c8bfSgjelinek * will append one automatically. 77116cfd72c6Sgjelinek */ 7712ff17c8bfSgjelinek cp = strchr(errbuf, '\n'); 7713ff17c8bfSgjelinek if (cp != NULL) 7714ff17c8bfSgjelinek *cp = '\0'; 7715ff17c8bfSgjelinek zerror(zone_name, "%s", errbuf); 7716ff17c8bfSgjelinek if (cp == NULL) 7717ff17c8bfSgjelinek break; 7718ff17c8bfSgjelinek errbuf = cp + 1; 7719ee519a1fSgjelinek } 7720ff17c8bfSgjelinek result = rvalp->rval == 0 ? 0 : -1; 7721ff17c8bfSgjelinek free(rvalp); 7722ff17c8bfSgjelinek return (result); 7723ee519a1fSgjelinek } 7724ee519a1fSgjelinek 7725ff17c8bfSgjelinek free(rvalp); 7726ff17c8bfSgjelinek return (-1); 7727ee519a1fSgjelinek } 7728cb8a054bSGlenn Faden 7729cb8a054bSGlenn Faden boolean_t 7730cb8a054bSGlenn Faden zonecfg_valid_auths(const char *auths, const char *zonename) 7731cb8a054bSGlenn Faden { 7732cb8a054bSGlenn Faden char *right; 7733cb8a054bSGlenn Faden char *tmpauths; 7734cb8a054bSGlenn Faden char *lasts; 7735cb8a054bSGlenn Faden char authname[MAXAUTHS]; 7736cb8a054bSGlenn Faden boolean_t status = B_TRUE; 7737cb8a054bSGlenn Faden 7738cb8a054bSGlenn Faden tmpauths = strdup(auths); 7739cb8a054bSGlenn Faden if (tmpauths == NULL) { 7740cb8a054bSGlenn Faden zerror(zonename, gettext("Out of memory")); 7741cb8a054bSGlenn Faden return (B_FALSE); 7742cb8a054bSGlenn Faden } 7743cb8a054bSGlenn Faden right = strtok_r(tmpauths, ",", &lasts); 7744cb8a054bSGlenn Faden while (right != NULL) { 7745cb8a054bSGlenn Faden (void) snprintf(authname, MAXAUTHS, "%s%s", 7746cb8a054bSGlenn Faden ZONE_AUTH_PREFIX, right); 7747cb8a054bSGlenn Faden if (getauthnam(authname) == NULL) { 7748cb8a054bSGlenn Faden status = B_FALSE; 7749*a20ee416SGlenn Faden zerror(zonename, 7750*a20ee416SGlenn Faden gettext("%s is not a valid authorization"), 7751cb8a054bSGlenn Faden right); 7752cb8a054bSGlenn Faden } 7753cb8a054bSGlenn Faden right = strtok_r(NULL, ",", &lasts); 7754cb8a054bSGlenn Faden } 7755cb8a054bSGlenn Faden free(tmpauths); 7756cb8a054bSGlenn Faden return (status); 7757cb8a054bSGlenn Faden } 7758cb8a054bSGlenn Faden 7759cb8a054bSGlenn Faden int 7760cb8a054bSGlenn Faden zonecfg_delete_admins(zone_dochandle_t handle, char *zonename) 7761cb8a054bSGlenn Faden { 7762cb8a054bSGlenn Faden int err; 7763cb8a054bSGlenn Faden struct zone_admintab admintab; 7764cb8a054bSGlenn Faden boolean_t changed = B_FALSE; 7765cb8a054bSGlenn Faden 7766cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 7767cb8a054bSGlenn Faden return (err); 7768cb8a054bSGlenn Faden } 7769cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 7770cb8a054bSGlenn Faden err = zonecfg_delete_admin(handle, &admintab, 7771cb8a054bSGlenn Faden zonename); 7772cb8a054bSGlenn Faden if (err != Z_OK) { 7773cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 7774cb8a054bSGlenn Faden return (err); 7775cb8a054bSGlenn Faden } else { 7776cb8a054bSGlenn Faden changed = B_TRUE; 7777cb8a054bSGlenn Faden } 7778cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 7779cb8a054bSGlenn Faden return (err); 7780cb8a054bSGlenn Faden } 7781cb8a054bSGlenn Faden } 7782cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 7783cb8a054bSGlenn Faden return (changed? Z_OK:Z_NO_ENTRY); 7784cb8a054bSGlenn Faden } 7785cb8a054bSGlenn Faden 7786cb8a054bSGlenn Faden /* 7787cb8a054bSGlenn Faden * Checks if a long authorization applies to this zone. 7788cb8a054bSGlenn Faden * If so, it returns true, after destructively stripping 7789cb8a054bSGlenn Faden * the authorization of its prefix and zone suffix. 7790cb8a054bSGlenn Faden */ 7791cb8a054bSGlenn Faden static boolean_t 7792cb8a054bSGlenn Faden is_zone_auth(char **auth, char *zonename, char *oldzonename) 7793cb8a054bSGlenn Faden { 7794cb8a054bSGlenn Faden char *suffix; 7795cb8a054bSGlenn Faden size_t offset; 7796cb8a054bSGlenn Faden 7797cb8a054bSGlenn Faden offset = strlen(ZONE_AUTH_PREFIX); 7798cb8a054bSGlenn Faden if ((strncmp(*auth, ZONE_AUTH_PREFIX, offset) == 0) && 7799cb8a054bSGlenn Faden ((suffix = strchr(*auth, '/')) != NULL)) { 7800cb8a054bSGlenn Faden if (strncmp(suffix + 1, zonename, strlen(zonename)) == 0) { 7801cb8a054bSGlenn Faden *auth += offset; 7802cb8a054bSGlenn Faden suffix[0] = '\0'; 7803cb8a054bSGlenn Faden return (B_TRUE); 7804cb8a054bSGlenn Faden } else if ((oldzonename != NULL) && 7805cb8a054bSGlenn Faden (strncmp(suffix + 1, oldzonename, 7806cb8a054bSGlenn Faden strlen(oldzonename)) == 0)) { 7807cb8a054bSGlenn Faden *auth += offset; 7808cb8a054bSGlenn Faden suffix[0] = '\0'; 7809cb8a054bSGlenn Faden return (B_TRUE); 7810cb8a054bSGlenn Faden } 7811cb8a054bSGlenn Faden } 7812cb8a054bSGlenn Faden return (B_FALSE); 7813cb8a054bSGlenn Faden } 7814cb8a054bSGlenn Faden 7815cb8a054bSGlenn Faden /* 7816cb8a054bSGlenn Faden * This function determines whether the zone-specific authorization 7817cb8a054bSGlenn Faden * assignments in /etc/user_attr have been changed more recently 7818cb8a054bSGlenn Faden * than the equivalent data stored in the zone's configuration file. 7819cb8a054bSGlenn Faden * This should only happen if the zone-specific authorizations in 7820cb8a054bSGlenn Faden * the user_attr file were modified using a tool other than zonecfg. 7821cb8a054bSGlenn Faden * If the configuration file is out-of-date with respect to these 7822cb8a054bSGlenn Faden * authorization assignments, it is updated to match those specified 7823cb8a054bSGlenn Faden * in /etc/user_attr. 7824cb8a054bSGlenn Faden */ 7825cb8a054bSGlenn Faden 7826cb8a054bSGlenn Faden int 7827cb8a054bSGlenn Faden zonecfg_update_userauths(zone_dochandle_t handle, char *zonename) 7828cb8a054bSGlenn Faden { 7829cb8a054bSGlenn Faden userattr_t *ua_ptr; 7830cb8a054bSGlenn Faden char *authlist; 7831cb8a054bSGlenn Faden char *lasts; 7832cb8a054bSGlenn Faden FILE *uaf; 7833cb8a054bSGlenn Faden struct zone_admintab admintab; 7834cb8a054bSGlenn Faden struct stat config_st, ua_st; 7835cb8a054bSGlenn Faden char config_file[MAXPATHLEN]; 7836cb8a054bSGlenn Faden boolean_t changed = B_FALSE; 7837cb8a054bSGlenn Faden int err; 7838cb8a054bSGlenn Faden 7839cb8a054bSGlenn Faden if ((uaf = fopen(USERATTR_FILENAME, "r")) == NULL) { 7840cb8a054bSGlenn Faden zerror(zonename, gettext("could not open file %s: %s"), 7841cb8a054bSGlenn Faden USERATTR_FILENAME, strerror(errno)); 7842cb8a054bSGlenn Faden if (errno == EACCES) 7843cb8a054bSGlenn Faden return (Z_ACCES); 7844cb8a054bSGlenn Faden if (errno == ENOENT) 7845cb8a054bSGlenn Faden return (Z_NO_ZONE); 7846cb8a054bSGlenn Faden return (Z_MISC_FS); 7847cb8a054bSGlenn Faden } 7848cb8a054bSGlenn Faden if ((err = fstat(fileno(uaf), &ua_st)) != 0) { 7849cb8a054bSGlenn Faden zerror(zonename, gettext("could not stat file %s: %s"), 7850cb8a054bSGlenn Faden USERATTR_FILENAME, strerror(errno)); 7851cb8a054bSGlenn Faden (void) fclose(uaf); 7852cb8a054bSGlenn Faden return (Z_MISC_FS); 7853cb8a054bSGlenn Faden } 7854cb8a054bSGlenn Faden if (!config_file_path(zonename, config_file)) { 7855cb8a054bSGlenn Faden (void) fclose(uaf); 7856cb8a054bSGlenn Faden return (Z_MISC_FS); 7857cb8a054bSGlenn Faden } 7858cb8a054bSGlenn Faden 7859cb8a054bSGlenn Faden if ((err = stat(config_file, &config_st)) != 0) { 7860cb8a054bSGlenn Faden zerror(zonename, gettext("could not stat file %s: %s"), 7861cb8a054bSGlenn Faden config_file, strerror(errno)); 7862cb8a054bSGlenn Faden (void) fclose(uaf); 7863cb8a054bSGlenn Faden return (Z_MISC_FS); 7864cb8a054bSGlenn Faden } 7865cb8a054bSGlenn Faden if (config_st.st_mtime >= ua_st.st_mtime) { 7866cb8a054bSGlenn Faden (void) fclose(uaf); 7867cb8a054bSGlenn Faden return (Z_NO_ENTRY); 7868cb8a054bSGlenn Faden } 7869cb8a054bSGlenn Faden if ((err = zonecfg_delete_admins(handle, zonename)) == Z_OK) { 7870cb8a054bSGlenn Faden changed = B_TRUE; 7871cb8a054bSGlenn Faden } else if (err != Z_NO_ENTRY) { 7872cb8a054bSGlenn Faden (void) fclose(uaf); 7873cb8a054bSGlenn Faden return (err); 7874cb8a054bSGlenn Faden } 7875cb8a054bSGlenn Faden while ((ua_ptr = fgetuserattr(uaf)) != NULL) { 7876cb8a054bSGlenn Faden if (ua_ptr->name[0] == '#') { 7877cb8a054bSGlenn Faden continue; 7878cb8a054bSGlenn Faden } 7879cb8a054bSGlenn Faden authlist = kva_match(ua_ptr->attr, USERATTR_AUTHS_KW); 7880cb8a054bSGlenn Faden if (authlist != NULL) { 7881cb8a054bSGlenn Faden char *cur_auth; 7882cb8a054bSGlenn Faden boolean_t first; 7883cb8a054bSGlenn Faden 7884cb8a054bSGlenn Faden first = B_TRUE; 7885cb8a054bSGlenn Faden bzero(&admintab.zone_admin_auths, MAXAUTHS); 7886cb8a054bSGlenn Faden cur_auth = strtok_r(authlist, ",", &lasts); 7887cb8a054bSGlenn Faden while (cur_auth != NULL) { 7888cb8a054bSGlenn Faden if (is_zone_auth(&cur_auth, zonename, 7889cb8a054bSGlenn Faden NULL)) { 7890cb8a054bSGlenn Faden /* 7891cb8a054bSGlenn Faden * Add auths for this zone 7892cb8a054bSGlenn Faden */ 7893cb8a054bSGlenn Faden if (first) { 7894cb8a054bSGlenn Faden first = B_FALSE; 7895cb8a054bSGlenn Faden } else { 7896cb8a054bSGlenn Faden (void) strlcat( 7897cb8a054bSGlenn Faden admintab.zone_admin_auths, 7898cb8a054bSGlenn Faden ",", MAXAUTHS); 7899cb8a054bSGlenn Faden } 7900cb8a054bSGlenn Faden (void) strlcat( 7901cb8a054bSGlenn Faden admintab.zone_admin_auths, 7902cb8a054bSGlenn Faden cur_auth, MAXAUTHS); 7903cb8a054bSGlenn Faden } 7904cb8a054bSGlenn Faden cur_auth = strtok_r(NULL, ",", &lasts); 7905cb8a054bSGlenn Faden } 7906cb8a054bSGlenn Faden if (!first) { 7907cb8a054bSGlenn Faden /* 7908cb8a054bSGlenn Faden * Add this right to config file 7909cb8a054bSGlenn Faden */ 7910cb8a054bSGlenn Faden (void) strlcpy(admintab.zone_admin_user, 7911cb8a054bSGlenn Faden ua_ptr->name, 7912cb8a054bSGlenn Faden sizeof (admintab.zone_admin_user)); 7913cb8a054bSGlenn Faden err = zonecfg_add_admin(handle, 7914cb8a054bSGlenn Faden &admintab, zonename); 7915cb8a054bSGlenn Faden if (err != Z_OK) { 7916cb8a054bSGlenn Faden (void) fclose(uaf); 7917cb8a054bSGlenn Faden return (err); 7918cb8a054bSGlenn Faden } else { 7919cb8a054bSGlenn Faden changed = B_TRUE; 7920cb8a054bSGlenn Faden } 7921cb8a054bSGlenn Faden } 7922cb8a054bSGlenn Faden } 7923cb8a054bSGlenn Faden } /* end-of-while-loop */ 7924cb8a054bSGlenn Faden (void) fclose(uaf); 7925cb8a054bSGlenn Faden return (changed? Z_OK: Z_NO_ENTRY); 7926cb8a054bSGlenn Faden } 7927cb8a054bSGlenn Faden 7928cb8a054bSGlenn Faden static void 7929cb8a054bSGlenn Faden update_profiles(char *rbac_profs, boolean_t add) 7930cb8a054bSGlenn Faden { 7931cb8a054bSGlenn Faden char new_profs[MAXPROFS]; 7932cb8a054bSGlenn Faden char *cur_prof; 7933cb8a054bSGlenn Faden boolean_t first = B_TRUE; 7934cb8a054bSGlenn Faden boolean_t found = B_FALSE; 7935cb8a054bSGlenn Faden char *lasts; 7936cb8a054bSGlenn Faden 7937cb8a054bSGlenn Faden cur_prof = strtok_r(rbac_profs, ",", &lasts); 7938cb8a054bSGlenn Faden while (cur_prof != NULL) { 7939cb8a054bSGlenn Faden if (strcmp(cur_prof, ZONE_MGMT_PROF) == 0) { 7940cb8a054bSGlenn Faden found = B_TRUE; 7941cb8a054bSGlenn Faden if (!add) { 7942cb8a054bSGlenn Faden cur_prof = strtok_r(NULL, ",", &lasts); 7943cb8a054bSGlenn Faden continue; 7944cb8a054bSGlenn Faden } 7945cb8a054bSGlenn Faden } 7946cb8a054bSGlenn Faden if (first) { 7947cb8a054bSGlenn Faden first = B_FALSE; 7948cb8a054bSGlenn Faden } else { 7949cb8a054bSGlenn Faden (void) strlcat(new_profs, ",", 7950cb8a054bSGlenn Faden MAXPROFS); 7951cb8a054bSGlenn Faden } 7952cb8a054bSGlenn Faden (void) strlcat(new_profs, cur_prof, 7953cb8a054bSGlenn Faden MAXPROFS); 7954cb8a054bSGlenn Faden cur_prof = strtok_r(NULL, ",", &lasts); 7955cb8a054bSGlenn Faden } 7956cb8a054bSGlenn Faden /* 7957cb8a054bSGlenn Faden * Now prepend the Zone Management profile at the beginning 7958cb8a054bSGlenn Faden * of the list if it is needed, and append the rest. 7959cb8a054bSGlenn Faden * Return the updated list in the original buffer. 7960cb8a054bSGlenn Faden */ 7961cb8a054bSGlenn Faden if (add && !found) { 7962cb8a054bSGlenn Faden first = B_FALSE; 7963cb8a054bSGlenn Faden (void) strlcpy(rbac_profs, ZONE_MGMT_PROF, MAXPROFS); 7964cb8a054bSGlenn Faden } else { 7965cb8a054bSGlenn Faden first = B_TRUE; 7966cb8a054bSGlenn Faden rbac_profs[0] = '\0'; 7967cb8a054bSGlenn Faden } 7968cb8a054bSGlenn Faden if (strlen(new_profs) > 0) { 7969cb8a054bSGlenn Faden if (!first) 7970cb8a054bSGlenn Faden (void) strlcat(rbac_profs, ",", MAXPROFS); 7971cb8a054bSGlenn Faden (void) strlcat(rbac_profs, new_profs, MAXPROFS); 7972cb8a054bSGlenn Faden } 7973cb8a054bSGlenn Faden } 7974cb8a054bSGlenn Faden 7975cb8a054bSGlenn Faden #define MAX_CMD_LEN 1024 7976cb8a054bSGlenn Faden 7977cb8a054bSGlenn Faden static int 7978cb8a054bSGlenn Faden do_subproc(char *zonename, char *cmdbuf) 7979cb8a054bSGlenn Faden { 7980cb8a054bSGlenn Faden char inbuf[MAX_CMD_LEN]; 7981cb8a054bSGlenn Faden FILE *file; 7982cb8a054bSGlenn Faden int status; 7983cb8a054bSGlenn Faden 7984cb8a054bSGlenn Faden file = popen(cmdbuf, "r"); 7985cb8a054bSGlenn Faden if (file == NULL) { 7986cb8a054bSGlenn Faden zerror(zonename, gettext("Could not launch: %s"), cmdbuf); 7987cb8a054bSGlenn Faden return (-1); 7988cb8a054bSGlenn Faden } 7989cb8a054bSGlenn Faden 7990cb8a054bSGlenn Faden while (fgets(inbuf, sizeof (inbuf), file) != NULL) 7991cb8a054bSGlenn Faden (void) fprintf(stderr, "%s", inbuf); 7992cb8a054bSGlenn Faden status = pclose(file); 7993cb8a054bSGlenn Faden 7994cb8a054bSGlenn Faden if (WIFSIGNALED(status)) { 7995cb8a054bSGlenn Faden zerror(zonename, gettext("%s unexpectedly terminated " 7996cb8a054bSGlenn Faden "due to signal %d"), 7997cb8a054bSGlenn Faden cmdbuf, WTERMSIG(status)); 7998cb8a054bSGlenn Faden return (-1); 7999cb8a054bSGlenn Faden } 8000cb8a054bSGlenn Faden assert(WIFEXITED(status)); 8001cb8a054bSGlenn Faden return (WEXITSTATUS(status)); 8002cb8a054bSGlenn Faden } 8003cb8a054bSGlenn Faden 8004cb8a054bSGlenn Faden /* 8005cb8a054bSGlenn Faden * This function updates the local /etc/user_attr file to 8006cb8a054bSGlenn Faden * correspond to the admin settings that are currently being 8007cb8a054bSGlenn Faden * committed. The updates are done via usermod and/or rolemod 8008cb8a054bSGlenn Faden * depending on the type of the specified user. It is also 8009cb8a054bSGlenn Faden * invoked to remove entries from user_attr corresponding to 8010cb8a054bSGlenn Faden * removed admin assignments, using an empty auths string. 8011cb8a054bSGlenn Faden * 8012cb8a054bSGlenn Faden * Because the removed entries are no longer included in the 8013cb8a054bSGlenn Faden * cofiguration that is being committed, a linked list of 8014cb8a054bSGlenn Faden * removed admin entries is maintained to keep track of such 8015cb8a054bSGlenn Faden * transactions. The head of the list is stored in the zone_dh_userauths 8016cb8a054bSGlenn Faden * element of the handle strcture. 8017cb8a054bSGlenn Faden */ 8018cb8a054bSGlenn Faden static int 8019cb8a054bSGlenn Faden zonecfg_authorize_user_impl(zone_dochandle_t handle, char *user, 8020cb8a054bSGlenn Faden char *auths, char *zonename) 8021cb8a054bSGlenn Faden { 8022cb8a054bSGlenn Faden char *right; 8023cb8a054bSGlenn Faden char old_auths[MAXAUTHS]; 8024cb8a054bSGlenn Faden char new_auths[MAXAUTHS]; 8025cb8a054bSGlenn Faden char rbac_profs[MAXPROFS]; 8026cb8a054bSGlenn Faden char *lasts; 8027cb8a054bSGlenn Faden userattr_t *u; 8028cb8a054bSGlenn Faden boolean_t first = B_TRUE; 8029cb8a054bSGlenn Faden boolean_t is_zone_admin = B_FALSE; 8030cb8a054bSGlenn Faden char user_cmd[] = "/usr/sbin/usermod"; 8031cb8a054bSGlenn Faden char role_cmd[] = "/usr/sbin/rolemod"; 8032cb8a054bSGlenn Faden char *auths_cmd = user_cmd; 8033cb8a054bSGlenn Faden 8034cb8a054bSGlenn Faden /* 8035cb8a054bSGlenn Faden * First get the existing authorizations for this user 8036cb8a054bSGlenn Faden */ 8037cb8a054bSGlenn Faden 8038cb8a054bSGlenn Faden bzero(&old_auths, sizeof (old_auths)); 8039cb8a054bSGlenn Faden bzero(&new_auths, sizeof (new_auths)); 8040cb8a054bSGlenn Faden bzero(&rbac_profs, sizeof (rbac_profs)); 8041cb8a054bSGlenn Faden if ((u = getusernam(user)) != NULL) { 8042cb8a054bSGlenn Faden char *current_auths; 8043cb8a054bSGlenn Faden char *current_profs; 8044cb8a054bSGlenn Faden char *type; 8045cb8a054bSGlenn Faden 8046cb8a054bSGlenn Faden type = kva_match(u->attr, USERATTR_TYPE_KW); 8047cb8a054bSGlenn Faden if (type != NULL) { 8048cb8a054bSGlenn Faden if (strcmp(type, USERATTR_TYPE_NONADMIN_KW) == 0) 8049cb8a054bSGlenn Faden auths_cmd = role_cmd; 8050cb8a054bSGlenn Faden } 8051cb8a054bSGlenn Faden 8052cb8a054bSGlenn Faden current_auths = kva_match(u->attr, USERATTR_AUTHS_KW); 8053cb8a054bSGlenn Faden if (current_auths != NULL) { 8054cb8a054bSGlenn Faden char *cur_auth; 8055cb8a054bSGlenn Faden char *delete_name; 8056cb8a054bSGlenn Faden size_t offset; 8057cb8a054bSGlenn Faden 8058cb8a054bSGlenn Faden offset = strlen(ZONE_AUTH_PREFIX); 8059cb8a054bSGlenn Faden 8060cb8a054bSGlenn Faden (void) strlcpy(old_auths, current_auths, MAXAUTHS); 8061cb8a054bSGlenn Faden cur_auth = strtok_r(current_auths, ",", &lasts); 8062cb8a054bSGlenn Faden 8063cb8a054bSGlenn Faden /* 8064cb8a054bSGlenn Faden * Next, remove any existing authorizations 8065cb8a054bSGlenn Faden * for this zone, and determine if the 8066cb8a054bSGlenn Faden * user still needs the Zone Management Profile. 8067cb8a054bSGlenn Faden */ 8068cb8a054bSGlenn Faden if (is_renaming(handle)) 8069cb8a054bSGlenn Faden delete_name = handle->zone_dh_delete_name; 8070cb8a054bSGlenn Faden else 8071cb8a054bSGlenn Faden delete_name = NULL; 8072cb8a054bSGlenn Faden while (cur_auth != NULL) { 8073cb8a054bSGlenn Faden if (!is_zone_auth(&cur_auth, zonename, 8074cb8a054bSGlenn Faden delete_name)) { 8075cb8a054bSGlenn Faden if (first) { 8076cb8a054bSGlenn Faden first = B_FALSE; 8077cb8a054bSGlenn Faden } else { 8078cb8a054bSGlenn Faden (void) strlcat(new_auths, ",", 8079cb8a054bSGlenn Faden MAXAUTHS); 8080cb8a054bSGlenn Faden } 8081cb8a054bSGlenn Faden (void) strlcat(new_auths, cur_auth, 8082cb8a054bSGlenn Faden MAXAUTHS); 8083cb8a054bSGlenn Faden /* 8084cb8a054bSGlenn Faden * If the user has authorizations 8085cb8a054bSGlenn Faden * for other zones, then set a 8086cb8a054bSGlenn Faden * flag indicate that the Zone 8087cb8a054bSGlenn Faden * Management profile should be 8088cb8a054bSGlenn Faden * preserved in user_attr. 8089cb8a054bSGlenn Faden */ 8090cb8a054bSGlenn Faden if (strncmp(cur_auth, 8091cb8a054bSGlenn Faden ZONE_AUTH_PREFIX, offset) == 0) 8092cb8a054bSGlenn Faden is_zone_admin = B_TRUE; 8093cb8a054bSGlenn Faden } 8094cb8a054bSGlenn Faden cur_auth = strtok_r(NULL, ",", &lasts); 8095cb8a054bSGlenn Faden } 8096cb8a054bSGlenn Faden } 8097cb8a054bSGlenn Faden current_profs = kva_match(u->attr, USERATTR_PROFILES_KW); 8098cb8a054bSGlenn Faden if (current_profs != NULL) { 8099cb8a054bSGlenn Faden (void) strlcpy(rbac_profs, current_profs, MAXPROFS); 8100cb8a054bSGlenn Faden } 8101cb8a054bSGlenn Faden free_userattr(u); 8102cb8a054bSGlenn Faden } 8103cb8a054bSGlenn Faden /* 8104cb8a054bSGlenn Faden * The following is done to avoid revisiting the 8105cb8a054bSGlenn Faden * user_attr entry for this user 8106cb8a054bSGlenn Faden */ 8107cb8a054bSGlenn Faden (void) zonecfg_remove_userauths(handle, user, "", B_FALSE); 8108cb8a054bSGlenn Faden 8109cb8a054bSGlenn Faden /* 8110cb8a054bSGlenn Faden * Convert each right into a properly formatted authorization 8111cb8a054bSGlenn Faden */ 8112cb8a054bSGlenn Faden right = strtok_r(auths, ",", &lasts); 8113cb8a054bSGlenn Faden while (right != NULL) { 8114cb8a054bSGlenn Faden char auth[MAXAUTHS]; 8115cb8a054bSGlenn Faden 8116cb8a054bSGlenn Faden (void) snprintf(auth, MAXAUTHS, "%s%s/%s", 8117cb8a054bSGlenn Faden ZONE_AUTH_PREFIX, right, zonename); 8118cb8a054bSGlenn Faden if (first) { 8119cb8a054bSGlenn Faden first = B_FALSE; 8120cb8a054bSGlenn Faden } else { 8121cb8a054bSGlenn Faden (void) strlcat(new_auths, ",", MAXAUTHS); 8122cb8a054bSGlenn Faden } 8123cb8a054bSGlenn Faden (void) strlcat(new_auths, auth, MAXAUTHS); 8124cb8a054bSGlenn Faden is_zone_admin = B_TRUE; 8125cb8a054bSGlenn Faden right = strtok_r(NULL, ",", &lasts); 8126cb8a054bSGlenn Faden } 8127cb8a054bSGlenn Faden 8128cb8a054bSGlenn Faden /* 8129cb8a054bSGlenn Faden * If the user's previous authorizations have changed 8130cb8a054bSGlenn Faden * execute the usermod progam to update them in user_attr 8131cb8a054bSGlenn Faden */ 8132cb8a054bSGlenn Faden if (strcmp(old_auths, new_auths) != 0) { 8133cb8a054bSGlenn Faden char *cmdbuf; 8134cb8a054bSGlenn Faden size_t cmd_len; 8135cb8a054bSGlenn Faden 8136cb8a054bSGlenn Faden update_profiles(rbac_profs, is_zone_admin); 8137cb8a054bSGlenn Faden cmd_len = snprintf(NULL, 0, "%s -A \"%s\" -P \"%s\" %s", 8138cb8a054bSGlenn Faden auths_cmd, new_auths, rbac_profs, user) + 1; 8139cb8a054bSGlenn Faden if ((cmdbuf = malloc(cmd_len)) == NULL) { 8140cb8a054bSGlenn Faden return (Z_NOMEM); 8141cb8a054bSGlenn Faden } 8142cb8a054bSGlenn Faden (void) snprintf(cmdbuf, cmd_len, "%s -A \"%s\" -P \"%s\" %s", 8143cb8a054bSGlenn Faden auths_cmd, new_auths, rbac_profs, user); 8144cb8a054bSGlenn Faden if (do_subproc(zonename, cmdbuf) != 0) { 8145cb8a054bSGlenn Faden free(cmdbuf); 8146cb8a054bSGlenn Faden return (Z_SYSTEM); 8147cb8a054bSGlenn Faden } 8148cb8a054bSGlenn Faden free(cmdbuf); 8149cb8a054bSGlenn Faden } 8150cb8a054bSGlenn Faden 8151cb8a054bSGlenn Faden return (Z_OK); 8152cb8a054bSGlenn Faden } 8153cb8a054bSGlenn Faden 8154cb8a054bSGlenn Faden int 8155cb8a054bSGlenn Faden zonecfg_authorize_users(zone_dochandle_t handle, char *zonename) 8156cb8a054bSGlenn Faden { 8157cb8a054bSGlenn Faden xmlNodePtr cur; 8158cb8a054bSGlenn Faden int err; 8159cb8a054bSGlenn Faden char user[MAXUSERNAME]; 8160cb8a054bSGlenn Faden char auths[MAXAUTHS]; 8161cb8a054bSGlenn Faden 8162cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 8163cb8a054bSGlenn Faden return (err); 8164cb8a054bSGlenn Faden 8165cb8a054bSGlenn Faden cur = handle->zone_dh_cur; 8166cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 8167cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 8168cb8a054bSGlenn Faden continue; 8169cb8a054bSGlenn Faden if (fetchprop(cur, DTD_ATTR_USER, user, 8170cb8a054bSGlenn Faden sizeof (user)) != Z_OK) 8171cb8a054bSGlenn Faden continue; 8172cb8a054bSGlenn Faden if (fetchprop(cur, DTD_ATTR_AUTHS, auths, 8173cb8a054bSGlenn Faden sizeof (auths)) != Z_OK) 8174cb8a054bSGlenn Faden continue; 8175cb8a054bSGlenn Faden if (zonecfg_authorize_user_impl(handle, user, auths, zonename) 8176cb8a054bSGlenn Faden != Z_OK) 8177cb8a054bSGlenn Faden return (Z_SYSTEM); 8178cb8a054bSGlenn Faden } 8179cb8a054bSGlenn Faden (void) zonecfg_remove_userauths(handle, "", "", B_TRUE); 8180cb8a054bSGlenn Faden 8181cb8a054bSGlenn Faden return (Z_OK); 8182cb8a054bSGlenn Faden } 8183cb8a054bSGlenn Faden 8184cb8a054bSGlenn Faden int 8185cb8a054bSGlenn Faden zonecfg_deauthorize_user(zone_dochandle_t handle, char *user, char *zonename) 8186cb8a054bSGlenn Faden { 8187cb8a054bSGlenn Faden return (zonecfg_authorize_user_impl(handle, user, "", zonename)); 8188cb8a054bSGlenn Faden } 8189cb8a054bSGlenn Faden 8190cb8a054bSGlenn Faden int 8191cb8a054bSGlenn Faden zonecfg_deauthorize_users(zone_dochandle_t handle, char *zonename) 8192cb8a054bSGlenn Faden { 8193cb8a054bSGlenn Faden xmlNodePtr cur; 8194cb8a054bSGlenn Faden int err; 8195cb8a054bSGlenn Faden char user[MAXUSERNAME]; 8196cb8a054bSGlenn Faden 8197cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 8198cb8a054bSGlenn Faden return (err); 8199cb8a054bSGlenn Faden 8200cb8a054bSGlenn Faden cur = handle->zone_dh_cur; 8201cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 8202cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 8203cb8a054bSGlenn Faden continue; 8204cb8a054bSGlenn Faden if (fetchprop(cur, DTD_ATTR_USER, user, 8205cb8a054bSGlenn Faden sizeof (user)) != Z_OK) 8206cb8a054bSGlenn Faden continue; 8207cb8a054bSGlenn Faden if ((err = zonecfg_deauthorize_user(handle, user, 8208cb8a054bSGlenn Faden zonename)) != Z_OK) 8209cb8a054bSGlenn Faden return (err); 8210cb8a054bSGlenn Faden } 8211cb8a054bSGlenn Faden return (Z_OK); 8212cb8a054bSGlenn Faden } 8213cb8a054bSGlenn Faden 8214cb8a054bSGlenn Faden int 8215cb8a054bSGlenn Faden zonecfg_insert_userauths(zone_dochandle_t handle, char *user, char *zonename) 8216cb8a054bSGlenn Faden { 8217cb8a054bSGlenn Faden zone_userauths_t *new, **prev, *next; 8218cb8a054bSGlenn Faden 8219cb8a054bSGlenn Faden prev = &handle->zone_dh_userauths; 8220cb8a054bSGlenn Faden next = *prev; 8221cb8a054bSGlenn Faden while (next) { 8222cb8a054bSGlenn Faden if ((strncmp(next->user, user, MAXUSERNAME) == 0) && 8223cb8a054bSGlenn Faden (strncmp(next->zonename, zonename, 8224cb8a054bSGlenn Faden ZONENAME_MAX) == 0)) { 8225cb8a054bSGlenn Faden /* 8226cb8a054bSGlenn Faden * user is already in list 8227cb8a054bSGlenn Faden * which isn't supposed to happen! 8228cb8a054bSGlenn Faden */ 8229cb8a054bSGlenn Faden return (Z_OK); 8230cb8a054bSGlenn Faden } 8231cb8a054bSGlenn Faden prev = &next->next; 8232cb8a054bSGlenn Faden next = *prev; 8233cb8a054bSGlenn Faden } 8234cb8a054bSGlenn Faden new = (zone_userauths_t *)malloc(sizeof (zone_userauths_t)); 8235cb8a054bSGlenn Faden if (new == NULL) 8236cb8a054bSGlenn Faden return (Z_NOMEM); 8237cb8a054bSGlenn Faden 8238cb8a054bSGlenn Faden (void) strlcpy(new->user, user, sizeof (new->user)); 8239cb8a054bSGlenn Faden (void) strlcpy(new->zonename, zonename, sizeof (new->zonename)); 8240cb8a054bSGlenn Faden new->next = NULL; 8241cb8a054bSGlenn Faden *prev = new; 8242cb8a054bSGlenn Faden return (Z_OK); 8243cb8a054bSGlenn Faden } 8244cb8a054bSGlenn Faden 8245cb8a054bSGlenn Faden int 8246cb8a054bSGlenn Faden zonecfg_remove_userauths(zone_dochandle_t handle, char *user, char *zonename, 8247cb8a054bSGlenn Faden boolean_t deauthorize) 8248cb8a054bSGlenn Faden { 8249cb8a054bSGlenn Faden zone_userauths_t *new, **prev, *next; 8250cb8a054bSGlenn Faden 8251cb8a054bSGlenn Faden prev = &handle->zone_dh_userauths; 8252cb8a054bSGlenn Faden next = *prev; 8253cb8a054bSGlenn Faden 8254cb8a054bSGlenn Faden while (next) { 8255cb8a054bSGlenn Faden if ((strlen(user) == 0 || 8256cb8a054bSGlenn Faden strncmp(next->user, user, MAXUSERNAME) == 0) && 8257cb8a054bSGlenn Faden (strlen(zonename) == 0 || 8258cb8a054bSGlenn Faden (strncmp(next->zonename, zonename, ZONENAME_MAX) == 0))) { 8259cb8a054bSGlenn Faden new = next; 8260cb8a054bSGlenn Faden *prev = next->next; 8261cb8a054bSGlenn Faden next = *prev; 8262cb8a054bSGlenn Faden if (deauthorize) 8263cb8a054bSGlenn Faden (void) zonecfg_deauthorize_user(handle, 8264cb8a054bSGlenn Faden new->user, new->zonename); 8265cb8a054bSGlenn Faden free(new); 8266cb8a054bSGlenn Faden continue; 8267cb8a054bSGlenn Faden } 8268cb8a054bSGlenn Faden prev = &next->next; 8269cb8a054bSGlenn Faden next = *prev; 8270cb8a054bSGlenn Faden } 8271cb8a054bSGlenn Faden return (Z_OK); 8272cb8a054bSGlenn Faden } 8273