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 /* 235e74f94dSGary Mills * Copyright 2014 Gary Mills 24a20ee416SGlenn Faden * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 25*bd93c05dSAlexander Eremin * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 267c478bd9Sstevel@tonic-gate */ 277c478bd9Sstevel@tonic-gate 28cf8f45c7Sdstaff #include <libsysevent.h> 29cf8f45c7Sdstaff #include <pthread.h> 30cf8f45c7Sdstaff #include <stdlib.h> 317c478bd9Sstevel@tonic-gate #include <errno.h> 327c478bd9Sstevel@tonic-gate #include <fnmatch.h> 337c478bd9Sstevel@tonic-gate #include <strings.h> 347c478bd9Sstevel@tonic-gate #include <unistd.h> 357c478bd9Sstevel@tonic-gate #include <assert.h> 367c478bd9Sstevel@tonic-gate #include <libgen.h> 377c478bd9Sstevel@tonic-gate #include <libintl.h> 387c478bd9Sstevel@tonic-gate #include <alloca.h> 397c478bd9Sstevel@tonic-gate #include <ctype.h> 409acbbeafSnn #include <sys/acl.h> 419acbbeafSnn #include <sys/stat.h> 429acbbeafSnn #include <sys/brand.h> 437c478bd9Sstevel@tonic-gate #include <sys/mntio.h> 447c478bd9Sstevel@tonic-gate #include <sys/mnttab.h> 45cf8f45c7Sdstaff #include <sys/nvpair.h> 469acbbeafSnn #include <sys/types.h> 47f4b3ec61Sdh #include <sys/sockio.h> 485679c89fSjv #include <sys/systeminfo.h> 49ee519a1fSgjelinek #include <ftw.h> 500209230bSgjelinek #include <pool.h> 510209230bSgjelinek #include <libscf.h> 520209230bSgjelinek #include <libproc.h> 530209230bSgjelinek #include <sys/priocntl.h> 5439935be5Sgjelinek #include <libuutil.h> 55ff17c8bfSgjelinek #include <wait.h> 56ff17c8bfSgjelinek #include <bsm/adt.h> 57cb8a054bSGlenn Faden #include <auth_attr.h> 58cb8a054bSGlenn Faden #include <auth_list.h> 59cb8a054bSGlenn Faden #include <secdb.h> 60cb8a054bSGlenn Faden #include <user_attr.h> 61cb8a054bSGlenn Faden #include <prof_attr.h> 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 647c478bd9Sstevel@tonic-gate #include <netdb.h> 657c478bd9Sstevel@tonic-gate 667c478bd9Sstevel@tonic-gate #include <libxml/xmlmemory.h> 677c478bd9Sstevel@tonic-gate #include <libxml/parser.h> 687c478bd9Sstevel@tonic-gate 697c478bd9Sstevel@tonic-gate #include <libdevinfo.h> 70108322fbScarlsonj #include <uuid/uuid.h> 71ee519a1fSgjelinek #include <dirent.h> 729acbbeafSnn #include <libbrand.h> 73ee519a1fSgjelinek 747c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 757c478bd9Sstevel@tonic-gate #include "zonecfg_impl.h" 767c478bd9Sstevel@tonic-gate 777c478bd9Sstevel@tonic-gate #define _PATH_TMPFILE "/zonecfg.XXXXXX" 78cf8f45c7Sdstaff #define ZONE_CB_RETRY_COUNT 10 79cf8f45c7Sdstaff #define ZONE_EVENT_PING_SUBCLASS "ping" 80cf8f45c7Sdstaff #define ZONE_EVENT_PING_PUBLISHER "solaris" 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate /* Hard-code the DTD element/attribute/entity names just once, here. */ 837c478bd9Sstevel@tonic-gate #define DTD_ELEM_ATTR (const xmlChar *) "attr" 847c478bd9Sstevel@tonic-gate #define DTD_ELEM_COMMENT (const xmlChar *) "comment" 857c478bd9Sstevel@tonic-gate #define DTD_ELEM_DEVICE (const xmlChar *) "device" 867c478bd9Sstevel@tonic-gate #define DTD_ELEM_FS (const xmlChar *) "filesystem" 877c478bd9Sstevel@tonic-gate #define DTD_ELEM_FSOPTION (const xmlChar *) "fsoption" 887c478bd9Sstevel@tonic-gate #define DTD_ELEM_NET (const xmlChar *) "network" 897c478bd9Sstevel@tonic-gate #define DTD_ELEM_RCTL (const xmlChar *) "rctl" 907c478bd9Sstevel@tonic-gate #define DTD_ELEM_RCTLVALUE (const xmlChar *) "rctl-value" 917c478bd9Sstevel@tonic-gate #define DTD_ELEM_ZONE (const xmlChar *) "zone" 92fa9e4066Sahrens #define DTD_ELEM_DATASET (const xmlChar *) "dataset" 930209230bSgjelinek #define DTD_ELEM_TMPPOOL (const xmlChar *) "tmp_pool" 940209230bSgjelinek #define DTD_ELEM_PSET (const xmlChar *) "pset" 950209230bSgjelinek #define DTD_ELEM_MCAP (const xmlChar *) "mcap" 96ee519a1fSgjelinek #define DTD_ELEM_PACKAGE (const xmlChar *) "package" 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" 103550b6e40SSowmini Varadhan #define DTD_ATTR_ALLOWED_ADDRESS (const xmlChar *) "allowed-address" 1047c478bd9Sstevel@tonic-gate #define DTD_ATTR_AUTOBOOT (const xmlChar *) "autoboot" 105f4b3ec61Sdh #define DTD_ATTR_IPTYPE (const xmlChar *) "ip-type" 106de860bd9Sgfaden #define DTD_ATTR_DEFROUTER (const xmlChar *) "defrouter" 1077c478bd9Sstevel@tonic-gate #define DTD_ATTR_DIR (const xmlChar *) "directory" 1087c478bd9Sstevel@tonic-gate #define DTD_ATTR_LIMIT (const xmlChar *) "limit" 109ffbafc53Scomay #define DTD_ATTR_LIMITPRIV (const xmlChar *) "limitpriv" 1103f2f09c1Sdp #define DTD_ATTR_BOOTARGS (const xmlChar *) "bootargs" 1110209230bSgjelinek #define DTD_ATTR_SCHED (const xmlChar *) "scheduling-class" 1127c478bd9Sstevel@tonic-gate #define DTD_ATTR_MATCH (const xmlChar *) "match" 1137c478bd9Sstevel@tonic-gate #define DTD_ATTR_NAME (const xmlChar *) "name" 1147c478bd9Sstevel@tonic-gate #define DTD_ATTR_PHYSICAL (const xmlChar *) "physical" 1157c478bd9Sstevel@tonic-gate #define DTD_ATTR_POOL (const xmlChar *) "pool" 1167c478bd9Sstevel@tonic-gate #define DTD_ATTR_PRIV (const xmlChar *) "priv" 1177c478bd9Sstevel@tonic-gate #define DTD_ATTR_RAW (const xmlChar *) "raw" 1187c478bd9Sstevel@tonic-gate #define DTD_ATTR_SPECIAL (const xmlChar *) "special" 1197c478bd9Sstevel@tonic-gate #define DTD_ATTR_TYPE (const xmlChar *) "type" 1207c478bd9Sstevel@tonic-gate #define DTD_ATTR_VALUE (const xmlChar *) "value" 1217c478bd9Sstevel@tonic-gate #define DTD_ATTR_ZONEPATH (const xmlChar *) "zonepath" 1220209230bSgjelinek #define DTD_ATTR_NCPU_MIN (const xmlChar *) "ncpu_min" 1230209230bSgjelinek #define DTD_ATTR_NCPU_MAX (const xmlChar *) "ncpu_max" 1240209230bSgjelinek #define DTD_ATTR_IMPORTANCE (const xmlChar *) "importance" 1250209230bSgjelinek #define DTD_ATTR_PHYSCAP (const xmlChar *) "physcap" 126ee519a1fSgjelinek #define DTD_ATTR_VERSION (const xmlChar *) "version" 127ee519a1fSgjelinek #define DTD_ATTR_ID (const xmlChar *) "id" 128ee519a1fSgjelinek #define DTD_ATTR_UID (const xmlChar *) "uid" 129ee519a1fSgjelinek #define DTD_ATTR_GID (const xmlChar *) "gid" 130ee519a1fSgjelinek #define DTD_ATTR_MODE (const xmlChar *) "mode" 131ee519a1fSgjelinek #define DTD_ATTR_ACL (const xmlChar *) "acl" 1329acbbeafSnn #define DTD_ATTR_BRAND (const xmlChar *) "brand" 1335679c89fSjv #define DTD_ATTR_HOSTID (const xmlChar *) "hostid" 134cb8a054bSGlenn Faden #define DTD_ATTR_USER (const xmlChar *) "user" 135cb8a054bSGlenn Faden #define DTD_ATTR_AUTHS (const xmlChar *) "auths" 1360fbb751dSJohn Levon #define DTD_ATTR_FS_ALLOWED (const xmlChar *) "fs-allowed" 1377c478bd9Sstevel@tonic-gate 1387c478bd9Sstevel@tonic-gate #define DTD_ENTITY_BOOLEAN "boolean" 1397c478bd9Sstevel@tonic-gate #define DTD_ENTITY_DEVPATH "devpath" 1407c478bd9Sstevel@tonic-gate #define DTD_ENTITY_DRIVER "driver" 1417c478bd9Sstevel@tonic-gate #define DTD_ENTITY_DRVMIN "drv_min" 1427c478bd9Sstevel@tonic-gate #define DTD_ENTITY_FALSE "false" 1437c478bd9Sstevel@tonic-gate #define DTD_ENTITY_INT "int" 1447c478bd9Sstevel@tonic-gate #define DTD_ENTITY_STRING "string" 1457c478bd9Sstevel@tonic-gate #define DTD_ENTITY_TRUE "true" 1467c478bd9Sstevel@tonic-gate #define DTD_ENTITY_UINT "uint" 1477c478bd9Sstevel@tonic-gate 148a1be23daSdp #define DTD_ENTITY_BOOL_LEN 6 /* "false" */ 149a1be23daSdp 150ee519a1fSgjelinek #define ATTACH_FORCED "SUNWattached.xml" 151ee519a1fSgjelinek 1520209230bSgjelinek #define TMP_POOL_NAME "SUNWtmp_%s" 1530209230bSgjelinek #define MAX_TMP_POOL_NAME (ZONENAME_MAX + 9) 1540209230bSgjelinek #define RCAP_SERVICE "system/rcap:default" 1550209230bSgjelinek #define POOLD_SERVICE "system/pools/dynamic:default" 1560209230bSgjelinek 1570209230bSgjelinek /* 1580209230bSgjelinek * rctl alias definitions 1590209230bSgjelinek * 1600209230bSgjelinek * This holds the alias, the full rctl name, the default priv value, action 1610209230bSgjelinek * and lower limit. The functions that handle rctl aliases step through 1620209230bSgjelinek * this table, matching on the alias, and using the full values for setting 1630209230bSgjelinek * the rctl entry as well the limit for validation. 1640209230bSgjelinek */ 1650209230bSgjelinek static struct alias { 1660209230bSgjelinek char *shortname; 1670209230bSgjelinek char *realname; 1680209230bSgjelinek char *priv; 1690209230bSgjelinek char *action; 1700209230bSgjelinek uint64_t low_limit; 1710209230bSgjelinek } aliases[] = { 1720209230bSgjelinek {ALIAS_MAXLWPS, "zone.max-lwps", "privileged", "deny", 100}, 1730209230bSgjelinek {ALIAS_MAXSHMMEM, "zone.max-shm-memory", "privileged", "deny", 0}, 1740209230bSgjelinek {ALIAS_MAXSHMIDS, "zone.max-shm-ids", "privileged", "deny", 0}, 1750209230bSgjelinek {ALIAS_MAXMSGIDS, "zone.max-msg-ids", "privileged", "deny", 0}, 1760209230bSgjelinek {ALIAS_MAXSEMIDS, "zone.max-sem-ids", "privileged", "deny", 0}, 1770209230bSgjelinek {ALIAS_MAXLOCKEDMEM, "zone.max-locked-memory", "privileged", "deny", 0}, 1780209230bSgjelinek {ALIAS_MAXSWAP, "zone.max-swap", "privileged", "deny", 0}, 1790209230bSgjelinek {ALIAS_SHARES, "zone.cpu-shares", "privileged", "none", 0}, 180c97ad5cdSakolb {ALIAS_CPUCAP, "zone.cpu-cap", "privileged", "deny", 0}, 181ff19e029SMenno Lageman {ALIAS_MAXPROCS, "zone.max-processes", "privileged", "deny", 100}, 1820209230bSgjelinek {NULL, NULL, NULL, NULL, 0} 1830209230bSgjelinek }; 1840209230bSgjelinek 1850209230bSgjelinek /* 1860209230bSgjelinek * Structure for applying rctls to a running zone. It allows important 1870209230bSgjelinek * process values to be passed together easily. 1880209230bSgjelinek */ 1890209230bSgjelinek typedef struct pr_info_handle { 1900209230bSgjelinek struct ps_prochandle *pr; 1910209230bSgjelinek pid_t pid; 1920209230bSgjelinek } pr_info_handle_t; 1930209230bSgjelinek 1947c478bd9Sstevel@tonic-gate struct zone_dochandle { 1957c478bd9Sstevel@tonic-gate char *zone_dh_rootdir; 1967c478bd9Sstevel@tonic-gate xmlDocPtr zone_dh_doc; 1977c478bd9Sstevel@tonic-gate xmlNodePtr zone_dh_cur; 1987c478bd9Sstevel@tonic-gate xmlNodePtr zone_dh_top; 199087719fdSdp boolean_t zone_dh_newzone; 200087719fdSdp boolean_t zone_dh_snapshot; 201ee519a1fSgjelinek boolean_t zone_dh_sw_inv; 202cb8a054bSGlenn Faden zone_userauths_t *zone_dh_userauths; 203087719fdSdp char zone_dh_delete_name[ZONENAME_MAX]; 2047c478bd9Sstevel@tonic-gate }; 2057c478bd9Sstevel@tonic-gate 206cf8f45c7Sdstaff struct znotify { 207cf8f45c7Sdstaff void * zn_private; 208cf8f45c7Sdstaff evchan_t *zn_eventchan; 209cf8f45c7Sdstaff int (*zn_callback)(const char *zonename, zoneid_t zid, 210cf8f45c7Sdstaff const char *newstate, const char *oldstate, hrtime_t when, void *p); 211cf8f45c7Sdstaff pthread_mutex_t zn_mutex; 212cf8f45c7Sdstaff pthread_cond_t zn_cond; 213cf8f45c7Sdstaff pthread_mutex_t zn_bigmutex; 214cf8f45c7Sdstaff volatile enum {ZN_UNLOCKED, ZN_LOCKED, ZN_PING_INFLIGHT, 215cf8f45c7Sdstaff ZN_PING_RECEIVED} zn_state; 216cf8f45c7Sdstaff char zn_subscriber_id[MAX_SUBID_LEN]; 217cf8f45c7Sdstaff volatile boolean_t zn_failed; 218cf8f45c7Sdstaff int zn_failure_count; 219cf8f45c7Sdstaff }; 220cf8f45c7Sdstaff 221ff17c8bfSgjelinek /* used to track nested zone-lock operations */ 222ff17c8bfSgjelinek static int zone_lock_cnt = 0; 2236cfd72c6Sgjelinek 224ff17c8bfSgjelinek /* used to communicate lock status to children */ 225ff17c8bfSgjelinek #define LOCK_ENV_VAR "_ZONEADM_LOCK_HELD" 226ff17c8bfSgjelinek static char zoneadm_lock_held[] = LOCK_ENV_VAR"=1"; 227ff17c8bfSgjelinek static char zoneadm_lock_not_held[] = LOCK_ENV_VAR"=0"; 22839935be5Sgjelinek 229108322fbScarlsonj char *zonecfg_root = ""; 230108322fbScarlsonj 2317c478bd9Sstevel@tonic-gate /* 2327c478bd9Sstevel@tonic-gate * For functions which return int, which is most of the functions herein, 2337c478bd9Sstevel@tonic-gate * the return values should be from the Z_foo set defined in <libzonecfg.h>. 2347c478bd9Sstevel@tonic-gate * In some instances, we take pains mapping some libc errno values to Z_foo 2357c478bd9Sstevel@tonic-gate * values from this set. 2367c478bd9Sstevel@tonic-gate */ 2377c478bd9Sstevel@tonic-gate 238108322fbScarlsonj /* 239108322fbScarlsonj * Set the root (/) path for all zonecfg configuration files. This is a 240108322fbScarlsonj * private interface used by Live Upgrade extensions to access zone 241108322fbScarlsonj * configuration inside mounted alternate boot environments. 2422a8b76b2SSusan Kamm-Worrell * This interface is also used by zoneadm mount and unmount subcommands. 243108322fbScarlsonj */ 244108322fbScarlsonj void 245108322fbScarlsonj zonecfg_set_root(const char *rootpath) 246108322fbScarlsonj { 247108322fbScarlsonj if (*zonecfg_root != '\0') 248108322fbScarlsonj free(zonecfg_root); 249108322fbScarlsonj if (rootpath == NULL || rootpath[0] == '\0' || rootpath[1] == '\0' || 250108322fbScarlsonj (zonecfg_root = strdup(rootpath)) == NULL) 251108322fbScarlsonj zonecfg_root = ""; 252108322fbScarlsonj } 253108322fbScarlsonj 254108322fbScarlsonj const char * 255108322fbScarlsonj zonecfg_get_root(void) 256108322fbScarlsonj { 257108322fbScarlsonj return (zonecfg_root); 258108322fbScarlsonj } 259108322fbScarlsonj 260108322fbScarlsonj boolean_t 261108322fbScarlsonj zonecfg_in_alt_root(void) 262108322fbScarlsonj { 263108322fbScarlsonj return (*zonecfg_root != '\0'); 264108322fbScarlsonj } 265108322fbScarlsonj 2667c478bd9Sstevel@tonic-gate /* 2677c478bd9Sstevel@tonic-gate * Callers of the _file_path() functions are expected to have the second 2687c478bd9Sstevel@tonic-gate * parameter be a (char foo[MAXPATHLEN]). 2697c478bd9Sstevel@tonic-gate */ 2707c478bd9Sstevel@tonic-gate 271108322fbScarlsonj static boolean_t 2727c478bd9Sstevel@tonic-gate config_file_path(const char *zonename, char *answer) 2737c478bd9Sstevel@tonic-gate { 274108322fbScarlsonj return (snprintf(answer, MAXPATHLEN, "%s%s/%s.xml", zonecfg_root, 275108322fbScarlsonj ZONE_CONFIG_ROOT, zonename) < MAXPATHLEN); 2767c478bd9Sstevel@tonic-gate } 2777c478bd9Sstevel@tonic-gate 278108322fbScarlsonj static boolean_t 279108322fbScarlsonj snap_file_path(const char *zonename, char *answer) 2807c478bd9Sstevel@tonic-gate { 281108322fbScarlsonj return (snprintf(answer, MAXPATHLEN, "%s%s/%s.snapshot.xml", 282108322fbScarlsonj zonecfg_root, ZONE_SNAPSHOT_ROOT, zonename) < MAXPATHLEN); 2837c478bd9Sstevel@tonic-gate } 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2867c478bd9Sstevel@tonic-gate static void 2877c478bd9Sstevel@tonic-gate zonecfg_error_func(void *ctx, const char *msg, ...) 2887c478bd9Sstevel@tonic-gate { 2897c478bd9Sstevel@tonic-gate /* 2907c478bd9Sstevel@tonic-gate * This function does nothing by design. Its purpose is to prevent 2917c478bd9Sstevel@tonic-gate * libxml from dumping unwanted messages to stdout/stderr. 2927c478bd9Sstevel@tonic-gate */ 2937c478bd9Sstevel@tonic-gate } 2947c478bd9Sstevel@tonic-gate 2957c478bd9Sstevel@tonic-gate zone_dochandle_t 2967c478bd9Sstevel@tonic-gate zonecfg_init_handle(void) 2977c478bd9Sstevel@tonic-gate { 298087719fdSdp zone_dochandle_t handle = calloc(1, sizeof (struct zone_dochandle)); 2997c478bd9Sstevel@tonic-gate if (handle == NULL) { 3007c478bd9Sstevel@tonic-gate errno = Z_NOMEM; 3017c478bd9Sstevel@tonic-gate return (NULL); 3027c478bd9Sstevel@tonic-gate } 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate /* generic libxml initialization */ 305ced33dd6Sjv (void) xmlLineNumbersDefault(1); 3067c478bd9Sstevel@tonic-gate xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS; 3077c478bd9Sstevel@tonic-gate xmlDoValidityCheckingDefaultValue = 1; 3087c478bd9Sstevel@tonic-gate (void) xmlKeepBlanksDefault(0); 3097c478bd9Sstevel@tonic-gate xmlGetWarningsDefaultValue = 0; 3107c478bd9Sstevel@tonic-gate xmlSetGenericErrorFunc(NULL, zonecfg_error_func); 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate return (handle); 3137c478bd9Sstevel@tonic-gate } 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate int 3167c478bd9Sstevel@tonic-gate zonecfg_check_handle(zone_dochandle_t handle) 3177c478bd9Sstevel@tonic-gate { 3187c478bd9Sstevel@tonic-gate if (handle == NULL || handle->zone_dh_doc == NULL) 3197c478bd9Sstevel@tonic-gate return (Z_BAD_HANDLE); 3207c478bd9Sstevel@tonic-gate return (Z_OK); 3217c478bd9Sstevel@tonic-gate } 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate void 3247c478bd9Sstevel@tonic-gate zonecfg_fini_handle(zone_dochandle_t handle) 3257c478bd9Sstevel@tonic-gate { 3267c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) == Z_OK) 3277c478bd9Sstevel@tonic-gate xmlFreeDoc(handle->zone_dh_doc); 3287c478bd9Sstevel@tonic-gate if (handle != NULL) 3297c478bd9Sstevel@tonic-gate free(handle); 3307c478bd9Sstevel@tonic-gate } 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate static int 3337c478bd9Sstevel@tonic-gate zonecfg_destroy_impl(char *filename) 3347c478bd9Sstevel@tonic-gate { 3357c478bd9Sstevel@tonic-gate if (unlink(filename) == -1) { 3367c478bd9Sstevel@tonic-gate if (errno == EACCES) 3377c478bd9Sstevel@tonic-gate return (Z_ACCES); 3387c478bd9Sstevel@tonic-gate if (errno == ENOENT) 3397c478bd9Sstevel@tonic-gate return (Z_NO_ZONE); 3407c478bd9Sstevel@tonic-gate return (Z_MISC_FS); 3417c478bd9Sstevel@tonic-gate } 3427c478bd9Sstevel@tonic-gate return (Z_OK); 3437c478bd9Sstevel@tonic-gate } 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate int 346087719fdSdp zonecfg_destroy(const char *zonename, boolean_t force) 3477c478bd9Sstevel@tonic-gate { 3487c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 349087719fdSdp struct zoneent ze; 350087719fdSdp int err, state_err; 351087719fdSdp zone_state_t state; 3527c478bd9Sstevel@tonic-gate 353108322fbScarlsonj if (!config_file_path(zonename, path)) 354108322fbScarlsonj return (Z_MISC_FS); 355087719fdSdp 356087719fdSdp state_err = zone_get_state((char *)zonename, &state); 357087719fdSdp err = access(path, W_OK); 358087719fdSdp 359087719fdSdp /* 360087719fdSdp * If there is no file, and no index entry, reliably indicate that no 361087719fdSdp * such zone exists. 362087719fdSdp */ 363087719fdSdp if ((state_err == Z_NO_ZONE) && (err == -1) && (errno == ENOENT)) 364087719fdSdp return (Z_NO_ZONE); 365087719fdSdp 366087719fdSdp /* 367087719fdSdp * Handle any other filesystem related errors (except if the XML 368087719fdSdp * file is missing, which we treat silently), unless we're forcing, 369087719fdSdp * in which case we plow on. 370087719fdSdp */ 371087719fdSdp if (err == -1 && errno != ENOENT) { 372087719fdSdp if (errno == EACCES) 373087719fdSdp return (Z_ACCES); 374087719fdSdp else if (!force) 375087719fdSdp return (Z_MISC_FS); 376087719fdSdp } 377087719fdSdp 378087719fdSdp if (state > ZONE_STATE_INSTALLED) 379087719fdSdp return (Z_BAD_ZONE_STATE); 380087719fdSdp 381087719fdSdp if (!force && state > ZONE_STATE_CONFIGURED) 382087719fdSdp return (Z_BAD_ZONE_STATE); 383087719fdSdp 384087719fdSdp /* 385087719fdSdp * Index deletion succeeds even if the entry doesn't exist. So this 386087719fdSdp * will fail only if we've had some more severe problem. 387087719fdSdp */ 388087719fdSdp bzero(&ze, sizeof (ze)); 389087719fdSdp (void) strlcpy(ze.zone_name, zonename, sizeof (ze.zone_name)); 390087719fdSdp if ((err = putzoneent(&ze, PZE_REMOVE)) != Z_OK) 391087719fdSdp if (!force) 392087719fdSdp return (err); 393087719fdSdp 394087719fdSdp err = zonecfg_destroy_impl(path); 395087719fdSdp 396087719fdSdp /* 397087719fdSdp * Treat failure to find the XML file silently, since, well, it's 398087719fdSdp * gone, and with the index file cleaned up, we're done. 399087719fdSdp */ 400087719fdSdp if (err == Z_OK || err == Z_NO_ZONE) 401087719fdSdp return (Z_OK); 402087719fdSdp return (err); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate int 406108322fbScarlsonj zonecfg_destroy_snapshot(const char *zonename) 4077c478bd9Sstevel@tonic-gate { 4087c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 4097c478bd9Sstevel@tonic-gate 410108322fbScarlsonj if (!snap_file_path(zonename, path)) 411108322fbScarlsonj return (Z_MISC_FS); 4127c478bd9Sstevel@tonic-gate return (zonecfg_destroy_impl(path)); 4137c478bd9Sstevel@tonic-gate } 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate static int 416a1be23daSdp getroot(zone_dochandle_t handle, xmlNodePtr *root) 4177c478bd9Sstevel@tonic-gate { 4187c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) == Z_BAD_HANDLE) 4197c478bd9Sstevel@tonic-gate return (Z_BAD_HANDLE); 4207c478bd9Sstevel@tonic-gate 421a1be23daSdp *root = xmlDocGetRootElement(handle->zone_dh_doc); 422a1be23daSdp 423a1be23daSdp if (*root == NULL) 4247c478bd9Sstevel@tonic-gate return (Z_EMPTY_DOCUMENT); 4257c478bd9Sstevel@tonic-gate 426a1be23daSdp if (xmlStrcmp((*root)->name, DTD_ELEM_ZONE)) 4277c478bd9Sstevel@tonic-gate return (Z_WRONG_DOC_TYPE); 428a1be23daSdp 429a1be23daSdp return (Z_OK); 430a1be23daSdp } 431a1be23daSdp 432a1be23daSdp static int 433a1be23daSdp operation_prep(zone_dochandle_t handle) 434a1be23daSdp { 435a1be23daSdp xmlNodePtr root; 436a1be23daSdp int err; 437a1be23daSdp 438a1be23daSdp if ((err = getroot(handle, &root)) != 0) 439a1be23daSdp return (err); 440a1be23daSdp 441a1be23daSdp handle->zone_dh_cur = root; 442a1be23daSdp handle->zone_dh_top = root; 443a1be23daSdp return (Z_OK); 444a1be23daSdp } 445a1be23daSdp 446ffbafc53Scomay static int 447ffbafc53Scomay fetchprop(xmlNodePtr cur, const xmlChar *propname, char *dst, size_t dstsize) 448ffbafc53Scomay { 449ffbafc53Scomay xmlChar *property; 450ffbafc53Scomay size_t srcsize; 451ffbafc53Scomay 452ffbafc53Scomay if ((property = xmlGetProp(cur, propname)) == NULL) 453ffbafc53Scomay return (Z_BAD_PROPERTY); 454ffbafc53Scomay srcsize = strlcpy(dst, (char *)property, dstsize); 455ffbafc53Scomay xmlFree(property); 456ffbafc53Scomay if (srcsize >= dstsize) 457ffbafc53Scomay return (Z_TOO_BIG); 458ffbafc53Scomay return (Z_OK); 459ffbafc53Scomay } 460ffbafc53Scomay 461ffbafc53Scomay static int 462ffbafc53Scomay fetch_alloc_prop(xmlNodePtr cur, const xmlChar *propname, char **dst) 463ffbafc53Scomay { 464ffbafc53Scomay xmlChar *property; 465ffbafc53Scomay 466ffbafc53Scomay if ((property = xmlGetProp(cur, propname)) == NULL) 467ffbafc53Scomay return (Z_BAD_PROPERTY); 468ffbafc53Scomay if ((*dst = strdup((char *)property)) == NULL) { 469ffbafc53Scomay xmlFree(property); 470ffbafc53Scomay return (Z_NOMEM); 471ffbafc53Scomay } 472ffbafc53Scomay xmlFree(property); 473ffbafc53Scomay return (Z_OK); 474ffbafc53Scomay } 475ffbafc53Scomay 476a1be23daSdp static int 477a1be23daSdp getrootattr(zone_dochandle_t handle, const xmlChar *propname, 478a1be23daSdp char *propval, size_t propsize) 479a1be23daSdp { 480a1be23daSdp xmlNodePtr root; 481a1be23daSdp int err; 482a1be23daSdp 483a1be23daSdp if ((err = getroot(handle, &root)) != 0) 484a1be23daSdp return (err); 485a1be23daSdp 486ffbafc53Scomay return (fetchprop(root, propname, propval, propsize)); 487ffbafc53Scomay } 488ffbafc53Scomay 489ffbafc53Scomay static int 490ffbafc53Scomay get_alloc_rootattr(zone_dochandle_t handle, const xmlChar *propname, 491ffbafc53Scomay char **propval) 492ffbafc53Scomay { 493ffbafc53Scomay xmlNodePtr root; 494ffbafc53Scomay int err; 495ffbafc53Scomay 496ffbafc53Scomay if ((err = getroot(handle, &root)) != 0) 497ffbafc53Scomay return (err); 498ffbafc53Scomay 499ffbafc53Scomay return (fetch_alloc_prop(root, propname, propval)); 500a1be23daSdp } 501a1be23daSdp 502a1be23daSdp static int 503108322fbScarlsonj setrootattr(zone_dochandle_t handle, const xmlChar *propname, 504108322fbScarlsonj const char *propval) 505a1be23daSdp { 506a1be23daSdp int err; 507a1be23daSdp xmlNodePtr root; 508a1be23daSdp 509a1be23daSdp if ((err = getroot(handle, &root)) != Z_OK) 510a1be23daSdp return (err); 511a1be23daSdp 5120209230bSgjelinek /* 5130209230bSgjelinek * If we get a null propval remove the property (ignore return since it 5140209230bSgjelinek * may not be set to begin with). 5150209230bSgjelinek */ 5160209230bSgjelinek if (propval == NULL) { 5170209230bSgjelinek (void) xmlUnsetProp(root, propname); 5180209230bSgjelinek } else { 5190209230bSgjelinek if (xmlSetProp(root, propname, (const xmlChar *) propval) 5200209230bSgjelinek == NULL) 5210209230bSgjelinek return (Z_INVAL); 5220209230bSgjelinek } 5237c478bd9Sstevel@tonic-gate return (Z_OK); 5247c478bd9Sstevel@tonic-gate } 5257c478bd9Sstevel@tonic-gate 526087719fdSdp static void 527087719fdSdp addcomment(zone_dochandle_t handle, const char *comment) 528087719fdSdp { 529087719fdSdp xmlNodePtr node; 530087719fdSdp node = xmlNewComment((xmlChar *) comment); 531087719fdSdp 532087719fdSdp if (node != NULL) 533087719fdSdp (void) xmlAddPrevSibling(handle->zone_dh_top, node); 534087719fdSdp } 535087719fdSdp 536087719fdSdp static void 537087719fdSdp stripcomments(zone_dochandle_t handle) 538087719fdSdp { 539087719fdSdp xmlDocPtr top; 540087719fdSdp xmlNodePtr child, next; 541087719fdSdp 542087719fdSdp top = handle->zone_dh_doc; 543087719fdSdp for (child = top->xmlChildrenNode; child != NULL; child = next) { 544087719fdSdp next = child->next; 545087719fdSdp if (child->name == NULL) 546087719fdSdp continue; 547087719fdSdp if (xmlStrcmp(child->name, DTD_ELEM_COMMENT) == 0) { 548087719fdSdp next = child->next; 549087719fdSdp xmlUnlinkNode(child); 550087719fdSdp xmlFreeNode(child); 551087719fdSdp } 552087719fdSdp } 553087719fdSdp } 554087719fdSdp 555ee519a1fSgjelinek static void 556ee519a1fSgjelinek strip_sw_inv(zone_dochandle_t handle) 557ee519a1fSgjelinek { 558ee519a1fSgjelinek xmlNodePtr root, child, next; 559ee519a1fSgjelinek 560ee519a1fSgjelinek root = xmlDocGetRootElement(handle->zone_dh_doc); 561ee519a1fSgjelinek for (child = root->xmlChildrenNode; child != NULL; child = next) { 562ee519a1fSgjelinek next = child->next; 563ee519a1fSgjelinek if (child->name == NULL) 564ee519a1fSgjelinek continue; 5654656d474SGarrett D'Amore if (xmlStrcmp(child->name, DTD_ELEM_PACKAGE) == 0) { 566ee519a1fSgjelinek next = child->next; 567ee519a1fSgjelinek xmlUnlinkNode(child); 568ee519a1fSgjelinek xmlFreeNode(child); 569ee519a1fSgjelinek } 570ee519a1fSgjelinek } 571ee519a1fSgjelinek } 572ee519a1fSgjelinek 5737c478bd9Sstevel@tonic-gate static int 574108322fbScarlsonj zonecfg_get_handle_impl(const char *zonename, const char *filename, 575108322fbScarlsonj zone_dochandle_t handle) 5767c478bd9Sstevel@tonic-gate { 5777c478bd9Sstevel@tonic-gate xmlValidCtxtPtr cvp; 5787c478bd9Sstevel@tonic-gate struct stat statbuf; 5797c478bd9Sstevel@tonic-gate int valid; 5807c478bd9Sstevel@tonic-gate 5817c478bd9Sstevel@tonic-gate if (zonename == NULL) 5827c478bd9Sstevel@tonic-gate return (Z_NO_ZONE); 5839acbbeafSnn 5847c478bd9Sstevel@tonic-gate if ((handle->zone_dh_doc = xmlParseFile(filename)) == NULL) { 5857c478bd9Sstevel@tonic-gate /* distinguish file not found vs. found but not parsed */ 5867c478bd9Sstevel@tonic-gate if (stat(filename, &statbuf) == 0) 5877c478bd9Sstevel@tonic-gate return (Z_INVALID_DOCUMENT); 5887c478bd9Sstevel@tonic-gate return (Z_NO_ZONE); 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate if ((cvp = xmlNewValidCtxt()) == NULL) 5917c478bd9Sstevel@tonic-gate return (Z_NOMEM); 5927c478bd9Sstevel@tonic-gate cvp->error = zonecfg_error_func; 5937c478bd9Sstevel@tonic-gate cvp->warning = zonecfg_error_func; 5947c478bd9Sstevel@tonic-gate valid = xmlValidateDocument(cvp, handle->zone_dh_doc); 5957c478bd9Sstevel@tonic-gate xmlFreeValidCtxt(cvp); 5967c478bd9Sstevel@tonic-gate if (valid == 0) 5977c478bd9Sstevel@tonic-gate return (Z_INVALID_DOCUMENT); 598087719fdSdp 5997c478bd9Sstevel@tonic-gate /* delete any comments such as inherited Sun copyright / ident str */ 600087719fdSdp stripcomments(handle); 6017c478bd9Sstevel@tonic-gate return (Z_OK); 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate int 605108322fbScarlsonj zonecfg_get_handle(const char *zonename, zone_dochandle_t handle) 6067c478bd9Sstevel@tonic-gate { 6077c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 6087c478bd9Sstevel@tonic-gate 609108322fbScarlsonj if (!config_file_path(zonename, path)) 610108322fbScarlsonj return (Z_MISC_FS); 611087719fdSdp handle->zone_dh_newzone = B_FALSE; 612087719fdSdp 6137c478bd9Sstevel@tonic-gate return (zonecfg_get_handle_impl(zonename, path, handle)); 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate 616ee519a1fSgjelinek int 61716ab8c7bSgjelinek zonecfg_get_attach_handle(const char *path, const char *fname, 61816ab8c7bSgjelinek const char *zonename, boolean_t preserve_sw, zone_dochandle_t handle) 619ee519a1fSgjelinek { 620ee519a1fSgjelinek char migpath[MAXPATHLEN]; 621ee519a1fSgjelinek int err; 622ee519a1fSgjelinek struct stat buf; 623ee519a1fSgjelinek 624ee519a1fSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/root", path) >= 625ee519a1fSgjelinek sizeof (migpath)) 626ee519a1fSgjelinek return (Z_NOMEM); 627ee519a1fSgjelinek 628ee519a1fSgjelinek if (stat(migpath, &buf) == -1 || !S_ISDIR(buf.st_mode)) 629ee519a1fSgjelinek return (Z_NO_ZONE); 630ee519a1fSgjelinek 63116ab8c7bSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/%s", path, fname) >= 632ee519a1fSgjelinek sizeof (migpath)) 633ee519a1fSgjelinek return (Z_NOMEM); 634ee519a1fSgjelinek 635ee519a1fSgjelinek if ((err = zonecfg_get_handle_impl(zonename, migpath, handle)) != Z_OK) 636ee519a1fSgjelinek return (err); 637ee519a1fSgjelinek 638ee519a1fSgjelinek if (!preserve_sw) 639ee519a1fSgjelinek strip_sw_inv(handle); 640ee519a1fSgjelinek 641ee519a1fSgjelinek handle->zone_dh_newzone = B_TRUE; 642ee519a1fSgjelinek if ((err = setrootattr(handle, DTD_ATTR_ZONEPATH, path)) != Z_OK) 643ee519a1fSgjelinek return (err); 644ee519a1fSgjelinek 645ee519a1fSgjelinek return (setrootattr(handle, DTD_ATTR_NAME, zonename)); 646ee519a1fSgjelinek } 647ee519a1fSgjelinek 6487c478bd9Sstevel@tonic-gate int 649108322fbScarlsonj zonecfg_get_snapshot_handle(const char *zonename, zone_dochandle_t handle) 6507c478bd9Sstevel@tonic-gate { 6517c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 6527c478bd9Sstevel@tonic-gate 653108322fbScarlsonj if (!snap_file_path(zonename, path)) 654108322fbScarlsonj return (Z_MISC_FS); 655087719fdSdp handle->zone_dh_newzone = B_FALSE; 6567c478bd9Sstevel@tonic-gate return (zonecfg_get_handle_impl(zonename, path, handle)); 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 659087719fdSdp int 660108322fbScarlsonj zonecfg_get_template_handle(const char *template, const char *zonename, 661087719fdSdp zone_dochandle_t handle) 662087719fdSdp { 663087719fdSdp char path[MAXPATHLEN]; 664087719fdSdp int err; 665087719fdSdp 666108322fbScarlsonj if (!config_file_path(template, path)) 667108322fbScarlsonj return (Z_MISC_FS); 668087719fdSdp 669087719fdSdp if ((err = zonecfg_get_handle_impl(template, path, handle)) != Z_OK) 670087719fdSdp return (err); 671087719fdSdp handle->zone_dh_newzone = B_TRUE; 672087719fdSdp return (setrootattr(handle, DTD_ATTR_NAME, zonename)); 673087719fdSdp } 674087719fdSdp 6759acbbeafSnn int 6769acbbeafSnn zonecfg_get_xml_handle(const char *path, zone_dochandle_t handle) 6779acbbeafSnn { 6789acbbeafSnn struct stat buf; 6799acbbeafSnn int err; 6809acbbeafSnn 6819acbbeafSnn if (stat(path, &buf) == -1) 6829acbbeafSnn return (Z_MISC_FS); 6839acbbeafSnn 6849acbbeafSnn if ((err = zonecfg_get_handle_impl("xml", path, handle)) != Z_OK) 6859acbbeafSnn return (err); 6869acbbeafSnn handle->zone_dh_newzone = B_TRUE; 6879acbbeafSnn return (Z_OK); 6889acbbeafSnn } 6899acbbeafSnn 6908cd327d5Sgjelinek /* 6918cd327d5Sgjelinek * Initialize two handles from the manifest read on fd. The rem_handle 6928cd327d5Sgjelinek * is initialized from the input file, including the sw inventory. The 6938cd327d5Sgjelinek * local_handle is initialized with the same zone configuration but with 6948cd327d5Sgjelinek * no sw inventory. 6958cd327d5Sgjelinek */ 6968cd327d5Sgjelinek int 6978cd327d5Sgjelinek zonecfg_attach_manifest(int fd, zone_dochandle_t local_handle, 6988cd327d5Sgjelinek zone_dochandle_t rem_handle) 6998cd327d5Sgjelinek { 7008cd327d5Sgjelinek xmlValidCtxtPtr cvp; 7018cd327d5Sgjelinek int valid; 7028cd327d5Sgjelinek 7038cd327d5Sgjelinek /* load the manifest into the handle for the remote system */ 7048cd327d5Sgjelinek if ((rem_handle->zone_dh_doc = xmlReadFd(fd, NULL, NULL, 0)) == NULL) { 7058cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7068cd327d5Sgjelinek } 7078cd327d5Sgjelinek if ((cvp = xmlNewValidCtxt()) == NULL) 7088cd327d5Sgjelinek return (Z_NOMEM); 7098cd327d5Sgjelinek cvp->error = zonecfg_error_func; 7108cd327d5Sgjelinek cvp->warning = zonecfg_error_func; 7118cd327d5Sgjelinek valid = xmlValidateDocument(cvp, rem_handle->zone_dh_doc); 7128cd327d5Sgjelinek xmlFreeValidCtxt(cvp); 7138cd327d5Sgjelinek if (valid == 0) 7148cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7158cd327d5Sgjelinek 7168cd327d5Sgjelinek /* delete any comments such as inherited Sun copyright / ident str */ 7178cd327d5Sgjelinek stripcomments(rem_handle); 7188cd327d5Sgjelinek 7198cd327d5Sgjelinek rem_handle->zone_dh_newzone = B_TRUE; 7208cd327d5Sgjelinek rem_handle->zone_dh_sw_inv = B_TRUE; 7218cd327d5Sgjelinek 7228cd327d5Sgjelinek /* 7238cd327d5Sgjelinek * Now use the remote system handle to generate a local system handle 7248cd327d5Sgjelinek * with an identical zones configuration but no sw inventory. 7258cd327d5Sgjelinek */ 7268cd327d5Sgjelinek if ((local_handle->zone_dh_doc = xmlCopyDoc(rem_handle->zone_dh_doc, 7278cd327d5Sgjelinek 1)) == NULL) { 7288cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7298cd327d5Sgjelinek } 7308cd327d5Sgjelinek 7318cd327d5Sgjelinek /* 7328cd327d5Sgjelinek * We need to re-run xmlValidateDocument on local_handle to properly 7338cd327d5Sgjelinek * update the in-core representation of the configuration. 7348cd327d5Sgjelinek */ 7358cd327d5Sgjelinek if ((cvp = xmlNewValidCtxt()) == NULL) 7368cd327d5Sgjelinek return (Z_NOMEM); 7378cd327d5Sgjelinek cvp->error = zonecfg_error_func; 7388cd327d5Sgjelinek cvp->warning = zonecfg_error_func; 7398cd327d5Sgjelinek valid = xmlValidateDocument(cvp, local_handle->zone_dh_doc); 7408cd327d5Sgjelinek xmlFreeValidCtxt(cvp); 7418cd327d5Sgjelinek if (valid == 0) 7428cd327d5Sgjelinek return (Z_INVALID_DOCUMENT); 7438cd327d5Sgjelinek 7448cd327d5Sgjelinek strip_sw_inv(local_handle); 7458cd327d5Sgjelinek 7468cd327d5Sgjelinek local_handle->zone_dh_newzone = B_TRUE; 7478cd327d5Sgjelinek local_handle->zone_dh_sw_inv = B_FALSE; 7488cd327d5Sgjelinek 7498cd327d5Sgjelinek return (Z_OK); 7508cd327d5Sgjelinek } 7518cd327d5Sgjelinek 752087719fdSdp static boolean_t 753087719fdSdp is_renaming(zone_dochandle_t handle) 754087719fdSdp { 755087719fdSdp if (handle->zone_dh_newzone) 756087719fdSdp return (B_FALSE); 757087719fdSdp if (strlen(handle->zone_dh_delete_name) > 0) 758087719fdSdp return (B_TRUE); 759087719fdSdp return (B_FALSE); 760087719fdSdp } 761087719fdSdp 762087719fdSdp static boolean_t 763087719fdSdp is_new(zone_dochandle_t handle) 764087719fdSdp { 765087719fdSdp return (handle->zone_dh_newzone || handle->zone_dh_snapshot); 766087719fdSdp } 767087719fdSdp 768087719fdSdp static boolean_t 769087719fdSdp is_snapshot(zone_dochandle_t handle) 770087719fdSdp { 771087719fdSdp return (handle->zone_dh_snapshot); 772087719fdSdp } 773087719fdSdp 774087719fdSdp /* 775087719fdSdp * It would be great to be able to use libc's ctype(3c) macros, but we 776087719fdSdp * can't, as they are locale sensitive, and it would break our limited thread 777087719fdSdp * safety if this routine had to change the app locale on the fly. 778087719fdSdp */ 779087719fdSdp int 780108322fbScarlsonj zonecfg_validate_zonename(const char *zone) 781087719fdSdp { 782087719fdSdp int i; 783087719fdSdp 784087719fdSdp if (strcmp(zone, GLOBAL_ZONENAME) == 0) 785087719fdSdp return (Z_BOGUS_ZONE_NAME); 786087719fdSdp 787087719fdSdp if (strlen(zone) >= ZONENAME_MAX) 788087719fdSdp return (Z_BOGUS_ZONE_NAME); 789087719fdSdp 790087719fdSdp if (!((zone[0] >= 'a' && zone[0] <= 'z') || 791087719fdSdp (zone[0] >= 'A' && zone[0] <= 'Z') || 792087719fdSdp (zone[0] >= '0' && zone[0] <= '9'))) 793087719fdSdp return (Z_BOGUS_ZONE_NAME); 794087719fdSdp 795087719fdSdp for (i = 1; zone[i] != '\0'; i++) { 796087719fdSdp if (!((zone[i] >= 'a' && zone[i] <= 'z') || 797087719fdSdp (zone[i] >= 'A' && zone[i] <= 'Z') || 798087719fdSdp (zone[i] >= '0' && zone[i] <= '9') || 799087719fdSdp (zone[i] == '-') || (zone[i] == '_') || (zone[i] == '.'))) 800087719fdSdp return (Z_BOGUS_ZONE_NAME); 801087719fdSdp } 802087719fdSdp 803087719fdSdp return (Z_OK); 804087719fdSdp } 805087719fdSdp 806087719fdSdp /* 807087719fdSdp * Changing the zone name requires us to track both the old and new 808087719fdSdp * name of the zone until commit time. 809087719fdSdp */ 8107c478bd9Sstevel@tonic-gate int 8117c478bd9Sstevel@tonic-gate zonecfg_get_name(zone_dochandle_t handle, char *name, size_t namesize) 8127c478bd9Sstevel@tonic-gate { 813a1be23daSdp return (getrootattr(handle, DTD_ATTR_NAME, name, namesize)); 814a1be23daSdp } 8157c478bd9Sstevel@tonic-gate 816cb8a054bSGlenn Faden static int 817cb8a054bSGlenn Faden insert_admins(zone_dochandle_t handle, char *zonename) 818cb8a054bSGlenn Faden { 819cb8a054bSGlenn Faden int err; 820cb8a054bSGlenn Faden struct zone_admintab admintab; 821cb8a054bSGlenn Faden 822cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 823cb8a054bSGlenn Faden return (err); 824cb8a054bSGlenn Faden } 825cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 826cb8a054bSGlenn Faden err = zonecfg_insert_userauths(handle, 827cb8a054bSGlenn Faden admintab.zone_admin_user, zonename); 828cb8a054bSGlenn Faden if (err != Z_OK) { 829cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 830cb8a054bSGlenn Faden return (err); 831cb8a054bSGlenn Faden } 832cb8a054bSGlenn Faden } 833cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 834cb8a054bSGlenn Faden return (Z_OK); 835cb8a054bSGlenn Faden } 836cb8a054bSGlenn Faden 837a1be23daSdp int 838a1be23daSdp zonecfg_set_name(zone_dochandle_t handle, char *name) 839a1be23daSdp { 840087719fdSdp zone_state_t state; 841087719fdSdp char curname[ZONENAME_MAX], old_delname[ZONENAME_MAX]; 842087719fdSdp int err; 843087719fdSdp 844087719fdSdp if ((err = getrootattr(handle, DTD_ATTR_NAME, curname, 845087719fdSdp sizeof (curname))) != Z_OK) 846087719fdSdp return (err); 847087719fdSdp 848087719fdSdp if (strcmp(name, curname) == 0) 849087719fdSdp return (Z_OK); 850087719fdSdp 851087719fdSdp /* 852087719fdSdp * Switching zone names to one beginning with SUNW is not permitted. 853087719fdSdp */ 854087719fdSdp if (strncmp(name, "SUNW", 4) == 0) 855087719fdSdp return (Z_BOGUS_ZONE_NAME); 856087719fdSdp 857087719fdSdp if ((err = zonecfg_validate_zonename(name)) != Z_OK) 858087719fdSdp return (err); 859087719fdSdp 860087719fdSdp /* 861087719fdSdp * Setting the name back to the original name (effectively a revert of 862087719fdSdp * the name) is fine. But if we carry on, we'll falsely identify the 863087719fdSdp * name as "in use," so special case here. 864087719fdSdp */ 865087719fdSdp if (strcmp(name, handle->zone_dh_delete_name) == 0) { 866087719fdSdp err = setrootattr(handle, DTD_ATTR_NAME, name); 867087719fdSdp handle->zone_dh_delete_name[0] = '\0'; 868087719fdSdp return (err); 869087719fdSdp } 870087719fdSdp 871087719fdSdp /* Check to see if new name chosen is already in use */ 872087719fdSdp if (zone_get_state(name, &state) != Z_NO_ZONE) 873087719fdSdp return (Z_NAME_IN_USE); 874087719fdSdp 875087719fdSdp /* 876087719fdSdp * If this isn't already "new" or in a renaming transition, then 877087719fdSdp * we're initiating a rename here; so stash the "delete name" 878087719fdSdp * (i.e. the name of the zone we'll be removing) for the rename. 879087719fdSdp */ 880087719fdSdp (void) strlcpy(old_delname, handle->zone_dh_delete_name, 881087719fdSdp sizeof (old_delname)); 882087719fdSdp if (!is_new(handle) && !is_renaming(handle)) { 883087719fdSdp /* 884087719fdSdp * Name change is allowed only when the zone we're altering 885087719fdSdp * is not ready or running. 886087719fdSdp */ 887087719fdSdp err = zone_get_state(curname, &state); 888087719fdSdp if (err == Z_OK) { 889087719fdSdp if (state > ZONE_STATE_INSTALLED) 890087719fdSdp return (Z_BAD_ZONE_STATE); 891087719fdSdp } else if (err != Z_NO_ZONE) { 892087719fdSdp return (err); 893087719fdSdp } 894087719fdSdp 895087719fdSdp (void) strlcpy(handle->zone_dh_delete_name, curname, 896087719fdSdp sizeof (handle->zone_dh_delete_name)); 897087719fdSdp assert(is_renaming(handle)); 898087719fdSdp } else if (is_renaming(handle)) { 899087719fdSdp err = zone_get_state(handle->zone_dh_delete_name, &state); 900087719fdSdp if (err == Z_OK) { 901087719fdSdp if (state > ZONE_STATE_INSTALLED) 902087719fdSdp return (Z_BAD_ZONE_STATE); 903087719fdSdp } else if (err != Z_NO_ZONE) { 904087719fdSdp return (err); 905087719fdSdp } 906087719fdSdp } 907087719fdSdp 908087719fdSdp if ((err = setrootattr(handle, DTD_ATTR_NAME, name)) != Z_OK) { 909087719fdSdp /* 910087719fdSdp * Restore the deletename to whatever it was at the 911087719fdSdp * top of the routine, since we've had a failure. 912087719fdSdp */ 913087719fdSdp (void) strlcpy(handle->zone_dh_delete_name, old_delname, 914087719fdSdp sizeof (handle->zone_dh_delete_name)); 915087719fdSdp return (err); 916087719fdSdp } 917087719fdSdp 918cb8a054bSGlenn Faden /* 919cb8a054bSGlenn Faden * Record the old admins from the old zonename 920cb8a054bSGlenn Faden * so that they can be deleted when the operation is committed. 921cb8a054bSGlenn Faden */ 922cb8a054bSGlenn Faden if ((err = insert_admins(handle, curname)) != Z_OK) 923cb8a054bSGlenn Faden return (err); 924cb8a054bSGlenn Faden else 925cb8a054bSGlenn Faden return (Z_OK); 926a1be23daSdp } 9277c478bd9Sstevel@tonic-gate 928a1be23daSdp int 929a1be23daSdp zonecfg_get_zonepath(zone_dochandle_t handle, char *path, size_t pathsize) 930a1be23daSdp { 931108322fbScarlsonj size_t len; 932108322fbScarlsonj 933108322fbScarlsonj if ((len = strlcpy(path, zonecfg_root, pathsize)) >= pathsize) 934108322fbScarlsonj return (Z_TOO_BIG); 935108322fbScarlsonj return (getrootattr(handle, DTD_ATTR_ZONEPATH, path + len, 936108322fbScarlsonj pathsize - len)); 937a1be23daSdp } 9387c478bd9Sstevel@tonic-gate 939a1be23daSdp int 940a1be23daSdp zonecfg_set_zonepath(zone_dochandle_t handle, char *zonepath) 941a1be23daSdp { 942555afedfScarlsonj size_t len; 9436fb06a2bSSusan Kamm-Worrell char *modpath, *copy_mp, *curr_mp; /* modified path ptrs */ 9446fb06a2bSSusan Kamm-Worrell char last_copied; 9456fb06a2bSSusan Kamm-Worrell int ret; 9466fb06a2bSSusan Kamm-Worrell 9476fb06a2bSSusan Kamm-Worrell /* 9486fb06a2bSSusan Kamm-Worrell * Collapse multiple contiguous slashes and remove trailing slash. 9496fb06a2bSSusan Kamm-Worrell */ 9506fb06a2bSSusan Kamm-Worrell modpath = strdup(zonepath); 9516fb06a2bSSusan Kamm-Worrell if (modpath == NULL) 9526fb06a2bSSusan Kamm-Worrell return (Z_NOMEM); 9536fb06a2bSSusan Kamm-Worrell last_copied = '\0'; 9546fb06a2bSSusan Kamm-Worrell for (copy_mp = curr_mp = modpath; *curr_mp != '\0'; curr_mp++) { 9556fb06a2bSSusan Kamm-Worrell if (*curr_mp != '/' || last_copied != '/') { 9566fb06a2bSSusan Kamm-Worrell last_copied = *copy_mp = *curr_mp; 9576fb06a2bSSusan Kamm-Worrell copy_mp++; 9586fb06a2bSSusan Kamm-Worrell } 9596fb06a2bSSusan Kamm-Worrell } 9606fb06a2bSSusan Kamm-Worrell if (last_copied == '/') 9616fb06a2bSSusan Kamm-Worrell copy_mp--; 9626fb06a2bSSusan Kamm-Worrell *copy_mp = '\0'; 963555afedfScarlsonj 964555afedfScarlsonj /* 965555afedfScarlsonj * The user deals in absolute paths in the running global zone, but the 966555afedfScarlsonj * internal configuration files deal with boot environment relative 967555afedfScarlsonj * paths. Strip out the alternate root when specified. 968555afedfScarlsonj */ 969555afedfScarlsonj len = strlen(zonecfg_root); 9706fb06a2bSSusan Kamm-Worrell if (strncmp(modpath, zonecfg_root, len) != 0 || modpath[len] != '/') { 9716fb06a2bSSusan Kamm-Worrell free(modpath); 972555afedfScarlsonj return (Z_BAD_PROPERTY); 9736fb06a2bSSusan Kamm-Worrell } 9746fb06a2bSSusan Kamm-Worrell curr_mp = modpath + len; 9756fb06a2bSSusan Kamm-Worrell ret = setrootattr(handle, DTD_ATTR_ZONEPATH, curr_mp); 9766fb06a2bSSusan Kamm-Worrell free(modpath); 9776fb06a2bSSusan Kamm-Worrell return (ret); 978a1be23daSdp } 979a1be23daSdp 980e5816e35SEdward Pilatowicz static int 981e5816e35SEdward Pilatowicz i_zonecfg_get_brand(zone_dochandle_t handle, char *brand, size_t brandsize, 982e5816e35SEdward Pilatowicz boolean_t default_query) 9839acbbeafSnn { 9849acbbeafSnn int ret, sz; 9859acbbeafSnn 9869acbbeafSnn ret = getrootattr(handle, DTD_ATTR_BRAND, brand, brandsize); 9879acbbeafSnn 988e5816e35SEdward Pilatowicz /* 989e5816e35SEdward Pilatowicz * If the lookup failed, or succeeded in finding a non-null brand 990e5816e35SEdward Pilatowicz * string then return. 991e5816e35SEdward Pilatowicz */ 992e5816e35SEdward Pilatowicz if (ret != Z_OK || brand[0] != '\0') 993e5816e35SEdward Pilatowicz return (ret); 994e5816e35SEdward Pilatowicz 995e5816e35SEdward Pilatowicz if (!default_query) { 996e5816e35SEdward Pilatowicz /* If the zone has no brand, it is the default brand. */ 997b08d9f75SEdward Pilatowicz return (zonecfg_default_brand(brand, brandsize)); 9989acbbeafSnn } 9999acbbeafSnn 1000e5816e35SEdward Pilatowicz /* if SUNWdefault didn't specify a brand, fallback to "native" */ 1001e5816e35SEdward Pilatowicz sz = strlcpy(brand, NATIVE_BRAND_NAME, brandsize); 1002e5816e35SEdward Pilatowicz if (sz >= brandsize) 1003e5816e35SEdward Pilatowicz return (Z_TOO_BIG); 1004e5816e35SEdward Pilatowicz return (Z_OK); 1005e5816e35SEdward Pilatowicz } 1006e5816e35SEdward Pilatowicz 1007e5816e35SEdward Pilatowicz int 1008e5816e35SEdward Pilatowicz zonecfg_get_brand(zone_dochandle_t handle, char *brand, size_t brandsize) 1009e5816e35SEdward Pilatowicz { 1010e5816e35SEdward Pilatowicz return (i_zonecfg_get_brand(handle, brand, brandsize, B_FALSE)); 10119acbbeafSnn } 10129acbbeafSnn 10139acbbeafSnn int 10149acbbeafSnn zonecfg_set_brand(zone_dochandle_t handle, char *brand) 10159acbbeafSnn { 10169acbbeafSnn return (setrootattr(handle, DTD_ATTR_BRAND, brand)); 10179acbbeafSnn } 10189acbbeafSnn 1019a1be23daSdp int 1020a1be23daSdp zonecfg_get_autoboot(zone_dochandle_t handle, boolean_t *autoboot) 1021a1be23daSdp { 1022a1be23daSdp char autobootstr[DTD_ENTITY_BOOL_LEN]; 1023a1be23daSdp int ret; 1024a1be23daSdp 1025a1be23daSdp if ((ret = getrootattr(handle, DTD_ATTR_AUTOBOOT, autobootstr, 1026a1be23daSdp sizeof (autobootstr))) != Z_OK) 1027a1be23daSdp return (ret); 1028a1be23daSdp 1029a1be23daSdp if (strcmp(autobootstr, DTD_ENTITY_TRUE) == 0) 1030a1be23daSdp *autoboot = B_TRUE; 1031a1be23daSdp else if (strcmp(autobootstr, DTD_ENTITY_FALSE) == 0) 1032a1be23daSdp *autoboot = B_FALSE; 1033a1be23daSdp else 1034a1be23daSdp ret = Z_BAD_PROPERTY; 1035a1be23daSdp return (ret); 1036a1be23daSdp } 1037a1be23daSdp 1038a1be23daSdp int 1039a1be23daSdp zonecfg_set_autoboot(zone_dochandle_t handle, boolean_t autoboot) 1040a1be23daSdp { 1041a1be23daSdp return (setrootattr(handle, DTD_ATTR_AUTOBOOT, 1042a1be23daSdp autoboot ? DTD_ENTITY_TRUE : DTD_ENTITY_FALSE)); 1043a1be23daSdp } 1044a1be23daSdp 1045a1be23daSdp int 1046a1be23daSdp zonecfg_get_pool(zone_dochandle_t handle, char *pool, size_t poolsize) 1047a1be23daSdp { 1048a1be23daSdp return (getrootattr(handle, DTD_ATTR_POOL, pool, poolsize)); 1049a1be23daSdp } 1050a1be23daSdp 1051a1be23daSdp int 1052a1be23daSdp zonecfg_set_pool(zone_dochandle_t handle, char *pool) 1053a1be23daSdp { 1054a1be23daSdp return (setrootattr(handle, DTD_ATTR_POOL, pool)); 1055a1be23daSdp } 1056a1be23daSdp 1057ffbafc53Scomay int 1058ffbafc53Scomay zonecfg_get_limitpriv(zone_dochandle_t handle, char **limitpriv) 1059ffbafc53Scomay { 1060ffbafc53Scomay return (get_alloc_rootattr(handle, DTD_ATTR_LIMITPRIV, limitpriv)); 1061ffbafc53Scomay } 1062ffbafc53Scomay 1063ffbafc53Scomay int 10643f2f09c1Sdp zonecfg_set_limitpriv(zone_dochandle_t handle, char *limitpriv) 1065ffbafc53Scomay { 10663f2f09c1Sdp return (setrootattr(handle, DTD_ATTR_LIMITPRIV, limitpriv)); 10673f2f09c1Sdp } 10683f2f09c1Sdp 10693f2f09c1Sdp int 10703f2f09c1Sdp zonecfg_get_bootargs(zone_dochandle_t handle, char *bargs, size_t bargssize) 10713f2f09c1Sdp { 10723f2f09c1Sdp return (getrootattr(handle, DTD_ATTR_BOOTARGS, bargs, bargssize)); 10733f2f09c1Sdp } 10743f2f09c1Sdp 10753f2f09c1Sdp int 10763f2f09c1Sdp zonecfg_set_bootargs(zone_dochandle_t handle, char *bargs) 10773f2f09c1Sdp { 10783f2f09c1Sdp return (setrootattr(handle, DTD_ATTR_BOOTARGS, bargs)); 1079ffbafc53Scomay } 1080ffbafc53Scomay 10810209230bSgjelinek int 10820209230bSgjelinek zonecfg_get_sched_class(zone_dochandle_t handle, char *sched, size_t schedsize) 10830209230bSgjelinek { 10840209230bSgjelinek return (getrootattr(handle, DTD_ATTR_SCHED, sched, schedsize)); 10850209230bSgjelinek } 10860209230bSgjelinek 10870209230bSgjelinek int 10880209230bSgjelinek zonecfg_set_sched(zone_dochandle_t handle, char *sched) 10890209230bSgjelinek { 10900209230bSgjelinek return (setrootattr(handle, DTD_ATTR_SCHED, sched)); 10910209230bSgjelinek } 10920209230bSgjelinek 1093a1be23daSdp /* 1094a1be23daSdp * /etc/zones/index caches a vital piece of information which is also 1095a1be23daSdp * in the <zonename>.xml file: the path to the zone. This is for performance, 1096a1be23daSdp * since we need to walk all zonepath's in order to be able to detect conflicts 1097a1be23daSdp * (see crosscheck_zonepaths() in the zoneadm command). 1098087719fdSdp * 1099087719fdSdp * An additional complexity is that when doing a rename, we'd like the entire 1100087719fdSdp * index update operation (rename, and potential state changes) to be atomic. 1101087719fdSdp * In general, the operation of this function should succeed or fail as 1102087719fdSdp * a unit. 1103a1be23daSdp */ 1104a1be23daSdp int 1105a1be23daSdp zonecfg_refresh_index_file(zone_dochandle_t handle) 1106a1be23daSdp { 1107a1be23daSdp char name[ZONENAME_MAX], zonepath[MAXPATHLEN]; 1108a1be23daSdp struct zoneent ze; 1109a1be23daSdp int err; 1110087719fdSdp int opcode; 1111087719fdSdp char *zn; 1112087719fdSdp 1113087719fdSdp bzero(&ze, sizeof (ze)); 1114087719fdSdp ze.zone_state = -1; /* Preserve existing state in index */ 1115a1be23daSdp 1116a1be23daSdp if ((err = zonecfg_get_name(handle, name, sizeof (name))) != Z_OK) 1117a1be23daSdp return (err); 1118087719fdSdp (void) strlcpy(ze.zone_name, name, sizeof (ze.zone_name)); 1119087719fdSdp 1120a1be23daSdp if ((err = zonecfg_get_zonepath(handle, zonepath, 1121a1be23daSdp sizeof (zonepath))) != Z_OK) 1122a1be23daSdp return (err); 1123555afedfScarlsonj (void) strlcpy(ze.zone_path, zonepath + strlen(zonecfg_root), 1124555afedfScarlsonj sizeof (ze.zone_path)); 1125087719fdSdp 1126087719fdSdp if (is_renaming(handle)) { 1127087719fdSdp opcode = PZE_MODIFY; 1128087719fdSdp (void) strlcpy(ze.zone_name, handle->zone_dh_delete_name, 1129087719fdSdp sizeof (ze.zone_name)); 1130087719fdSdp (void) strlcpy(ze.zone_newname, name, sizeof (ze.zone_newname)); 1131087719fdSdp } else if (is_new(handle)) { 1132087719fdSdp FILE *cookie; 1133087719fdSdp /* 1134087719fdSdp * Be tolerant of the zone already existing in the index file, 1135087719fdSdp * since we might be forcibly overwriting an existing 1136087719fdSdp * configuration with a new one (for example 'create -F' 1137087719fdSdp * in zonecfg). 1138087719fdSdp */ 1139087719fdSdp opcode = PZE_ADD; 1140087719fdSdp cookie = setzoneent(); 1141087719fdSdp while ((zn = getzoneent(cookie)) != NULL) { 1142087719fdSdp if (strcmp(zn, name) == 0) { 1143087719fdSdp opcode = PZE_MODIFY; 1144087719fdSdp free(zn); 1145087719fdSdp break; 1146087719fdSdp } 1147087719fdSdp free(zn); 1148087719fdSdp } 1149087719fdSdp endzoneent(cookie); 1150087719fdSdp ze.zone_state = ZONE_STATE_CONFIGURED; 1151087719fdSdp } else { 1152087719fdSdp opcode = PZE_MODIFY; 1153087719fdSdp } 1154087719fdSdp 1155087719fdSdp if ((err = putzoneent(&ze, opcode)) != Z_OK) 1156087719fdSdp return (err); 1157087719fdSdp 1158087719fdSdp return (Z_OK); 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 1161087719fdSdp /* 1162087719fdSdp * The goal of this routine is to cause the index file update and the 1163087719fdSdp * document save to happen as an atomic operation. We do the document 1164087719fdSdp * first, saving a backup copy using a hard link; if that succeeds, we go 1165087719fdSdp * on to the index. If that fails, we roll the document back into place. 1166087719fdSdp * 1167087719fdSdp * Strategy: 1168087719fdSdp * 1169087719fdSdp * New zone 'foo' configuration: 1170087719fdSdp * Create tmpfile (zonecfg.xxxxxx) 1171087719fdSdp * Write XML to tmpfile 1172087719fdSdp * Rename tmpfile to xmlfile (zonecfg.xxxxxx -> foo.xml) 1173087719fdSdp * Add entry to index file 1174087719fdSdp * If it fails, delete foo.xml, leaving nothing behind. 1175087719fdSdp * 1176087719fdSdp * Save existing zone 'foo': 1177087719fdSdp * Make backup of foo.xml -> .backup 1178087719fdSdp * Create tmpfile (zonecfg.xxxxxx) 1179087719fdSdp * Write XML to tmpfile 1180087719fdSdp * Rename tmpfile to xmlfile (zonecfg.xxxxxx -> foo.xml) 1181087719fdSdp * Modify index file as needed 1182087719fdSdp * If it fails, recover from .backup -> foo.xml 1183087719fdSdp * 1184087719fdSdp * Rename 'foo' to 'bar': 1185087719fdSdp * Create tmpfile (zonecfg.xxxxxx) 1186087719fdSdp * Write XML to tmpfile 1187087719fdSdp * Rename tmpfile to xmlfile (zonecfg.xxxxxx -> bar.xml) 1188087719fdSdp * Add entry for 'bar' to index file, Remove entry for 'foo' (refresh) 1189087719fdSdp * If it fails, delete bar.xml; foo.xml is left behind. 1190087719fdSdp */ 11917c478bd9Sstevel@tonic-gate static int 11927c478bd9Sstevel@tonic-gate zonecfg_save_impl(zone_dochandle_t handle, char *filename) 11937c478bd9Sstevel@tonic-gate { 11947c478bd9Sstevel@tonic-gate char tmpfile[MAXPATHLEN]; 1195087719fdSdp char bakdir[MAXPATHLEN], bakbase[MAXPATHLEN], bakfile[MAXPATHLEN]; 11969acbbeafSnn int tmpfd, err, valid; 11977c478bd9Sstevel@tonic-gate xmlValidCtxt cvp = { NULL }; 1198087719fdSdp boolean_t backup; 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate (void) strlcpy(tmpfile, filename, sizeof (tmpfile)); 12017c478bd9Sstevel@tonic-gate (void) dirname(tmpfile); 12027c478bd9Sstevel@tonic-gate (void) strlcat(tmpfile, _PATH_TMPFILE, sizeof (tmpfile)); 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate tmpfd = mkstemp(tmpfile); 12057c478bd9Sstevel@tonic-gate if (tmpfd == -1) { 12067c478bd9Sstevel@tonic-gate (void) unlink(tmpfile); 12077c478bd9Sstevel@tonic-gate return (Z_TEMP_FILE); 12087c478bd9Sstevel@tonic-gate } 12097c478bd9Sstevel@tonic-gate (void) close(tmpfd); 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate cvp.error = zonecfg_error_func; 12127c478bd9Sstevel@tonic-gate cvp.warning = zonecfg_error_func; 12137c478bd9Sstevel@tonic-gate 1214087719fdSdp /* 12159acbbeafSnn * We do a final validation of the document. Since the library has 12169acbbeafSnn * malfunctioned if it fails to validate, we follow-up with an 12179acbbeafSnn * assert() that the doc is valid. 1218087719fdSdp */ 12199acbbeafSnn valid = xmlValidateDocument(&cvp, handle->zone_dh_doc); 12209acbbeafSnn assert(valid != 0); 12217c478bd9Sstevel@tonic-gate 12227c478bd9Sstevel@tonic-gate if (xmlSaveFormatFile(tmpfile, handle->zone_dh_doc, 1) <= 0) 12237c478bd9Sstevel@tonic-gate goto err; 1224087719fdSdp 12257c478bd9Sstevel@tonic-gate (void) chmod(tmpfile, 0644); 12267c478bd9Sstevel@tonic-gate 1227087719fdSdp /* 1228087719fdSdp * In the event we are doing a standard save, hard link a copy of the 1229087719fdSdp * original file in .backup.<pid>.filename so we can restore it if 1230087719fdSdp * something goes wrong. 1231087719fdSdp */ 1232087719fdSdp if (!is_new(handle) && !is_renaming(handle)) { 1233087719fdSdp backup = B_TRUE; 1234087719fdSdp 1235087719fdSdp (void) strlcpy(bakdir, filename, sizeof (bakdir)); 1236087719fdSdp (void) strlcpy(bakbase, filename, sizeof (bakbase)); 1237087719fdSdp (void) snprintf(bakfile, sizeof (bakfile), "%s/.backup.%d.%s", 1238087719fdSdp dirname(bakdir), getpid(), basename(bakbase)); 1239087719fdSdp 1240087719fdSdp if (link(filename, bakfile) == -1) { 1241087719fdSdp err = errno; 1242087719fdSdp (void) unlink(tmpfile); 1243087719fdSdp if (errno == EACCES) 1244087719fdSdp return (Z_ACCES); 1245087719fdSdp return (Z_MISC_FS); 1246087719fdSdp } 1247087719fdSdp } 1248087719fdSdp 1249087719fdSdp /* 1250087719fdSdp * Move the new document over top of the old. 1251087719fdSdp * i.e.: zonecfg.XXXXXX -> myzone.xml 1252087719fdSdp */ 12537c478bd9Sstevel@tonic-gate if (rename(tmpfile, filename) == -1) { 1254087719fdSdp err = errno; 12557c478bd9Sstevel@tonic-gate (void) unlink(tmpfile); 1256087719fdSdp if (backup) 1257087719fdSdp (void) unlink(bakfile); 1258087719fdSdp if (err == EACCES) 12597c478bd9Sstevel@tonic-gate return (Z_ACCES); 12607c478bd9Sstevel@tonic-gate return (Z_MISC_FS); 12617c478bd9Sstevel@tonic-gate } 1262a1be23daSdp 1263087719fdSdp /* 1264087719fdSdp * If this is a snapshot, we're done-- don't add an index entry. 1265087719fdSdp */ 1266087719fdSdp if (is_snapshot(handle)) 1267087719fdSdp return (Z_OK); 1268087719fdSdp 1269087719fdSdp /* now update the index file to reflect whatever we just did */ 1270087719fdSdp if ((err = zonecfg_refresh_index_file(handle)) != Z_OK) { 1271087719fdSdp if (backup) { 1272087719fdSdp /* 1273087719fdSdp * Try to restore from our backup. 1274087719fdSdp */ 1275087719fdSdp (void) unlink(filename); 1276087719fdSdp (void) rename(bakfile, filename); 1277087719fdSdp } else { 1278087719fdSdp /* 1279087719fdSdp * Either the zone is new, in which case we can delete 1280087719fdSdp * new.xml, or we're doing a rename, so ditto. 1281087719fdSdp */ 1282087719fdSdp assert(is_new(handle) || is_renaming(handle)); 1283087719fdSdp (void) unlink(filename); 1284087719fdSdp } 1285087719fdSdp return (Z_UPDATING_INDEX); 1286087719fdSdp } 1287087719fdSdp 1288087719fdSdp if (backup) 1289087719fdSdp (void) unlink(bakfile); 1290087719fdSdp 1291087719fdSdp return (Z_OK); 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate err: 12947c478bd9Sstevel@tonic-gate (void) unlink(tmpfile); 12957c478bd9Sstevel@tonic-gate return (Z_SAVING_FILE); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate int 12997c478bd9Sstevel@tonic-gate zonecfg_save(zone_dochandle_t handle) 13007c478bd9Sstevel@tonic-gate { 1301087719fdSdp char zname[ZONENAME_MAX], path[MAXPATHLEN]; 1302087719fdSdp char delpath[MAXPATHLEN]; 1303087719fdSdp int err = Z_SAVING_FILE; 1304087719fdSdp 1305087719fdSdp if (zonecfg_check_handle(handle) != Z_OK) 1306087719fdSdp return (Z_BAD_HANDLE); 13077c478bd9Sstevel@tonic-gate 1308087719fdSdp /* 1309ee519a1fSgjelinek * We don't support saving snapshots or a tree containing a sw 1310ee519a1fSgjelinek * inventory at this time. 1311087719fdSdp */ 1312ee519a1fSgjelinek if (handle->zone_dh_snapshot || handle->zone_dh_sw_inv) 1313087719fdSdp return (Z_INVAL); 1314087719fdSdp 1315087719fdSdp if ((err = zonecfg_get_name(handle, zname, sizeof (zname))) != Z_OK) 13167c478bd9Sstevel@tonic-gate return (err); 1317087719fdSdp 1318108322fbScarlsonj if (!config_file_path(zname, path)) 1319108322fbScarlsonj return (Z_MISC_FS); 1320087719fdSdp 1321087719fdSdp addcomment(handle, "\n DO NOT EDIT THIS " 1322087719fdSdp "FILE. Use zonecfg(1M) instead.\n"); 1323087719fdSdp 1324cb8a054bSGlenn Faden /* 1325cb8a054bSGlenn Faden * Update user_attr first so that it will be older 1326cb8a054bSGlenn Faden * than the config file. 1327cb8a054bSGlenn Faden */ 1328cb8a054bSGlenn Faden (void) zonecfg_authorize_users(handle, zname); 1329087719fdSdp err = zonecfg_save_impl(handle, path); 1330087719fdSdp 1331087719fdSdp stripcomments(handle); 1332087719fdSdp 1333087719fdSdp if (err != Z_OK) 1334087719fdSdp return (err); 1335087719fdSdp 1336087719fdSdp handle->zone_dh_newzone = B_FALSE; 1337087719fdSdp 1338087719fdSdp if (is_renaming(handle)) { 1339108322fbScarlsonj if (config_file_path(handle->zone_dh_delete_name, delpath)) 1340108322fbScarlsonj (void) unlink(delpath); 1341087719fdSdp handle->zone_dh_delete_name[0] = '\0'; 1342087719fdSdp } 1343087719fdSdp 1344087719fdSdp return (Z_OK); 13457c478bd9Sstevel@tonic-gate } 13467c478bd9Sstevel@tonic-gate 13479acbbeafSnn int 13489acbbeafSnn zonecfg_verify_save(zone_dochandle_t handle, char *filename) 13499acbbeafSnn { 13509acbbeafSnn int valid; 13519acbbeafSnn 13529acbbeafSnn xmlValidCtxt cvp = { NULL }; 13539acbbeafSnn 13549acbbeafSnn if (zonecfg_check_handle(handle) != Z_OK) 13559acbbeafSnn return (Z_BAD_HANDLE); 13569acbbeafSnn 13579acbbeafSnn cvp.error = zonecfg_error_func; 13589acbbeafSnn cvp.warning = zonecfg_error_func; 13599acbbeafSnn 13609acbbeafSnn /* 13619acbbeafSnn * We do a final validation of the document. Since the library has 13629acbbeafSnn * malfunctioned if it fails to validate, we follow-up with an 13639acbbeafSnn * assert() that the doc is valid. 13649acbbeafSnn */ 13659acbbeafSnn valid = xmlValidateDocument(&cvp, handle->zone_dh_doc); 13669acbbeafSnn assert(valid != 0); 13679acbbeafSnn 13689acbbeafSnn if (xmlSaveFormatFile(filename, handle->zone_dh_doc, 1) <= 0) 13699acbbeafSnn return (Z_SAVING_FILE); 13709acbbeafSnn 13719acbbeafSnn return (Z_OK); 13729acbbeafSnn } 13739acbbeafSnn 1374ee519a1fSgjelinek int 13758cd327d5Sgjelinek zonecfg_detach_save(zone_dochandle_t handle, uint_t flags) 1376ee519a1fSgjelinek { 1377ee519a1fSgjelinek char zname[ZONENAME_MAX]; 1378ee519a1fSgjelinek char path[MAXPATHLEN]; 1379ee519a1fSgjelinek char migpath[MAXPATHLEN]; 1380ee519a1fSgjelinek xmlValidCtxt cvp = { NULL }; 1381ee519a1fSgjelinek int err = Z_SAVING_FILE; 13829acbbeafSnn int valid; 1383ee519a1fSgjelinek 1384ee519a1fSgjelinek if (zonecfg_check_handle(handle) != Z_OK) 1385ee519a1fSgjelinek return (Z_BAD_HANDLE); 1386ee519a1fSgjelinek 13878cd327d5Sgjelinek if (flags & ZONE_DRY_RUN) { 13888cd327d5Sgjelinek (void) strlcpy(migpath, "-", sizeof (migpath)); 13898cd327d5Sgjelinek } else { 13908cd327d5Sgjelinek if ((err = zonecfg_get_name(handle, zname, sizeof (zname))) 13918cd327d5Sgjelinek != Z_OK) 13928cd327d5Sgjelinek return (err); 1393ee519a1fSgjelinek 13948cd327d5Sgjelinek if ((err = zone_get_zonepath(zname, path, sizeof (path))) 13958cd327d5Sgjelinek != Z_OK) 13968cd327d5Sgjelinek return (err); 1397ee519a1fSgjelinek 139816ab8c7bSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/%s", path, 139916ab8c7bSgjelinek ZONE_DETACHED) >= sizeof (migpath)) 14008cd327d5Sgjelinek return (Z_NOMEM); 14018cd327d5Sgjelinek } 1402ee519a1fSgjelinek 1403ee519a1fSgjelinek if ((err = operation_prep(handle)) != Z_OK) 1404ee519a1fSgjelinek return (err); 1405ee519a1fSgjelinek 1406ee519a1fSgjelinek addcomment(handle, "\n DO NOT EDIT THIS FILE. " 1407ee519a1fSgjelinek "Use zonecfg(1M) and zoneadm(1M) attach.\n"); 1408ee519a1fSgjelinek 1409ee519a1fSgjelinek cvp.error = zonecfg_error_func; 1410ee519a1fSgjelinek cvp.warning = zonecfg_error_func; 1411ee519a1fSgjelinek 1412ee519a1fSgjelinek /* 14139acbbeafSnn * We do a final validation of the document. Since the library has 14149acbbeafSnn * malfunctioned if it fails to validate, we follow-up with an 14159acbbeafSnn * assert() that the doc is valid. 1416ee519a1fSgjelinek */ 14179acbbeafSnn valid = xmlValidateDocument(&cvp, handle->zone_dh_doc); 14189acbbeafSnn assert(valid != 0); 1419ee519a1fSgjelinek 1420ee519a1fSgjelinek if (xmlSaveFormatFile(migpath, handle->zone_dh_doc, 1) <= 0) 1421ee519a1fSgjelinek return (Z_SAVING_FILE); 1422ee519a1fSgjelinek 14238cd327d5Sgjelinek if (!(flags & ZONE_DRY_RUN)) 14248cd327d5Sgjelinek (void) chmod(migpath, 0644); 1425ee519a1fSgjelinek 1426ee519a1fSgjelinek stripcomments(handle); 1427ee519a1fSgjelinek 1428ee519a1fSgjelinek handle->zone_dh_newzone = B_FALSE; 1429ee519a1fSgjelinek 1430ee519a1fSgjelinek return (Z_OK); 1431ee519a1fSgjelinek } 1432ee519a1fSgjelinek 1433ee519a1fSgjelinek boolean_t 1434ee519a1fSgjelinek zonecfg_detached(const char *path) 1435ee519a1fSgjelinek { 1436ee519a1fSgjelinek char migpath[MAXPATHLEN]; 1437ee519a1fSgjelinek struct stat buf; 1438ee519a1fSgjelinek 143916ab8c7bSgjelinek if (snprintf(migpath, sizeof (migpath), "%s/%s", path, ZONE_DETACHED) >= 1440ee519a1fSgjelinek sizeof (migpath)) 1441ee519a1fSgjelinek return (B_FALSE); 1442ee519a1fSgjelinek 1443ee519a1fSgjelinek if (stat(migpath, &buf) != -1) 1444ee519a1fSgjelinek return (B_TRUE); 1445ee519a1fSgjelinek 1446ee519a1fSgjelinek return (B_FALSE); 1447ee519a1fSgjelinek } 1448ee519a1fSgjelinek 1449ee519a1fSgjelinek void 1450ee519a1fSgjelinek zonecfg_rm_detached(zone_dochandle_t handle, boolean_t forced) 1451ee519a1fSgjelinek { 1452ee519a1fSgjelinek char zname[ZONENAME_MAX]; 1453ee519a1fSgjelinek char path[MAXPATHLEN]; 1454ee519a1fSgjelinek char detached[MAXPATHLEN]; 1455ee519a1fSgjelinek char attached[MAXPATHLEN]; 1456ee519a1fSgjelinek 1457ee519a1fSgjelinek if (zonecfg_check_handle(handle) != Z_OK) 1458ee519a1fSgjelinek return; 1459ee519a1fSgjelinek 1460ee519a1fSgjelinek if (zonecfg_get_name(handle, zname, sizeof (zname)) != Z_OK) 1461ee519a1fSgjelinek return; 1462ee519a1fSgjelinek 1463ee519a1fSgjelinek if (zone_get_zonepath(zname, path, sizeof (path)) != Z_OK) 1464ee519a1fSgjelinek return; 1465ee519a1fSgjelinek 146616ab8c7bSgjelinek (void) snprintf(detached, sizeof (detached), "%s/%s", path, 146716ab8c7bSgjelinek ZONE_DETACHED); 1468ee519a1fSgjelinek (void) snprintf(attached, sizeof (attached), "%s/%s", path, 1469ee519a1fSgjelinek ATTACH_FORCED); 1470ee519a1fSgjelinek 1471ee519a1fSgjelinek if (forced) { 1472ee519a1fSgjelinek (void) rename(detached, attached); 1473ee519a1fSgjelinek } else { 1474ee519a1fSgjelinek (void) unlink(attached); 1475ee519a1fSgjelinek (void) unlink(detached); 1476ee519a1fSgjelinek } 1477ee519a1fSgjelinek } 1478ee519a1fSgjelinek 14797c478bd9Sstevel@tonic-gate /* 14807c478bd9Sstevel@tonic-gate * Special case: if access(2) fails with ENOENT, then try again using 14817c478bd9Sstevel@tonic-gate * ZONE_CONFIG_ROOT instead of config_file_path(zonename). This is how we 14827c478bd9Sstevel@tonic-gate * work around the case of a config file which has not been created yet: 14837c478bd9Sstevel@tonic-gate * the user will need access to the directory so use that as a heuristic. 14847c478bd9Sstevel@tonic-gate */ 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate int 14877c478bd9Sstevel@tonic-gate zonecfg_access(const char *zonename, int amode) 14887c478bd9Sstevel@tonic-gate { 14897c478bd9Sstevel@tonic-gate char path[MAXPATHLEN]; 14907c478bd9Sstevel@tonic-gate 1491108322fbScarlsonj if (!config_file_path(zonename, path)) 1492108322fbScarlsonj return (Z_INVAL); 14937c478bd9Sstevel@tonic-gate if (access(path, amode) == 0) 14947c478bd9Sstevel@tonic-gate return (Z_OK); 1495108322fbScarlsonj if (errno == ENOENT) { 1496108322fbScarlsonj if (snprintf(path, sizeof (path), "%s%s", zonecfg_root, 1497108322fbScarlsonj ZONE_CONFIG_ROOT) >= sizeof (path)) 1498108322fbScarlsonj return (Z_INVAL); 1499108322fbScarlsonj if (access(path, amode) == 0) 1500108322fbScarlsonj return (Z_OK); 1501108322fbScarlsonj } 15027c478bd9Sstevel@tonic-gate if (errno == EACCES) 15037c478bd9Sstevel@tonic-gate return (Z_ACCES); 15047c478bd9Sstevel@tonic-gate if (errno == EINVAL) 15057c478bd9Sstevel@tonic-gate return (Z_INVAL); 15067c478bd9Sstevel@tonic-gate return (Z_MISC_FS); 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate int 1510108322fbScarlsonj zonecfg_create_snapshot(const char *zonename) 15117c478bd9Sstevel@tonic-gate { 15127c478bd9Sstevel@tonic-gate zone_dochandle_t handle; 15137c478bd9Sstevel@tonic-gate char path[MAXPATHLEN], zonepath[MAXPATHLEN], rpath[MAXPATHLEN]; 15147c478bd9Sstevel@tonic-gate int error = Z_OK, res; 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 15177c478bd9Sstevel@tonic-gate return (Z_NOMEM); 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate 1520087719fdSdp handle->zone_dh_newzone = B_TRUE; 1521087719fdSdp handle->zone_dh_snapshot = B_TRUE; 1522087719fdSdp 15237c478bd9Sstevel@tonic-gate if ((error = zonecfg_get_handle(zonename, handle)) != Z_OK) 15247c478bd9Sstevel@tonic-gate goto out; 15257c478bd9Sstevel@tonic-gate if ((error = operation_prep(handle)) != Z_OK) 15267c478bd9Sstevel@tonic-gate goto out; 15277c478bd9Sstevel@tonic-gate error = zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)); 15287c478bd9Sstevel@tonic-gate if (error != Z_OK) 15297c478bd9Sstevel@tonic-gate goto out; 15307c478bd9Sstevel@tonic-gate if ((res = resolvepath(zonepath, rpath, sizeof (rpath))) == -1) { 15317c478bd9Sstevel@tonic-gate error = Z_RESOLVED_PATH; 15327c478bd9Sstevel@tonic-gate goto out; 15337c478bd9Sstevel@tonic-gate } 15347c478bd9Sstevel@tonic-gate /* 15357c478bd9Sstevel@tonic-gate * If the resolved path is not the same as the original path, then 15367c478bd9Sstevel@tonic-gate * save the resolved path in the snapshot, thus preventing any 15377c478bd9Sstevel@tonic-gate * potential problems down the line when zoneadmd goes to unmount 15387c478bd9Sstevel@tonic-gate * file systems and depends on initial string matches with resolved 15397c478bd9Sstevel@tonic-gate * paths. 15407c478bd9Sstevel@tonic-gate */ 15417c478bd9Sstevel@tonic-gate rpath[res] = '\0'; 15427c478bd9Sstevel@tonic-gate if (strcmp(zonepath, rpath) != 0) { 15437c478bd9Sstevel@tonic-gate if ((error = zonecfg_set_zonepath(handle, rpath)) != Z_OK) 15447c478bd9Sstevel@tonic-gate goto out; 15457c478bd9Sstevel@tonic-gate } 1546108322fbScarlsonj if (snprintf(path, sizeof (path), "%s%s", zonecfg_root, 1547108322fbScarlsonj ZONE_SNAPSHOT_ROOT) >= sizeof (path)) { 1548108322fbScarlsonj error = Z_MISC_FS; 1549108322fbScarlsonj goto out; 1550108322fbScarlsonj } 1551108322fbScarlsonj if ((mkdir(path, S_IRWXU) == -1) && (errno != EEXIST)) { 15527c478bd9Sstevel@tonic-gate error = Z_MISC_FS; 15537c478bd9Sstevel@tonic-gate goto out; 15547c478bd9Sstevel@tonic-gate } 15557c478bd9Sstevel@tonic-gate 1556108322fbScarlsonj if (!snap_file_path(zonename, path)) { 1557108322fbScarlsonj error = Z_MISC_FS; 1558108322fbScarlsonj goto out; 1559108322fbScarlsonj } 1560087719fdSdp 1561087719fdSdp addcomment(handle, "\n DO NOT EDIT THIS FILE. " 1562087719fdSdp "It is a snapshot of running zone state.\n"); 1563087719fdSdp 15647c478bd9Sstevel@tonic-gate error = zonecfg_save_impl(handle, path); 15657c478bd9Sstevel@tonic-gate 1566087719fdSdp stripcomments(handle); 1567087719fdSdp 15687c478bd9Sstevel@tonic-gate out: 15697c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 15707c478bd9Sstevel@tonic-gate return (error); 15717c478bd9Sstevel@tonic-gate } 15727c478bd9Sstevel@tonic-gate 1573f4b3ec61Sdh int 1574f4b3ec61Sdh zonecfg_get_iptype(zone_dochandle_t handle, zone_iptype_t *iptypep) 1575f4b3ec61Sdh { 1576f4b3ec61Sdh char property[10]; /* 10 is big enough for "shared"/"exclusive" */ 1577f4b3ec61Sdh int err; 1578f4b3ec61Sdh 1579f4b3ec61Sdh err = getrootattr(handle, DTD_ATTR_IPTYPE, property, sizeof (property)); 1580f4b3ec61Sdh if (err == Z_BAD_PROPERTY) { 1581f4b3ec61Sdh /* Return default value */ 1582f4b3ec61Sdh *iptypep = ZS_SHARED; 1583f4b3ec61Sdh return (Z_OK); 1584f4b3ec61Sdh } else if (err != Z_OK) { 1585f4b3ec61Sdh return (err); 1586f4b3ec61Sdh } 1587f4b3ec61Sdh 1588f4b3ec61Sdh if (strlen(property) == 0 || 1589f4b3ec61Sdh strcmp(property, "shared") == 0) 1590f4b3ec61Sdh *iptypep = ZS_SHARED; 1591f4b3ec61Sdh else if (strcmp(property, "exclusive") == 0) 1592f4b3ec61Sdh *iptypep = ZS_EXCLUSIVE; 1593f4b3ec61Sdh else 1594f4b3ec61Sdh return (Z_INVAL); 1595f4b3ec61Sdh 1596f4b3ec61Sdh return (Z_OK); 1597f4b3ec61Sdh } 1598f4b3ec61Sdh 1599f4b3ec61Sdh int 1600f4b3ec61Sdh zonecfg_set_iptype(zone_dochandle_t handle, zone_iptype_t iptype) 1601f4b3ec61Sdh { 1602f4b3ec61Sdh xmlNodePtr cur; 1603f4b3ec61Sdh 1604f4b3ec61Sdh if (handle == NULL) 1605f4b3ec61Sdh return (Z_INVAL); 1606f4b3ec61Sdh 1607f4b3ec61Sdh cur = xmlDocGetRootElement(handle->zone_dh_doc); 1608f4b3ec61Sdh if (cur == NULL) { 1609f4b3ec61Sdh return (Z_EMPTY_DOCUMENT); 1610f4b3ec61Sdh } 1611f4b3ec61Sdh 1612f4b3ec61Sdh if (xmlStrcmp(cur->name, DTD_ELEM_ZONE) != 0) { 1613f4b3ec61Sdh return (Z_WRONG_DOC_TYPE); 1614f4b3ec61Sdh } 1615f4b3ec61Sdh switch (iptype) { 1616f4b3ec61Sdh case ZS_SHARED: 1617f4b3ec61Sdh /* 1618f4b3ec61Sdh * Since "shared" is the default, we don't write it to the 1619f4b3ec61Sdh * configuration file, so that it's easier to migrate those 1620f4b3ec61Sdh * zones elsewhere, eg., to systems which are not IP-Instances 1621f4b3ec61Sdh * aware. 1622f4b3ec61Sdh * xmlUnsetProp only fails when the attribute doesn't exist, 1623f4b3ec61Sdh * which we don't care. 1624f4b3ec61Sdh */ 1625f4b3ec61Sdh (void) xmlUnsetProp(cur, DTD_ATTR_IPTYPE); 1626f4b3ec61Sdh break; 1627f4b3ec61Sdh case ZS_EXCLUSIVE: 1628f4b3ec61Sdh if (xmlSetProp(cur, DTD_ATTR_IPTYPE, 1629f4b3ec61Sdh (const xmlChar *) "exclusive") == NULL) 1630f4b3ec61Sdh return (Z_INVAL); 1631f4b3ec61Sdh break; 1632f4b3ec61Sdh } 1633f4b3ec61Sdh return (Z_OK); 1634f4b3ec61Sdh } 1635f4b3ec61Sdh 16367c478bd9Sstevel@tonic-gate static int 1637a1be23daSdp newprop(xmlNodePtr node, const xmlChar *attrname, char *src) 16387c478bd9Sstevel@tonic-gate { 16397c478bd9Sstevel@tonic-gate xmlAttrPtr newattr; 16407c478bd9Sstevel@tonic-gate 16417c478bd9Sstevel@tonic-gate newattr = xmlNewProp(node, attrname, (xmlChar *)src); 16427c478bd9Sstevel@tonic-gate if (newattr == NULL) { 16437c478bd9Sstevel@tonic-gate xmlUnlinkNode(node); 16447c478bd9Sstevel@tonic-gate xmlFreeNode(node); 16457c478bd9Sstevel@tonic-gate return (Z_BAD_PROPERTY); 16467c478bd9Sstevel@tonic-gate } 16477c478bd9Sstevel@tonic-gate return (Z_OK); 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate static int 16517c478bd9Sstevel@tonic-gate zonecfg_add_filesystem_core(zone_dochandle_t handle, struct zone_fstab *tabptr) 16527c478bd9Sstevel@tonic-gate { 16537c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur, options_node; 16547c478bd9Sstevel@tonic-gate zone_fsopt_t *ptr; 16557c478bd9Sstevel@tonic-gate int err; 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_FS, NULL); 1658a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_SPECIAL, 16597c478bd9Sstevel@tonic-gate tabptr->zone_fs_special)) != Z_OK) 16607c478bd9Sstevel@tonic-gate return (err); 16617c478bd9Sstevel@tonic-gate if (tabptr->zone_fs_raw[0] != '\0' && 1662a1be23daSdp (err = newprop(newnode, DTD_ATTR_RAW, tabptr->zone_fs_raw)) != Z_OK) 16637c478bd9Sstevel@tonic-gate return (err); 1664a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_DIR, tabptr->zone_fs_dir)) != Z_OK) 16657c478bd9Sstevel@tonic-gate return (err); 1666a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_TYPE, 16677c478bd9Sstevel@tonic-gate tabptr->zone_fs_type)) != Z_OK) 16687c478bd9Sstevel@tonic-gate return (err); 16697c478bd9Sstevel@tonic-gate if (tabptr->zone_fs_options != NULL) { 16707c478bd9Sstevel@tonic-gate for (ptr = tabptr->zone_fs_options; ptr != NULL; 16717c478bd9Sstevel@tonic-gate ptr = ptr->zone_fsopt_next) { 16727c478bd9Sstevel@tonic-gate options_node = xmlNewTextChild(newnode, NULL, 16737c478bd9Sstevel@tonic-gate DTD_ELEM_FSOPTION, NULL); 1674a1be23daSdp if ((err = newprop(options_node, DTD_ATTR_NAME, 16757c478bd9Sstevel@tonic-gate ptr->zone_fsopt_opt)) != Z_OK) 16767c478bd9Sstevel@tonic-gate return (err); 16777c478bd9Sstevel@tonic-gate } 16787c478bd9Sstevel@tonic-gate } 16797c478bd9Sstevel@tonic-gate return (Z_OK); 16807c478bd9Sstevel@tonic-gate } 16817c478bd9Sstevel@tonic-gate 16827c478bd9Sstevel@tonic-gate int 16837c478bd9Sstevel@tonic-gate zonecfg_add_filesystem(zone_dochandle_t handle, struct zone_fstab *tabptr) 16847c478bd9Sstevel@tonic-gate { 16857c478bd9Sstevel@tonic-gate int err; 16867c478bd9Sstevel@tonic-gate 16877c478bd9Sstevel@tonic-gate if (tabptr == NULL) 16887c478bd9Sstevel@tonic-gate return (Z_INVAL); 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 16917c478bd9Sstevel@tonic-gate return (err); 16927c478bd9Sstevel@tonic-gate 16937c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_filesystem_core(handle, tabptr)) != Z_OK) 16947c478bd9Sstevel@tonic-gate return (err); 16957c478bd9Sstevel@tonic-gate 16967c478bd9Sstevel@tonic-gate return (Z_OK); 16977c478bd9Sstevel@tonic-gate } 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate int 17007c478bd9Sstevel@tonic-gate zonecfg_add_fs_option(struct zone_fstab *tabptr, char *option) 17017c478bd9Sstevel@tonic-gate { 17027c478bd9Sstevel@tonic-gate zone_fsopt_t *last, *old, *new; 17037c478bd9Sstevel@tonic-gate 17047c478bd9Sstevel@tonic-gate last = tabptr->zone_fs_options; 17057c478bd9Sstevel@tonic-gate for (old = last; old != NULL; old = old->zone_fsopt_next) 17067c478bd9Sstevel@tonic-gate last = old; /* walk to the end of the list */ 17077c478bd9Sstevel@tonic-gate new = (zone_fsopt_t *)malloc(sizeof (zone_fsopt_t)); 17087c478bd9Sstevel@tonic-gate if (new == NULL) 17097c478bd9Sstevel@tonic-gate return (Z_NOMEM); 17107c478bd9Sstevel@tonic-gate (void) strlcpy(new->zone_fsopt_opt, option, 17117c478bd9Sstevel@tonic-gate sizeof (new->zone_fsopt_opt)); 17127c478bd9Sstevel@tonic-gate new->zone_fsopt_next = NULL; 17137c478bd9Sstevel@tonic-gate if (last == NULL) 17147c478bd9Sstevel@tonic-gate tabptr->zone_fs_options = new; 17157c478bd9Sstevel@tonic-gate else 17167c478bd9Sstevel@tonic-gate last->zone_fsopt_next = new; 17177c478bd9Sstevel@tonic-gate return (Z_OK); 17187c478bd9Sstevel@tonic-gate } 17197c478bd9Sstevel@tonic-gate 17207c478bd9Sstevel@tonic-gate int 17217c478bd9Sstevel@tonic-gate zonecfg_remove_fs_option(struct zone_fstab *tabptr, char *option) 17227c478bd9Sstevel@tonic-gate { 17237c478bd9Sstevel@tonic-gate zone_fsopt_t *last, *this, *next; 17247c478bd9Sstevel@tonic-gate 17257c478bd9Sstevel@tonic-gate last = tabptr->zone_fs_options; 17267c478bd9Sstevel@tonic-gate for (this = last; this != NULL; this = this->zone_fsopt_next) { 17277c478bd9Sstevel@tonic-gate if (strcmp(this->zone_fsopt_opt, option) == 0) { 17287c478bd9Sstevel@tonic-gate next = this->zone_fsopt_next; 17297c478bd9Sstevel@tonic-gate if (this == tabptr->zone_fs_options) 17307c478bd9Sstevel@tonic-gate tabptr->zone_fs_options = next; 17317c478bd9Sstevel@tonic-gate else 17327c478bd9Sstevel@tonic-gate last->zone_fsopt_next = next; 17337c478bd9Sstevel@tonic-gate free(this); 17347c478bd9Sstevel@tonic-gate return (Z_OK); 17357c478bd9Sstevel@tonic-gate } else 17367c478bd9Sstevel@tonic-gate last = this; 17377c478bd9Sstevel@tonic-gate } 17387c478bd9Sstevel@tonic-gate return (Z_NO_PROPERTY_ID); 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate void 17427c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(zone_fsopt_t *list) 17437c478bd9Sstevel@tonic-gate { 17447c478bd9Sstevel@tonic-gate zone_fsopt_t *this, *next; 17457c478bd9Sstevel@tonic-gate 17467c478bd9Sstevel@tonic-gate for (this = list; this != NULL; this = next) { 17477c478bd9Sstevel@tonic-gate next = this->zone_fsopt_next; 17487c478bd9Sstevel@tonic-gate free(this); 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate 17527c478bd9Sstevel@tonic-gate void 17537c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(struct zone_rctlvaltab *valtab) 17547c478bd9Sstevel@tonic-gate { 17557c478bd9Sstevel@tonic-gate if (valtab == NULL) 17567c478bd9Sstevel@tonic-gate return; 17577c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(valtab->zone_rctlval_next); 17587c478bd9Sstevel@tonic-gate free(valtab); 17597c478bd9Sstevel@tonic-gate } 17607c478bd9Sstevel@tonic-gate 17617c478bd9Sstevel@tonic-gate static boolean_t 17627c478bd9Sstevel@tonic-gate match_prop(xmlNodePtr cur, const xmlChar *attr, char *user_prop) 17637c478bd9Sstevel@tonic-gate { 17647c478bd9Sstevel@tonic-gate xmlChar *gotten_prop; 17657c478bd9Sstevel@tonic-gate int prop_result; 17667c478bd9Sstevel@tonic-gate 17677c478bd9Sstevel@tonic-gate gotten_prop = xmlGetProp(cur, attr); 17687c478bd9Sstevel@tonic-gate if (gotten_prop == NULL) /* shouldn't happen */ 17697c478bd9Sstevel@tonic-gate return (B_FALSE); 17707c478bd9Sstevel@tonic-gate prop_result = xmlStrcmp(gotten_prop, (const xmlChar *) user_prop); 17717c478bd9Sstevel@tonic-gate xmlFree(gotten_prop); 17725e74f94dSGary Mills return ((prop_result == 0)); /* empty strings will match */ 17737c478bd9Sstevel@tonic-gate } 17747c478bd9Sstevel@tonic-gate 17757c478bd9Sstevel@tonic-gate static int 17767c478bd9Sstevel@tonic-gate zonecfg_delete_filesystem_core(zone_dochandle_t handle, 17777c478bd9Sstevel@tonic-gate struct zone_fstab *tabptr) 17787c478bd9Sstevel@tonic-gate { 17797c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 17807c478bd9Sstevel@tonic-gate boolean_t dir_match, spec_match, raw_match, type_match; 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 17837c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_FS)) 17847c478bd9Sstevel@tonic-gate continue; 17857c478bd9Sstevel@tonic-gate dir_match = match_prop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir); 17867c478bd9Sstevel@tonic-gate spec_match = match_prop(cur, DTD_ATTR_SPECIAL, 17877c478bd9Sstevel@tonic-gate tabptr->zone_fs_special); 17887c478bd9Sstevel@tonic-gate raw_match = match_prop(cur, DTD_ATTR_RAW, 17897c478bd9Sstevel@tonic-gate tabptr->zone_fs_raw); 17907c478bd9Sstevel@tonic-gate type_match = match_prop(cur, DTD_ATTR_TYPE, 17917c478bd9Sstevel@tonic-gate tabptr->zone_fs_type); 17927c478bd9Sstevel@tonic-gate if (dir_match && spec_match && raw_match && type_match) { 17937c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 17947c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 17957c478bd9Sstevel@tonic-gate return (Z_OK); 17967c478bd9Sstevel@tonic-gate } 17977c478bd9Sstevel@tonic-gate } 17987c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 17997c478bd9Sstevel@tonic-gate } 18007c478bd9Sstevel@tonic-gate 18017c478bd9Sstevel@tonic-gate int 18027c478bd9Sstevel@tonic-gate zonecfg_delete_filesystem(zone_dochandle_t handle, struct zone_fstab *tabptr) 18037c478bd9Sstevel@tonic-gate { 18047c478bd9Sstevel@tonic-gate int err; 18057c478bd9Sstevel@tonic-gate 18067c478bd9Sstevel@tonic-gate if (tabptr == NULL) 18077c478bd9Sstevel@tonic-gate return (Z_INVAL); 18087c478bd9Sstevel@tonic-gate 18097c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18107c478bd9Sstevel@tonic-gate return (err); 18117c478bd9Sstevel@tonic-gate 18127c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem_core(handle, tabptr)) != Z_OK) 18137c478bd9Sstevel@tonic-gate return (err); 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate return (Z_OK); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate int 18197c478bd9Sstevel@tonic-gate zonecfg_modify_filesystem( 18207c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 18217c478bd9Sstevel@tonic-gate struct zone_fstab *oldtabptr, 18227c478bd9Sstevel@tonic-gate struct zone_fstab *newtabptr) 18237c478bd9Sstevel@tonic-gate { 18247c478bd9Sstevel@tonic-gate int err; 18257c478bd9Sstevel@tonic-gate 18267c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 18277c478bd9Sstevel@tonic-gate return (Z_INVAL); 18287c478bd9Sstevel@tonic-gate 18297c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18307c478bd9Sstevel@tonic-gate return (err); 18317c478bd9Sstevel@tonic-gate 18327c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem_core(handle, oldtabptr)) != Z_OK) 18337c478bd9Sstevel@tonic-gate return (err); 18347c478bd9Sstevel@tonic-gate 18357c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_filesystem_core(handle, newtabptr)) != Z_OK) 18367c478bd9Sstevel@tonic-gate return (err); 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate return (Z_OK); 18397c478bd9Sstevel@tonic-gate } 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate int 18427c478bd9Sstevel@tonic-gate zonecfg_lookup_filesystem( 18437c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 18447c478bd9Sstevel@tonic-gate struct zone_fstab *tabptr) 18457c478bd9Sstevel@tonic-gate { 18467c478bd9Sstevel@tonic-gate xmlNodePtr cur, options, firstmatch; 18477c478bd9Sstevel@tonic-gate int err; 18487c478bd9Sstevel@tonic-gate char dirname[MAXPATHLEN], special[MAXPATHLEN], raw[MAXPATHLEN]; 18497c478bd9Sstevel@tonic-gate char type[FSTYPSZ]; 18507c478bd9Sstevel@tonic-gate char options_str[MAX_MNTOPT_STR]; 18517c478bd9Sstevel@tonic-gate 18527c478bd9Sstevel@tonic-gate if (tabptr == NULL) 18537c478bd9Sstevel@tonic-gate return (Z_INVAL); 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 18567c478bd9Sstevel@tonic-gate return (err); 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate /* 18597c478bd9Sstevel@tonic-gate * Walk the list of children looking for matches on any properties 18607c478bd9Sstevel@tonic-gate * specified in the fstab parameter. If more than one resource 18617c478bd9Sstevel@tonic-gate * matches, we return Z_INSUFFICIENT_SPEC; if none match, we return 18627c478bd9Sstevel@tonic-gate * Z_NO_RESOURCE_ID. 18637c478bd9Sstevel@tonic-gate */ 18647c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 18657c478bd9Sstevel@tonic-gate firstmatch = NULL; 18667c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 18677c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_FS)) 18687c478bd9Sstevel@tonic-gate continue; 18697c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_dir) > 0) { 18707c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_DIR, dirname, 18717c478bd9Sstevel@tonic-gate sizeof (dirname)) == Z_OK) && 18727c478bd9Sstevel@tonic-gate (strcmp(tabptr->zone_fs_dir, dirname) == 0)) { 18737c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 18747c478bd9Sstevel@tonic-gate firstmatch = cur; 18757c478bd9Sstevel@tonic-gate else 18767c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 18777c478bd9Sstevel@tonic-gate } 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_special) > 0) { 18807c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_SPECIAL, special, 18817c478bd9Sstevel@tonic-gate sizeof (special)) == Z_OK)) { 18827c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_fs_special, 18837c478bd9Sstevel@tonic-gate special) == 0) { 18847c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 18857c478bd9Sstevel@tonic-gate firstmatch = cur; 18867c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 18877c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 18887c478bd9Sstevel@tonic-gate } else { 18897c478bd9Sstevel@tonic-gate /* 18907c478bd9Sstevel@tonic-gate * If another property matched but this 18917c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 18927c478bd9Sstevel@tonic-gate */ 18937c478bd9Sstevel@tonic-gate if (firstmatch == cur) 18947c478bd9Sstevel@tonic-gate firstmatch = NULL; 18957c478bd9Sstevel@tonic-gate } 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate } 18987c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_raw) > 0) { 18997c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_RAW, raw, 19007c478bd9Sstevel@tonic-gate sizeof (raw)) == Z_OK)) { 19017c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_fs_raw, raw) == 0) { 19027c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19037c478bd9Sstevel@tonic-gate firstmatch = cur; 19047c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 19057c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19067c478bd9Sstevel@tonic-gate } else { 19077c478bd9Sstevel@tonic-gate /* 19087c478bd9Sstevel@tonic-gate * If another property matched but this 19097c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 19107c478bd9Sstevel@tonic-gate */ 19117c478bd9Sstevel@tonic-gate if (firstmatch == cur) 19127c478bd9Sstevel@tonic-gate firstmatch = NULL; 19137c478bd9Sstevel@tonic-gate } 19147c478bd9Sstevel@tonic-gate } 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_fs_type) > 0) { 19177c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_TYPE, type, 19187c478bd9Sstevel@tonic-gate sizeof (type)) == Z_OK)) { 19197c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_fs_type, type) == 0) { 19207c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19217c478bd9Sstevel@tonic-gate firstmatch = cur; 19227c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 19237c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19247c478bd9Sstevel@tonic-gate } else { 19257c478bd9Sstevel@tonic-gate /* 19267c478bd9Sstevel@tonic-gate * If another property matched but this 19277c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 19287c478bd9Sstevel@tonic-gate */ 19297c478bd9Sstevel@tonic-gate if (firstmatch == cur) 19307c478bd9Sstevel@tonic-gate firstmatch = NULL; 19317c478bd9Sstevel@tonic-gate } 19327c478bd9Sstevel@tonic-gate } 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate } 19357c478bd9Sstevel@tonic-gate 19367c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 19377c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 19387c478bd9Sstevel@tonic-gate 19397c478bd9Sstevel@tonic-gate cur = firstmatch; 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir, 19427c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_dir))) != Z_OK) 19437c478bd9Sstevel@tonic-gate return (err); 19447c478bd9Sstevel@tonic-gate 19457c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_SPECIAL, tabptr->zone_fs_special, 19467c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_special))) != Z_OK) 19477c478bd9Sstevel@tonic-gate return (err); 19487c478bd9Sstevel@tonic-gate 19497c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_RAW, tabptr->zone_fs_raw, 19507c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_raw))) != Z_OK) 19517c478bd9Sstevel@tonic-gate return (err); 19527c478bd9Sstevel@tonic-gate 19537c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_fs_type, 19547c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_fs_type))) != Z_OK) 19557c478bd9Sstevel@tonic-gate return (err); 19567c478bd9Sstevel@tonic-gate 19577c478bd9Sstevel@tonic-gate /* options are optional */ 19587c478bd9Sstevel@tonic-gate tabptr->zone_fs_options = NULL; 19597c478bd9Sstevel@tonic-gate for (options = cur->xmlChildrenNode; options != NULL; 19607c478bd9Sstevel@tonic-gate options = options->next) { 19617c478bd9Sstevel@tonic-gate if ((fetchprop(options, DTD_ATTR_NAME, options_str, 19627c478bd9Sstevel@tonic-gate sizeof (options_str)) != Z_OK)) 19637c478bd9Sstevel@tonic-gate break; 19647c478bd9Sstevel@tonic-gate if (zonecfg_add_fs_option(tabptr, options_str) != Z_OK) 19657c478bd9Sstevel@tonic-gate break; 19667c478bd9Sstevel@tonic-gate } 19677c478bd9Sstevel@tonic-gate return (Z_OK); 19687c478bd9Sstevel@tonic-gate } 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate /* 19717c478bd9Sstevel@tonic-gate * Compare two IP addresses in string form. Allow for the possibility that 19727c478bd9Sstevel@tonic-gate * one might have "/<prefix-length>" at the end: allow a match on just the 19737c478bd9Sstevel@tonic-gate * IP address (or host name) part. 19747c478bd9Sstevel@tonic-gate */ 19757c478bd9Sstevel@tonic-gate 19767c478bd9Sstevel@tonic-gate boolean_t 19777c478bd9Sstevel@tonic-gate zonecfg_same_net_address(char *a1, char *a2) 19787c478bd9Sstevel@tonic-gate { 19797c478bd9Sstevel@tonic-gate char *slashp, *slashp1, *slashp2; 19807c478bd9Sstevel@tonic-gate int result; 19817c478bd9Sstevel@tonic-gate 19827c478bd9Sstevel@tonic-gate if (strcmp(a1, a2) == 0) 19837c478bd9Sstevel@tonic-gate return (B_TRUE); 19847c478bd9Sstevel@tonic-gate 19857c478bd9Sstevel@tonic-gate /* 19867c478bd9Sstevel@tonic-gate * If neither has a slash or both do, they need to match to be 19877c478bd9Sstevel@tonic-gate * considered the same, but they did not match above, so fail. 19887c478bd9Sstevel@tonic-gate */ 19897c478bd9Sstevel@tonic-gate slashp1 = strchr(a1, '/'); 19907c478bd9Sstevel@tonic-gate slashp2 = strchr(a2, '/'); 19917c478bd9Sstevel@tonic-gate if ((slashp1 == NULL && slashp2 == NULL) || 19927c478bd9Sstevel@tonic-gate (slashp1 != NULL && slashp2 != NULL)) 19937c478bd9Sstevel@tonic-gate return (B_FALSE); 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate /* 19967c478bd9Sstevel@tonic-gate * Only one had a slash: pick that one, zero out the slash, compare 19977c478bd9Sstevel@tonic-gate * the "address only" strings, restore the slash, and return the 19987c478bd9Sstevel@tonic-gate * result of the comparison. 19997c478bd9Sstevel@tonic-gate */ 20007c478bd9Sstevel@tonic-gate slashp = (slashp1 == NULL) ? slashp2 : slashp1; 20017c478bd9Sstevel@tonic-gate *slashp = '\0'; 20027c478bd9Sstevel@tonic-gate result = strcmp(a1, a2); 20037c478bd9Sstevel@tonic-gate *slashp = '/'; 20047c478bd9Sstevel@tonic-gate return ((result == 0)); 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate 20077c478bd9Sstevel@tonic-gate int 20087c478bd9Sstevel@tonic-gate zonecfg_valid_net_address(char *address, struct lifreq *lifr) 20097c478bd9Sstevel@tonic-gate { 20107c478bd9Sstevel@tonic-gate struct sockaddr_in *sin4; 20117c478bd9Sstevel@tonic-gate struct sockaddr_in6 *sin6; 20127c478bd9Sstevel@tonic-gate struct addrinfo hints, *result; 20137c478bd9Sstevel@tonic-gate char *slashp = strchr(address, '/'); 20147c478bd9Sstevel@tonic-gate 20157c478bd9Sstevel@tonic-gate bzero(lifr, sizeof (struct lifreq)); 20167c478bd9Sstevel@tonic-gate sin4 = (struct sockaddr_in *)&lifr->lifr_addr; 20177c478bd9Sstevel@tonic-gate sin6 = (struct sockaddr_in6 *)&lifr->lifr_addr; 20187c478bd9Sstevel@tonic-gate if (slashp != NULL) 20197c478bd9Sstevel@tonic-gate *slashp = '\0'; 20207c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, address, &sin4->sin_addr) == 1) { 20217c478bd9Sstevel@tonic-gate sin4->sin_family = AF_INET; 20227c478bd9Sstevel@tonic-gate } else if (inet_pton(AF_INET6, address, &sin6->sin6_addr) == 1) { 20237c478bd9Sstevel@tonic-gate if (slashp == NULL) 20247c478bd9Sstevel@tonic-gate return (Z_IPV6_ADDR_PREFIX_LEN); 20257c478bd9Sstevel@tonic-gate sin6->sin6_family = AF_INET6; 20267c478bd9Sstevel@tonic-gate } else { 20277c478bd9Sstevel@tonic-gate /* "address" may be a host name */ 20287c478bd9Sstevel@tonic-gate (void) memset(&hints, 0, sizeof (hints)); 20297c478bd9Sstevel@tonic-gate hints.ai_family = PF_INET; 20307c478bd9Sstevel@tonic-gate if (getaddrinfo(address, NULL, &hints, &result) != 0) 20317c478bd9Sstevel@tonic-gate return (Z_BOGUS_ADDRESS); 20327c478bd9Sstevel@tonic-gate sin4->sin_family = result->ai_family; 2033a1be23daSdp 20347c478bd9Sstevel@tonic-gate (void) memcpy(&sin4->sin_addr, 20357c478bd9Sstevel@tonic-gate /* LINTED E_BAD_PTR_CAST_ALIGN */ 20367c478bd9Sstevel@tonic-gate &((struct sockaddr_in *)result->ai_addr)->sin_addr, 20377c478bd9Sstevel@tonic-gate sizeof (struct in_addr)); 2038a1be23daSdp 20397c478bd9Sstevel@tonic-gate freeaddrinfo(result); 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate return (Z_OK); 20427c478bd9Sstevel@tonic-gate } 20437c478bd9Sstevel@tonic-gate 2044f4b3ec61Sdh boolean_t 2045f4b3ec61Sdh zonecfg_ifname_exists(sa_family_t af, char *ifname) 2046f4b3ec61Sdh { 2047f4b3ec61Sdh struct lifreq lifr; 2048f4b3ec61Sdh int so; 2049f4b3ec61Sdh int save_errno; 2050f4b3ec61Sdh 2051f4b3ec61Sdh (void) memset(&lifr, 0, sizeof (lifr)); 2052f4b3ec61Sdh (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name)); 2053f4b3ec61Sdh lifr.lifr_addr.ss_family = af; 2054f4b3ec61Sdh if ((so = socket(af, SOCK_DGRAM, 0)) < 0) { 2055f4b3ec61Sdh /* Odd - can't tell if the ifname exists */ 2056f4b3ec61Sdh return (B_FALSE); 2057f4b3ec61Sdh } 2058f4b3ec61Sdh if (ioctl(so, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) { 2059f4b3ec61Sdh save_errno = errno; 2060f4b3ec61Sdh (void) close(so); 2061f4b3ec61Sdh errno = save_errno; 2062f4b3ec61Sdh return (B_FALSE); 2063f4b3ec61Sdh } 2064f4b3ec61Sdh (void) close(so); 2065f4b3ec61Sdh return (B_TRUE); 2066f4b3ec61Sdh } 2067f4b3ec61Sdh 2068a8053275Sjv /* 206934eb7836Sjv * Determines whether there is a net resource with the physical interface, IP 207034eb7836Sjv * address, and default router specified by 'tabptr' in the zone configuration 207134eb7836Sjv * to which 'handle' refers. 'tabptr' must have an interface, an address, a 207234eb7836Sjv * default router, or a combination of the three. This function returns Z_OK 207334eb7836Sjv * iff there is exactly one net resource matching the query specified by 207434eb7836Sjv * 'tabptr'. The function returns Z_INSUFFICIENT_SPEC if there are multiple 207534eb7836Sjv * matches or 'tabptr' does not specify a physical interface, address, or 207634eb7836Sjv * default router. The function returns Z_NO_RESOURCE_ID if are no matches. 2077a8053275Sjv * 2078a8053275Sjv * Errors might also be returned if the entry that exactly matches the 2079a8053275Sjv * query lacks critical network resource information. 2080a8053275Sjv * 208134eb7836Sjv * If there is a single match, then the matching entry's physical interface, IP 208234eb7836Sjv * address, and default router information are stored in 'tabptr'. 2083a8053275Sjv */ 20847c478bd9Sstevel@tonic-gate int 20857c478bd9Sstevel@tonic-gate zonecfg_lookup_nwif(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 20867c478bd9Sstevel@tonic-gate { 2087a8053275Sjv xmlNodePtr cur; 2088a8053275Sjv xmlNodePtr firstmatch; 20897c478bd9Sstevel@tonic-gate int err; 2090a8053275Sjv char address[INET6_ADDRSTRLEN]; 2091a8053275Sjv char physical[LIFNAMSIZ]; 2092a8053275Sjv size_t addrspec; /* nonzero if tabptr has IP addr */ 2093a8053275Sjv size_t physspec; /* nonzero if tabptr has interface */ 209434eb7836Sjv size_t defrouterspec; /* nonzero if tabptr has def. router */ 2095550b6e40SSowmini Varadhan size_t allowed_addrspec; 2096550b6e40SSowmini Varadhan zone_iptype_t iptype; 20977c478bd9Sstevel@tonic-gate 20987c478bd9Sstevel@tonic-gate if (tabptr == NULL) 20997c478bd9Sstevel@tonic-gate return (Z_INVAL); 21007c478bd9Sstevel@tonic-gate 2101a8053275Sjv /* 210234eb7836Sjv * Determine the fields that will be searched. There must be at least 210334eb7836Sjv * one. 210434eb7836Sjv * 210534eb7836Sjv * zone_nwif_address, zone_nwif_physical, and zone_nwif_defrouter are 210634eb7836Sjv * arrays, so no NULL checks are necessary. 2107a8053275Sjv */ 2108a8053275Sjv addrspec = strlen(tabptr->zone_nwif_address); 2109a8053275Sjv physspec = strlen(tabptr->zone_nwif_physical); 211034eb7836Sjv defrouterspec = strlen(tabptr->zone_nwif_defrouter); 2111550b6e40SSowmini Varadhan allowed_addrspec = strlen(tabptr->zone_nwif_allowed_address); 2112550b6e40SSowmini Varadhan if (addrspec != 0 && allowed_addrspec != 0) 2113550b6e40SSowmini Varadhan return (Z_INVAL); /* can't specify both */ 2114550b6e40SSowmini Varadhan if (addrspec == 0 && physspec == 0 && defrouterspec == 0 && 2115550b6e40SSowmini Varadhan allowed_addrspec == 0) 211634eb7836Sjv return (Z_INSUFFICIENT_SPEC); 2117a8053275Sjv 21187c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 21197c478bd9Sstevel@tonic-gate return (err); 21207c478bd9Sstevel@tonic-gate 2121550b6e40SSowmini Varadhan if ((err = zonecfg_get_iptype(handle, &iptype)) != Z_OK) 2122550b6e40SSowmini Varadhan return (err); 212334eb7836Sjv /* 212434eb7836Sjv * Iterate over the configuration's elements and look for net elements 212534eb7836Sjv * that match the query. 212634eb7836Sjv */ 21277c478bd9Sstevel@tonic-gate firstmatch = NULL; 2128a8053275Sjv cur = handle->zone_dh_cur; 21297c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 2130a8053275Sjv /* Skip non-net elements */ 21317c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_NET)) 21327c478bd9Sstevel@tonic-gate continue; 2133a8053275Sjv 2134a8053275Sjv /* 213534eb7836Sjv * If any relevant fields don't match the query, then skip 213634eb7836Sjv * the current net element. 2137a8053275Sjv */ 213834eb7836Sjv if (physspec != 0 && (fetchprop(cur, DTD_ATTR_PHYSICAL, 213934eb7836Sjv physical, sizeof (physical)) != Z_OK || 214034eb7836Sjv strcmp(tabptr->zone_nwif_physical, physical) != 0)) 214134eb7836Sjv continue; 2142550b6e40SSowmini Varadhan if (iptype == ZS_SHARED && addrspec != 0 && 2143550b6e40SSowmini Varadhan (fetchprop(cur, DTD_ATTR_ADDRESS, address, 214434eb7836Sjv sizeof (address)) != Z_OK || 214534eb7836Sjv !zonecfg_same_net_address(tabptr->zone_nwif_address, 214634eb7836Sjv address))) 214734eb7836Sjv continue; 2148550b6e40SSowmini Varadhan if (iptype == ZS_EXCLUSIVE && allowed_addrspec != 0 && 2149550b6e40SSowmini Varadhan (fetchprop(cur, DTD_ATTR_ALLOWED_ADDRESS, address, 2150550b6e40SSowmini Varadhan sizeof (address)) != Z_OK || 2151550b6e40SSowmini Varadhan !zonecfg_same_net_address(tabptr->zone_nwif_allowed_address, 2152550b6e40SSowmini Varadhan address))) 2153550b6e40SSowmini Varadhan continue; 215434eb7836Sjv if (defrouterspec != 0 && (fetchprop(cur, DTD_ATTR_DEFROUTER, 215534eb7836Sjv address, sizeof (address)) != Z_OK || 215634eb7836Sjv !zonecfg_same_net_address(tabptr->zone_nwif_defrouter, 215734eb7836Sjv address))) 215834eb7836Sjv continue; 215934eb7836Sjv 216034eb7836Sjv /* 216134eb7836Sjv * The current net element matches the query. Select it if 216234eb7836Sjv * it's the first match; otherwise, abort the search. 216334eb7836Sjv */ 216434eb7836Sjv if (firstmatch == NULL) 216534eb7836Sjv firstmatch = cur; 216634eb7836Sjv else 216734eb7836Sjv return (Z_INSUFFICIENT_SPEC); 21687c478bd9Sstevel@tonic-gate } 21697c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 21707c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate cur = firstmatch; 21737c478bd9Sstevel@tonic-gate 21747c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_PHYSICAL, tabptr->zone_nwif_physical, 21757c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_nwif_physical))) != Z_OK) 21767c478bd9Sstevel@tonic-gate return (err); 21777c478bd9Sstevel@tonic-gate 2178550b6e40SSowmini Varadhan if (iptype == ZS_SHARED && 2179550b6e40SSowmini Varadhan (err = fetchprop(cur, DTD_ATTR_ADDRESS, tabptr->zone_nwif_address, 21807c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_nwif_address))) != Z_OK) 21817c478bd9Sstevel@tonic-gate return (err); 21827c478bd9Sstevel@tonic-gate 2183550b6e40SSowmini Varadhan if (iptype == ZS_EXCLUSIVE && 2184550b6e40SSowmini Varadhan (err = fetchprop(cur, DTD_ATTR_ALLOWED_ADDRESS, 2185550b6e40SSowmini Varadhan tabptr->zone_nwif_allowed_address, 2186550b6e40SSowmini Varadhan sizeof (tabptr->zone_nwif_allowed_address))) != Z_OK) 2187550b6e40SSowmini Varadhan return (err); 2188550b6e40SSowmini Varadhan 2189de860bd9Sgfaden if ((err = fetchprop(cur, DTD_ATTR_DEFROUTER, 2190de860bd9Sgfaden tabptr->zone_nwif_defrouter, 2191de860bd9Sgfaden sizeof (tabptr->zone_nwif_defrouter))) != Z_OK) 2192de860bd9Sgfaden return (err); 2193de860bd9Sgfaden 21947c478bd9Sstevel@tonic-gate return (Z_OK); 21957c478bd9Sstevel@tonic-gate } 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate static int 21987c478bd9Sstevel@tonic-gate zonecfg_add_nwif_core(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 21997c478bd9Sstevel@tonic-gate { 22007c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 22017c478bd9Sstevel@tonic-gate int err; 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_NET, NULL); 2204550b6e40SSowmini Varadhan if (strlen(tabptr->zone_nwif_address) > 0 && 2205550b6e40SSowmini Varadhan (err = newprop(newnode, DTD_ATTR_ADDRESS, 22067c478bd9Sstevel@tonic-gate tabptr->zone_nwif_address)) != Z_OK) 22077c478bd9Sstevel@tonic-gate return (err); 2208550b6e40SSowmini Varadhan if (strlen(tabptr->zone_nwif_allowed_address) > 0 && 2209550b6e40SSowmini Varadhan (err = newprop(newnode, DTD_ATTR_ALLOWED_ADDRESS, 2210550b6e40SSowmini Varadhan tabptr->zone_nwif_allowed_address)) != Z_OK) 2211550b6e40SSowmini Varadhan return (err); 2212a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_PHYSICAL, 22137c478bd9Sstevel@tonic-gate tabptr->zone_nwif_physical)) != Z_OK) 22147c478bd9Sstevel@tonic-gate return (err); 221544ce818bSjparcel /* 221644ce818bSjparcel * Do not add this property when it is not set, for backwards 221744ce818bSjparcel * compatibility and because it is optional. 221844ce818bSjparcel */ 221944ce818bSjparcel if ((strlen(tabptr->zone_nwif_defrouter) > 0) && 222044ce818bSjparcel ((err = newprop(newnode, DTD_ATTR_DEFROUTER, 222144ce818bSjparcel tabptr->zone_nwif_defrouter)) != Z_OK)) 2222de860bd9Sgfaden return (err); 22237c478bd9Sstevel@tonic-gate return (Z_OK); 22247c478bd9Sstevel@tonic-gate } 22257c478bd9Sstevel@tonic-gate 22267c478bd9Sstevel@tonic-gate int 22277c478bd9Sstevel@tonic-gate zonecfg_add_nwif(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 22287c478bd9Sstevel@tonic-gate { 22297c478bd9Sstevel@tonic-gate int err; 22307c478bd9Sstevel@tonic-gate 22317c478bd9Sstevel@tonic-gate if (tabptr == NULL) 22327c478bd9Sstevel@tonic-gate return (Z_INVAL); 22337c478bd9Sstevel@tonic-gate 22347c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 22357c478bd9Sstevel@tonic-gate return (err); 22367c478bd9Sstevel@tonic-gate 22377c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_nwif_core(handle, tabptr)) != Z_OK) 22387c478bd9Sstevel@tonic-gate return (err); 22397c478bd9Sstevel@tonic-gate 22407c478bd9Sstevel@tonic-gate return (Z_OK); 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate 22437c478bd9Sstevel@tonic-gate static int 22447c478bd9Sstevel@tonic-gate zonecfg_delete_nwif_core(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 22457c478bd9Sstevel@tonic-gate { 22467c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 2247550b6e40SSowmini Varadhan boolean_t addr_match, phys_match, allowed_addr_match; 22487c478bd9Sstevel@tonic-gate 22497c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 22507c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_NET)) 22517c478bd9Sstevel@tonic-gate continue; 22527c478bd9Sstevel@tonic-gate 22537c478bd9Sstevel@tonic-gate addr_match = match_prop(cur, DTD_ATTR_ADDRESS, 22547c478bd9Sstevel@tonic-gate tabptr->zone_nwif_address); 2255550b6e40SSowmini Varadhan allowed_addr_match = match_prop(cur, DTD_ATTR_ALLOWED_ADDRESS, 2256550b6e40SSowmini Varadhan tabptr->zone_nwif_allowed_address); 22577c478bd9Sstevel@tonic-gate phys_match = match_prop(cur, DTD_ATTR_PHYSICAL, 22587c478bd9Sstevel@tonic-gate tabptr->zone_nwif_physical); 22597c478bd9Sstevel@tonic-gate 22605e74f94dSGary Mills if (addr_match && allowed_addr_match && phys_match) { 22617c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 22627c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 22637c478bd9Sstevel@tonic-gate return (Z_OK); 22647c478bd9Sstevel@tonic-gate } 22657c478bd9Sstevel@tonic-gate } 22667c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 22677c478bd9Sstevel@tonic-gate } 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate int 22707c478bd9Sstevel@tonic-gate zonecfg_delete_nwif(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 22717c478bd9Sstevel@tonic-gate { 22727c478bd9Sstevel@tonic-gate int err; 22737c478bd9Sstevel@tonic-gate 22747c478bd9Sstevel@tonic-gate if (tabptr == NULL) 22757c478bd9Sstevel@tonic-gate return (Z_INVAL); 22767c478bd9Sstevel@tonic-gate 22777c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 22787c478bd9Sstevel@tonic-gate return (err); 22797c478bd9Sstevel@tonic-gate 22807c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif_core(handle, tabptr)) != Z_OK) 22817c478bd9Sstevel@tonic-gate return (err); 22827c478bd9Sstevel@tonic-gate 22837c478bd9Sstevel@tonic-gate return (Z_OK); 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate 22867c478bd9Sstevel@tonic-gate int 22877c478bd9Sstevel@tonic-gate zonecfg_modify_nwif( 22887c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 22897c478bd9Sstevel@tonic-gate struct zone_nwiftab *oldtabptr, 22907c478bd9Sstevel@tonic-gate struct zone_nwiftab *newtabptr) 22917c478bd9Sstevel@tonic-gate { 22927c478bd9Sstevel@tonic-gate int err; 22937c478bd9Sstevel@tonic-gate 22947c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 22957c478bd9Sstevel@tonic-gate return (Z_INVAL); 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 22987c478bd9Sstevel@tonic-gate return (err); 22997c478bd9Sstevel@tonic-gate 23007c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif_core(handle, oldtabptr)) != Z_OK) 23017c478bd9Sstevel@tonic-gate return (err); 23027c478bd9Sstevel@tonic-gate 23037c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_nwif_core(handle, newtabptr)) != Z_OK) 23047c478bd9Sstevel@tonic-gate return (err); 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate return (Z_OK); 23077c478bd9Sstevel@tonic-gate } 23087c478bd9Sstevel@tonic-gate 23095679c89fSjv /* 23100fbb751dSJohn Levon * Must be a comma-separated list of alpha-numeric file system names. 23115679c89fSjv */ 23120fbb751dSJohn Levon static int 23130fbb751dSJohn Levon zonecfg_valid_fs_allowed(const char *fsallowedp) 23140fbb751dSJohn Levon { 23150fbb751dSJohn Levon char tmp[ZONE_FS_ALLOWED_MAX]; 23160fbb751dSJohn Levon char *cp = tmp; 23170fbb751dSJohn Levon char *p; 23180fbb751dSJohn Levon 23190fbb751dSJohn Levon if (strlen(fsallowedp) > ZONE_FS_ALLOWED_MAX) 23200fbb751dSJohn Levon return (Z_TOO_BIG); 23210fbb751dSJohn Levon 23220fbb751dSJohn Levon (void) strlcpy(tmp, fsallowedp, sizeof (tmp)); 23230fbb751dSJohn Levon 23240fbb751dSJohn Levon while (*cp != '\0') { 23250fbb751dSJohn Levon p = cp; 23260fbb751dSJohn Levon while (*p != '\0' && *p != ',') { 23278cd81a20SJerry Jelinek if (!isalnum(*p) && *p != '-') 23280fbb751dSJohn Levon return (Z_INVALID_PROPERTY); 23290fbb751dSJohn Levon p++; 23300fbb751dSJohn Levon } 23310fbb751dSJohn Levon 23320fbb751dSJohn Levon if (*p == ',') { 23330fbb751dSJohn Levon if (p == cp) 23340fbb751dSJohn Levon return (Z_INVALID_PROPERTY); 23350fbb751dSJohn Levon 23360fbb751dSJohn Levon p++; 23370fbb751dSJohn Levon 23380fbb751dSJohn Levon if (*p == '\0') 23390fbb751dSJohn Levon return (Z_INVALID_PROPERTY); 23400fbb751dSJohn Levon } 23410fbb751dSJohn Levon 23420fbb751dSJohn Levon cp = p; 23430fbb751dSJohn Levon } 23440fbb751dSJohn Levon 23450fbb751dSJohn Levon return (Z_OK); 23460fbb751dSJohn Levon } 23470fbb751dSJohn Levon 23485679c89fSjv int 23490fbb751dSJohn Levon zonecfg_get_fs_allowed(zone_dochandle_t handle, char *bufp, size_t buflen) 23505679c89fSjv { 23515679c89fSjv int err; 23525679c89fSjv 23530fbb751dSJohn Levon if ((err = getrootattr(handle, DTD_ATTR_FS_ALLOWED, 23540fbb751dSJohn Levon bufp, buflen)) != Z_OK) 23555679c89fSjv return (err); 23565679c89fSjv if (bufp[0] == '\0') 23575679c89fSjv return (Z_BAD_PROPERTY); 23580fbb751dSJohn Levon return (zonecfg_valid_fs_allowed(bufp)); 23595679c89fSjv } 23605679c89fSjv 23615679c89fSjv int 23620fbb751dSJohn Levon zonecfg_set_fs_allowed(zone_dochandle_t handle, const char *bufp) 23635679c89fSjv { 23645679c89fSjv int err; 23655679c89fSjv 23660fbb751dSJohn Levon if (bufp == NULL || (err = zonecfg_valid_fs_allowed(bufp)) == Z_OK) 23670fbb751dSJohn Levon return (setrootattr(handle, DTD_ATTR_FS_ALLOWED, bufp)); 23685679c89fSjv return (err); 23695679c89fSjv } 23705679c89fSjv 23715679c89fSjv /* 23725679c89fSjv * Determines if the specified string is a valid hostid string. This function 23735679c89fSjv * returns Z_OK if the string is a valid hostid string. It returns Z_INVAL if 23745679c89fSjv * 'hostidp' is NULL, Z_TOO_BIG if 'hostidp' refers to a string buffer 23750fbb751dSJohn Levon * containing a hex string with more than 8 digits, and Z_INVALID_PROPERTY if 23760fbb751dSJohn Levon * the string has an invalid format. 23775679c89fSjv */ 23780fbb751dSJohn Levon static int 23795679c89fSjv zonecfg_valid_hostid(const char *hostidp) 23805679c89fSjv { 23815679c89fSjv char *currentp; 23825679c89fSjv u_longlong_t hostidval; 23835679c89fSjv size_t len; 23845679c89fSjv 23855679c89fSjv if (hostidp == NULL) 23865679c89fSjv return (Z_INVAL); 23875679c89fSjv 23885679c89fSjv /* Empty strings and strings with whitespace are invalid. */ 23895679c89fSjv if (*hostidp == '\0') 23900fbb751dSJohn Levon return (Z_INVALID_PROPERTY); 23915679c89fSjv for (currentp = (char *)hostidp; *currentp != '\0'; ++currentp) { 23925679c89fSjv if (isspace(*currentp)) 23930fbb751dSJohn Levon return (Z_INVALID_PROPERTY); 23945679c89fSjv } 23955679c89fSjv len = (size_t)(currentp - hostidp); 23965679c89fSjv 23975679c89fSjv /* 23985679c89fSjv * The caller might pass a hostid that is larger than the maximum 23995679c89fSjv * unsigned 32-bit integral value. Check for this! Also, make sure 24005679c89fSjv * that the whole string is converted (this helps us find illegal 24015679c89fSjv * characters) and that the whole string fits within a buffer of size 24025679c89fSjv * HW_HOSTID_LEN. 24035679c89fSjv */ 24045679c89fSjv currentp = (char *)hostidp; 24055679c89fSjv if (strncmp(hostidp, "0x", 2) == 0 || strncmp(hostidp, "0X", 2) == 0) 24065679c89fSjv currentp += 2; 24075679c89fSjv hostidval = strtoull(currentp, ¤tp, 16); 24085679c89fSjv if ((size_t)(currentp - hostidp) >= HW_HOSTID_LEN) 24095679c89fSjv return (Z_TOO_BIG); 24105679c89fSjv if (hostidval > UINT_MAX || hostidval == HW_INVALID_HOSTID || 24115679c89fSjv currentp != hostidp + len) 24120fbb751dSJohn Levon return (Z_INVALID_PROPERTY); 24135679c89fSjv return (Z_OK); 24145679c89fSjv } 24155679c89fSjv 24160fbb751dSJohn Levon /* 24170fbb751dSJohn Levon * Gets the zone hostid string stored in the specified zone configuration 24180fbb751dSJohn Levon * document. This function returns Z_OK on success. Z_BAD_PROPERTY is returned 24190fbb751dSJohn Levon * if the config file doesn't specify a hostid or if the hostid is blank. 24200fbb751dSJohn Levon * 24210fbb751dSJohn Levon * Note that buflen should be at least HW_HOSTID_LEN. 24220fbb751dSJohn Levon */ 24230fbb751dSJohn Levon int 24240fbb751dSJohn Levon zonecfg_get_hostid(zone_dochandle_t handle, char *bufp, size_t buflen) 24250fbb751dSJohn Levon { 24260fbb751dSJohn Levon int err; 24270fbb751dSJohn Levon 24280fbb751dSJohn Levon if ((err = getrootattr(handle, DTD_ATTR_HOSTID, bufp, buflen)) != Z_OK) 24290fbb751dSJohn Levon return (err); 24300fbb751dSJohn Levon if (bufp[0] == '\0') 24310fbb751dSJohn Levon return (Z_BAD_PROPERTY); 24320fbb751dSJohn Levon return (zonecfg_valid_hostid(bufp)); 24330fbb751dSJohn Levon } 24340fbb751dSJohn Levon 24350fbb751dSJohn Levon /* 24360fbb751dSJohn Levon * Sets the hostid string in the specified zone config document to the given 24370fbb751dSJohn Levon * string value. If 'hostidp' is NULL, then the config document's hostid 24380fbb751dSJohn Levon * attribute is cleared. Non-NULL hostids are validated. This function returns 24390fbb751dSJohn Levon * Z_OK on success. Any other return value indicates failure. 24400fbb751dSJohn Levon */ 24410fbb751dSJohn Levon int 24420fbb751dSJohn Levon zonecfg_set_hostid(zone_dochandle_t handle, const char *hostidp) 24430fbb751dSJohn Levon { 24440fbb751dSJohn Levon int err; 24450fbb751dSJohn Levon 24460fbb751dSJohn Levon /* 24470fbb751dSJohn Levon * A NULL hostid string is interpreted as a request to clear the 24480fbb751dSJohn Levon * hostid. 24490fbb751dSJohn Levon */ 24500fbb751dSJohn Levon if (hostidp == NULL || (err = zonecfg_valid_hostid(hostidp)) == Z_OK) 24510fbb751dSJohn Levon return (setrootattr(handle, DTD_ATTR_HOSTID, hostidp)); 24520fbb751dSJohn Levon return (err); 24530fbb751dSJohn Levon } 24540fbb751dSJohn Levon 24557c478bd9Sstevel@tonic-gate int 24567c478bd9Sstevel@tonic-gate zonecfg_lookup_dev(zone_dochandle_t handle, struct zone_devtab *tabptr) 24577c478bd9Sstevel@tonic-gate { 24587c478bd9Sstevel@tonic-gate xmlNodePtr cur, firstmatch; 24597c478bd9Sstevel@tonic-gate int err; 24607c478bd9Sstevel@tonic-gate char match[MAXPATHLEN]; 24617c478bd9Sstevel@tonic-gate 24627c478bd9Sstevel@tonic-gate if (tabptr == NULL) 24637c478bd9Sstevel@tonic-gate return (Z_INVAL); 24647c478bd9Sstevel@tonic-gate 24657c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 24667c478bd9Sstevel@tonic-gate return (err); 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 24697c478bd9Sstevel@tonic-gate firstmatch = NULL; 24707c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 24717c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_DEVICE)) 24727c478bd9Sstevel@tonic-gate continue; 24737c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_dev_match) == 0) 24747c478bd9Sstevel@tonic-gate continue; 24757c478bd9Sstevel@tonic-gate 24767c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_MATCH, match, 24777c478bd9Sstevel@tonic-gate sizeof (match)) == Z_OK)) { 24787c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_dev_match, 24797c478bd9Sstevel@tonic-gate match) == 0) { 24807c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 24817c478bd9Sstevel@tonic-gate firstmatch = cur; 24827c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 24837c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24847c478bd9Sstevel@tonic-gate } else { 24857c478bd9Sstevel@tonic-gate /* 24867c478bd9Sstevel@tonic-gate * If another property matched but this 24877c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 24887c478bd9Sstevel@tonic-gate */ 24897c478bd9Sstevel@tonic-gate if (firstmatch == cur) 24907c478bd9Sstevel@tonic-gate firstmatch = NULL; 24917c478bd9Sstevel@tonic-gate } 24927c478bd9Sstevel@tonic-gate } 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 24957c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 24967c478bd9Sstevel@tonic-gate 24977c478bd9Sstevel@tonic-gate cur = firstmatch; 24987c478bd9Sstevel@tonic-gate 24997c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_MATCH, tabptr->zone_dev_match, 25007c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_dev_match))) != Z_OK) 25017c478bd9Sstevel@tonic-gate return (err); 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate return (Z_OK); 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate 25067c478bd9Sstevel@tonic-gate static int 25077c478bd9Sstevel@tonic-gate zonecfg_add_dev_core(zone_dochandle_t handle, struct zone_devtab *tabptr) 25087c478bd9Sstevel@tonic-gate { 25097c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 25107c478bd9Sstevel@tonic-gate int err; 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_DEVICE, NULL); 25137c478bd9Sstevel@tonic-gate 2514a1be23daSdp if ((err = newprop(newnode, DTD_ATTR_MATCH, 25157c478bd9Sstevel@tonic-gate 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 int 25227c478bd9Sstevel@tonic-gate zonecfg_add_dev(zone_dochandle_t handle, struct zone_devtab *tabptr) 25237c478bd9Sstevel@tonic-gate { 25247c478bd9Sstevel@tonic-gate int err; 25257c478bd9Sstevel@tonic-gate 25267c478bd9Sstevel@tonic-gate if (tabptr == NULL) 25277c478bd9Sstevel@tonic-gate return (Z_INVAL); 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 25307c478bd9Sstevel@tonic-gate return (err); 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_dev_core(handle, tabptr)) != Z_OK) 25337c478bd9Sstevel@tonic-gate return (err); 25347c478bd9Sstevel@tonic-gate 25357c478bd9Sstevel@tonic-gate return (Z_OK); 25367c478bd9Sstevel@tonic-gate } 25377c478bd9Sstevel@tonic-gate 25387c478bd9Sstevel@tonic-gate static int 25397c478bd9Sstevel@tonic-gate zonecfg_delete_dev_core(zone_dochandle_t handle, struct zone_devtab *tabptr) 25407c478bd9Sstevel@tonic-gate { 2541facf4a8dSllai xmlNodePtr cur = handle->zone_dh_cur; 25427c478bd9Sstevel@tonic-gate int match_match; 25437c478bd9Sstevel@tonic-gate 25447c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 25457c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_DEVICE)) 25467c478bd9Sstevel@tonic-gate continue; 25477c478bd9Sstevel@tonic-gate 25487c478bd9Sstevel@tonic-gate match_match = match_prop(cur, DTD_ATTR_MATCH, 25497c478bd9Sstevel@tonic-gate tabptr->zone_dev_match); 25507c478bd9Sstevel@tonic-gate 25517c478bd9Sstevel@tonic-gate if (match_match) { 25527c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 25537c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 25547c478bd9Sstevel@tonic-gate return (Z_OK); 25557c478bd9Sstevel@tonic-gate } 25567c478bd9Sstevel@tonic-gate } 25577c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 25587c478bd9Sstevel@tonic-gate } 25597c478bd9Sstevel@tonic-gate 25607c478bd9Sstevel@tonic-gate int 25617c478bd9Sstevel@tonic-gate zonecfg_delete_dev(zone_dochandle_t handle, struct zone_devtab *tabptr) 25627c478bd9Sstevel@tonic-gate { 25637c478bd9Sstevel@tonic-gate int err; 25647c478bd9Sstevel@tonic-gate 25657c478bd9Sstevel@tonic-gate if (tabptr == NULL) 25667c478bd9Sstevel@tonic-gate return (Z_INVAL); 25677c478bd9Sstevel@tonic-gate 25687c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 25697c478bd9Sstevel@tonic-gate return (err); 25707c478bd9Sstevel@tonic-gate 25717c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev_core(handle, tabptr)) != Z_OK) 25727c478bd9Sstevel@tonic-gate return (err); 25737c478bd9Sstevel@tonic-gate 25747c478bd9Sstevel@tonic-gate return (Z_OK); 25757c478bd9Sstevel@tonic-gate } 25767c478bd9Sstevel@tonic-gate 25777c478bd9Sstevel@tonic-gate int 25787c478bd9Sstevel@tonic-gate zonecfg_modify_dev( 25797c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 25807c478bd9Sstevel@tonic-gate struct zone_devtab *oldtabptr, 25817c478bd9Sstevel@tonic-gate struct zone_devtab *newtabptr) 25827c478bd9Sstevel@tonic-gate { 25837c478bd9Sstevel@tonic-gate int err; 25847c478bd9Sstevel@tonic-gate 25857c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 25867c478bd9Sstevel@tonic-gate return (Z_INVAL); 25877c478bd9Sstevel@tonic-gate 25887c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 25897c478bd9Sstevel@tonic-gate return (err); 25907c478bd9Sstevel@tonic-gate 25917c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev_core(handle, oldtabptr)) != Z_OK) 25927c478bd9Sstevel@tonic-gate return (err); 25937c478bd9Sstevel@tonic-gate 25947c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_dev_core(handle, newtabptr)) != Z_OK) 25957c478bd9Sstevel@tonic-gate return (err); 25967c478bd9Sstevel@tonic-gate 25977c478bd9Sstevel@tonic-gate return (Z_OK); 25987c478bd9Sstevel@tonic-gate } 25997c478bd9Sstevel@tonic-gate 2600cb8a054bSGlenn Faden static int 2601cb8a054bSGlenn Faden zonecfg_add_auth_core(zone_dochandle_t handle, struct zone_admintab *tabptr, 2602cb8a054bSGlenn Faden char *zonename) 2603cb8a054bSGlenn Faden { 2604cb8a054bSGlenn Faden xmlNodePtr newnode, cur = handle->zone_dh_cur; 2605cb8a054bSGlenn Faden int err; 2606cb8a054bSGlenn Faden 2607cb8a054bSGlenn Faden newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_ADMIN, NULL); 2608cb8a054bSGlenn Faden err = newprop(newnode, DTD_ATTR_USER, tabptr->zone_admin_user); 2609cb8a054bSGlenn Faden if (err != Z_OK) 2610cb8a054bSGlenn Faden return (err); 2611cb8a054bSGlenn Faden err = newprop(newnode, DTD_ATTR_AUTHS, tabptr->zone_admin_auths); 2612cb8a054bSGlenn Faden if (err != Z_OK) 2613cb8a054bSGlenn Faden return (err); 2614cb8a054bSGlenn Faden if ((err = zonecfg_remove_userauths( 2615cb8a054bSGlenn Faden handle, tabptr->zone_admin_user, zonename, B_FALSE)) != Z_OK) 2616cb8a054bSGlenn Faden return (err); 2617cb8a054bSGlenn Faden return (Z_OK); 2618cb8a054bSGlenn Faden } 2619cb8a054bSGlenn Faden 2620cb8a054bSGlenn Faden int 2621cb8a054bSGlenn Faden zonecfg_add_admin(zone_dochandle_t handle, struct zone_admintab *tabptr, 2622cb8a054bSGlenn Faden char *zonename) 2623cb8a054bSGlenn Faden { 2624cb8a054bSGlenn Faden int err; 2625cb8a054bSGlenn Faden 2626cb8a054bSGlenn Faden if (tabptr == NULL) 2627cb8a054bSGlenn Faden return (Z_INVAL); 2628cb8a054bSGlenn Faden 2629cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2630cb8a054bSGlenn Faden return (err); 2631cb8a054bSGlenn Faden 2632cb8a054bSGlenn Faden if ((err = zonecfg_add_auth_core(handle, tabptr, 2633cb8a054bSGlenn Faden zonename)) != Z_OK) 2634cb8a054bSGlenn Faden return (err); 2635cb8a054bSGlenn Faden 2636cb8a054bSGlenn Faden return (Z_OK); 2637cb8a054bSGlenn Faden } 2638cb8a054bSGlenn Faden static int 2639cb8a054bSGlenn Faden zonecfg_delete_auth_core(zone_dochandle_t handle, struct zone_admintab *tabptr, 2640cb8a054bSGlenn Faden char *zonename) 2641cb8a054bSGlenn Faden { 2642cb8a054bSGlenn Faden xmlNodePtr cur = handle->zone_dh_cur; 2643cb8a054bSGlenn Faden boolean_t auth_match; 2644cb8a054bSGlenn Faden int err; 2645cb8a054bSGlenn Faden 2646cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 2647cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 2648cb8a054bSGlenn Faden continue; 2649cb8a054bSGlenn Faden auth_match = match_prop(cur, DTD_ATTR_USER, 2650cb8a054bSGlenn Faden tabptr->zone_admin_user); 2651cb8a054bSGlenn Faden if (auth_match) { 2652cb8a054bSGlenn Faden if ((err = zonecfg_insert_userauths( 2653cb8a054bSGlenn Faden handle, tabptr->zone_admin_user, 2654cb8a054bSGlenn Faden zonename)) != Z_OK) 2655cb8a054bSGlenn Faden return (err); 2656cb8a054bSGlenn Faden xmlUnlinkNode(cur); 2657cb8a054bSGlenn Faden xmlFreeNode(cur); 2658cb8a054bSGlenn Faden return (Z_OK); 2659cb8a054bSGlenn Faden } 2660cb8a054bSGlenn Faden } 2661cb8a054bSGlenn Faden return (Z_NO_RESOURCE_ID); 2662cb8a054bSGlenn Faden } 2663cb8a054bSGlenn Faden 2664cb8a054bSGlenn Faden int 2665cb8a054bSGlenn Faden zonecfg_delete_admin(zone_dochandle_t handle, struct zone_admintab *tabptr, 2666cb8a054bSGlenn Faden char *zonename) 2667cb8a054bSGlenn Faden { 2668cb8a054bSGlenn Faden int err; 2669cb8a054bSGlenn Faden 2670cb8a054bSGlenn Faden if (tabptr == NULL) 2671cb8a054bSGlenn Faden return (Z_INVAL); 2672cb8a054bSGlenn Faden 2673cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2674cb8a054bSGlenn Faden return (err); 2675cb8a054bSGlenn Faden 2676cb8a054bSGlenn Faden if ((err = zonecfg_delete_auth_core(handle, tabptr, zonename)) != Z_OK) 2677cb8a054bSGlenn Faden return (err); 2678cb8a054bSGlenn Faden 2679cb8a054bSGlenn Faden return (Z_OK); 2680cb8a054bSGlenn Faden } 2681cb8a054bSGlenn Faden 2682cb8a054bSGlenn Faden int 2683cb8a054bSGlenn Faden zonecfg_modify_admin(zone_dochandle_t handle, struct zone_admintab *oldtabptr, 2684cb8a054bSGlenn Faden struct zone_admintab *newtabptr, char *zonename) 2685cb8a054bSGlenn Faden { 2686cb8a054bSGlenn Faden int err; 2687cb8a054bSGlenn Faden 2688cb8a054bSGlenn Faden if (oldtabptr == NULL || newtabptr == NULL) 2689cb8a054bSGlenn Faden return (Z_INVAL); 2690cb8a054bSGlenn Faden 2691cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2692cb8a054bSGlenn Faden return (err); 2693cb8a054bSGlenn Faden 2694cb8a054bSGlenn Faden if ((err = zonecfg_delete_auth_core(handle, oldtabptr, zonename)) 2695cb8a054bSGlenn Faden != Z_OK) 2696cb8a054bSGlenn Faden return (err); 2697cb8a054bSGlenn Faden 2698cb8a054bSGlenn Faden if ((err = zonecfg_add_auth_core(handle, newtabptr, 2699cb8a054bSGlenn Faden zonename)) != Z_OK) 2700cb8a054bSGlenn Faden return (err); 2701cb8a054bSGlenn Faden 2702cb8a054bSGlenn Faden return (Z_OK); 2703cb8a054bSGlenn Faden } 2704cb8a054bSGlenn Faden 2705cb8a054bSGlenn Faden int 2706cb8a054bSGlenn Faden zonecfg_lookup_admin(zone_dochandle_t handle, struct zone_admintab *tabptr) 2707cb8a054bSGlenn Faden { 2708cb8a054bSGlenn Faden xmlNodePtr cur, firstmatch; 2709cb8a054bSGlenn Faden int err; 2710cb8a054bSGlenn Faden char user[MAXUSERNAME]; 2711cb8a054bSGlenn Faden 2712cb8a054bSGlenn Faden if (tabptr == NULL) 2713cb8a054bSGlenn Faden return (Z_INVAL); 2714cb8a054bSGlenn Faden 2715cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 2716cb8a054bSGlenn Faden return (err); 2717cb8a054bSGlenn Faden 2718cb8a054bSGlenn Faden cur = handle->zone_dh_cur; 2719cb8a054bSGlenn Faden firstmatch = NULL; 2720cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 2721cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 2722cb8a054bSGlenn Faden continue; 2723cb8a054bSGlenn Faden if (strlen(tabptr->zone_admin_user) > 0) { 2724cb8a054bSGlenn Faden if ((fetchprop(cur, DTD_ATTR_USER, user, 2725cb8a054bSGlenn Faden sizeof (user)) == Z_OK) && 2726cb8a054bSGlenn Faden (strcmp(tabptr->zone_admin_user, user) == 0)) { 2727cb8a054bSGlenn Faden if (firstmatch == NULL) 2728cb8a054bSGlenn Faden firstmatch = cur; 2729cb8a054bSGlenn Faden else 2730cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2731cb8a054bSGlenn Faden } 2732cb8a054bSGlenn Faden } 2733cb8a054bSGlenn Faden } 2734cb8a054bSGlenn Faden if (firstmatch == NULL) 2735cb8a054bSGlenn Faden return (Z_NO_RESOURCE_ID); 2736cb8a054bSGlenn Faden 2737cb8a054bSGlenn Faden cur = firstmatch; 2738cb8a054bSGlenn Faden 2739cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_USER, tabptr->zone_admin_user, 2740cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_user))) != Z_OK) 2741cb8a054bSGlenn Faden return (err); 2742cb8a054bSGlenn Faden 2743cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_AUTHS, tabptr->zone_admin_auths, 2744cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_auths))) != Z_OK) 2745cb8a054bSGlenn Faden return (err); 2746cb8a054bSGlenn Faden 2747cb8a054bSGlenn Faden return (Z_OK); 2748cb8a054bSGlenn Faden } 2749cb8a054bSGlenn Faden 2750cb8a054bSGlenn Faden 2751ff17c8bfSgjelinek /* Lock to serialize all devwalks */ 2752ee519a1fSgjelinek static pthread_mutex_t zonecfg_devwalk_lock = PTHREAD_MUTEX_INITIALIZER; 2753ee519a1fSgjelinek /* 2754ff17c8bfSgjelinek * Global variables used to pass data from zonecfg_dev_manifest to the nftw 2755ee519a1fSgjelinek * call-back (zonecfg_devwalk_cb). g_devwalk_data is really the void* 2756ff17c8bfSgjelinek * parameter and g_devwalk_cb is really the *cb parameter from 2757ff17c8bfSgjelinek * zonecfg_dev_manifest. 2758ee519a1fSgjelinek */ 2759ff17c8bfSgjelinek typedef struct __g_devwalk_data *g_devwalk_data_t; 2760ff17c8bfSgjelinek static g_devwalk_data_t g_devwalk_data; 2761ee519a1fSgjelinek static int (*g_devwalk_cb)(const char *, uid_t, gid_t, mode_t, const char *, 2762ee519a1fSgjelinek void *); 2763ee519a1fSgjelinek static size_t g_devwalk_skip_prefix; 2764ee519a1fSgjelinek 2765ee519a1fSgjelinek /* 2766ff17c8bfSgjelinek * zonecfg_dev_manifest call-back function used during detach to generate the 2767ff17c8bfSgjelinek * dev info in the manifest. 2768ff17c8bfSgjelinek */ 2769ff17c8bfSgjelinek static int 2770ff17c8bfSgjelinek get_detach_dev_entry(const char *name, uid_t uid, gid_t gid, mode_t mode, 2771ff17c8bfSgjelinek const char *acl, void *hdl) 2772ff17c8bfSgjelinek { 2773ff17c8bfSgjelinek zone_dochandle_t handle = (zone_dochandle_t)hdl; 2774ff17c8bfSgjelinek xmlNodePtr newnode; 2775ff17c8bfSgjelinek xmlNodePtr cur; 2776ff17c8bfSgjelinek int err; 2777ff17c8bfSgjelinek char buf[128]; 2778ff17c8bfSgjelinek 2779ff17c8bfSgjelinek if ((err = operation_prep(handle)) != Z_OK) 2780ff17c8bfSgjelinek return (err); 2781ff17c8bfSgjelinek 2782ff17c8bfSgjelinek cur = handle->zone_dh_cur; 2783ff17c8bfSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_DEV_PERM, NULL); 2784ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_NAME, (char *)name)) != Z_OK) 2785ff17c8bfSgjelinek return (err); 2786ff17c8bfSgjelinek (void) snprintf(buf, sizeof (buf), "%lu", uid); 2787ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_UID, buf)) != Z_OK) 2788ff17c8bfSgjelinek return (err); 2789ff17c8bfSgjelinek (void) snprintf(buf, sizeof (buf), "%lu", gid); 2790ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_GID, buf)) != Z_OK) 2791ff17c8bfSgjelinek return (err); 2792ff17c8bfSgjelinek (void) snprintf(buf, sizeof (buf), "%o", mode); 2793ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_MODE, buf)) != Z_OK) 2794ff17c8bfSgjelinek return (err); 2795ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_ACL, (char *)acl)) != Z_OK) 2796ff17c8bfSgjelinek return (err); 2797ff17c8bfSgjelinek return (Z_OK); 2798ff17c8bfSgjelinek } 2799ff17c8bfSgjelinek 2800ff17c8bfSgjelinek /* 2801ff17c8bfSgjelinek * This is the nftw call-back function used by zonecfg_dev_manifest. It is 2802ff17c8bfSgjelinek * responsible for calling the actual call-back. 2803ee519a1fSgjelinek */ 2804ee519a1fSgjelinek /* ARGSUSED2 */ 2805ee519a1fSgjelinek static int 2806ee519a1fSgjelinek zonecfg_devwalk_cb(const char *path, const struct stat *st, int f, 2807ee519a1fSgjelinek struct FTW *ftw) 2808ee519a1fSgjelinek { 2809ee519a1fSgjelinek acl_t *acl; 2810ee519a1fSgjelinek char *acl_txt = NULL; 2811ee519a1fSgjelinek 2812ee519a1fSgjelinek /* skip all but character and block devices */ 2813ee519a1fSgjelinek if (!S_ISBLK(st->st_mode) && !S_ISCHR(st->st_mode)) 2814ee519a1fSgjelinek return (0); 2815ee519a1fSgjelinek 2816ee519a1fSgjelinek if ((acl_get(path, ACL_NO_TRIVIAL, &acl) == 0) && 2817ee519a1fSgjelinek acl != NULL) { 2818ee519a1fSgjelinek acl_txt = acl_totext(acl, ACL_NORESOLVE); 2819ee519a1fSgjelinek acl_free(acl); 2820ee519a1fSgjelinek } 2821ee519a1fSgjelinek 2822ee519a1fSgjelinek if (strlen(path) <= g_devwalk_skip_prefix) 2823ee519a1fSgjelinek return (0); 2824ee519a1fSgjelinek 2825ee519a1fSgjelinek g_devwalk_cb(path + g_devwalk_skip_prefix, st->st_uid, st->st_gid, 2826ee519a1fSgjelinek st->st_mode & S_IAMB, acl_txt != NULL ? acl_txt : "", 2827ee519a1fSgjelinek g_devwalk_data); 2828ee519a1fSgjelinek free(acl_txt); 2829ee519a1fSgjelinek return (0); 2830ee519a1fSgjelinek } 2831ee519a1fSgjelinek 2832ee519a1fSgjelinek /* 2833ff17c8bfSgjelinek * Walk the dev tree for the zone specified by hdl and call the 2834ff17c8bfSgjelinek * get_detach_dev_entry call-back function for each entry in the tree. The 2835ff17c8bfSgjelinek * call-back will be passed the name, uid, gid, mode, acl string and the 2836ff17c8bfSgjelinek * handle input parameter for each dev entry. 2837ee519a1fSgjelinek * 2838ff17c8bfSgjelinek * Data is passed to get_detach_dev_entry through the global variables 2839ee519a1fSgjelinek * g_devwalk_data, *g_devwalk_cb, and g_devwalk_skip_prefix. The 2840ff17c8bfSgjelinek * zonecfg_devwalk_cb function will actually call get_detach_dev_entry. 2841ee519a1fSgjelinek */ 2842ee519a1fSgjelinek int 2843ff17c8bfSgjelinek zonecfg_dev_manifest(zone_dochandle_t hdl) 2844ee519a1fSgjelinek { 2845ee519a1fSgjelinek char path[MAXPATHLEN]; 2846ee519a1fSgjelinek int ret; 2847ee519a1fSgjelinek 2848ee519a1fSgjelinek if ((ret = zonecfg_get_zonepath(hdl, path, sizeof (path))) != Z_OK) 2849ee519a1fSgjelinek return (ret); 2850ee519a1fSgjelinek 2851ee519a1fSgjelinek if (strlcat(path, "/dev", sizeof (path)) >= sizeof (path)) 2852ee519a1fSgjelinek return (Z_TOO_BIG); 2853ee519a1fSgjelinek 2854ee519a1fSgjelinek /* 2855ff17c8bfSgjelinek * We have to serialize all devwalks in the same process 2856ee519a1fSgjelinek * (which should be fine), since nftw() is so badly designed. 2857ee519a1fSgjelinek */ 2858ee519a1fSgjelinek (void) pthread_mutex_lock(&zonecfg_devwalk_lock); 2859ee519a1fSgjelinek 2860ff17c8bfSgjelinek g_devwalk_skip_prefix = strlen(path) + 1; 2861ff17c8bfSgjelinek g_devwalk_data = (g_devwalk_data_t)hdl; 2862ff17c8bfSgjelinek g_devwalk_cb = get_detach_dev_entry; 2863ee519a1fSgjelinek (void) nftw(path, zonecfg_devwalk_cb, 0, FTW_PHYS); 2864ee519a1fSgjelinek 2865ee519a1fSgjelinek (void) pthread_mutex_unlock(&zonecfg_devwalk_lock); 2866ee519a1fSgjelinek return (Z_OK); 2867ee519a1fSgjelinek } 2868ee519a1fSgjelinek 2869ee519a1fSgjelinek /* 2870ee519a1fSgjelinek * Update the owner, group, mode and acl on the specified dev (inpath) for 2871ee519a1fSgjelinek * the zone (hdl). This function can be used to fix up the dev tree after 2872ee519a1fSgjelinek * attaching a migrated zone. 2873ee519a1fSgjelinek */ 2874ee519a1fSgjelinek int 2875ee519a1fSgjelinek zonecfg_devperms_apply(zone_dochandle_t hdl, const char *inpath, uid_t owner, 2876ee519a1fSgjelinek gid_t group, mode_t mode, const char *acltxt) 2877ee519a1fSgjelinek { 2878ee519a1fSgjelinek int ret; 2879ee519a1fSgjelinek char path[MAXPATHLEN]; 2880ee519a1fSgjelinek struct stat st; 2881ee519a1fSgjelinek acl_t *aclp; 2882ee519a1fSgjelinek 2883ee519a1fSgjelinek if ((ret = zonecfg_get_zonepath(hdl, path, sizeof (path))) != Z_OK) 2884ee519a1fSgjelinek return (ret); 2885ee519a1fSgjelinek 2886ee519a1fSgjelinek if (strlcat(path, "/dev/", sizeof (path)) >= sizeof (path)) 2887ee519a1fSgjelinek return (Z_TOO_BIG); 2888ee519a1fSgjelinek if (strlcat(path, inpath, sizeof (path)) >= sizeof (path)) 2889ee519a1fSgjelinek return (Z_TOO_BIG); 2890ee519a1fSgjelinek 2891ee519a1fSgjelinek if (stat(path, &st) == -1) 2892ee519a1fSgjelinek return (Z_INVAL); 2893ee519a1fSgjelinek 2894ee519a1fSgjelinek /* make sure we're only touching device nodes */ 2895ee519a1fSgjelinek if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) 2896ee519a1fSgjelinek return (Z_INVAL); 2897ee519a1fSgjelinek 2898ee519a1fSgjelinek if (chown(path, owner, group) == -1) 2899ee519a1fSgjelinek return (Z_SYSTEM); 2900ee519a1fSgjelinek 2901ee519a1fSgjelinek if (chmod(path, mode) == -1) 2902ee519a1fSgjelinek return (Z_SYSTEM); 2903ee519a1fSgjelinek 2904ee519a1fSgjelinek if ((acltxt == NULL) || (strcmp(acltxt, "") == 0)) 2905ee519a1fSgjelinek return (Z_OK); 2906ee519a1fSgjelinek 29072ad45a84Sjv if (acl_fromtext(acltxt, &aclp) != 0) { 29082ad45a84Sjv errno = EINVAL; 2909ee519a1fSgjelinek return (Z_SYSTEM); 29102ad45a84Sjv } 2911ee519a1fSgjelinek 2912ee519a1fSgjelinek errno = 0; 2913ee519a1fSgjelinek if (acl_set(path, aclp) == -1) { 2914ee519a1fSgjelinek free(aclp); 2915ee519a1fSgjelinek return (Z_SYSTEM); 2916ee519a1fSgjelinek } 2917ee519a1fSgjelinek 2918ee519a1fSgjelinek free(aclp); 2919ee519a1fSgjelinek return (Z_OK); 2920ee519a1fSgjelinek } 2921ee519a1fSgjelinek 29227c478bd9Sstevel@tonic-gate /* 29237c478bd9Sstevel@tonic-gate * This function finds everything mounted under a zone's rootpath. 29247c478bd9Sstevel@tonic-gate * This returns the number of mounts under rootpath, or -1 on error. 29257c478bd9Sstevel@tonic-gate * callback is called once per mount found with the first argument 29260094b373Sjv * pointing to a mnttab structure containing the mount's information. 29277c478bd9Sstevel@tonic-gate * 29287c478bd9Sstevel@tonic-gate * If the callback function returns non-zero zonecfg_find_mounts 29297c478bd9Sstevel@tonic-gate * aborts with an error. 29307c478bd9Sstevel@tonic-gate */ 29317c478bd9Sstevel@tonic-gate int 29320094b373Sjv zonecfg_find_mounts(char *rootpath, int (*callback)(const struct mnttab *, 29330094b373Sjv void *), void *priv) { 29347c478bd9Sstevel@tonic-gate FILE *mnttab; 29357c478bd9Sstevel@tonic-gate struct mnttab m; 29367c478bd9Sstevel@tonic-gate size_t l; 293707b574eeSgjelinek int zfsl; 29387c478bd9Sstevel@tonic-gate int rv = 0; 293907b574eeSgjelinek char zfs_path[MAXPATHLEN]; 29407c478bd9Sstevel@tonic-gate 29417c478bd9Sstevel@tonic-gate assert(rootpath != NULL); 29427c478bd9Sstevel@tonic-gate 294307b574eeSgjelinek if ((zfsl = snprintf(zfs_path, sizeof (zfs_path), "%s/.zfs/", rootpath)) 294407b574eeSgjelinek >= sizeof (zfs_path)) 294507b574eeSgjelinek return (-1); 294607b574eeSgjelinek 29477c478bd9Sstevel@tonic-gate l = strlen(rootpath); 29487c478bd9Sstevel@tonic-gate 29497c478bd9Sstevel@tonic-gate mnttab = fopen("/etc/mnttab", "r"); 29507c478bd9Sstevel@tonic-gate 29517c478bd9Sstevel@tonic-gate if (mnttab == NULL) 29527c478bd9Sstevel@tonic-gate return (-1); 29537c478bd9Sstevel@tonic-gate 29547c478bd9Sstevel@tonic-gate if (ioctl(fileno(mnttab), MNTIOC_SHOWHIDDEN, NULL) < 0) { 29557c478bd9Sstevel@tonic-gate rv = -1; 29567c478bd9Sstevel@tonic-gate goto out; 29577c478bd9Sstevel@tonic-gate } 29587c478bd9Sstevel@tonic-gate 29597c478bd9Sstevel@tonic-gate while (!getmntent(mnttab, &m)) { 29607c478bd9Sstevel@tonic-gate if ((strncmp(rootpath, m.mnt_mountp, l) == 0) && 296107b574eeSgjelinek (m.mnt_mountp[l] == '/') && 296207b574eeSgjelinek (strncmp(zfs_path, m.mnt_mountp, zfsl) != 0)) { 29637c478bd9Sstevel@tonic-gate rv++; 29647c478bd9Sstevel@tonic-gate if (callback == NULL) 29657c478bd9Sstevel@tonic-gate continue; 29660094b373Sjv if (callback(&m, priv)) { 29677c478bd9Sstevel@tonic-gate rv = -1; 29687c478bd9Sstevel@tonic-gate goto out; 29697c478bd9Sstevel@tonic-gate 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate } 29727c478bd9Sstevel@tonic-gate } 29737c478bd9Sstevel@tonic-gate 29747c478bd9Sstevel@tonic-gate out: 29757c478bd9Sstevel@tonic-gate (void) fclose(mnttab); 29767c478bd9Sstevel@tonic-gate return (rv); 29777c478bd9Sstevel@tonic-gate } 29787c478bd9Sstevel@tonic-gate 29797c478bd9Sstevel@tonic-gate int 29807c478bd9Sstevel@tonic-gate zonecfg_lookup_attr(zone_dochandle_t handle, struct zone_attrtab *tabptr) 29817c478bd9Sstevel@tonic-gate { 29827c478bd9Sstevel@tonic-gate xmlNodePtr cur, firstmatch; 29837c478bd9Sstevel@tonic-gate int err; 29847c478bd9Sstevel@tonic-gate char name[MAXNAMELEN], type[MAXNAMELEN], value[MAXNAMELEN]; 29857c478bd9Sstevel@tonic-gate 29867c478bd9Sstevel@tonic-gate if (tabptr == NULL) 29877c478bd9Sstevel@tonic-gate return (Z_INVAL); 29887c478bd9Sstevel@tonic-gate 29897c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 29907c478bd9Sstevel@tonic-gate return (err); 29917c478bd9Sstevel@tonic-gate 29927c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 29937c478bd9Sstevel@tonic-gate firstmatch = NULL; 29947c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 29957c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_ATTR)) 29967c478bd9Sstevel@tonic-gate continue; 29977c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_attr_name) > 0) { 29987c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_NAME, name, 29997c478bd9Sstevel@tonic-gate sizeof (name)) == Z_OK) && 30007c478bd9Sstevel@tonic-gate (strcmp(tabptr->zone_attr_name, name) == 0)) { 30017c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30027c478bd9Sstevel@tonic-gate firstmatch = cur; 30037c478bd9Sstevel@tonic-gate else 30047c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 30057c478bd9Sstevel@tonic-gate } 30067c478bd9Sstevel@tonic-gate } 30077c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_attr_type) > 0) { 30087c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_TYPE, type, 30097c478bd9Sstevel@tonic-gate sizeof (type)) == Z_OK)) { 30107c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_attr_type, type) == 0) { 30117c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30127c478bd9Sstevel@tonic-gate firstmatch = cur; 30137c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 30147c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 30157c478bd9Sstevel@tonic-gate } else { 30167c478bd9Sstevel@tonic-gate /* 30177c478bd9Sstevel@tonic-gate * If another property matched but this 30187c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 30197c478bd9Sstevel@tonic-gate */ 30207c478bd9Sstevel@tonic-gate if (firstmatch == cur) 30217c478bd9Sstevel@tonic-gate firstmatch = NULL; 30227c478bd9Sstevel@tonic-gate } 30237c478bd9Sstevel@tonic-gate } 30247c478bd9Sstevel@tonic-gate } 30257c478bd9Sstevel@tonic-gate if (strlen(tabptr->zone_attr_value) > 0) { 30267c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_VALUE, value, 30277c478bd9Sstevel@tonic-gate sizeof (value)) == Z_OK)) { 30287c478bd9Sstevel@tonic-gate if (strcmp(tabptr->zone_attr_value, value) == 30297c478bd9Sstevel@tonic-gate 0) { 30307c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30317c478bd9Sstevel@tonic-gate firstmatch = cur; 30327c478bd9Sstevel@tonic-gate else if (firstmatch != cur) 30337c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 30347c478bd9Sstevel@tonic-gate } else { 30357c478bd9Sstevel@tonic-gate /* 30367c478bd9Sstevel@tonic-gate * If another property matched but this 30377c478bd9Sstevel@tonic-gate * one doesn't then reset firstmatch. 30387c478bd9Sstevel@tonic-gate */ 30397c478bd9Sstevel@tonic-gate if (firstmatch == cur) 30407c478bd9Sstevel@tonic-gate firstmatch = NULL; 30417c478bd9Sstevel@tonic-gate } 30427c478bd9Sstevel@tonic-gate } 30437c478bd9Sstevel@tonic-gate } 30447c478bd9Sstevel@tonic-gate } 30457c478bd9Sstevel@tonic-gate if (firstmatch == NULL) 30467c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 30477c478bd9Sstevel@tonic-gate 30487c478bd9Sstevel@tonic-gate cur = firstmatch; 30497c478bd9Sstevel@tonic-gate 30507c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_attr_name, 30517c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_attr_name))) != Z_OK) 30527c478bd9Sstevel@tonic-gate return (err); 30537c478bd9Sstevel@tonic-gate 30547c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_attr_type, 30557c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_attr_type))) != Z_OK) 30567c478bd9Sstevel@tonic-gate return (err); 30577c478bd9Sstevel@tonic-gate 30587c478bd9Sstevel@tonic-gate if ((err = fetchprop(cur, DTD_ATTR_VALUE, tabptr->zone_attr_value, 30597c478bd9Sstevel@tonic-gate sizeof (tabptr->zone_attr_value))) != Z_OK) 30607c478bd9Sstevel@tonic-gate return (err); 30617c478bd9Sstevel@tonic-gate 30627c478bd9Sstevel@tonic-gate return (Z_OK); 30637c478bd9Sstevel@tonic-gate } 30647c478bd9Sstevel@tonic-gate 30657c478bd9Sstevel@tonic-gate static int 30667c478bd9Sstevel@tonic-gate zonecfg_add_attr_core(zone_dochandle_t handle, struct zone_attrtab *tabptr) 30677c478bd9Sstevel@tonic-gate { 30687c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur; 30697c478bd9Sstevel@tonic-gate int err; 30707c478bd9Sstevel@tonic-gate 30717c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_ATTR, NULL); 3072a1be23daSdp err = newprop(newnode, DTD_ATTR_NAME, tabptr->zone_attr_name); 30737c478bd9Sstevel@tonic-gate if (err != Z_OK) 30747c478bd9Sstevel@tonic-gate return (err); 3075a1be23daSdp err = newprop(newnode, DTD_ATTR_TYPE, tabptr->zone_attr_type); 30767c478bd9Sstevel@tonic-gate if (err != Z_OK) 30777c478bd9Sstevel@tonic-gate return (err); 3078a1be23daSdp err = newprop(newnode, DTD_ATTR_VALUE, tabptr->zone_attr_value); 30797c478bd9Sstevel@tonic-gate if (err != Z_OK) 30807c478bd9Sstevel@tonic-gate return (err); 30817c478bd9Sstevel@tonic-gate return (Z_OK); 30827c478bd9Sstevel@tonic-gate } 30837c478bd9Sstevel@tonic-gate 30847c478bd9Sstevel@tonic-gate int 30857c478bd9Sstevel@tonic-gate zonecfg_add_attr(zone_dochandle_t handle, struct zone_attrtab *tabptr) 30867c478bd9Sstevel@tonic-gate { 30877c478bd9Sstevel@tonic-gate int err; 30887c478bd9Sstevel@tonic-gate 30897c478bd9Sstevel@tonic-gate if (tabptr == NULL) 30907c478bd9Sstevel@tonic-gate return (Z_INVAL); 30917c478bd9Sstevel@tonic-gate 30927c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 30937c478bd9Sstevel@tonic-gate return (err); 30947c478bd9Sstevel@tonic-gate 30957c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_attr_core(handle, tabptr)) != Z_OK) 30967c478bd9Sstevel@tonic-gate return (err); 30977c478bd9Sstevel@tonic-gate 30987c478bd9Sstevel@tonic-gate return (Z_OK); 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate 31017c478bd9Sstevel@tonic-gate static int 31027c478bd9Sstevel@tonic-gate zonecfg_delete_attr_core(zone_dochandle_t handle, struct zone_attrtab *tabptr) 31037c478bd9Sstevel@tonic-gate { 31047c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 31057c478bd9Sstevel@tonic-gate int name_match, type_match, value_match; 31067c478bd9Sstevel@tonic-gate 31077c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 31087c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_ATTR)) 31097c478bd9Sstevel@tonic-gate continue; 31107c478bd9Sstevel@tonic-gate 31117c478bd9Sstevel@tonic-gate name_match = match_prop(cur, DTD_ATTR_NAME, 31127c478bd9Sstevel@tonic-gate tabptr->zone_attr_name); 31137c478bd9Sstevel@tonic-gate type_match = match_prop(cur, DTD_ATTR_TYPE, 31147c478bd9Sstevel@tonic-gate tabptr->zone_attr_type); 31157c478bd9Sstevel@tonic-gate value_match = match_prop(cur, DTD_ATTR_VALUE, 31167c478bd9Sstevel@tonic-gate tabptr->zone_attr_value); 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate if (name_match && type_match && value_match) { 31197c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 31207c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 31217c478bd9Sstevel@tonic-gate return (Z_OK); 31227c478bd9Sstevel@tonic-gate } 31237c478bd9Sstevel@tonic-gate } 31247c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 31257c478bd9Sstevel@tonic-gate } 31267c478bd9Sstevel@tonic-gate 31277c478bd9Sstevel@tonic-gate int 31287c478bd9Sstevel@tonic-gate zonecfg_delete_attr(zone_dochandle_t handle, struct zone_attrtab *tabptr) 31297c478bd9Sstevel@tonic-gate { 31307c478bd9Sstevel@tonic-gate int err; 31317c478bd9Sstevel@tonic-gate 31327c478bd9Sstevel@tonic-gate if (tabptr == NULL) 31337c478bd9Sstevel@tonic-gate return (Z_INVAL); 31347c478bd9Sstevel@tonic-gate 31357c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 31367c478bd9Sstevel@tonic-gate return (err); 31377c478bd9Sstevel@tonic-gate 31387c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr_core(handle, tabptr)) != Z_OK) 31397c478bd9Sstevel@tonic-gate return (err); 31407c478bd9Sstevel@tonic-gate 31417c478bd9Sstevel@tonic-gate return (Z_OK); 31427c478bd9Sstevel@tonic-gate } 31437c478bd9Sstevel@tonic-gate 31447c478bd9Sstevel@tonic-gate int 31457c478bd9Sstevel@tonic-gate zonecfg_modify_attr( 31467c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 31477c478bd9Sstevel@tonic-gate struct zone_attrtab *oldtabptr, 31487c478bd9Sstevel@tonic-gate struct zone_attrtab *newtabptr) 31497c478bd9Sstevel@tonic-gate { 31507c478bd9Sstevel@tonic-gate int err; 31517c478bd9Sstevel@tonic-gate 31527c478bd9Sstevel@tonic-gate if (oldtabptr == NULL || newtabptr == NULL) 31537c478bd9Sstevel@tonic-gate return (Z_INVAL); 31547c478bd9Sstevel@tonic-gate 31557c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 31567c478bd9Sstevel@tonic-gate return (err); 31577c478bd9Sstevel@tonic-gate 31587c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr_core(handle, oldtabptr)) != Z_OK) 31597c478bd9Sstevel@tonic-gate return (err); 31607c478bd9Sstevel@tonic-gate 31617c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_attr_core(handle, newtabptr)) != Z_OK) 31627c478bd9Sstevel@tonic-gate return (err); 31637c478bd9Sstevel@tonic-gate 31647c478bd9Sstevel@tonic-gate return (Z_OK); 31657c478bd9Sstevel@tonic-gate } 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate int 31687c478bd9Sstevel@tonic-gate zonecfg_get_attr_boolean(const struct zone_attrtab *attr, boolean_t *value) 31697c478bd9Sstevel@tonic-gate { 31707c478bd9Sstevel@tonic-gate if (attr == NULL) 31717c478bd9Sstevel@tonic-gate return (Z_INVAL); 31727c478bd9Sstevel@tonic-gate 31737c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_BOOLEAN) != 0) 31747c478bd9Sstevel@tonic-gate return (Z_INVAL); 31757c478bd9Sstevel@tonic-gate 31767c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_value, DTD_ENTITY_TRUE) == 0) { 31777c478bd9Sstevel@tonic-gate *value = B_TRUE; 31787c478bd9Sstevel@tonic-gate return (Z_OK); 31797c478bd9Sstevel@tonic-gate } 31807c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_value, DTD_ENTITY_FALSE) == 0) { 31817c478bd9Sstevel@tonic-gate *value = B_FALSE; 31827c478bd9Sstevel@tonic-gate return (Z_OK); 31837c478bd9Sstevel@tonic-gate } 31847c478bd9Sstevel@tonic-gate return (Z_INVAL); 31857c478bd9Sstevel@tonic-gate } 31867c478bd9Sstevel@tonic-gate 31877c478bd9Sstevel@tonic-gate int 31887c478bd9Sstevel@tonic-gate zonecfg_get_attr_int(const struct zone_attrtab *attr, int64_t *value) 31897c478bd9Sstevel@tonic-gate { 31907c478bd9Sstevel@tonic-gate long long result; 31917c478bd9Sstevel@tonic-gate char *endptr; 31927c478bd9Sstevel@tonic-gate 31937c478bd9Sstevel@tonic-gate if (attr == NULL) 31947c478bd9Sstevel@tonic-gate return (Z_INVAL); 31957c478bd9Sstevel@tonic-gate 31967c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_INT) != 0) 31977c478bd9Sstevel@tonic-gate return (Z_INVAL); 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate errno = 0; 32007c478bd9Sstevel@tonic-gate result = strtoll(attr->zone_attr_value, &endptr, 10); 32017c478bd9Sstevel@tonic-gate if (errno != 0 || *endptr != '\0') 32027c478bd9Sstevel@tonic-gate return (Z_INVAL); 32037c478bd9Sstevel@tonic-gate *value = result; 32047c478bd9Sstevel@tonic-gate return (Z_OK); 32057c478bd9Sstevel@tonic-gate } 32067c478bd9Sstevel@tonic-gate 32077c478bd9Sstevel@tonic-gate int 32087c478bd9Sstevel@tonic-gate zonecfg_get_attr_string(const struct zone_attrtab *attr, char *value, 32097c478bd9Sstevel@tonic-gate size_t val_sz) 32107c478bd9Sstevel@tonic-gate { 32117c478bd9Sstevel@tonic-gate if (attr == NULL) 32127c478bd9Sstevel@tonic-gate return (Z_INVAL); 32137c478bd9Sstevel@tonic-gate 32147c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_STRING) != 0) 32157c478bd9Sstevel@tonic-gate return (Z_INVAL); 32167c478bd9Sstevel@tonic-gate 32177c478bd9Sstevel@tonic-gate if (strlcpy(value, attr->zone_attr_value, val_sz) >= val_sz) 32187c478bd9Sstevel@tonic-gate return (Z_TOO_BIG); 32197c478bd9Sstevel@tonic-gate return (Z_OK); 32207c478bd9Sstevel@tonic-gate } 32217c478bd9Sstevel@tonic-gate 32227c478bd9Sstevel@tonic-gate int 32237c478bd9Sstevel@tonic-gate zonecfg_get_attr_uint(const struct zone_attrtab *attr, uint64_t *value) 32247c478bd9Sstevel@tonic-gate { 32257c478bd9Sstevel@tonic-gate unsigned long long result; 32267c478bd9Sstevel@tonic-gate long long neg_result; 32277c478bd9Sstevel@tonic-gate char *endptr; 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate if (attr == NULL) 32307c478bd9Sstevel@tonic-gate return (Z_INVAL); 32317c478bd9Sstevel@tonic-gate 32327c478bd9Sstevel@tonic-gate if (strcmp(attr->zone_attr_type, DTD_ENTITY_UINT) != 0) 32337c478bd9Sstevel@tonic-gate return (Z_INVAL); 32347c478bd9Sstevel@tonic-gate 32357c478bd9Sstevel@tonic-gate errno = 0; 32367c478bd9Sstevel@tonic-gate result = strtoull(attr->zone_attr_value, &endptr, 10); 32377c478bd9Sstevel@tonic-gate if (errno != 0 || *endptr != '\0') 32387c478bd9Sstevel@tonic-gate return (Z_INVAL); 32397c478bd9Sstevel@tonic-gate errno = 0; 32407c478bd9Sstevel@tonic-gate neg_result = strtoll(attr->zone_attr_value, &endptr, 10); 32417c478bd9Sstevel@tonic-gate /* 32427c478bd9Sstevel@tonic-gate * Incredibly, strtoull("<negative number>", ...) will not fail but 32437c478bd9Sstevel@tonic-gate * return whatever (negative) number cast as a u_longlong_t, so we 32447c478bd9Sstevel@tonic-gate * need to look for this here. 32457c478bd9Sstevel@tonic-gate */ 32467c478bd9Sstevel@tonic-gate if (errno == 0 && neg_result < 0) 32477c478bd9Sstevel@tonic-gate return (Z_INVAL); 32487c478bd9Sstevel@tonic-gate *value = result; 32497c478bd9Sstevel@tonic-gate return (Z_OK); 32507c478bd9Sstevel@tonic-gate } 32517c478bd9Sstevel@tonic-gate 32527c478bd9Sstevel@tonic-gate int 32537c478bd9Sstevel@tonic-gate zonecfg_lookup_rctl(zone_dochandle_t handle, struct zone_rctltab *tabptr) 32547c478bd9Sstevel@tonic-gate { 32557c478bd9Sstevel@tonic-gate xmlNodePtr cur, val; 32567c478bd9Sstevel@tonic-gate char savedname[MAXNAMELEN]; 32577c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 32587c478bd9Sstevel@tonic-gate int err; 32597c478bd9Sstevel@tonic-gate 32602ad45a84Sjv if (strlen(tabptr->zone_rctl_name) == 0) 32617c478bd9Sstevel@tonic-gate return (Z_INVAL); 32627c478bd9Sstevel@tonic-gate 32637c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 32647c478bd9Sstevel@tonic-gate return (err); 32657c478bd9Sstevel@tonic-gate 32667c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 32677c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 32687c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_RCTL)) 32697c478bd9Sstevel@tonic-gate continue; 32707c478bd9Sstevel@tonic-gate if ((fetchprop(cur, DTD_ATTR_NAME, savedname, 32717c478bd9Sstevel@tonic-gate sizeof (savedname)) == Z_OK) && 32727c478bd9Sstevel@tonic-gate (strcmp(savedname, tabptr->zone_rctl_name) == 0)) { 32737c478bd9Sstevel@tonic-gate tabptr->zone_rctl_valptr = NULL; 32747c478bd9Sstevel@tonic-gate for (val = cur->xmlChildrenNode; val != NULL; 32757c478bd9Sstevel@tonic-gate val = val->next) { 32767c478bd9Sstevel@tonic-gate valptr = (struct zone_rctlvaltab *)malloc( 32777c478bd9Sstevel@tonic-gate sizeof (struct zone_rctlvaltab)); 32787c478bd9Sstevel@tonic-gate if (valptr == NULL) 32797c478bd9Sstevel@tonic-gate return (Z_NOMEM); 32807c478bd9Sstevel@tonic-gate if ((fetchprop(val, DTD_ATTR_PRIV, 32817c478bd9Sstevel@tonic-gate valptr->zone_rctlval_priv, 32827c478bd9Sstevel@tonic-gate sizeof (valptr->zone_rctlval_priv)) != 32837c478bd9Sstevel@tonic-gate Z_OK)) 32847c478bd9Sstevel@tonic-gate break; 32857c478bd9Sstevel@tonic-gate if ((fetchprop(val, DTD_ATTR_LIMIT, 32867c478bd9Sstevel@tonic-gate valptr->zone_rctlval_limit, 32877c478bd9Sstevel@tonic-gate sizeof (valptr->zone_rctlval_limit)) != 32887c478bd9Sstevel@tonic-gate Z_OK)) 32897c478bd9Sstevel@tonic-gate break; 32907c478bd9Sstevel@tonic-gate if ((fetchprop(val, DTD_ATTR_ACTION, 32917c478bd9Sstevel@tonic-gate valptr->zone_rctlval_action, 32927c478bd9Sstevel@tonic-gate sizeof (valptr->zone_rctlval_action)) != 32937c478bd9Sstevel@tonic-gate Z_OK)) 32947c478bd9Sstevel@tonic-gate break; 32957c478bd9Sstevel@tonic-gate if (zonecfg_add_rctl_value(tabptr, valptr) != 32967c478bd9Sstevel@tonic-gate Z_OK) 32977c478bd9Sstevel@tonic-gate break; 32987c478bd9Sstevel@tonic-gate } 32997c478bd9Sstevel@tonic-gate return (Z_OK); 33007c478bd9Sstevel@tonic-gate } 33017c478bd9Sstevel@tonic-gate } 33027c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 33037c478bd9Sstevel@tonic-gate } 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate static int 33067c478bd9Sstevel@tonic-gate zonecfg_add_rctl_core(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33077c478bd9Sstevel@tonic-gate { 33087c478bd9Sstevel@tonic-gate xmlNodePtr newnode, cur = handle->zone_dh_cur, valnode; 33097c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 33107c478bd9Sstevel@tonic-gate int err; 33117c478bd9Sstevel@tonic-gate 33127c478bd9Sstevel@tonic-gate newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_RCTL, NULL); 3313a1be23daSdp err = newprop(newnode, DTD_ATTR_NAME, tabptr->zone_rctl_name); 33147c478bd9Sstevel@tonic-gate if (err != Z_OK) 33157c478bd9Sstevel@tonic-gate return (err); 33167c478bd9Sstevel@tonic-gate for (valptr = tabptr->zone_rctl_valptr; valptr != NULL; 33177c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 33187c478bd9Sstevel@tonic-gate valnode = xmlNewTextChild(newnode, NULL, 33197c478bd9Sstevel@tonic-gate DTD_ELEM_RCTLVALUE, NULL); 3320a1be23daSdp err = newprop(valnode, DTD_ATTR_PRIV, 33217c478bd9Sstevel@tonic-gate valptr->zone_rctlval_priv); 33227c478bd9Sstevel@tonic-gate if (err != Z_OK) 33237c478bd9Sstevel@tonic-gate return (err); 3324a1be23daSdp err = newprop(valnode, DTD_ATTR_LIMIT, 33257c478bd9Sstevel@tonic-gate valptr->zone_rctlval_limit); 33267c478bd9Sstevel@tonic-gate if (err != Z_OK) 33277c478bd9Sstevel@tonic-gate return (err); 3328a1be23daSdp err = newprop(valnode, DTD_ATTR_ACTION, 33297c478bd9Sstevel@tonic-gate valptr->zone_rctlval_action); 33307c478bd9Sstevel@tonic-gate if (err != Z_OK) 33317c478bd9Sstevel@tonic-gate return (err); 33327c478bd9Sstevel@tonic-gate } 33337c478bd9Sstevel@tonic-gate return (Z_OK); 33347c478bd9Sstevel@tonic-gate } 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate int 33377c478bd9Sstevel@tonic-gate zonecfg_add_rctl(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33387c478bd9Sstevel@tonic-gate { 33397c478bd9Sstevel@tonic-gate int err; 33407c478bd9Sstevel@tonic-gate 33412ad45a84Sjv if (tabptr == NULL) 33427c478bd9Sstevel@tonic-gate return (Z_INVAL); 33437c478bd9Sstevel@tonic-gate 33447c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 33457c478bd9Sstevel@tonic-gate return (err); 33467c478bd9Sstevel@tonic-gate 33477c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_rctl_core(handle, tabptr)) != Z_OK) 33487c478bd9Sstevel@tonic-gate return (err); 33497c478bd9Sstevel@tonic-gate 33507c478bd9Sstevel@tonic-gate return (Z_OK); 33517c478bd9Sstevel@tonic-gate } 33527c478bd9Sstevel@tonic-gate 33537c478bd9Sstevel@tonic-gate static int 33547c478bd9Sstevel@tonic-gate zonecfg_delete_rctl_core(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33557c478bd9Sstevel@tonic-gate { 33567c478bd9Sstevel@tonic-gate xmlNodePtr cur = handle->zone_dh_cur; 33577c478bd9Sstevel@tonic-gate xmlChar *savedname; 33587c478bd9Sstevel@tonic-gate int name_result; 33597c478bd9Sstevel@tonic-gate 33607c478bd9Sstevel@tonic-gate for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 33617c478bd9Sstevel@tonic-gate if (xmlStrcmp(cur->name, DTD_ELEM_RCTL)) 33627c478bd9Sstevel@tonic-gate continue; 33637c478bd9Sstevel@tonic-gate 33647c478bd9Sstevel@tonic-gate savedname = xmlGetProp(cur, DTD_ATTR_NAME); 33657c478bd9Sstevel@tonic-gate if (savedname == NULL) /* shouldn't happen */ 33667c478bd9Sstevel@tonic-gate continue; 33677c478bd9Sstevel@tonic-gate name_result = xmlStrcmp(savedname, 33687c478bd9Sstevel@tonic-gate (const xmlChar *) tabptr->zone_rctl_name); 33697c478bd9Sstevel@tonic-gate xmlFree(savedname); 33707c478bd9Sstevel@tonic-gate 33717c478bd9Sstevel@tonic-gate if (name_result == 0) { 33727c478bd9Sstevel@tonic-gate xmlUnlinkNode(cur); 33737c478bd9Sstevel@tonic-gate xmlFreeNode(cur); 33747c478bd9Sstevel@tonic-gate return (Z_OK); 33757c478bd9Sstevel@tonic-gate } 33767c478bd9Sstevel@tonic-gate } 33777c478bd9Sstevel@tonic-gate return (Z_NO_RESOURCE_ID); 33787c478bd9Sstevel@tonic-gate } 33797c478bd9Sstevel@tonic-gate 33807c478bd9Sstevel@tonic-gate int 33817c478bd9Sstevel@tonic-gate zonecfg_delete_rctl(zone_dochandle_t handle, struct zone_rctltab *tabptr) 33827c478bd9Sstevel@tonic-gate { 33837c478bd9Sstevel@tonic-gate int err; 33847c478bd9Sstevel@tonic-gate 33852ad45a84Sjv if (tabptr == NULL) 33867c478bd9Sstevel@tonic-gate return (Z_INVAL); 33877c478bd9Sstevel@tonic-gate 33887c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 33897c478bd9Sstevel@tonic-gate return (err); 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl_core(handle, tabptr)) != Z_OK) 33927c478bd9Sstevel@tonic-gate return (err); 33937c478bd9Sstevel@tonic-gate 33947c478bd9Sstevel@tonic-gate return (Z_OK); 33957c478bd9Sstevel@tonic-gate } 33967c478bd9Sstevel@tonic-gate 33977c478bd9Sstevel@tonic-gate int 33987c478bd9Sstevel@tonic-gate zonecfg_modify_rctl( 33997c478bd9Sstevel@tonic-gate zone_dochandle_t handle, 34007c478bd9Sstevel@tonic-gate struct zone_rctltab *oldtabptr, 34017c478bd9Sstevel@tonic-gate struct zone_rctltab *newtabptr) 34027c478bd9Sstevel@tonic-gate { 34037c478bd9Sstevel@tonic-gate int err; 34047c478bd9Sstevel@tonic-gate 34052ad45a84Sjv if (oldtabptr == NULL || newtabptr == NULL) 34067c478bd9Sstevel@tonic-gate return (Z_INVAL); 34077c478bd9Sstevel@tonic-gate 34087c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) 34097c478bd9Sstevel@tonic-gate return (err); 34107c478bd9Sstevel@tonic-gate 34117c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl_core(handle, oldtabptr)) != Z_OK) 34127c478bd9Sstevel@tonic-gate return (err); 34137c478bd9Sstevel@tonic-gate 34147c478bd9Sstevel@tonic-gate if ((err = zonecfg_add_rctl_core(handle, newtabptr)) != Z_OK) 34157c478bd9Sstevel@tonic-gate return (err); 34167c478bd9Sstevel@tonic-gate 34177c478bd9Sstevel@tonic-gate return (Z_OK); 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate 34207c478bd9Sstevel@tonic-gate int 34217c478bd9Sstevel@tonic-gate zonecfg_add_rctl_value( 34227c478bd9Sstevel@tonic-gate struct zone_rctltab *tabptr, 34237c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valtabptr) 34247c478bd9Sstevel@tonic-gate { 34257c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *last, *old, *new; 34267c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk = alloca(rctlblk_size()); 34277c478bd9Sstevel@tonic-gate 34287c478bd9Sstevel@tonic-gate last = tabptr->zone_rctl_valptr; 34297c478bd9Sstevel@tonic-gate for (old = last; old != NULL; old = old->zone_rctlval_next) 34307c478bd9Sstevel@tonic-gate last = old; /* walk to the end of the list */ 34317c478bd9Sstevel@tonic-gate new = valtabptr; /* alloc'd by caller */ 34327c478bd9Sstevel@tonic-gate new->zone_rctlval_next = NULL; 34337c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(valtabptr, rctlblk) != Z_OK) 34347c478bd9Sstevel@tonic-gate return (Z_INVAL); 34357c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlblk(rctlblk)) 34367c478bd9Sstevel@tonic-gate return (Z_INVAL); 34377c478bd9Sstevel@tonic-gate if (last == NULL) 34387c478bd9Sstevel@tonic-gate tabptr->zone_rctl_valptr = new; 34397c478bd9Sstevel@tonic-gate else 34407c478bd9Sstevel@tonic-gate last->zone_rctlval_next = new; 34417c478bd9Sstevel@tonic-gate return (Z_OK); 34427c478bd9Sstevel@tonic-gate } 34437c478bd9Sstevel@tonic-gate 34447c478bd9Sstevel@tonic-gate int 34457c478bd9Sstevel@tonic-gate zonecfg_remove_rctl_value( 34467c478bd9Sstevel@tonic-gate struct zone_rctltab *tabptr, 34477c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valtabptr) 34487c478bd9Sstevel@tonic-gate { 34497c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *last, *this, *next; 34507c478bd9Sstevel@tonic-gate 34517c478bd9Sstevel@tonic-gate last = tabptr->zone_rctl_valptr; 34527c478bd9Sstevel@tonic-gate for (this = last; this != NULL; this = this->zone_rctlval_next) { 34537c478bd9Sstevel@tonic-gate if (strcmp(this->zone_rctlval_priv, 34547c478bd9Sstevel@tonic-gate valtabptr->zone_rctlval_priv) == 0 && 34557c478bd9Sstevel@tonic-gate strcmp(this->zone_rctlval_limit, 34567c478bd9Sstevel@tonic-gate valtabptr->zone_rctlval_limit) == 0 && 34577c478bd9Sstevel@tonic-gate strcmp(this->zone_rctlval_action, 34587c478bd9Sstevel@tonic-gate valtabptr->zone_rctlval_action) == 0) { 34597c478bd9Sstevel@tonic-gate next = this->zone_rctlval_next; 34607c478bd9Sstevel@tonic-gate if (this == tabptr->zone_rctl_valptr) 34617c478bd9Sstevel@tonic-gate tabptr->zone_rctl_valptr = next; 34627c478bd9Sstevel@tonic-gate else 34637c478bd9Sstevel@tonic-gate last->zone_rctlval_next = next; 34647c478bd9Sstevel@tonic-gate free(this); 34657c478bd9Sstevel@tonic-gate return (Z_OK); 34667c478bd9Sstevel@tonic-gate } else 34677c478bd9Sstevel@tonic-gate last = this; 34687c478bd9Sstevel@tonic-gate } 34697c478bd9Sstevel@tonic-gate return (Z_NO_PROPERTY_ID); 34707c478bd9Sstevel@tonic-gate } 34717c478bd9Sstevel@tonic-gate 3472ff17c8bfSgjelinek void 3473ff17c8bfSgjelinek zonecfg_set_swinv(zone_dochandle_t handle) 3474ff17c8bfSgjelinek { 3475ff17c8bfSgjelinek handle->zone_dh_sw_inv = B_TRUE; 3476ff17c8bfSgjelinek } 3477ff17c8bfSgjelinek 3478ff17c8bfSgjelinek /* 3479ff17c8bfSgjelinek * Add the pkg to the sw inventory on the handle. 3480ff17c8bfSgjelinek */ 3481ff17c8bfSgjelinek int 3482ff17c8bfSgjelinek zonecfg_add_pkg(zone_dochandle_t handle, char *name, char *version) 3483ff17c8bfSgjelinek { 3484ff17c8bfSgjelinek xmlNodePtr newnode; 3485ff17c8bfSgjelinek xmlNodePtr cur; 3486ff17c8bfSgjelinek int err; 3487ff17c8bfSgjelinek 3488ff17c8bfSgjelinek if ((err = operation_prep(handle)) != Z_OK) 3489ff17c8bfSgjelinek return (err); 3490ff17c8bfSgjelinek 3491ff17c8bfSgjelinek cur = handle->zone_dh_cur; 3492ff17c8bfSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_PACKAGE, NULL); 3493ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_NAME, name)) != Z_OK) 3494ff17c8bfSgjelinek return (err); 3495ff17c8bfSgjelinek if ((err = newprop(newnode, DTD_ATTR_VERSION, version)) != Z_OK) 3496ff17c8bfSgjelinek return (err); 3497ff17c8bfSgjelinek return (Z_OK); 3498ff17c8bfSgjelinek } 3499ff17c8bfSgjelinek 35007c478bd9Sstevel@tonic-gate char * 35017c478bd9Sstevel@tonic-gate zonecfg_strerror(int errnum) 35027c478bd9Sstevel@tonic-gate { 35037c478bd9Sstevel@tonic-gate switch (errnum) { 35047c478bd9Sstevel@tonic-gate case Z_OK: 35057c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "OK")); 35067c478bd9Sstevel@tonic-gate case Z_EMPTY_DOCUMENT: 35077c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Empty document")); 35087c478bd9Sstevel@tonic-gate case Z_WRONG_DOC_TYPE: 35097c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Wrong document type")); 35107c478bd9Sstevel@tonic-gate case Z_BAD_PROPERTY: 35117c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Bad document property")); 35127c478bd9Sstevel@tonic-gate case Z_TEMP_FILE: 35137c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 35147c478bd9Sstevel@tonic-gate "Problem creating temporary file")); 35157c478bd9Sstevel@tonic-gate case Z_SAVING_FILE: 35167c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Problem saving file")); 35177c478bd9Sstevel@tonic-gate case Z_NO_ENTRY: 35187c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such entry")); 35197c478bd9Sstevel@tonic-gate case Z_BOGUS_ZONE_NAME: 35207c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Bogus zone name")); 35217c478bd9Sstevel@tonic-gate case Z_REQD_RESOURCE_MISSING: 35227c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Required resource missing")); 35237c478bd9Sstevel@tonic-gate case Z_REQD_PROPERTY_MISSING: 35247c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Required property missing")); 35257c478bd9Sstevel@tonic-gate case Z_BAD_HANDLE: 35267c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Bad handle")); 35277c478bd9Sstevel@tonic-gate case Z_NOMEM: 35287c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Out of memory")); 35297c478bd9Sstevel@tonic-gate case Z_INVAL: 35307c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Invalid argument")); 35317c478bd9Sstevel@tonic-gate case Z_ACCES: 35327c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Permission denied")); 35337c478bd9Sstevel@tonic-gate case Z_TOO_BIG: 35347c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Argument list too long")); 35357c478bd9Sstevel@tonic-gate case Z_MISC_FS: 35367c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 35377c478bd9Sstevel@tonic-gate "Miscellaneous file system error")); 35387c478bd9Sstevel@tonic-gate case Z_NO_ZONE: 35397c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such zone configured")); 35407c478bd9Sstevel@tonic-gate case Z_NO_RESOURCE_TYPE: 35417c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such resource type")); 35427c478bd9Sstevel@tonic-gate case Z_NO_RESOURCE_ID: 35437c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such resource with that id")); 35447c478bd9Sstevel@tonic-gate case Z_NO_PROPERTY_TYPE: 35457c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such property type")); 35467c478bd9Sstevel@tonic-gate case Z_NO_PROPERTY_ID: 35477c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such property with that id")); 3548087719fdSdp case Z_BAD_ZONE_STATE: 35497c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 3550087719fdSdp "Zone state is invalid for the requested operation")); 35517c478bd9Sstevel@tonic-gate case Z_INVALID_DOCUMENT: 35527c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Invalid document")); 3553087719fdSdp case Z_NAME_IN_USE: 3554087719fdSdp return (dgettext(TEXT_DOMAIN, "Zone name already in use")); 35557c478bd9Sstevel@tonic-gate case Z_NO_SUCH_ID: 35567c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "No such zone ID")); 35577c478bd9Sstevel@tonic-gate case Z_UPDATING_INDEX: 35587c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Problem updating index file")); 35597c478bd9Sstevel@tonic-gate case Z_LOCKING_FILE: 35607c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Locking index file")); 35617c478bd9Sstevel@tonic-gate case Z_UNLOCKING_FILE: 35627c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Unlocking index file")); 35637c478bd9Sstevel@tonic-gate case Z_INSUFFICIENT_SPEC: 35647c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Insufficient specification")); 35657c478bd9Sstevel@tonic-gate case Z_RESOLVED_PATH: 35667c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Resolved path mismatch")); 35677c478bd9Sstevel@tonic-gate case Z_IPV6_ADDR_PREFIX_LEN: 35687c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 35697c478bd9Sstevel@tonic-gate "IPv6 address missing required prefix length")); 35707c478bd9Sstevel@tonic-gate case Z_BOGUS_ADDRESS: 35717c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, 35727c478bd9Sstevel@tonic-gate "Neither an IPv4 nor an IPv6 address nor a host name")); 3573ffbafc53Scomay case Z_PRIV_PROHIBITED: 3574ffbafc53Scomay return (dgettext(TEXT_DOMAIN, 3575ffbafc53Scomay "Specified privilege is prohibited")); 3576ffbafc53Scomay case Z_PRIV_REQUIRED: 3577ffbafc53Scomay return (dgettext(TEXT_DOMAIN, 3578ffbafc53Scomay "Required privilege is missing")); 3579ffbafc53Scomay case Z_PRIV_UNKNOWN: 3580ffbafc53Scomay return (dgettext(TEXT_DOMAIN, 3581ffbafc53Scomay "Specified privilege is unknown")); 35829acbbeafSnn case Z_BRAND_ERROR: 35839acbbeafSnn return (dgettext(TEXT_DOMAIN, 35849acbbeafSnn "Brand-specific error")); 35850209230bSgjelinek case Z_INCOMPATIBLE: 35860209230bSgjelinek return (dgettext(TEXT_DOMAIN, "Incompatible settings")); 35870209230bSgjelinek case Z_ALIAS_DISALLOW: 35880209230bSgjelinek return (dgettext(TEXT_DOMAIN, 35890209230bSgjelinek "An incompatible rctl already exists for this property")); 35900209230bSgjelinek case Z_CLEAR_DISALLOW: 35910209230bSgjelinek return (dgettext(TEXT_DOMAIN, 35920209230bSgjelinek "Clearing this property is not allowed")); 35930209230bSgjelinek case Z_POOL: 35940209230bSgjelinek return (dgettext(TEXT_DOMAIN, "libpool(3LIB) error")); 35950209230bSgjelinek case Z_POOLS_NOT_ACTIVE: 35960209230bSgjelinek return (dgettext(TEXT_DOMAIN, "Pools facility not active; " 35970209230bSgjelinek "zone will not be bound to pool")); 35980209230bSgjelinek case Z_POOL_ENABLE: 35990209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36000209230bSgjelinek "Could not enable pools facility")); 36010209230bSgjelinek case Z_NO_POOL: 36020209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36030209230bSgjelinek "Pool not found; using default pool")); 36040209230bSgjelinek case Z_POOL_CREATE: 36050209230bSgjelinek return (dgettext(TEXT_DOMAIN, 36060209230bSgjelinek "Could not create a temporary pool")); 36070209230bSgjelinek case Z_POOL_BIND: 36080209230bSgjelinek return (dgettext(TEXT_DOMAIN, "Could not bind zone to pool")); 36090fbb751dSJohn Levon case Z_INVALID_PROPERTY: 36100fbb751dSJohn Levon return (dgettext(TEXT_DOMAIN, "Specified property is invalid")); 36112ad45a84Sjv case Z_SYSTEM: 36122ad45a84Sjv return (strerror(errno)); 36137c478bd9Sstevel@tonic-gate default: 36147c478bd9Sstevel@tonic-gate return (dgettext(TEXT_DOMAIN, "Unknown error")); 36157c478bd9Sstevel@tonic-gate } 36167c478bd9Sstevel@tonic-gate } 36177c478bd9Sstevel@tonic-gate 36187c478bd9Sstevel@tonic-gate /* 36197c478bd9Sstevel@tonic-gate * Note that the zonecfg_setXent() and zonecfg_endXent() calls are all the 36207c478bd9Sstevel@tonic-gate * same, as they just turn around and call zonecfg_setent() / zonecfg_endent(). 36217c478bd9Sstevel@tonic-gate */ 36227c478bd9Sstevel@tonic-gate 36237c478bd9Sstevel@tonic-gate static int 36247c478bd9Sstevel@tonic-gate zonecfg_setent(zone_dochandle_t handle) 36257c478bd9Sstevel@tonic-gate { 36267c478bd9Sstevel@tonic-gate xmlNodePtr cur; 36277c478bd9Sstevel@tonic-gate int err; 36287c478bd9Sstevel@tonic-gate 36297c478bd9Sstevel@tonic-gate if (handle == NULL) 36307c478bd9Sstevel@tonic-gate return (Z_INVAL); 36317c478bd9Sstevel@tonic-gate 36327c478bd9Sstevel@tonic-gate if ((err = operation_prep(handle)) != Z_OK) { 36337c478bd9Sstevel@tonic-gate handle->zone_dh_cur = NULL; 36347c478bd9Sstevel@tonic-gate return (err); 36357c478bd9Sstevel@tonic-gate } 36367c478bd9Sstevel@tonic-gate cur = handle->zone_dh_cur; 36377c478bd9Sstevel@tonic-gate cur = cur->xmlChildrenNode; 36387c478bd9Sstevel@tonic-gate handle->zone_dh_cur = cur; 36397c478bd9Sstevel@tonic-gate return (Z_OK); 36407c478bd9Sstevel@tonic-gate } 36417c478bd9Sstevel@tonic-gate 36427c478bd9Sstevel@tonic-gate static int 36437c478bd9Sstevel@tonic-gate zonecfg_endent(zone_dochandle_t handle) 36447c478bd9Sstevel@tonic-gate { 36457c478bd9Sstevel@tonic-gate if (handle == NULL) 36467c478bd9Sstevel@tonic-gate return (Z_INVAL); 36477c478bd9Sstevel@tonic-gate 36487c478bd9Sstevel@tonic-gate handle->zone_dh_cur = handle->zone_dh_top; 36497c478bd9Sstevel@tonic-gate return (Z_OK); 36507c478bd9Sstevel@tonic-gate } 36517c478bd9Sstevel@tonic-gate 36520209230bSgjelinek /* 36530209230bSgjelinek * Do the work required to manipulate a process through libproc. 36540209230bSgjelinek * If grab_process() returns no errors (0), then release_process() 36550209230bSgjelinek * must eventually be called. 36560209230bSgjelinek * 36570209230bSgjelinek * Return values: 36580209230bSgjelinek * 0 Successful creation of agent thread 36590209230bSgjelinek * 1 Error grabbing 36600209230bSgjelinek * 2 Error creating agent 36610209230bSgjelinek */ 36620209230bSgjelinek static int 36630209230bSgjelinek grab_process(pr_info_handle_t *p) 36647c478bd9Sstevel@tonic-gate { 36650209230bSgjelinek int ret; 36660209230bSgjelinek 36670209230bSgjelinek if ((p->pr = Pgrab(p->pid, 0, &ret)) != NULL) { 36680209230bSgjelinek 36690209230bSgjelinek if (Psetflags(p->pr, PR_RLC) != 0) { 36700209230bSgjelinek Prelease(p->pr, 0); 36710209230bSgjelinek return (1); 36720209230bSgjelinek } 36730209230bSgjelinek if (Pcreate_agent(p->pr) == 0) { 36740209230bSgjelinek return (0); 36750209230bSgjelinek 36760209230bSgjelinek } else { 36770209230bSgjelinek Prelease(p->pr, 0); 36780209230bSgjelinek return (2); 36790209230bSgjelinek } 36800209230bSgjelinek } else { 36810209230bSgjelinek return (1); 36820209230bSgjelinek } 36837c478bd9Sstevel@tonic-gate } 36847c478bd9Sstevel@tonic-gate 36850209230bSgjelinek /* 36860209230bSgjelinek * Release the specified process. This destroys the agent 36870209230bSgjelinek * and releases the process. If the process is NULL, nothing 36880209230bSgjelinek * is done. This function should only be called if grab_process() 36890209230bSgjelinek * has previously been called and returned success. 36900209230bSgjelinek * 36910209230bSgjelinek * This function is Pgrab-safe. 36920209230bSgjelinek */ 36930209230bSgjelinek static void 36940209230bSgjelinek release_process(struct ps_prochandle *Pr) 36957c478bd9Sstevel@tonic-gate { 36960209230bSgjelinek if (Pr == NULL) 36970209230bSgjelinek return; 36987c478bd9Sstevel@tonic-gate 36990209230bSgjelinek Pdestroy_agent(Pr); 37000209230bSgjelinek Prelease(Pr, 0); 37010209230bSgjelinek } 37027c478bd9Sstevel@tonic-gate 37030209230bSgjelinek static boolean_t 37040209230bSgjelinek grab_zone_proc(char *zonename, pr_info_handle_t *p) 37050209230bSgjelinek { 37060209230bSgjelinek DIR *dirp; 37070209230bSgjelinek struct dirent *dentp; 37080209230bSgjelinek zoneid_t zoneid; 37090209230bSgjelinek int pid_self; 37100209230bSgjelinek psinfo_t psinfo; 37117c478bd9Sstevel@tonic-gate 37120209230bSgjelinek if (zone_get_id(zonename, &zoneid) != 0) 37130209230bSgjelinek return (B_FALSE); 37147c478bd9Sstevel@tonic-gate 37150209230bSgjelinek pid_self = getpid(); 37167c478bd9Sstevel@tonic-gate 37170209230bSgjelinek if ((dirp = opendir("/proc")) == NULL) 37180209230bSgjelinek return (B_FALSE); 37197c478bd9Sstevel@tonic-gate 37200209230bSgjelinek while (dentp = readdir(dirp)) { 37210209230bSgjelinek p->pid = atoi(dentp->d_name); 37227c478bd9Sstevel@tonic-gate 37230209230bSgjelinek /* Skip self */ 37240209230bSgjelinek if (p->pid == pid_self) 37250209230bSgjelinek continue; 37267c478bd9Sstevel@tonic-gate 37270209230bSgjelinek if (proc_get_psinfo(p->pid, &psinfo) != 0) 37280209230bSgjelinek continue; 37290209230bSgjelinek 37300209230bSgjelinek if (psinfo.pr_zoneid != zoneid) 37310209230bSgjelinek continue; 37320209230bSgjelinek 37330209230bSgjelinek /* attempt to grab process */ 37340209230bSgjelinek if (grab_process(p) != 0) 37350209230bSgjelinek continue; 37360209230bSgjelinek 37370209230bSgjelinek if (pr_getzoneid(p->pr) != zoneid) { 37380209230bSgjelinek release_process(p->pr); 37390209230bSgjelinek continue; 37400209230bSgjelinek } 37410209230bSgjelinek 37420209230bSgjelinek (void) closedir(dirp); 37430209230bSgjelinek return (B_TRUE); 37447c478bd9Sstevel@tonic-gate } 37457c478bd9Sstevel@tonic-gate 37460209230bSgjelinek (void) closedir(dirp); 37470209230bSgjelinek return (B_FALSE); 37487c478bd9Sstevel@tonic-gate } 37497c478bd9Sstevel@tonic-gate 37500209230bSgjelinek static boolean_t 37510209230bSgjelinek get_priv_rctl(struct ps_prochandle *pr, char *name, rctlblk_t *rblk) 37527c478bd9Sstevel@tonic-gate { 37530209230bSgjelinek if (pr_getrctl(pr, name, NULL, rblk, RCTL_FIRST)) 37540209230bSgjelinek return (B_FALSE); 37557c478bd9Sstevel@tonic-gate 37560209230bSgjelinek if (rctlblk_get_privilege(rblk) == RCPRIV_PRIVILEGED) 37570209230bSgjelinek return (B_TRUE); 37580209230bSgjelinek 37590209230bSgjelinek while (pr_getrctl(pr, name, rblk, rblk, RCTL_NEXT) == 0) { 37600209230bSgjelinek if (rctlblk_get_privilege(rblk) == RCPRIV_PRIVILEGED) 37610209230bSgjelinek return (B_TRUE); 37620209230bSgjelinek } 37630209230bSgjelinek 37640209230bSgjelinek return (B_FALSE); 37657c478bd9Sstevel@tonic-gate } 37667c478bd9Sstevel@tonic-gate 37670209230bSgjelinek /* 37680209230bSgjelinek * Apply the current rctl settings to the specified, running zone. 37690209230bSgjelinek */ 37707c478bd9Sstevel@tonic-gate int 37710209230bSgjelinek zonecfg_apply_rctls(char *zone_name, zone_dochandle_t handle) 37727c478bd9Sstevel@tonic-gate { 37737c478bd9Sstevel@tonic-gate int err; 37740209230bSgjelinek int res = Z_OK; 37750209230bSgjelinek rctlblk_t *rblk; 37760209230bSgjelinek pr_info_handle_t p; 37770209230bSgjelinek struct zone_rctltab rctl; 37787c478bd9Sstevel@tonic-gate 37790209230bSgjelinek if ((err = zonecfg_setrctlent(handle)) != Z_OK) 37800209230bSgjelinek return (err); 37817c478bd9Sstevel@tonic-gate 37820209230bSgjelinek if ((rblk = (rctlblk_t *)malloc(rctlblk_size())) == NULL) { 37830209230bSgjelinek (void) zonecfg_endrctlent(handle); 37840209230bSgjelinek return (Z_NOMEM); 37850209230bSgjelinek } 37867c478bd9Sstevel@tonic-gate 37870209230bSgjelinek if (!grab_zone_proc(zone_name, &p)) { 37880209230bSgjelinek (void) zonecfg_endrctlent(handle); 37890209230bSgjelinek free(rblk); 37900209230bSgjelinek return (Z_SYSTEM); 37917c478bd9Sstevel@tonic-gate } 37927c478bd9Sstevel@tonic-gate 37930209230bSgjelinek while (zonecfg_getrctlent(handle, &rctl) == Z_OK) { 37940209230bSgjelinek char *rname; 37950209230bSgjelinek struct zone_rctlvaltab *valptr; 37960209230bSgjelinek 37970209230bSgjelinek rname = rctl.zone_rctl_name; 37980209230bSgjelinek 37990209230bSgjelinek /* first delete all current privileged settings for this rctl */ 38000209230bSgjelinek while (get_priv_rctl(p.pr, rname, rblk)) { 38010209230bSgjelinek if (pr_setrctl(p.pr, rname, NULL, rblk, RCTL_DELETE) != 38020209230bSgjelinek 0) { 38030209230bSgjelinek res = Z_SYSTEM; 38040209230bSgjelinek goto done; 38050209230bSgjelinek } 38060209230bSgjelinek } 38070209230bSgjelinek 38080209230bSgjelinek /* now set each new value for the rctl */ 38090209230bSgjelinek for (valptr = rctl.zone_rctl_valptr; valptr != NULL; 38100209230bSgjelinek valptr = valptr->zone_rctlval_next) { 38110209230bSgjelinek if ((err = zonecfg_construct_rctlblk(valptr, rblk)) 38120209230bSgjelinek != Z_OK) { 38130209230bSgjelinek res = errno = err; 38140209230bSgjelinek goto done; 38150209230bSgjelinek } 38160209230bSgjelinek 38170209230bSgjelinek if (pr_setrctl(p.pr, rname, NULL, rblk, RCTL_INSERT)) { 38180209230bSgjelinek res = Z_SYSTEM; 38190209230bSgjelinek goto done; 38200209230bSgjelinek } 38210209230bSgjelinek } 38227c478bd9Sstevel@tonic-gate } 38237c478bd9Sstevel@tonic-gate 38240209230bSgjelinek done: 38250209230bSgjelinek release_process(p.pr); 38260209230bSgjelinek free(rblk); 38270209230bSgjelinek (void) zonecfg_endrctlent(handle); 38280209230bSgjelinek 38290209230bSgjelinek return (res); 38307c478bd9Sstevel@tonic-gate } 38317c478bd9Sstevel@tonic-gate 38320209230bSgjelinek static const xmlChar * 38330209230bSgjelinek nm_to_dtd(char *nm) 38347c478bd9Sstevel@tonic-gate { 38350209230bSgjelinek if (strcmp(nm, "device") == 0) 38360209230bSgjelinek return (DTD_ELEM_DEVICE); 38370209230bSgjelinek if (strcmp(nm, "fs") == 0) 38380209230bSgjelinek return (DTD_ELEM_FS); 38390209230bSgjelinek if (strcmp(nm, "net") == 0) 38400209230bSgjelinek return (DTD_ELEM_NET); 38410209230bSgjelinek if (strcmp(nm, "attr") == 0) 38420209230bSgjelinek return (DTD_ELEM_ATTR); 38430209230bSgjelinek if (strcmp(nm, "rctl") == 0) 38440209230bSgjelinek return (DTD_ELEM_RCTL); 38450209230bSgjelinek if (strcmp(nm, "dataset") == 0) 38460209230bSgjelinek return (DTD_ELEM_DATASET); 3847cb8a054bSGlenn Faden if (strcmp(nm, "admin") == 0) 3848cb8a054bSGlenn Faden return (DTD_ELEM_ADMIN); 38490209230bSgjelinek 38500209230bSgjelinek return (NULL); 38517c478bd9Sstevel@tonic-gate } 38527c478bd9Sstevel@tonic-gate 38537c478bd9Sstevel@tonic-gate int 38540209230bSgjelinek zonecfg_num_resources(zone_dochandle_t handle, char *rsrc) 38557c478bd9Sstevel@tonic-gate { 38560209230bSgjelinek int num = 0; 38570209230bSgjelinek const xmlChar *dtd; 38580209230bSgjelinek xmlNodePtr cur; 38590209230bSgjelinek 38600209230bSgjelinek if ((dtd = nm_to_dtd(rsrc)) == NULL) 38610209230bSgjelinek return (num); 38620209230bSgjelinek 38630209230bSgjelinek if (zonecfg_setent(handle) != Z_OK) 38640209230bSgjelinek return (num); 38650209230bSgjelinek 38660209230bSgjelinek for (cur = handle->zone_dh_cur; cur != NULL; cur = cur->next) 38670209230bSgjelinek if (xmlStrcmp(cur->name, dtd) == 0) 38680209230bSgjelinek num++; 38690209230bSgjelinek 38700209230bSgjelinek (void) zonecfg_endent(handle); 38710209230bSgjelinek 38720209230bSgjelinek return (num); 38737c478bd9Sstevel@tonic-gate } 38747c478bd9Sstevel@tonic-gate 38757c478bd9Sstevel@tonic-gate int 38760209230bSgjelinek zonecfg_del_all_resources(zone_dochandle_t handle, char *rsrc) 38777c478bd9Sstevel@tonic-gate { 38787c478bd9Sstevel@tonic-gate int err; 38790209230bSgjelinek const xmlChar *dtd; 38800209230bSgjelinek xmlNodePtr cur; 38817c478bd9Sstevel@tonic-gate 38820209230bSgjelinek if ((dtd = nm_to_dtd(rsrc)) == NULL) 38830209230bSgjelinek return (Z_NO_RESOURCE_TYPE); 38847c478bd9Sstevel@tonic-gate 38850209230bSgjelinek if ((err = zonecfg_setent(handle)) != Z_OK) 38860209230bSgjelinek return (err); 38877c478bd9Sstevel@tonic-gate 38880209230bSgjelinek cur = handle->zone_dh_cur; 38890209230bSgjelinek while (cur != NULL) { 38900209230bSgjelinek xmlNodePtr tmp; 38917c478bd9Sstevel@tonic-gate 38920209230bSgjelinek if (xmlStrcmp(cur->name, dtd)) { 38930209230bSgjelinek cur = cur->next; 38940209230bSgjelinek continue; 38950209230bSgjelinek } 38967c478bd9Sstevel@tonic-gate 38970209230bSgjelinek tmp = cur->next; 38980209230bSgjelinek xmlUnlinkNode(cur); 38990209230bSgjelinek xmlFreeNode(cur); 39000209230bSgjelinek cur = tmp; 39017c478bd9Sstevel@tonic-gate } 39027c478bd9Sstevel@tonic-gate 39030209230bSgjelinek (void) zonecfg_endent(handle); 39047c478bd9Sstevel@tonic-gate return (Z_OK); 39057c478bd9Sstevel@tonic-gate } 39067c478bd9Sstevel@tonic-gate 39070209230bSgjelinek static boolean_t 39080209230bSgjelinek valid_uint(char *s, uint64_t *n) 39097c478bd9Sstevel@tonic-gate { 39100209230bSgjelinek char *endp; 39117c478bd9Sstevel@tonic-gate 39120209230bSgjelinek /* strtoull accepts '-'?! so we want to flag that as an error */ 39130209230bSgjelinek if (strchr(s, '-') != NULL) 39140209230bSgjelinek return (B_FALSE); 39150209230bSgjelinek 39160209230bSgjelinek errno = 0; 39170209230bSgjelinek *n = strtoull(s, &endp, 10); 39180209230bSgjelinek 39190209230bSgjelinek if (errno != 0 || *endp != '\0') 39200209230bSgjelinek return (B_FALSE); 39210209230bSgjelinek return (B_TRUE); 39227c478bd9Sstevel@tonic-gate } 39237c478bd9Sstevel@tonic-gate 39240209230bSgjelinek /* 39250209230bSgjelinek * Convert a string representing a number (possibly a fraction) into an integer. 39260209230bSgjelinek * The string can have a modifier (K, M, G or T). The modifiers are treated 39270209230bSgjelinek * as powers of two (not 10). 39280209230bSgjelinek */ 39297c478bd9Sstevel@tonic-gate int 39300209230bSgjelinek zonecfg_str_to_bytes(char *str, uint64_t *bytes) 39317c478bd9Sstevel@tonic-gate { 39320209230bSgjelinek long double val; 39330209230bSgjelinek char *unitp; 39340209230bSgjelinek uint64_t scale; 39357c478bd9Sstevel@tonic-gate 39360209230bSgjelinek if ((val = strtold(str, &unitp)) < 0) 39370209230bSgjelinek return (-1); 39387c478bd9Sstevel@tonic-gate 39390209230bSgjelinek /* remove any leading white space from units string */ 39400209230bSgjelinek while (isspace(*unitp) != 0) 39410209230bSgjelinek ++unitp; 39427c478bd9Sstevel@tonic-gate 39430209230bSgjelinek /* if no units explicitly set, error */ 39440209230bSgjelinek if (unitp == NULL || *unitp == '\0') { 39450209230bSgjelinek scale = 1; 39460209230bSgjelinek } else { 39470209230bSgjelinek int i; 39480209230bSgjelinek char *units[] = {"K", "M", "G", "T", NULL}; 39497c478bd9Sstevel@tonic-gate 39500209230bSgjelinek scale = 1024; 39510209230bSgjelinek 39520209230bSgjelinek /* update scale based on units */ 39530209230bSgjelinek for (i = 0; units[i] != NULL; i++) { 39540209230bSgjelinek if (strcasecmp(unitp, units[i]) == 0) 39550209230bSgjelinek break; 39560209230bSgjelinek scale <<= 10; 39570209230bSgjelinek } 39580209230bSgjelinek 39590209230bSgjelinek if (units[i] == NULL) 39600209230bSgjelinek return (-1); 39617c478bd9Sstevel@tonic-gate } 39627c478bd9Sstevel@tonic-gate 39630209230bSgjelinek *bytes = (uint64_t)(val * scale); 39640209230bSgjelinek return (0); 39657c478bd9Sstevel@tonic-gate } 39667c478bd9Sstevel@tonic-gate 39670209230bSgjelinek boolean_t 39680209230bSgjelinek zonecfg_valid_ncpus(char *lowstr, char *highstr) 39697c478bd9Sstevel@tonic-gate { 39700209230bSgjelinek uint64_t low, high; 39717c478bd9Sstevel@tonic-gate 39720209230bSgjelinek if (!valid_uint(lowstr, &low) || !valid_uint(highstr, &high) || 39730209230bSgjelinek low < 1 || low > high) 39740209230bSgjelinek return (B_FALSE); 39750209230bSgjelinek 39760209230bSgjelinek return (B_TRUE); 39777c478bd9Sstevel@tonic-gate } 39787c478bd9Sstevel@tonic-gate 39790209230bSgjelinek boolean_t 39800209230bSgjelinek zonecfg_valid_importance(char *impstr) 39817c478bd9Sstevel@tonic-gate { 39820209230bSgjelinek uint64_t num; 39837c478bd9Sstevel@tonic-gate 39840209230bSgjelinek if (!valid_uint(impstr, &num)) 39850209230bSgjelinek return (B_FALSE); 39867c478bd9Sstevel@tonic-gate 39870209230bSgjelinek return (B_TRUE); 39880209230bSgjelinek } 39897c478bd9Sstevel@tonic-gate 39900209230bSgjelinek boolean_t 39910209230bSgjelinek zonecfg_valid_alias_limit(char *name, char *limitstr, uint64_t *limit) 39920209230bSgjelinek { 39930209230bSgjelinek int i; 39940209230bSgjelinek 39950209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 39960209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 39977c478bd9Sstevel@tonic-gate break; 39987c478bd9Sstevel@tonic-gate 39990209230bSgjelinek if (aliases[i].shortname == NULL) 40000209230bSgjelinek return (B_FALSE); 40017c478bd9Sstevel@tonic-gate 40020209230bSgjelinek if (!valid_uint(limitstr, limit) || *limit < aliases[i].low_limit) 40030209230bSgjelinek return (B_FALSE); 40047c478bd9Sstevel@tonic-gate 40050209230bSgjelinek return (B_TRUE); 40067c478bd9Sstevel@tonic-gate } 40077c478bd9Sstevel@tonic-gate 40080209230bSgjelinek boolean_t 40090209230bSgjelinek zonecfg_valid_memlimit(char *memstr, uint64_t *mem_val) 40107c478bd9Sstevel@tonic-gate { 40110209230bSgjelinek if (zonecfg_str_to_bytes(memstr, mem_val) != 0) 40120209230bSgjelinek return (B_FALSE); 40130209230bSgjelinek 40140209230bSgjelinek return (B_TRUE); 40157c478bd9Sstevel@tonic-gate } 40167c478bd9Sstevel@tonic-gate 40170209230bSgjelinek static int 40180209230bSgjelinek zerr_pool(char *pool_err, int err_size, int res) 40197c478bd9Sstevel@tonic-gate { 40200209230bSgjelinek (void) strlcpy(pool_err, pool_strerror(pool_error()), err_size); 40210209230bSgjelinek return (res); 40227c478bd9Sstevel@tonic-gate } 40237c478bd9Sstevel@tonic-gate 40240209230bSgjelinek static int 40250209230bSgjelinek create_tmp_pset(char *pool_err, int err_size, pool_conf_t *pconf, pool_t *pool, 40260209230bSgjelinek char *name, int min, int max) 40277c478bd9Sstevel@tonic-gate { 40280209230bSgjelinek pool_resource_t *res; 40290209230bSgjelinek pool_elem_t *elem; 40300209230bSgjelinek pool_value_t *val; 40317c478bd9Sstevel@tonic-gate 40320209230bSgjelinek if ((res = pool_resource_create(pconf, "pset", name)) == NULL) 40330209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40347c478bd9Sstevel@tonic-gate 40350209230bSgjelinek if (pool_associate(pconf, pool, res) != PO_SUCCESS) 40360209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40377c478bd9Sstevel@tonic-gate 40380209230bSgjelinek if ((elem = pool_resource_to_elem(pconf, res)) == NULL) 40390209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40407c478bd9Sstevel@tonic-gate 40410209230bSgjelinek if ((val = pool_value_alloc()) == NULL) 40420209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40437c478bd9Sstevel@tonic-gate 40440209230bSgjelinek /* set the maximum number of cpus for the pset */ 40450209230bSgjelinek pool_value_set_uint64(val, (uint64_t)max); 40460209230bSgjelinek 40470209230bSgjelinek if (pool_put_property(pconf, elem, "pset.max", val) != PO_SUCCESS) { 40480209230bSgjelinek pool_value_free(val); 40490209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40507c478bd9Sstevel@tonic-gate } 40517c478bd9Sstevel@tonic-gate 40520209230bSgjelinek /* set the minimum number of cpus for the pset */ 40530209230bSgjelinek pool_value_set_uint64(val, (uint64_t)min); 40540209230bSgjelinek 40550209230bSgjelinek if (pool_put_property(pconf, elem, "pset.min", val) != PO_SUCCESS) { 40560209230bSgjelinek pool_value_free(val); 40570209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 40587c478bd9Sstevel@tonic-gate } 40597c478bd9Sstevel@tonic-gate 40600209230bSgjelinek pool_value_free(val); 40610209230bSgjelinek 40627c478bd9Sstevel@tonic-gate return (Z_OK); 40637c478bd9Sstevel@tonic-gate } 40647c478bd9Sstevel@tonic-gate 40650209230bSgjelinek static int 40660209230bSgjelinek create_tmp_pool(char *pool_err, int err_size, pool_conf_t *pconf, char *name, 40670209230bSgjelinek struct zone_psettab *pset_tab) 40687c478bd9Sstevel@tonic-gate { 40690209230bSgjelinek pool_t *pool; 40700209230bSgjelinek int res = Z_OK; 40717c478bd9Sstevel@tonic-gate 40720209230bSgjelinek /* create a temporary pool configuration */ 40730209230bSgjelinek if (pool_conf_open(pconf, NULL, PO_TEMP) != PO_SUCCESS) { 40740209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 40750209230bSgjelinek return (res); 40760209230bSgjelinek } 4077ffbafc53Scomay 40780209230bSgjelinek if ((pool = pool_create(pconf, name)) == NULL) { 40790209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL_CREATE); 40800209230bSgjelinek goto done; 40810209230bSgjelinek } 4082ffbafc53Scomay 40830209230bSgjelinek /* set pool importance */ 40840209230bSgjelinek if (pset_tab->zone_importance[0] != '\0') { 40850209230bSgjelinek pool_elem_t *elem; 40860209230bSgjelinek pool_value_t *val; 40879acbbeafSnn 40880209230bSgjelinek if ((elem = pool_to_elem(pconf, pool)) == NULL) { 40890209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 40900209230bSgjelinek goto done; 40910209230bSgjelinek } 40929acbbeafSnn 40930209230bSgjelinek if ((val = pool_value_alloc()) == NULL) { 40940209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 40950209230bSgjelinek goto done; 40960209230bSgjelinek } 40979acbbeafSnn 40980209230bSgjelinek pool_value_set_int64(val, 40990209230bSgjelinek (int64_t)atoi(pset_tab->zone_importance)); 41009acbbeafSnn 41010209230bSgjelinek if (pool_put_property(pconf, elem, "pool.importance", val) 41020209230bSgjelinek != PO_SUCCESS) { 41030209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41040209230bSgjelinek pool_value_free(val); 41050209230bSgjelinek goto done; 41060209230bSgjelinek } 41079acbbeafSnn 41080209230bSgjelinek pool_value_free(val); 41099acbbeafSnn } 41109acbbeafSnn 41110209230bSgjelinek if ((res = create_tmp_pset(pool_err, err_size, pconf, pool, name, 41120209230bSgjelinek atoi(pset_tab->zone_ncpu_min), 41130209230bSgjelinek atoi(pset_tab->zone_ncpu_max))) != Z_OK) 41140209230bSgjelinek goto done; 41150209230bSgjelinek 41160209230bSgjelinek /* validation */ 41170209230bSgjelinek if (pool_conf_status(pconf) == POF_INVALID) { 41180209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41190209230bSgjelinek goto done; 41209acbbeafSnn } 41219acbbeafSnn 41220209230bSgjelinek /* 41230209230bSgjelinek * This validation is the one we expect to fail if the user specified 41240209230bSgjelinek * an invalid configuration (too many cpus) for this system. 41250209230bSgjelinek */ 41260209230bSgjelinek if (pool_conf_validate(pconf, POV_RUNTIME) != PO_SUCCESS) { 41270209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL_CREATE); 41280209230bSgjelinek goto done; 41290209230bSgjelinek } 41309acbbeafSnn 41310209230bSgjelinek /* 41320209230bSgjelinek * Commit the dynamic configuration but not the pool configuration 41330209230bSgjelinek * file. 41340209230bSgjelinek */ 41350209230bSgjelinek if (pool_conf_commit(pconf, 1) != PO_SUCCESS) 41360209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 41379acbbeafSnn 41380209230bSgjelinek done: 41390209230bSgjelinek (void) pool_conf_close(pconf); 41400209230bSgjelinek return (res); 41419acbbeafSnn } 41429acbbeafSnn 41439acbbeafSnn static int 41440209230bSgjelinek get_running_tmp_pset(pool_conf_t *pconf, pool_t *pool, pool_resource_t *pset, 41450209230bSgjelinek struct zone_psettab *pset_tab) 41460209230bSgjelinek { 41470209230bSgjelinek int nfound = 0; 41480209230bSgjelinek pool_elem_t *pe; 41490209230bSgjelinek pool_value_t *pv = pool_value_alloc(); 41500209230bSgjelinek uint64_t val_uint; 41510209230bSgjelinek 41520209230bSgjelinek if (pool != NULL) { 41530209230bSgjelinek pe = pool_to_elem(pconf, pool); 41540209230bSgjelinek if (pool_get_property(pconf, pe, "pool.importance", pv) 41550209230bSgjelinek != POC_INVAL) { 41560209230bSgjelinek int64_t val_int; 41570209230bSgjelinek 41580209230bSgjelinek (void) pool_value_get_int64(pv, &val_int); 41590209230bSgjelinek (void) snprintf(pset_tab->zone_importance, 41600209230bSgjelinek sizeof (pset_tab->zone_importance), "%d", val_int); 41610209230bSgjelinek nfound++; 41620209230bSgjelinek } 41639acbbeafSnn } 41649acbbeafSnn 41650209230bSgjelinek if (pset != NULL) { 41660209230bSgjelinek pe = pool_resource_to_elem(pconf, pset); 41670209230bSgjelinek if (pool_get_property(pconf, pe, "pset.min", pv) != POC_INVAL) { 41680209230bSgjelinek (void) pool_value_get_uint64(pv, &val_uint); 41690209230bSgjelinek (void) snprintf(pset_tab->zone_ncpu_min, 41700209230bSgjelinek sizeof (pset_tab->zone_ncpu_min), "%u", val_uint); 41710209230bSgjelinek nfound++; 41720209230bSgjelinek } 41739acbbeafSnn 41740209230bSgjelinek if (pool_get_property(pconf, pe, "pset.max", pv) != POC_INVAL) { 41750209230bSgjelinek (void) pool_value_get_uint64(pv, &val_uint); 41760209230bSgjelinek (void) snprintf(pset_tab->zone_ncpu_max, 41770209230bSgjelinek sizeof (pset_tab->zone_ncpu_max), "%u", val_uint); 41780209230bSgjelinek nfound++; 41790209230bSgjelinek } 41809acbbeafSnn } 41819acbbeafSnn 41820209230bSgjelinek pool_value_free(pv); 41839acbbeafSnn 41840209230bSgjelinek if (nfound == 3) 41850209230bSgjelinek return (PO_SUCCESS); 41860209230bSgjelinek 41870209230bSgjelinek return (PO_FAIL); 41889acbbeafSnn } 41899acbbeafSnn 41900209230bSgjelinek /* 41910209230bSgjelinek * Determine if a tmp pool is configured and if so, if the configuration is 41920209230bSgjelinek * still valid or if it has been changed since the tmp pool was created. 41930209230bSgjelinek * If the tmp pool configuration is no longer valid, delete the tmp pool. 41940209230bSgjelinek * 41950209230bSgjelinek * Set *valid=B_TRUE if there is an existing, valid tmp pool configuration. 41960209230bSgjelinek */ 41979acbbeafSnn static int 41980209230bSgjelinek verify_del_tmp_pool(pool_conf_t *pconf, char *tmp_name, char *pool_err, 41990209230bSgjelinek int err_size, struct zone_psettab *pset_tab, boolean_t *exists) 42009acbbeafSnn { 42010209230bSgjelinek int res = Z_OK; 42020209230bSgjelinek pool_t *pool; 42030209230bSgjelinek pool_resource_t *pset; 42040209230bSgjelinek struct zone_psettab pset_current; 42057c478bd9Sstevel@tonic-gate 42060209230bSgjelinek *exists = B_FALSE; 42077c478bd9Sstevel@tonic-gate 42080209230bSgjelinek if (pool_conf_open(pconf, pool_dynamic_location(), PO_RDWR) 42090209230bSgjelinek != PO_SUCCESS) { 42100209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42110209230bSgjelinek return (res); 42120209230bSgjelinek } 42137c478bd9Sstevel@tonic-gate 42140209230bSgjelinek pool = pool_get_pool(pconf, tmp_name); 42150209230bSgjelinek pset = pool_get_resource(pconf, "pset", tmp_name); 42160209230bSgjelinek 42170209230bSgjelinek if (pool == NULL && pset == NULL) { 42180209230bSgjelinek /* no tmp pool configured */ 42190209230bSgjelinek goto done; 42207c478bd9Sstevel@tonic-gate } 42219acbbeafSnn 42220209230bSgjelinek /* 42230209230bSgjelinek * If an existing tmp pool for this zone is configured with the proper 42240209230bSgjelinek * settings, then the tmp pool is valid. 42250209230bSgjelinek */ 42260209230bSgjelinek if (get_running_tmp_pset(pconf, pool, pset, &pset_current) 42270209230bSgjelinek == PO_SUCCESS && 42280209230bSgjelinek strcmp(pset_tab->zone_ncpu_min, 42290209230bSgjelinek pset_current.zone_ncpu_min) == 0 && 42300209230bSgjelinek strcmp(pset_tab->zone_ncpu_max, 42310209230bSgjelinek pset_current.zone_ncpu_max) == 0 && 42320209230bSgjelinek strcmp(pset_tab->zone_importance, 42330209230bSgjelinek pset_current.zone_importance) == 0) { 42340209230bSgjelinek *exists = B_TRUE; 42357c478bd9Sstevel@tonic-gate 42360209230bSgjelinek } else { 42370209230bSgjelinek /* 42380209230bSgjelinek * An out-of-date tmp pool configuration exists. Delete it 42390209230bSgjelinek * so that we can create the correct tmp pool config. 42400209230bSgjelinek */ 42410209230bSgjelinek if (pset != NULL && 42420209230bSgjelinek pool_resource_destroy(pconf, pset) != PO_SUCCESS) { 42430209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42440209230bSgjelinek goto done; 42450209230bSgjelinek } 42469acbbeafSnn 42470209230bSgjelinek if (pool != NULL && 42480209230bSgjelinek pool_destroy(pconf, pool) != PO_SUCCESS) { 42490209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42500209230bSgjelinek goto done; 42510209230bSgjelinek } 42529acbbeafSnn 42530209230bSgjelinek /* commit dynamic config */ 42540209230bSgjelinek if (pool_conf_commit(pconf, 0) != PO_SUCCESS) 42550209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42560209230bSgjelinek } 42570209230bSgjelinek 42580209230bSgjelinek done: 42590209230bSgjelinek (void) pool_conf_close(pconf); 42600209230bSgjelinek 42610209230bSgjelinek return (res); 4262ffbafc53Scomay } 4263ffbafc53Scomay 4264ffbafc53Scomay /* 42650209230bSgjelinek * Destroy any existing tmp pool. 4266ffbafc53Scomay */ 42670209230bSgjelinek int 42680209230bSgjelinek zonecfg_destroy_tmp_pool(char *zone_name, char *pool_err, int err_size) 4269ffbafc53Scomay { 42700209230bSgjelinek int status; 42710209230bSgjelinek int res = Z_OK; 42720209230bSgjelinek pool_conf_t *pconf; 42730209230bSgjelinek pool_t *pool; 42740209230bSgjelinek pool_resource_t *pset; 42750209230bSgjelinek char tmp_name[MAX_TMP_POOL_NAME]; 4276ffbafc53Scomay 42770209230bSgjelinek /* if pools not enabled then nothing to do */ 42780209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) 42790209230bSgjelinek return (Z_OK); 4280ffbafc53Scomay 42810209230bSgjelinek if ((pconf = pool_conf_alloc()) == NULL) 42820209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 42839acbbeafSnn 42840209230bSgjelinek (void) snprintf(tmp_name, sizeof (tmp_name), TMP_POOL_NAME, zone_name); 4285ffbafc53Scomay 42860209230bSgjelinek if (pool_conf_open(pconf, pool_dynamic_location(), PO_RDWR) 42870209230bSgjelinek != PO_SUCCESS) { 42880209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 42890209230bSgjelinek pool_conf_free(pconf); 42900209230bSgjelinek return (res); 4291ffbafc53Scomay } 4292ffbafc53Scomay 42930209230bSgjelinek pool = pool_get_pool(pconf, tmp_name); 42940209230bSgjelinek pset = pool_get_resource(pconf, "pset", tmp_name); 4295ffbafc53Scomay 42960209230bSgjelinek if (pool == NULL && pset == NULL) { 42970209230bSgjelinek /* nothing to destroy, we're done */ 42980209230bSgjelinek goto done; 4299ffbafc53Scomay } 4300ffbafc53Scomay 43010209230bSgjelinek if (pset != NULL && pool_resource_destroy(pconf, pset) != PO_SUCCESS) { 43020209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43030209230bSgjelinek goto done; 4304ffbafc53Scomay } 4305ffbafc53Scomay 43060209230bSgjelinek if (pool != NULL && pool_destroy(pconf, pool) != PO_SUCCESS) { 43070209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43080209230bSgjelinek goto done; 4309ffbafc53Scomay } 4310ffbafc53Scomay 43110209230bSgjelinek /* commit dynamic config */ 43120209230bSgjelinek if (pool_conf_commit(pconf, 0) != PO_SUCCESS) 43130209230bSgjelinek res = zerr_pool(pool_err, err_size, Z_POOL); 43140209230bSgjelinek 43150209230bSgjelinek done: 43160209230bSgjelinek (void) pool_conf_close(pconf); 43170209230bSgjelinek pool_conf_free(pconf); 43180209230bSgjelinek 43190209230bSgjelinek return (res); 4320ffbafc53Scomay } 4321ffbafc53Scomay 4322ffbafc53Scomay /* 43230209230bSgjelinek * Attempt to bind to a tmp pool for this zone. If there is no tmp pool 43240209230bSgjelinek * configured, we just return Z_OK. 4325ffbafc53Scomay * 43260209230bSgjelinek * We either attempt to create the tmp pool for this zone or rebind to an 43270209230bSgjelinek * existing tmp pool for this zone. 43280209230bSgjelinek * 43290209230bSgjelinek * Rebinding is used when a zone with a tmp pool reboots so that we don't have 43300209230bSgjelinek * to recreate the tmp pool. To do this we need to be sure we work correctly 43310209230bSgjelinek * for the following cases: 43320209230bSgjelinek * 43330209230bSgjelinek * - there is an existing, properly configured tmp pool. 43340209230bSgjelinek * - zonecfg added tmp pool after zone was booted, must now create. 43350209230bSgjelinek * - zonecfg updated tmp pool config after zone was booted, in this case 43360209230bSgjelinek * we destroy the old tmp pool and create a new one. 4337ffbafc53Scomay */ 4338ffbafc53Scomay int 43390209230bSgjelinek zonecfg_bind_tmp_pool(zone_dochandle_t handle, zoneid_t zoneid, char *pool_err, 43400209230bSgjelinek int err_size) 4341ffbafc53Scomay { 43420209230bSgjelinek struct zone_psettab pset_tab; 43430209230bSgjelinek int err; 43440209230bSgjelinek int status; 43450209230bSgjelinek pool_conf_t *pconf; 43460209230bSgjelinek boolean_t exists; 43470209230bSgjelinek char zone_name[ZONENAME_MAX]; 43480209230bSgjelinek char tmp_name[MAX_TMP_POOL_NAME]; 43490209230bSgjelinek 43500209230bSgjelinek (void) getzonenamebyid(zoneid, zone_name, sizeof (zone_name)); 43510209230bSgjelinek 43520209230bSgjelinek err = zonecfg_lookup_pset(handle, &pset_tab); 43530209230bSgjelinek 43540209230bSgjelinek /* if no temporary pool configured, we're done */ 43550209230bSgjelinek if (err == Z_NO_ENTRY) 43560209230bSgjelinek return (Z_OK); 4357ffbafc53Scomay 4358ffbafc53Scomay /* 43590209230bSgjelinek * importance might not have a value but we need to validate it here, 43600209230bSgjelinek * so set the default. 4361ffbafc53Scomay */ 43620209230bSgjelinek if (pset_tab.zone_importance[0] == '\0') 43630209230bSgjelinek (void) strlcpy(pset_tab.zone_importance, "1", 43640209230bSgjelinek sizeof (pset_tab.zone_importance)); 43659acbbeafSnn 43660209230bSgjelinek /* if pools not enabled, enable them now */ 43670209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) { 43680209230bSgjelinek if (pool_set_status(POOL_ENABLED) != PO_SUCCESS) 43690209230bSgjelinek return (Z_POOL_ENABLE); 4370ffbafc53Scomay } 4371ffbafc53Scomay 43720209230bSgjelinek if ((pconf = pool_conf_alloc()) == NULL) 43730209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 43740209230bSgjelinek 43750209230bSgjelinek (void) snprintf(tmp_name, sizeof (tmp_name), TMP_POOL_NAME, zone_name); 43760209230bSgjelinek 4377ffbafc53Scomay /* 43780209230bSgjelinek * Check if a valid tmp pool/pset already exists. If so, we just 43790209230bSgjelinek * reuse it. 4380ffbafc53Scomay */ 43810209230bSgjelinek if ((err = verify_del_tmp_pool(pconf, tmp_name, pool_err, err_size, 43820209230bSgjelinek &pset_tab, &exists)) != Z_OK) { 43830209230bSgjelinek pool_conf_free(pconf); 43840209230bSgjelinek return (err); 43850209230bSgjelinek } 4386ffbafc53Scomay 43870209230bSgjelinek if (!exists) 43880209230bSgjelinek err = create_tmp_pool(pool_err, err_size, pconf, tmp_name, 43890209230bSgjelinek &pset_tab); 43900209230bSgjelinek 43910209230bSgjelinek pool_conf_free(pconf); 43920209230bSgjelinek 43930209230bSgjelinek if (err != Z_OK) 43940209230bSgjelinek return (err); 43950209230bSgjelinek 43960209230bSgjelinek /* Bind the zone to the pool. */ 43970209230bSgjelinek if (pool_set_binding(tmp_name, P_ZONEID, zoneid) != PO_SUCCESS) 43980209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL_BIND)); 43990209230bSgjelinek 44000209230bSgjelinek return (Z_OK); 4401ffbafc53Scomay } 4402ffbafc53Scomay 44030209230bSgjelinek /* 44040209230bSgjelinek * Attempt to bind to a permanent pool for this zone. If there is no 44050209230bSgjelinek * permanent pool configured, we just return Z_OK. 44060209230bSgjelinek */ 44077c478bd9Sstevel@tonic-gate int 44080209230bSgjelinek zonecfg_bind_pool(zone_dochandle_t handle, zoneid_t zoneid, char *pool_err, 44090209230bSgjelinek int err_size) 44107c478bd9Sstevel@tonic-gate { 44110209230bSgjelinek pool_conf_t *poolconf; 44120209230bSgjelinek pool_t *pool; 44130209230bSgjelinek char poolname[MAXPATHLEN]; 44140209230bSgjelinek int status; 44150209230bSgjelinek int error; 4416108322fbScarlsonj 44170209230bSgjelinek /* 44180209230bSgjelinek * Find the pool mentioned in the zone configuration, and bind to it. 44190209230bSgjelinek */ 44200209230bSgjelinek error = zonecfg_get_pool(handle, poolname, sizeof (poolname)); 44210209230bSgjelinek if (error == Z_NO_ENTRY || (error == Z_OK && strlen(poolname) == 0)) { 44220209230bSgjelinek /* 44230209230bSgjelinek * The property is not set on the zone, so the pool 44240209230bSgjelinek * should be bound to the default pool. But that's 44250209230bSgjelinek * already done by the kernel, so we can just return. 44260209230bSgjelinek */ 44277c478bd9Sstevel@tonic-gate return (Z_OK); 44287c478bd9Sstevel@tonic-gate } 44290209230bSgjelinek if (error != Z_OK) { 44300209230bSgjelinek /* 44310209230bSgjelinek * Not an error, even though it shouldn't be happening. 44320209230bSgjelinek */ 44330209230bSgjelinek return (Z_OK); 44340209230bSgjelinek } 44350209230bSgjelinek /* 44360209230bSgjelinek * Don't do anything if pools aren't enabled. 44370209230bSgjelinek */ 44380209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) 44390209230bSgjelinek return (Z_POOLS_NOT_ACTIVE); 44407c478bd9Sstevel@tonic-gate 44417c478bd9Sstevel@tonic-gate /* 44420209230bSgjelinek * Try to provide a sane error message if the requested pool doesn't 44430209230bSgjelinek * exist. 44447c478bd9Sstevel@tonic-gate */ 44450209230bSgjelinek if ((poolconf = pool_conf_alloc()) == NULL) 44460209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 44477c478bd9Sstevel@tonic-gate 44480209230bSgjelinek if (pool_conf_open(poolconf, pool_dynamic_location(), PO_RDONLY) != 44490209230bSgjelinek PO_SUCCESS) { 44500209230bSgjelinek pool_conf_free(poolconf); 44510209230bSgjelinek return (zerr_pool(pool_err, err_size, Z_POOL)); 44520209230bSgjelinek } 44530209230bSgjelinek pool = pool_get_pool(poolconf, poolname); 44540209230bSgjelinek (void) pool_conf_close(poolconf); 44550209230bSgjelinek pool_conf_free(poolconf); 44560209230bSgjelinek if (pool == NULL) 44570209230bSgjelinek return (Z_NO_POOL); 44587c478bd9Sstevel@tonic-gate 44597c478bd9Sstevel@tonic-gate /* 44600209230bSgjelinek * Bind the zone to the pool. 44617c478bd9Sstevel@tonic-gate */ 44620209230bSgjelinek if (pool_set_binding(poolname, P_ZONEID, zoneid) != PO_SUCCESS) { 44630209230bSgjelinek /* if bind fails, return poolname for the error msg */ 44640209230bSgjelinek (void) strlcpy(pool_err, poolname, err_size); 44650209230bSgjelinek return (Z_POOL_BIND); 44667c478bd9Sstevel@tonic-gate } 44670209230bSgjelinek 44680209230bSgjelinek return (Z_OK); 44690209230bSgjelinek } 44700209230bSgjelinek 44710dc2366fSVenugopal Iyer int 44720dc2366fSVenugopal Iyer zonecfg_get_poolname(zone_dochandle_t handle, char *zone, char *pool, 44730dc2366fSVenugopal Iyer size_t poolsize) 44740dc2366fSVenugopal Iyer { 44750dc2366fSVenugopal Iyer int err; 44760dc2366fSVenugopal Iyer struct zone_psettab pset_tab; 44770dc2366fSVenugopal Iyer 44780dc2366fSVenugopal Iyer err = zonecfg_lookup_pset(handle, &pset_tab); 44790dc2366fSVenugopal Iyer if ((err != Z_NO_ENTRY) && (err != Z_OK)) 44800dc2366fSVenugopal Iyer return (err); 44810dc2366fSVenugopal Iyer 44820dc2366fSVenugopal Iyer /* pset was found so a temporary pool was created */ 44830dc2366fSVenugopal Iyer if (err == Z_OK) { 44840dc2366fSVenugopal Iyer (void) snprintf(pool, poolsize, TMP_POOL_NAME, zone); 44850dc2366fSVenugopal Iyer return (Z_OK); 44860dc2366fSVenugopal Iyer } 44870dc2366fSVenugopal Iyer 44880dc2366fSVenugopal Iyer /* lookup the poolname in zonecfg */ 44890dc2366fSVenugopal Iyer return (zonecfg_get_pool(handle, pool, poolsize)); 44900dc2366fSVenugopal Iyer } 44910209230bSgjelinek 44920209230bSgjelinek static boolean_t 44930209230bSgjelinek svc_enabled(char *svc_name) 44940209230bSgjelinek { 44950209230bSgjelinek scf_simple_prop_t *prop; 44960209230bSgjelinek boolean_t found = B_FALSE; 44970209230bSgjelinek 44980209230bSgjelinek prop = scf_simple_prop_get(NULL, svc_name, SCF_PG_GENERAL, 44990209230bSgjelinek SCF_PROPERTY_ENABLED); 45000209230bSgjelinek 45010209230bSgjelinek if (scf_simple_prop_numvalues(prop) == 1 && 45020209230bSgjelinek *scf_simple_prop_next_boolean(prop) != 0) 45030209230bSgjelinek found = B_TRUE; 45040209230bSgjelinek 45050209230bSgjelinek scf_simple_prop_free(prop); 45060209230bSgjelinek 45070209230bSgjelinek return (found); 45087c478bd9Sstevel@tonic-gate } 45097c478bd9Sstevel@tonic-gate 45100209230bSgjelinek /* 45110209230bSgjelinek * If the zone has capped-memory, make sure the rcap service is enabled. 45120209230bSgjelinek */ 45137c478bd9Sstevel@tonic-gate int 45140209230bSgjelinek zonecfg_enable_rcapd(char *err, int size) 45157c478bd9Sstevel@tonic-gate { 45160209230bSgjelinek if (!svc_enabled(RCAP_SERVICE) && 45170209230bSgjelinek smf_enable_instance(RCAP_SERVICE, 0) == -1) { 45180209230bSgjelinek (void) strlcpy(err, scf_strerror(scf_error()), size); 45190209230bSgjelinek return (Z_SYSTEM); 45200209230bSgjelinek } 45217c478bd9Sstevel@tonic-gate 45227c478bd9Sstevel@tonic-gate return (Z_OK); 45237c478bd9Sstevel@tonic-gate } 45247c478bd9Sstevel@tonic-gate 45250209230bSgjelinek /* 45260209230bSgjelinek * Return true if pset has cpu range specified and poold is not enabled. 45270209230bSgjelinek */ 45280209230bSgjelinek boolean_t 45290209230bSgjelinek zonecfg_warn_poold(zone_dochandle_t handle) 45309acbbeafSnn { 45310209230bSgjelinek struct zone_psettab pset_tab; 45320209230bSgjelinek int min, max; 45339acbbeafSnn int err; 45349acbbeafSnn 45350209230bSgjelinek err = zonecfg_lookup_pset(handle, &pset_tab); 45360209230bSgjelinek 45370209230bSgjelinek /* if no temporary pool configured, we're done */ 45380209230bSgjelinek if (err == Z_NO_ENTRY) 45390209230bSgjelinek return (B_FALSE); 45400209230bSgjelinek 45410209230bSgjelinek min = atoi(pset_tab.zone_ncpu_min); 45420209230bSgjelinek max = atoi(pset_tab.zone_ncpu_max); 45430209230bSgjelinek 45440209230bSgjelinek /* range not specified, no need for poold */ 45450209230bSgjelinek if (min == max) 45460209230bSgjelinek return (B_FALSE); 45470209230bSgjelinek 45480209230bSgjelinek /* we have a range, check if poold service is enabled */ 45490209230bSgjelinek if (svc_enabled(POOLD_SERVICE)) 45500209230bSgjelinek return (B_FALSE); 45510209230bSgjelinek 45520209230bSgjelinek return (B_TRUE); 45530209230bSgjelinek } 45540209230bSgjelinek 455534eb7836Sjv /* 455634eb7836Sjv * Retrieve the specified pool's thread scheduling class. 'poolname' must 455734eb7836Sjv * refer to the name of a configured resource pool. The thread scheduling 455834eb7836Sjv * class specified by the pool will be stored in the buffer to which 'class' 455934eb7836Sjv * points. 'clsize' is the byte size of the buffer to which 'class' points. 456034eb7836Sjv * 456134eb7836Sjv * This function returns Z_OK if it successfully stored the specified pool's 456234eb7836Sjv * thread scheduling class into the buffer to which 'class' points. It returns 456334eb7836Sjv * Z_NO_POOL if resource pools are not enabled, the function is unable to 456434eb7836Sjv * access the system's resource pools configuration, or the specified pool 456534eb7836Sjv * does not exist. The function returns Z_TOO_BIG if the buffer to which 456634eb7836Sjv * 'class' points is not large enough to contain the thread scheduling class' 456734eb7836Sjv * name. The function returns Z_NO_ENTRY if the pool does not specify a thread 456834eb7836Sjv * scheduling class. 456934eb7836Sjv */ 45700209230bSgjelinek static int 45710209230bSgjelinek get_pool_sched_class(char *poolname, char *class, int clsize) 45720209230bSgjelinek { 45730209230bSgjelinek int status; 45740209230bSgjelinek pool_conf_t *poolconf; 45750209230bSgjelinek pool_t *pool; 45760209230bSgjelinek pool_elem_t *pe; 45770209230bSgjelinek pool_value_t *pv = pool_value_alloc(); 45780209230bSgjelinek const char *sched_str; 45790209230bSgjelinek 45800209230bSgjelinek if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) 45810209230bSgjelinek return (Z_NO_POOL); 45820209230bSgjelinek 45830209230bSgjelinek if ((poolconf = pool_conf_alloc()) == NULL) 45840209230bSgjelinek return (Z_NO_POOL); 45850209230bSgjelinek 45860209230bSgjelinek if (pool_conf_open(poolconf, pool_dynamic_location(), PO_RDONLY) != 45870209230bSgjelinek PO_SUCCESS) { 45880209230bSgjelinek pool_conf_free(poolconf); 45890209230bSgjelinek return (Z_NO_POOL); 45909acbbeafSnn } 45919acbbeafSnn 45920209230bSgjelinek if ((pool = pool_get_pool(poolconf, poolname)) == NULL) { 45930209230bSgjelinek (void) pool_conf_close(poolconf); 45940209230bSgjelinek pool_conf_free(poolconf); 45950209230bSgjelinek return (Z_NO_POOL); 45969acbbeafSnn } 45979acbbeafSnn 45980209230bSgjelinek pe = pool_to_elem(poolconf, pool); 459934eb7836Sjv if (pool_get_property(poolconf, pe, "pool.scheduler", pv) != 460034eb7836Sjv POC_STRING) { 460134eb7836Sjv (void) pool_conf_close(poolconf); 460234eb7836Sjv pool_conf_free(poolconf); 460334eb7836Sjv return (Z_NO_ENTRY); 46040209230bSgjelinek } 460534eb7836Sjv (void) pool_value_get_string(pv, &sched_str); 46060209230bSgjelinek (void) pool_conf_close(poolconf); 46070209230bSgjelinek pool_conf_free(poolconf); 460834eb7836Sjv if (strlcpy(class, sched_str, clsize) >= clsize) 460934eb7836Sjv return (Z_TOO_BIG); 46100209230bSgjelinek return (Z_OK); 46119acbbeafSnn } 46129acbbeafSnn 4613facf4a8dSllai /* 46140209230bSgjelinek * Get the default scheduling class for the zone. This will either be the 46150209230bSgjelinek * class set on the zone's pool or the system default scheduling class. 4616facf4a8dSllai */ 4617facf4a8dSllai int 46180209230bSgjelinek zonecfg_get_dflt_sched_class(zone_dochandle_t handle, char *class, int clsize) 4619facf4a8dSllai { 46200209230bSgjelinek char poolname[MAXPATHLEN]; 4621facf4a8dSllai 46220209230bSgjelinek if (zonecfg_get_pool(handle, poolname, sizeof (poolname)) == Z_OK) { 46230209230bSgjelinek /* check if the zone's pool specified a sched class */ 46240209230bSgjelinek if (get_pool_sched_class(poolname, class, clsize) == Z_OK) 46250209230bSgjelinek return (Z_OK); 46260209230bSgjelinek } 4627facf4a8dSllai 46280209230bSgjelinek if (priocntl(0, 0, PC_GETDFLCL, class, (uint64_t)clsize) == -1) 4629facf4a8dSllai return (Z_TOO_BIG); 46300209230bSgjelinek 4631facf4a8dSllai return (Z_OK); 4632facf4a8dSllai } 4633facf4a8dSllai 46340209230bSgjelinek int 46350209230bSgjelinek zonecfg_setfsent(zone_dochandle_t handle) 46367c478bd9Sstevel@tonic-gate { 46370209230bSgjelinek return (zonecfg_setent(handle)); 46387c478bd9Sstevel@tonic-gate } 46397c478bd9Sstevel@tonic-gate 46407c478bd9Sstevel@tonic-gate int 46410209230bSgjelinek zonecfg_getfsent(zone_dochandle_t handle, struct zone_fstab *tabptr) 46427c478bd9Sstevel@tonic-gate { 46430209230bSgjelinek xmlNodePtr cur, options; 46440209230bSgjelinek char options_str[MAX_MNTOPT_STR]; 46450209230bSgjelinek int err; 46467c478bd9Sstevel@tonic-gate 46470209230bSgjelinek if (handle == NULL) 46487c478bd9Sstevel@tonic-gate return (Z_INVAL); 46497c478bd9Sstevel@tonic-gate 46500209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 46510209230bSgjelinek return (Z_NO_ENTRY); 46520209230bSgjelinek 46530209230bSgjelinek for (; cur != NULL; cur = cur->next) 46540209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_FS)) 46550209230bSgjelinek break; 46560209230bSgjelinek if (cur == NULL) { 46570209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 46580209230bSgjelinek return (Z_NO_ENTRY); 4659108322fbScarlsonj } 4660108322fbScarlsonj 46610209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_SPECIAL, tabptr->zone_fs_special, 46620209230bSgjelinek sizeof (tabptr->zone_fs_special))) != Z_OK) { 46630209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 46640209230bSgjelinek return (err); 46657c478bd9Sstevel@tonic-gate } 46667c478bd9Sstevel@tonic-gate 46670209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_RAW, tabptr->zone_fs_raw, 46680209230bSgjelinek sizeof (tabptr->zone_fs_raw))) != Z_OK) { 46690209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 46700209230bSgjelinek return (err); 46710209230bSgjelinek } 46720209230bSgjelinek 46730209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_DIR, tabptr->zone_fs_dir, 46740209230bSgjelinek sizeof (tabptr->zone_fs_dir))) != Z_OK) { 46750209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 46760209230bSgjelinek return (err); 46770209230bSgjelinek } 46780209230bSgjelinek 46790209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_fs_type, 46800209230bSgjelinek sizeof (tabptr->zone_fs_type))) != Z_OK) { 46810209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 46820209230bSgjelinek return (err); 46830209230bSgjelinek } 46840209230bSgjelinek 46850209230bSgjelinek /* OK for options to be NULL */ 46860209230bSgjelinek tabptr->zone_fs_options = NULL; 46870209230bSgjelinek for (options = cur->xmlChildrenNode; options != NULL; 46880209230bSgjelinek options = options->next) { 46890209230bSgjelinek if (fetchprop(options, DTD_ATTR_NAME, options_str, 46900209230bSgjelinek sizeof (options_str)) != Z_OK) 46910209230bSgjelinek break; 46920209230bSgjelinek if (zonecfg_add_fs_option(tabptr, options_str) != Z_OK) 46937c478bd9Sstevel@tonic-gate break; 46947c478bd9Sstevel@tonic-gate } 46950209230bSgjelinek 46960209230bSgjelinek handle->zone_dh_cur = cur->next; 46970209230bSgjelinek return (Z_OK); 46987c478bd9Sstevel@tonic-gate } 46997c478bd9Sstevel@tonic-gate 47007c478bd9Sstevel@tonic-gate int 47010209230bSgjelinek zonecfg_endfsent(zone_dochandle_t handle) 47027c478bd9Sstevel@tonic-gate { 47030209230bSgjelinek return (zonecfg_endent(handle)); 47047c478bd9Sstevel@tonic-gate } 47057c478bd9Sstevel@tonic-gate 4706108322fbScarlsonj int 47070209230bSgjelinek zonecfg_setnwifent(zone_dochandle_t handle) 4708108322fbScarlsonj { 47090209230bSgjelinek return (zonecfg_setent(handle)); 4710108322fbScarlsonj } 4711108322fbScarlsonj 4712108322fbScarlsonj int 47130209230bSgjelinek zonecfg_getnwifent(zone_dochandle_t handle, struct zone_nwiftab *tabptr) 4714108322fbScarlsonj { 47150209230bSgjelinek xmlNodePtr cur; 47160209230bSgjelinek int err; 4717108322fbScarlsonj 47180209230bSgjelinek if (handle == NULL) 47190209230bSgjelinek return (Z_INVAL); 47200209230bSgjelinek 47210209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 47220209230bSgjelinek return (Z_NO_ENTRY); 47230209230bSgjelinek 47240209230bSgjelinek for (; cur != NULL; cur = cur->next) 47250209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_NET)) 4726108322fbScarlsonj break; 47270209230bSgjelinek if (cur == NULL) { 47280209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47290209230bSgjelinek return (Z_NO_ENTRY); 4730108322fbScarlsonj } 47310209230bSgjelinek 47320209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_ADDRESS, tabptr->zone_nwif_address, 47330209230bSgjelinek sizeof (tabptr->zone_nwif_address))) != Z_OK) { 47340209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47350209230bSgjelinek return (err); 47360209230bSgjelinek } 47370209230bSgjelinek 4738550b6e40SSowmini Varadhan if ((err = fetchprop(cur, DTD_ATTR_ALLOWED_ADDRESS, 4739550b6e40SSowmini Varadhan tabptr->zone_nwif_allowed_address, 4740550b6e40SSowmini Varadhan sizeof (tabptr->zone_nwif_allowed_address))) != Z_OK) { 4741550b6e40SSowmini Varadhan handle->zone_dh_cur = handle->zone_dh_top; 4742550b6e40SSowmini Varadhan return (err); 4743550b6e40SSowmini Varadhan } 4744550b6e40SSowmini Varadhan 47450209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_PHYSICAL, tabptr->zone_nwif_physical, 47460209230bSgjelinek sizeof (tabptr->zone_nwif_physical))) != Z_OK) { 47470209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 4748de860bd9Sgfaden return (err); 4749de860bd9Sgfaden } 4750de860bd9Sgfaden 4751de860bd9Sgfaden if ((err = fetchprop(cur, DTD_ATTR_DEFROUTER, 4752de860bd9Sgfaden tabptr->zone_nwif_defrouter, 4753de860bd9Sgfaden sizeof (tabptr->zone_nwif_defrouter))) != Z_OK) { 4754de860bd9Sgfaden handle->zone_dh_cur = handle->zone_dh_top; 47550209230bSgjelinek return (err); 4756108322fbScarlsonj } 47570209230bSgjelinek 47580209230bSgjelinek handle->zone_dh_cur = cur->next; 47590209230bSgjelinek return (Z_OK); 4760108322fbScarlsonj } 4761108322fbScarlsonj 47620209230bSgjelinek int 47630209230bSgjelinek zonecfg_endnwifent(zone_dochandle_t handle) 47647c478bd9Sstevel@tonic-gate { 47650209230bSgjelinek return (zonecfg_endent(handle)); 47667c478bd9Sstevel@tonic-gate } 47677c478bd9Sstevel@tonic-gate 47680209230bSgjelinek int 47690209230bSgjelinek zonecfg_setdevent(zone_dochandle_t handle) 47700209230bSgjelinek { 47710209230bSgjelinek return (zonecfg_setent(handle)); 47720209230bSgjelinek } 47737c478bd9Sstevel@tonic-gate 47747c478bd9Sstevel@tonic-gate int 47750209230bSgjelinek zonecfg_getdevent(zone_dochandle_t handle, struct zone_devtab *tabptr) 47767c478bd9Sstevel@tonic-gate { 47770209230bSgjelinek xmlNodePtr cur; 47780209230bSgjelinek int err; 47797c478bd9Sstevel@tonic-gate 47800209230bSgjelinek if (handle == NULL) 47817c478bd9Sstevel@tonic-gate return (Z_INVAL); 47827c478bd9Sstevel@tonic-gate 47830209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 47840209230bSgjelinek return (Z_NO_ENTRY); 47850209230bSgjelinek 47860209230bSgjelinek for (; cur != NULL; cur = cur->next) 47870209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_DEVICE)) 47880209230bSgjelinek break; 47890209230bSgjelinek if (cur == NULL) { 47900209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47910209230bSgjelinek return (Z_NO_ENTRY); 47927c478bd9Sstevel@tonic-gate } 47937c478bd9Sstevel@tonic-gate 47940209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_MATCH, tabptr->zone_dev_match, 47950209230bSgjelinek sizeof (tabptr->zone_dev_match))) != Z_OK) { 47960209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 47970209230bSgjelinek return (err); 47987c478bd9Sstevel@tonic-gate } 47990209230bSgjelinek 48000209230bSgjelinek handle->zone_dh_cur = cur->next; 48017c478bd9Sstevel@tonic-gate return (Z_OK); 48027c478bd9Sstevel@tonic-gate } 48037c478bd9Sstevel@tonic-gate 48040209230bSgjelinek int 48050209230bSgjelinek zonecfg_enddevent(zone_dochandle_t handle) 48067c478bd9Sstevel@tonic-gate { 48070209230bSgjelinek return (zonecfg_endent(handle)); 48080209230bSgjelinek } 48097c478bd9Sstevel@tonic-gate 48100209230bSgjelinek int 48110209230bSgjelinek zonecfg_setrctlent(zone_dochandle_t handle) 48120209230bSgjelinek { 48130209230bSgjelinek return (zonecfg_setent(handle)); 48140209230bSgjelinek } 48150209230bSgjelinek 48160209230bSgjelinek int 48170209230bSgjelinek zonecfg_getrctlent(zone_dochandle_t handle, struct zone_rctltab *tabptr) 48180209230bSgjelinek { 48190209230bSgjelinek xmlNodePtr cur, val; 48200209230bSgjelinek struct zone_rctlvaltab *valptr; 48210209230bSgjelinek int err; 48220209230bSgjelinek 48230209230bSgjelinek if (handle == NULL) 48240209230bSgjelinek return (Z_INVAL); 48250209230bSgjelinek 48260209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 48270209230bSgjelinek return (Z_NO_ENTRY); 48280209230bSgjelinek 48290209230bSgjelinek for (; cur != NULL; cur = cur->next) 48300209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_RCTL)) 48310209230bSgjelinek break; 48320209230bSgjelinek if (cur == NULL) { 48330209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48340209230bSgjelinek return (Z_NO_ENTRY); 48350209230bSgjelinek } 48360209230bSgjelinek 48370209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_rctl_name, 48380209230bSgjelinek sizeof (tabptr->zone_rctl_name))) != Z_OK) { 48390209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48400209230bSgjelinek return (err); 48410209230bSgjelinek } 48420209230bSgjelinek 48430209230bSgjelinek tabptr->zone_rctl_valptr = NULL; 48440209230bSgjelinek for (val = cur->xmlChildrenNode; val != NULL; val = val->next) { 48450209230bSgjelinek valptr = (struct zone_rctlvaltab *)malloc( 48460209230bSgjelinek sizeof (struct zone_rctlvaltab)); 48470209230bSgjelinek if (valptr == NULL) 48480209230bSgjelinek return (Z_NOMEM); 48490209230bSgjelinek if (fetchprop(val, DTD_ATTR_PRIV, valptr->zone_rctlval_priv, 48500209230bSgjelinek sizeof (valptr->zone_rctlval_priv)) != Z_OK) 48510209230bSgjelinek break; 48520209230bSgjelinek if (fetchprop(val, DTD_ATTR_LIMIT, valptr->zone_rctlval_limit, 48530209230bSgjelinek sizeof (valptr->zone_rctlval_limit)) != Z_OK) 48540209230bSgjelinek break; 48550209230bSgjelinek if (fetchprop(val, DTD_ATTR_ACTION, valptr->zone_rctlval_action, 48560209230bSgjelinek sizeof (valptr->zone_rctlval_action)) != Z_OK) 48570209230bSgjelinek break; 48580209230bSgjelinek if (zonecfg_add_rctl_value(tabptr, valptr) != Z_OK) 48590209230bSgjelinek break; 48600209230bSgjelinek } 48610209230bSgjelinek 48620209230bSgjelinek handle->zone_dh_cur = cur->next; 48630209230bSgjelinek return (Z_OK); 48640209230bSgjelinek } 48650209230bSgjelinek 48660209230bSgjelinek int 48670209230bSgjelinek zonecfg_endrctlent(zone_dochandle_t handle) 48680209230bSgjelinek { 48690209230bSgjelinek return (zonecfg_endent(handle)); 48700209230bSgjelinek } 48710209230bSgjelinek 48720209230bSgjelinek int 48730209230bSgjelinek zonecfg_setattrent(zone_dochandle_t handle) 48740209230bSgjelinek { 48750209230bSgjelinek return (zonecfg_setent(handle)); 48760209230bSgjelinek } 48770209230bSgjelinek 48780209230bSgjelinek int 48790209230bSgjelinek zonecfg_getattrent(zone_dochandle_t handle, struct zone_attrtab *tabptr) 48800209230bSgjelinek { 48810209230bSgjelinek xmlNodePtr cur; 48820209230bSgjelinek int err; 48830209230bSgjelinek 48840209230bSgjelinek if (handle == NULL) 48850209230bSgjelinek return (Z_INVAL); 48860209230bSgjelinek 48870209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 48880209230bSgjelinek return (Z_NO_ENTRY); 48890209230bSgjelinek 48900209230bSgjelinek for (; cur != NULL; cur = cur->next) 48910209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_ATTR)) 48920209230bSgjelinek break; 48930209230bSgjelinek if (cur == NULL) { 48940209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 48950209230bSgjelinek return (Z_NO_ENTRY); 48960209230bSgjelinek } 48970209230bSgjelinek 48980209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_attr_name, 48990209230bSgjelinek sizeof (tabptr->zone_attr_name))) != Z_OK) { 49000209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49010209230bSgjelinek return (err); 49020209230bSgjelinek } 49030209230bSgjelinek 49040209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_TYPE, tabptr->zone_attr_type, 49050209230bSgjelinek sizeof (tabptr->zone_attr_type))) != Z_OK) { 49060209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49070209230bSgjelinek return (err); 49080209230bSgjelinek } 49090209230bSgjelinek 49100209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_VALUE, tabptr->zone_attr_value, 49110209230bSgjelinek sizeof (tabptr->zone_attr_value))) != Z_OK) { 49120209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 49130209230bSgjelinek return (err); 49140209230bSgjelinek } 49150209230bSgjelinek 49160209230bSgjelinek handle->zone_dh_cur = cur->next; 49170209230bSgjelinek return (Z_OK); 49180209230bSgjelinek } 49190209230bSgjelinek 49200209230bSgjelinek int 49210209230bSgjelinek zonecfg_endattrent(zone_dochandle_t handle) 49220209230bSgjelinek { 49230209230bSgjelinek return (zonecfg_endent(handle)); 49240209230bSgjelinek } 49250209230bSgjelinek 4926cb8a054bSGlenn Faden int 4927cb8a054bSGlenn Faden zonecfg_setadminent(zone_dochandle_t handle) 4928cb8a054bSGlenn Faden { 4929cb8a054bSGlenn Faden return (zonecfg_setent(handle)); 4930cb8a054bSGlenn Faden } 4931cb8a054bSGlenn Faden 4932cb8a054bSGlenn Faden int 4933cb8a054bSGlenn Faden zonecfg_getadminent(zone_dochandle_t handle, struct zone_admintab *tabptr) 4934cb8a054bSGlenn Faden { 4935cb8a054bSGlenn Faden xmlNodePtr cur; 4936cb8a054bSGlenn Faden int err; 4937cb8a054bSGlenn Faden 4938cb8a054bSGlenn Faden if (handle == NULL) 4939cb8a054bSGlenn Faden return (Z_INVAL); 4940cb8a054bSGlenn Faden 4941cb8a054bSGlenn Faden if ((cur = handle->zone_dh_cur) == NULL) 4942cb8a054bSGlenn Faden return (Z_NO_ENTRY); 4943cb8a054bSGlenn Faden 4944cb8a054bSGlenn Faden for (; cur != NULL; cur = cur->next) 4945cb8a054bSGlenn Faden if (!xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 4946cb8a054bSGlenn Faden break; 4947cb8a054bSGlenn Faden if (cur == NULL) { 4948cb8a054bSGlenn Faden handle->zone_dh_cur = handle->zone_dh_top; 4949cb8a054bSGlenn Faden return (Z_NO_ENTRY); 4950cb8a054bSGlenn Faden } 4951cb8a054bSGlenn Faden 4952cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_USER, tabptr->zone_admin_user, 4953cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_user))) != Z_OK) { 4954cb8a054bSGlenn Faden handle->zone_dh_cur = handle->zone_dh_top; 4955cb8a054bSGlenn Faden return (err); 4956cb8a054bSGlenn Faden } 4957cb8a054bSGlenn Faden 4958cb8a054bSGlenn Faden 4959cb8a054bSGlenn Faden if ((err = fetchprop(cur, DTD_ATTR_AUTHS, tabptr->zone_admin_auths, 4960cb8a054bSGlenn Faden sizeof (tabptr->zone_admin_auths))) != Z_OK) { 4961cb8a054bSGlenn Faden handle->zone_dh_cur = handle->zone_dh_top; 4962cb8a054bSGlenn Faden return (err); 4963cb8a054bSGlenn Faden } 4964cb8a054bSGlenn Faden 4965cb8a054bSGlenn Faden handle->zone_dh_cur = cur->next; 4966cb8a054bSGlenn Faden return (Z_OK); 4967cb8a054bSGlenn Faden } 4968cb8a054bSGlenn Faden 4969cb8a054bSGlenn Faden int 4970cb8a054bSGlenn Faden zonecfg_endadminent(zone_dochandle_t handle) 4971cb8a054bSGlenn Faden { 4972cb8a054bSGlenn Faden return (zonecfg_endent(handle)); 4973cb8a054bSGlenn Faden } 4974cb8a054bSGlenn Faden 49750209230bSgjelinek /* 49760209230bSgjelinek * The privileges available on the system and described in privileges(5) 49770209230bSgjelinek * fall into four categories with respect to non-global zones: 49780209230bSgjelinek * 49790209230bSgjelinek * Default set of privileges considered safe for all non-global 49800209230bSgjelinek * zones. These privileges are "safe" in the sense that a 49810209230bSgjelinek * privileged process in the zone cannot affect processes in any 49820209230bSgjelinek * other zone on the system. 49830209230bSgjelinek * 49840209230bSgjelinek * Set of privileges not currently permitted within a non-global 49850209230bSgjelinek * zone. These privileges are considered by default, "unsafe," 49860209230bSgjelinek * and include ones which affect global resources (such as the 49870209230bSgjelinek * system clock or physical memory) or are overly broad and cover 49880209230bSgjelinek * more than one mechanism in the system. In other cases, there 49890209230bSgjelinek * has not been sufficient virtualization in the parts of the 49900209230bSgjelinek * system the privilege covers to allow its use within a 49910209230bSgjelinek * non-global zone. 49920209230bSgjelinek * 49930209230bSgjelinek * Set of privileges required in order to get a zone booted and 49940209230bSgjelinek * init(1M) started. These cannot be removed from the zone's 49950209230bSgjelinek * privilege set. 49960209230bSgjelinek * 49970209230bSgjelinek * All other privileges are optional and are potentially useful for 49980209230bSgjelinek * processes executing inside a non-global zone. 49990209230bSgjelinek * 50000209230bSgjelinek * When privileges are added to the system, a determination needs to be 50010209230bSgjelinek * made as to which category the privilege belongs to. Ideally, 50020209230bSgjelinek * privileges should be fine-grained enough and the mechanisms they cover 50030209230bSgjelinek * virtualized enough so that they can be made available to non-global 50040209230bSgjelinek * zones. 50050209230bSgjelinek */ 50060209230bSgjelinek 50070209230bSgjelinek /* 50080209230bSgjelinek * Define some of the tokens that priv_str_to_set(3C) recognizes. Since 50090209230bSgjelinek * the privilege string separator can be any character, although it is 50100209230bSgjelinek * usually a comma character, define these here as well in the event that 50110209230bSgjelinek * they change or are augmented in the future. 50120209230bSgjelinek */ 50130209230bSgjelinek #define BASIC_TOKEN "basic" 50140209230bSgjelinek #define DEFAULT_TOKEN "default" 50150209230bSgjelinek #define ZONE_TOKEN "zone" 50160209230bSgjelinek #define TOKEN_PRIV_CHAR ',' 50170209230bSgjelinek #define TOKEN_PRIV_STR "," 50180209230bSgjelinek 50190209230bSgjelinek typedef struct priv_node { 50200209230bSgjelinek struct priv_node *pn_next; /* Next privilege */ 50210209230bSgjelinek char *pn_priv; /* Privileges name */ 50220209230bSgjelinek } priv_node_t; 50230209230bSgjelinek 50240209230bSgjelinek /* Privileges lists can differ across brands */ 50250209230bSgjelinek typedef struct priv_lists { 50260209230bSgjelinek /* Privileges considered safe for all non-global zones of a brand */ 50270209230bSgjelinek struct priv_node *pl_default; 50280209230bSgjelinek 50290209230bSgjelinek /* Privileges not permitted for all non-global zones of a brand */ 50300209230bSgjelinek struct priv_node *pl_prohibited; 50310209230bSgjelinek 50320209230bSgjelinek /* Privileges required for all non-global zones of a brand */ 50330209230bSgjelinek struct priv_node *pl_required; 5034bf1d7e28Sdh 5035bf1d7e28Sdh /* 5036bf1d7e28Sdh * ip-type of the zone these privileges lists apply to. 5037bf1d7e28Sdh * It is used to pass ip-type to the callback function, 5038bf1d7e28Sdh * priv_lists_cb, which has no way of getting the ip-type. 5039bf1d7e28Sdh */ 5040bf1d7e28Sdh const char *pl_iptype; 50410209230bSgjelinek } priv_lists_t; 50420209230bSgjelinek 50430209230bSgjelinek static int 5044bf1d7e28Sdh priv_lists_cb(void *data, priv_iter_t *priv_iter) 50450209230bSgjelinek { 50460209230bSgjelinek priv_lists_t *plp = (priv_lists_t *)data; 50470209230bSgjelinek priv_node_t *pnp; 50480209230bSgjelinek 5049bf1d7e28Sdh /* Skip this privilege if ip-type does not match */ 5050bf1d7e28Sdh if ((strcmp(priv_iter->pi_iptype, "all") != 0) && 5051bf1d7e28Sdh (strcmp(priv_iter->pi_iptype, plp->pl_iptype) != 0)) 5052bf1d7e28Sdh return (0); 5053bf1d7e28Sdh 50540209230bSgjelinek /* Allocate a new priv list node. */ 50550209230bSgjelinek if ((pnp = malloc(sizeof (*pnp))) == NULL) 50560209230bSgjelinek return (-1); 5057bf1d7e28Sdh if ((pnp->pn_priv = strdup(priv_iter->pi_name)) == NULL) { 50580209230bSgjelinek free(pnp); 50590209230bSgjelinek return (-1); 50600209230bSgjelinek } 50610209230bSgjelinek 50620209230bSgjelinek /* Insert the new priv list node into the right list */ 5063bf1d7e28Sdh if (strcmp(priv_iter->pi_set, "default") == 0) { 50640209230bSgjelinek pnp->pn_next = plp->pl_default; 50650209230bSgjelinek plp->pl_default = pnp; 5066bf1d7e28Sdh } else if (strcmp(priv_iter->pi_set, "prohibited") == 0) { 50670209230bSgjelinek pnp->pn_next = plp->pl_prohibited; 50680209230bSgjelinek plp->pl_prohibited = pnp; 5069bf1d7e28Sdh } else if (strcmp(priv_iter->pi_set, "required") == 0) { 50700209230bSgjelinek pnp->pn_next = plp->pl_required; 50710209230bSgjelinek plp->pl_required = pnp; 50720209230bSgjelinek } else { 50730209230bSgjelinek free(pnp->pn_priv); 50740209230bSgjelinek free(pnp); 50750209230bSgjelinek return (-1); 50760209230bSgjelinek } 50770209230bSgjelinek return (0); 50780209230bSgjelinek } 50790209230bSgjelinek 50800209230bSgjelinek static void 50810209230bSgjelinek priv_lists_destroy(priv_lists_t *plp) 50820209230bSgjelinek { 50830209230bSgjelinek priv_node_t *pnp; 50840209230bSgjelinek 50850209230bSgjelinek assert(plp != NULL); 50860209230bSgjelinek 50870209230bSgjelinek while ((pnp = plp->pl_default) != NULL) { 50880209230bSgjelinek plp->pl_default = pnp->pn_next; 50890209230bSgjelinek free(pnp->pn_priv); 50900209230bSgjelinek free(pnp); 50910209230bSgjelinek } 50920209230bSgjelinek while ((pnp = plp->pl_prohibited) != NULL) { 50930209230bSgjelinek plp->pl_prohibited = pnp->pn_next; 50940209230bSgjelinek free(pnp->pn_priv); 50950209230bSgjelinek free(pnp); 50960209230bSgjelinek } 50970209230bSgjelinek while ((pnp = plp->pl_required) != NULL) { 50980209230bSgjelinek plp->pl_required = pnp->pn_next; 50990209230bSgjelinek free(pnp->pn_priv); 51000209230bSgjelinek free(pnp); 51010209230bSgjelinek } 51020209230bSgjelinek free(plp); 51030209230bSgjelinek } 51040209230bSgjelinek 51050209230bSgjelinek static int 5106e5816e35SEdward Pilatowicz priv_lists_create(zone_dochandle_t handle, char *brand, priv_lists_t **plpp, 5107bf1d7e28Sdh const char *curr_iptype) 51080209230bSgjelinek { 51090209230bSgjelinek priv_lists_t *plp; 51100209230bSgjelinek brand_handle_t bh; 5111e5816e35SEdward Pilatowicz char brand_str[MAXNAMELEN]; 5112e5816e35SEdward Pilatowicz 5113e5816e35SEdward Pilatowicz /* handle or brand must be set, but never both */ 5114e5816e35SEdward Pilatowicz assert((handle != NULL) || (brand != NULL)); 5115e5816e35SEdward Pilatowicz assert((handle == NULL) || (brand == NULL)); 51160209230bSgjelinek 51170209230bSgjelinek if (handle != NULL) { 5118e5816e35SEdward Pilatowicz brand = brand_str; 5119e5816e35SEdward Pilatowicz if (zonecfg_get_brand(handle, brand, sizeof (brand_str)) != 0) 51200209230bSgjelinek return (Z_BRAND_ERROR); 51210209230bSgjelinek } 51220209230bSgjelinek 51230209230bSgjelinek if ((bh = brand_open(brand)) == NULL) 51240209230bSgjelinek return (Z_BRAND_ERROR); 51250209230bSgjelinek 51260209230bSgjelinek if ((plp = calloc(1, sizeof (priv_lists_t))) == NULL) { 51270209230bSgjelinek brand_close(bh); 51280209230bSgjelinek return (Z_NOMEM); 51290209230bSgjelinek } 51300209230bSgjelinek 5131bf1d7e28Sdh plp->pl_iptype = curr_iptype; 5132bf1d7e28Sdh 51330209230bSgjelinek /* construct the privilege lists */ 51340209230bSgjelinek if (brand_config_iter_privilege(bh, priv_lists_cb, plp) != 0) { 51350209230bSgjelinek priv_lists_destroy(plp); 51360209230bSgjelinek brand_close(bh); 51370209230bSgjelinek return (Z_BRAND_ERROR); 51380209230bSgjelinek } 51390209230bSgjelinek 51400209230bSgjelinek brand_close(bh); 51410209230bSgjelinek *plpp = plp; 51420209230bSgjelinek return (Z_OK); 51430209230bSgjelinek } 51440209230bSgjelinek 51450209230bSgjelinek static int 51460209230bSgjelinek get_default_privset(priv_set_t *privs, priv_lists_t *plp) 51470209230bSgjelinek { 51480209230bSgjelinek priv_node_t *pnp; 51490209230bSgjelinek priv_set_t *basic; 51500209230bSgjelinek 51510209230bSgjelinek basic = priv_str_to_set(BASIC_TOKEN, TOKEN_PRIV_STR, NULL); 51520209230bSgjelinek if (basic == NULL) 51530209230bSgjelinek return (errno == ENOMEM ? Z_NOMEM : Z_INVAL); 51540209230bSgjelinek 51550209230bSgjelinek priv_union(basic, privs); 51560209230bSgjelinek priv_freeset(basic); 51570209230bSgjelinek 51580209230bSgjelinek for (pnp = plp->pl_default; pnp != NULL; pnp = pnp->pn_next) { 51590209230bSgjelinek if (priv_addset(privs, pnp->pn_priv) != 0) 51600209230bSgjelinek return (Z_INVAL); 51610209230bSgjelinek } 51620209230bSgjelinek 51630209230bSgjelinek return (Z_OK); 51640209230bSgjelinek } 51650209230bSgjelinek 5166e5816e35SEdward Pilatowicz int 5167e5816e35SEdward Pilatowicz zonecfg_default_brand(char *brand, size_t brandsize) 5168e5816e35SEdward Pilatowicz { 5169e5816e35SEdward Pilatowicz zone_dochandle_t handle; 51707522f2fcSEdward Pilatowicz int myzoneid = getzoneid(); 5171e5816e35SEdward Pilatowicz int ret; 5172e5816e35SEdward Pilatowicz 51737522f2fcSEdward Pilatowicz /* 51747522f2fcSEdward Pilatowicz * If we're running within a zone, then the default brand is the 51757522f2fcSEdward Pilatowicz * current zone's brand. 51767522f2fcSEdward Pilatowicz */ 51777522f2fcSEdward Pilatowicz if (myzoneid != GLOBAL_ZONEID) { 51787522f2fcSEdward Pilatowicz ret = zone_getattr(myzoneid, ZONE_ATTR_BRAND, brand, brandsize); 51797522f2fcSEdward Pilatowicz if (ret < 0) 51807522f2fcSEdward Pilatowicz return ((errno == EFAULT) ? Z_TOO_BIG : Z_INVAL); 51817522f2fcSEdward Pilatowicz return (Z_OK); 51827522f2fcSEdward Pilatowicz } 51837522f2fcSEdward Pilatowicz 5184e5816e35SEdward Pilatowicz if ((handle = zonecfg_init_handle()) == NULL) 5185e5816e35SEdward Pilatowicz return (Z_NOMEM); 5186e5816e35SEdward Pilatowicz if ((ret = zonecfg_get_handle("SUNWdefault", handle)) == Z_OK) { 5187e5816e35SEdward Pilatowicz ret = i_zonecfg_get_brand(handle, brand, brandsize, B_TRUE); 5188e5816e35SEdward Pilatowicz zonecfg_fini_handle(handle); 5189e5816e35SEdward Pilatowicz return (ret); 5190e5816e35SEdward Pilatowicz } 5191e5816e35SEdward Pilatowicz return (ret); 5192e5816e35SEdward Pilatowicz } 5193e5816e35SEdward Pilatowicz 51940209230bSgjelinek int 5195bf1d7e28Sdh zonecfg_default_privset(priv_set_t *privs, const char *curr_iptype) 51960209230bSgjelinek { 51970209230bSgjelinek priv_lists_t *plp; 5198e5816e35SEdward Pilatowicz char buf[MAXNAMELEN]; 51990209230bSgjelinek int ret; 52000209230bSgjelinek 5201e5816e35SEdward Pilatowicz if ((ret = zonecfg_default_brand(buf, sizeof (buf))) != Z_OK) 5202e5816e35SEdward Pilatowicz return (ret); 5203e5816e35SEdward Pilatowicz if ((ret = priv_lists_create(NULL, buf, &plp, curr_iptype)) != Z_OK) 52040209230bSgjelinek return (ret); 52050209230bSgjelinek ret = get_default_privset(privs, plp); 52060209230bSgjelinek priv_lists_destroy(plp); 52070209230bSgjelinek return (ret); 52080209230bSgjelinek } 52090209230bSgjelinek 52100209230bSgjelinek void 52110209230bSgjelinek append_priv_token(char *priv, char *str, size_t strlen) 52120209230bSgjelinek { 52130209230bSgjelinek if (*str != '\0') 52140209230bSgjelinek (void) strlcat(str, TOKEN_PRIV_STR, strlen); 52150209230bSgjelinek (void) strlcat(str, priv, strlen); 52160209230bSgjelinek } 52170209230bSgjelinek 52180209230bSgjelinek /* 52190209230bSgjelinek * Verify that the supplied string is a valid privilege limit set for a 52200209230bSgjelinek * non-global zone. This string must not only be acceptable to 52210209230bSgjelinek * priv_str_to_set(3C) which parses it, but it also must resolve to a 52220209230bSgjelinek * privilege set that includes certain required privileges and lacks 52230209230bSgjelinek * certain prohibited privileges. 52240209230bSgjelinek */ 52250209230bSgjelinek static int 52260209230bSgjelinek verify_privset(char *privbuf, priv_set_t *privs, char **privname, 52270209230bSgjelinek boolean_t add_default, priv_lists_t *plp) 52280209230bSgjelinek { 52290209230bSgjelinek priv_node_t *pnp; 52300209230bSgjelinek char *tmp, *cp, *lasts; 52310209230bSgjelinek size_t len; 52320209230bSgjelinek priv_set_t *mergeset; 52330209230bSgjelinek const char *token; 52340209230bSgjelinek 52350209230bSgjelinek /* 52360209230bSgjelinek * The verification of the privilege string occurs in several 52370209230bSgjelinek * phases. In the first phase, the supplied string is scanned for 52380209230bSgjelinek * the ZONE_TOKEN token which is not support as part of the 52390209230bSgjelinek * "limitpriv" property. 52400209230bSgjelinek * 52410209230bSgjelinek * Duplicate the supplied privilege string since strtok_r(3C) 52420209230bSgjelinek * tokenizes its input by null-terminating the tokens. 52430209230bSgjelinek */ 52440209230bSgjelinek if ((tmp = strdup(privbuf)) == NULL) 52450209230bSgjelinek return (Z_NOMEM); 52460209230bSgjelinek for (cp = strtok_r(tmp, TOKEN_PRIV_STR, &lasts); cp != NULL; 52470209230bSgjelinek cp = strtok_r(NULL, TOKEN_PRIV_STR, &lasts)) { 52480209230bSgjelinek if (strcmp(cp, ZONE_TOKEN) == 0) { 52490209230bSgjelinek free(tmp); 52500209230bSgjelinek if ((*privname = strdup(ZONE_TOKEN)) == NULL) 52510209230bSgjelinek return (Z_NOMEM); 52520209230bSgjelinek else 52530209230bSgjelinek return (Z_PRIV_UNKNOWN); 52540209230bSgjelinek } 52550209230bSgjelinek } 52560209230bSgjelinek free(tmp); 52570209230bSgjelinek 52580209230bSgjelinek if (add_default) { 52590209230bSgjelinek /* 52600209230bSgjelinek * If DEFAULT_TOKEN was specified, a string needs to be 52610209230bSgjelinek * built containing the privileges from the default, safe 52620209230bSgjelinek * set along with those of the "limitpriv" property. 52630209230bSgjelinek */ 52640209230bSgjelinek len = strlen(privbuf) + sizeof (BASIC_TOKEN) + 2; 52650209230bSgjelinek 52660209230bSgjelinek for (pnp = plp->pl_default; pnp != NULL; pnp = pnp->pn_next) 52670209230bSgjelinek len += strlen(pnp->pn_priv) + 1; 52680209230bSgjelinek tmp = alloca(len); 52690209230bSgjelinek *tmp = '\0'; 52700209230bSgjelinek 52710209230bSgjelinek append_priv_token(BASIC_TOKEN, tmp, len); 52720209230bSgjelinek for (pnp = plp->pl_default; pnp != NULL; pnp = pnp->pn_next) 52730209230bSgjelinek append_priv_token(pnp->pn_priv, tmp, len); 52740209230bSgjelinek (void) strlcat(tmp, TOKEN_PRIV_STR, len); 52750209230bSgjelinek (void) strlcat(tmp, privbuf, len); 52760209230bSgjelinek } else { 52770209230bSgjelinek tmp = privbuf; 52780209230bSgjelinek } 52790209230bSgjelinek 52800209230bSgjelinek 52810209230bSgjelinek /* 52820209230bSgjelinek * In the next phase, attempt to convert the merged privilege 52830209230bSgjelinek * string into a privilege set. In the case of an error, either 52840209230bSgjelinek * there was a memory allocation failure or there was an invalid 52850209230bSgjelinek * privilege token in the string. In either case, return an 52860209230bSgjelinek * appropriate error code but in the event of an invalid token, 52870209230bSgjelinek * allocate a string containing its name and return that back to 52880209230bSgjelinek * the caller. 52890209230bSgjelinek */ 52900209230bSgjelinek mergeset = priv_str_to_set(tmp, TOKEN_PRIV_STR, &token); 52910209230bSgjelinek if (mergeset == NULL) { 52920209230bSgjelinek if (token == NULL) 52930209230bSgjelinek return (Z_NOMEM); 52940209230bSgjelinek if ((cp = strchr(token, TOKEN_PRIV_CHAR)) != NULL) 52950209230bSgjelinek *cp = '\0'; 52960209230bSgjelinek if ((*privname = strdup(token)) == NULL) 52970209230bSgjelinek return (Z_NOMEM); 52980209230bSgjelinek else 52990209230bSgjelinek return (Z_PRIV_UNKNOWN); 53000209230bSgjelinek } 53010209230bSgjelinek 53020209230bSgjelinek /* 53030209230bSgjelinek * Next, verify that none of the prohibited zone privileges are 53040209230bSgjelinek * present in the merged privilege set. 53050209230bSgjelinek */ 53060209230bSgjelinek for (pnp = plp->pl_prohibited; pnp != NULL; pnp = pnp->pn_next) { 53070209230bSgjelinek if (priv_ismember(mergeset, pnp->pn_priv)) { 53080209230bSgjelinek priv_freeset(mergeset); 53090209230bSgjelinek if ((*privname = strdup(pnp->pn_priv)) == NULL) 53100209230bSgjelinek return (Z_NOMEM); 53110209230bSgjelinek else 53120209230bSgjelinek return (Z_PRIV_PROHIBITED); 53130209230bSgjelinek } 53140209230bSgjelinek } 53150209230bSgjelinek 53160209230bSgjelinek /* 53170209230bSgjelinek * Finally, verify that all of the required zone privileges are 53180209230bSgjelinek * present in the merged privilege set. 53190209230bSgjelinek */ 53200209230bSgjelinek for (pnp = plp->pl_required; pnp != NULL; pnp = pnp->pn_next) { 53210209230bSgjelinek if (!priv_ismember(mergeset, pnp->pn_priv)) { 53220209230bSgjelinek priv_freeset(mergeset); 53230209230bSgjelinek if ((*privname = strdup(pnp->pn_priv)) == NULL) 53240209230bSgjelinek return (Z_NOMEM); 53250209230bSgjelinek else 53260209230bSgjelinek return (Z_PRIV_REQUIRED); 53270209230bSgjelinek } 53280209230bSgjelinek } 53290209230bSgjelinek 53300209230bSgjelinek priv_copyset(mergeset, privs); 53310209230bSgjelinek priv_freeset(mergeset); 53320209230bSgjelinek return (Z_OK); 53330209230bSgjelinek } 53340209230bSgjelinek 53350209230bSgjelinek /* 53360209230bSgjelinek * Fill in the supplied privilege set with either the default, safe set of 53370209230bSgjelinek * privileges suitable for a non-global zone, or one based on the 53380209230bSgjelinek * "limitpriv" property in the zone's configuration. 53390209230bSgjelinek * 53400209230bSgjelinek * In the event of an invalid privilege specification in the 53410209230bSgjelinek * configuration, a string is allocated and returned containing the 53420209230bSgjelinek * "privilege" causing the issue. It is the caller's responsibility to 53430209230bSgjelinek * free this memory when it is done with it. 53440209230bSgjelinek */ 53450209230bSgjelinek int 53460209230bSgjelinek zonecfg_get_privset(zone_dochandle_t handle, priv_set_t *privs, 53470209230bSgjelinek char **privname) 53480209230bSgjelinek { 53490209230bSgjelinek priv_lists_t *plp; 53500209230bSgjelinek char *cp, *limitpriv = NULL; 53510209230bSgjelinek int err, limitlen; 5352bf1d7e28Sdh zone_iptype_t iptype; 5353bf1d7e28Sdh const char *curr_iptype; 53540209230bSgjelinek 53550209230bSgjelinek /* 53560209230bSgjelinek * Attempt to lookup the "limitpriv" property. If it does not 53570209230bSgjelinek * exist or matches the string DEFAULT_TOKEN exactly, then the 53580209230bSgjelinek * default, safe privilege set is returned. 53590209230bSgjelinek */ 53600209230bSgjelinek if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) != Z_OK) 53610209230bSgjelinek return (err); 53620209230bSgjelinek 5363bf1d7e28Sdh if ((err = zonecfg_get_iptype(handle, &iptype)) != Z_OK) 5364bf1d7e28Sdh return (err); 5365bf1d7e28Sdh 5366bf1d7e28Sdh switch (iptype) { 5367bf1d7e28Sdh case ZS_SHARED: 5368bf1d7e28Sdh curr_iptype = "shared"; 5369bf1d7e28Sdh break; 5370bf1d7e28Sdh case ZS_EXCLUSIVE: 5371bf1d7e28Sdh curr_iptype = "exclusive"; 5372bf1d7e28Sdh break; 5373bf1d7e28Sdh } 5374bf1d7e28Sdh 5375e5816e35SEdward Pilatowicz if ((err = priv_lists_create(handle, NULL, &plp, curr_iptype)) != Z_OK) 53760209230bSgjelinek return (err); 53770209230bSgjelinek 53780209230bSgjelinek limitlen = strlen(limitpriv); 53790209230bSgjelinek if (limitlen == 0 || strcmp(limitpriv, DEFAULT_TOKEN) == 0) { 53800209230bSgjelinek free(limitpriv); 53810209230bSgjelinek err = get_default_privset(privs, plp); 53820209230bSgjelinek priv_lists_destroy(plp); 53830209230bSgjelinek return (err); 53840209230bSgjelinek } 53850209230bSgjelinek 53860209230bSgjelinek /* 53870209230bSgjelinek * Check if the string DEFAULT_TOKEN is the first token in a list 53880209230bSgjelinek * of privileges. 53890209230bSgjelinek */ 53900209230bSgjelinek cp = strchr(limitpriv, TOKEN_PRIV_CHAR); 53910209230bSgjelinek if (cp != NULL && 53920209230bSgjelinek strncmp(limitpriv, DEFAULT_TOKEN, cp - limitpriv) == 0) 53930209230bSgjelinek err = verify_privset(cp + 1, privs, privname, B_TRUE, plp); 53940209230bSgjelinek else 53950209230bSgjelinek err = verify_privset(limitpriv, privs, privname, B_FALSE, plp); 53960209230bSgjelinek 53970209230bSgjelinek free(limitpriv); 53980209230bSgjelinek priv_lists_destroy(plp); 53990209230bSgjelinek return (err); 54000209230bSgjelinek } 54010209230bSgjelinek 54020209230bSgjelinek int 54030209230bSgjelinek zone_get_zonepath(char *zone_name, char *zonepath, size_t rp_sz) 54040209230bSgjelinek { 54050209230bSgjelinek zone_dochandle_t handle; 54060209230bSgjelinek boolean_t found = B_FALSE; 54070209230bSgjelinek struct zoneent *ze; 54080209230bSgjelinek FILE *cookie; 54090209230bSgjelinek int err; 54100209230bSgjelinek char *cp; 54110209230bSgjelinek 54120209230bSgjelinek if (zone_name == NULL) 54130209230bSgjelinek return (Z_INVAL); 54140209230bSgjelinek 54150209230bSgjelinek (void) strlcpy(zonepath, zonecfg_root, rp_sz); 54160209230bSgjelinek cp = zonepath + strlen(zonepath); 54170209230bSgjelinek while (cp > zonepath && cp[-1] == '/') 54180209230bSgjelinek *--cp = '\0'; 54190209230bSgjelinek 54200209230bSgjelinek if (strcmp(zone_name, GLOBAL_ZONENAME) == 0) { 54210209230bSgjelinek if (zonepath[0] == '\0') 54220209230bSgjelinek (void) strlcpy(zonepath, "/", rp_sz); 54230209230bSgjelinek return (Z_OK); 54240209230bSgjelinek } 54250209230bSgjelinek 54260209230bSgjelinek /* 54270209230bSgjelinek * First check the index file. Because older versions did not have 54280209230bSgjelinek * a copy of the zone path, allow for it to be zero length, in which 54290209230bSgjelinek * case we ignore this result and fall back to the XML files. 54300209230bSgjelinek */ 54310209230bSgjelinek cookie = setzoneent(); 54320209230bSgjelinek while ((ze = getzoneent_private(cookie)) != NULL) { 54330209230bSgjelinek if (strcmp(ze->zone_name, zone_name) == 0) { 54340209230bSgjelinek found = B_TRUE; 54350209230bSgjelinek if (ze->zone_path[0] != '\0') 54360209230bSgjelinek (void) strlcpy(cp, ze->zone_path, 54370209230bSgjelinek rp_sz - (cp - zonepath)); 54380209230bSgjelinek } 54390209230bSgjelinek free(ze); 54400209230bSgjelinek if (found) 54410209230bSgjelinek break; 54420209230bSgjelinek } 54430209230bSgjelinek endzoneent(cookie); 54440209230bSgjelinek if (found && *cp != '\0') 54450209230bSgjelinek return (Z_OK); 54460209230bSgjelinek 54470209230bSgjelinek /* Fall back to the XML files. */ 54480209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) 54490209230bSgjelinek return (Z_NOMEM); 54500209230bSgjelinek 54510209230bSgjelinek /* 54520209230bSgjelinek * Check the snapshot first: if a zone is running, its zonepath 54530209230bSgjelinek * may have changed. 54540209230bSgjelinek */ 54550209230bSgjelinek if (zonecfg_get_snapshot_handle(zone_name, handle) != Z_OK) { 5456e767a340Sgjelinek if ((err = zonecfg_get_handle(zone_name, handle)) != Z_OK) { 5457e767a340Sgjelinek zonecfg_fini_handle(handle); 54580209230bSgjelinek return (err); 5459e767a340Sgjelinek } 54600209230bSgjelinek } 54610209230bSgjelinek err = zonecfg_get_zonepath(handle, zonepath, rp_sz); 54620209230bSgjelinek zonecfg_fini_handle(handle); 54630209230bSgjelinek return (err); 54640209230bSgjelinek } 54650209230bSgjelinek 54660209230bSgjelinek int 54670209230bSgjelinek zone_get_rootpath(char *zone_name, char *rootpath, size_t rp_sz) 54680209230bSgjelinek { 54690209230bSgjelinek int err; 54700209230bSgjelinek 54710209230bSgjelinek /* This function makes sense for non-global zones only. */ 54720209230bSgjelinek if (strcmp(zone_name, GLOBAL_ZONENAME) == 0) 54730209230bSgjelinek return (Z_BOGUS_ZONE_NAME); 54740209230bSgjelinek if ((err = zone_get_zonepath(zone_name, rootpath, rp_sz)) != Z_OK) 54750209230bSgjelinek return (err); 54760209230bSgjelinek if (strlcat(rootpath, "/root", rp_sz) >= rp_sz) 54770209230bSgjelinek return (Z_TOO_BIG); 54780209230bSgjelinek return (Z_OK); 54790209230bSgjelinek } 54800209230bSgjelinek 54810209230bSgjelinek int 54820209230bSgjelinek zone_get_brand(char *zone_name, char *brandname, size_t rp_sz) 54830209230bSgjelinek { 54840209230bSgjelinek int err; 54850209230bSgjelinek zone_dochandle_t handle; 54860209230bSgjelinek char myzone[MAXNAMELEN]; 54870209230bSgjelinek int myzoneid = getzoneid(); 54880209230bSgjelinek 54890209230bSgjelinek /* 54900209230bSgjelinek * If we are not in the global zone, then we don't have the zone 54910209230bSgjelinek * .xml files with the brand name available. Thus, we are going to 54920209230bSgjelinek * have to ask the kernel for the information. 54930209230bSgjelinek */ 54940209230bSgjelinek if (myzoneid != GLOBAL_ZONEID) { 54952ec67e04Sgjelinek if (is_system_labeled()) { 54962ec67e04Sgjelinek (void) strlcpy(brandname, NATIVE_BRAND_NAME, rp_sz); 54972ec67e04Sgjelinek return (Z_OK); 54982ec67e04Sgjelinek } 54990209230bSgjelinek if (zone_getattr(myzoneid, ZONE_ATTR_NAME, myzone, 55000209230bSgjelinek sizeof (myzone)) < 0) 55010209230bSgjelinek return (Z_NO_ZONE); 55021d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India if (!zonecfg_is_scratch(myzone)) { 55031d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India if (strncmp(zone_name, myzone, MAXNAMELEN) != 0) 55041d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India return (Z_NO_ZONE); 55051d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India } 55060209230bSgjelinek err = zone_getattr(myzoneid, ZONE_ATTR_BRAND, brandname, rp_sz); 55070209230bSgjelinek if (err < 0) 55080209230bSgjelinek return ((errno == EFAULT) ? Z_TOO_BIG : Z_INVAL); 55091d6979b7Ssaurabh vyas - Sun Microsystems - Bangalore India 55100209230bSgjelinek return (Z_OK); 55110209230bSgjelinek } 55120209230bSgjelinek 5513e5816e35SEdward Pilatowicz if (strcmp(zone_name, "global") == 0) 5514e5816e35SEdward Pilatowicz return (zonecfg_default_brand(brandname, rp_sz)); 5515e5816e35SEdward Pilatowicz 55160209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) 55170209230bSgjelinek return (Z_NOMEM); 55180209230bSgjelinek 55190209230bSgjelinek err = zonecfg_get_handle((char *)zone_name, handle); 55200209230bSgjelinek if (err == Z_OK) 55210209230bSgjelinek err = zonecfg_get_brand(handle, brandname, rp_sz); 55220209230bSgjelinek 55230209230bSgjelinek zonecfg_fini_handle(handle); 55240209230bSgjelinek return (err); 55250209230bSgjelinek } 55260209230bSgjelinek 55270209230bSgjelinek /* 55280209230bSgjelinek * Return the appropriate root for the active /dev. 55290209230bSgjelinek * For normal zone, the path is $ZONEPATH/root; 55300209230bSgjelinek * for scratch zone, the dev path is $ZONEPATH/lu. 55310209230bSgjelinek */ 55320209230bSgjelinek int 55330209230bSgjelinek zone_get_devroot(char *zone_name, char *devroot, size_t rp_sz) 55340209230bSgjelinek { 55350209230bSgjelinek int err; 55360209230bSgjelinek char *suffix; 55370209230bSgjelinek zone_state_t state; 55380209230bSgjelinek 55390209230bSgjelinek /* This function makes sense for non-global zones only. */ 55400209230bSgjelinek if (strcmp(zone_name, GLOBAL_ZONENAME) == 0) 55410209230bSgjelinek return (Z_BOGUS_ZONE_NAME); 55420209230bSgjelinek if ((err = zone_get_zonepath(zone_name, devroot, rp_sz)) != Z_OK) 55430209230bSgjelinek return (err); 55440209230bSgjelinek 55450209230bSgjelinek if (zone_get_state(zone_name, &state) == Z_OK && 55460209230bSgjelinek state == ZONE_STATE_MOUNTED) 55470209230bSgjelinek suffix = "/lu"; 55480209230bSgjelinek else 55490209230bSgjelinek suffix = "/root"; 55500209230bSgjelinek if (strlcat(devroot, suffix, rp_sz) >= rp_sz) 55510209230bSgjelinek return (Z_TOO_BIG); 55520209230bSgjelinek return (Z_OK); 55530209230bSgjelinek } 55540209230bSgjelinek 55550209230bSgjelinek static zone_state_t 55560209230bSgjelinek kernel_state_to_user_state(zoneid_t zoneid, zone_status_t kernel_state) 55570209230bSgjelinek { 55580209230bSgjelinek char zoneroot[MAXPATHLEN]; 55590209230bSgjelinek size_t zlen; 55600209230bSgjelinek 55610209230bSgjelinek assert(kernel_state <= ZONE_MAX_STATE); 55620209230bSgjelinek switch (kernel_state) { 55630209230bSgjelinek case ZONE_IS_UNINITIALIZED: 5564bd41d0a8Snordmark case ZONE_IS_INITIALIZED: 5565bd41d0a8Snordmark /* The kernel will not return these two states */ 55660209230bSgjelinek return (ZONE_STATE_READY); 55670209230bSgjelinek case ZONE_IS_READY: 55680209230bSgjelinek /* 55690209230bSgjelinek * If the zone's root is mounted on $ZONEPATH/lu, then 55700209230bSgjelinek * it's a mounted scratch zone. 55710209230bSgjelinek */ 55720209230bSgjelinek if (zone_getattr(zoneid, ZONE_ATTR_ROOT, zoneroot, 55730209230bSgjelinek sizeof (zoneroot)) >= 0) { 55740209230bSgjelinek zlen = strlen(zoneroot); 55750209230bSgjelinek if (zlen > 3 && 55760209230bSgjelinek strcmp(zoneroot + zlen - 3, "/lu") == 0) 55770209230bSgjelinek return (ZONE_STATE_MOUNTED); 55780209230bSgjelinek } 55790209230bSgjelinek return (ZONE_STATE_READY); 55800209230bSgjelinek case ZONE_IS_BOOTING: 55810209230bSgjelinek case ZONE_IS_RUNNING: 55820209230bSgjelinek return (ZONE_STATE_RUNNING); 55830209230bSgjelinek case ZONE_IS_SHUTTING_DOWN: 55840209230bSgjelinek case ZONE_IS_EMPTY: 55850209230bSgjelinek return (ZONE_STATE_SHUTTING_DOWN); 55860209230bSgjelinek case ZONE_IS_DOWN: 55870209230bSgjelinek case ZONE_IS_DYING: 55880209230bSgjelinek case ZONE_IS_DEAD: 55890209230bSgjelinek default: 55900209230bSgjelinek return (ZONE_STATE_DOWN); 55910209230bSgjelinek } 55920209230bSgjelinek /* NOTREACHED */ 55930209230bSgjelinek } 55940209230bSgjelinek 55950209230bSgjelinek int 55960209230bSgjelinek zone_get_state(char *zone_name, zone_state_t *state_num) 55970209230bSgjelinek { 55980209230bSgjelinek zone_status_t status; 55990209230bSgjelinek zoneid_t zone_id; 56000209230bSgjelinek struct zoneent *ze; 56010209230bSgjelinek boolean_t found = B_FALSE; 56020209230bSgjelinek FILE *cookie; 56030209230bSgjelinek char kernzone[ZONENAME_MAX]; 56040209230bSgjelinek FILE *fp; 56050209230bSgjelinek 56060209230bSgjelinek if (zone_name == NULL) 56070209230bSgjelinek return (Z_INVAL); 56080209230bSgjelinek 56090209230bSgjelinek /* 56100209230bSgjelinek * If we're looking at an alternate root, then we need to query the 56110209230bSgjelinek * kernel using the scratch zone name. 56120209230bSgjelinek */ 56130209230bSgjelinek zone_id = -1; 56140209230bSgjelinek if (*zonecfg_root != '\0' && !zonecfg_is_scratch(zone_name)) { 56150209230bSgjelinek if ((fp = zonecfg_open_scratch("", B_FALSE)) != NULL) { 56160209230bSgjelinek if (zonecfg_find_scratch(fp, zone_name, zonecfg_root, 56170209230bSgjelinek kernzone, sizeof (kernzone)) == 0) 56180209230bSgjelinek zone_id = getzoneidbyname(kernzone); 56190209230bSgjelinek zonecfg_close_scratch(fp); 56200209230bSgjelinek } 56210209230bSgjelinek } else { 56220209230bSgjelinek zone_id = getzoneidbyname(zone_name); 56230209230bSgjelinek } 56240209230bSgjelinek 56250209230bSgjelinek /* check to see if zone is running */ 56260209230bSgjelinek if (zone_id != -1 && 56270209230bSgjelinek zone_getattr(zone_id, ZONE_ATTR_STATUS, &status, 56280209230bSgjelinek sizeof (status)) >= 0) { 56290209230bSgjelinek *state_num = kernel_state_to_user_state(zone_id, status); 56300209230bSgjelinek return (Z_OK); 56310209230bSgjelinek } 56320209230bSgjelinek 56330209230bSgjelinek cookie = setzoneent(); 56340209230bSgjelinek while ((ze = getzoneent_private(cookie)) != NULL) { 56350209230bSgjelinek if (strcmp(ze->zone_name, zone_name) == 0) { 56360209230bSgjelinek found = B_TRUE; 56370209230bSgjelinek *state_num = ze->zone_state; 56380209230bSgjelinek } 56390209230bSgjelinek free(ze); 56400209230bSgjelinek if (found) 56410209230bSgjelinek break; 56420209230bSgjelinek } 56430209230bSgjelinek endzoneent(cookie); 56440209230bSgjelinek return ((found) ? Z_OK : Z_NO_ZONE); 56450209230bSgjelinek } 56460209230bSgjelinek 56470209230bSgjelinek int 56480209230bSgjelinek zone_set_state(char *zone, zone_state_t state) 56490209230bSgjelinek { 56500209230bSgjelinek struct zoneent ze; 56510209230bSgjelinek 56520209230bSgjelinek if (state != ZONE_STATE_CONFIGURED && state != ZONE_STATE_INSTALLED && 56530209230bSgjelinek state != ZONE_STATE_INCOMPLETE) 56540209230bSgjelinek return (Z_INVAL); 56550209230bSgjelinek 56560209230bSgjelinek bzero(&ze, sizeof (ze)); 56570209230bSgjelinek (void) strlcpy(ze.zone_name, zone, sizeof (ze.zone_name)); 56580209230bSgjelinek ze.zone_state = state; 56590209230bSgjelinek (void) strlcpy(ze.zone_path, "", sizeof (ze.zone_path)); 56600209230bSgjelinek return (putzoneent(&ze, PZE_MODIFY)); 56610209230bSgjelinek } 56620209230bSgjelinek 56630209230bSgjelinek /* 56640209230bSgjelinek * Get id (if any) for specified zone. There are four possible outcomes: 56650209230bSgjelinek * - If the string corresponds to the numeric id of an active (booted) 56660209230bSgjelinek * zone, sets *zip to the zone id and returns 0. 56670209230bSgjelinek * - If the string corresponds to the name of an active (booted) zone, 56680209230bSgjelinek * sets *zip to the zone id and returns 0. 56690209230bSgjelinek * - If the string is a name in the configuration but is not booted, 56700209230bSgjelinek * sets *zip to ZONE_ID_UNDEFINED and returns 0. 56710209230bSgjelinek * - Otherwise, leaves *zip unchanged and returns -1. 56720209230bSgjelinek * 56730209230bSgjelinek * This function acts as an auxiliary filter on the function of the same 56740209230bSgjelinek * name in libc; the linker binds to this version if libzonecfg exists, 56750209230bSgjelinek * and the libc version if it doesn't. Any changes to this version of 56760209230bSgjelinek * the function should probably be reflected in the libc version as well. 56770209230bSgjelinek */ 56780209230bSgjelinek int 56790209230bSgjelinek zone_get_id(const char *str, zoneid_t *zip) 56800209230bSgjelinek { 56810209230bSgjelinek zone_dochandle_t hdl; 56820209230bSgjelinek zoneid_t zoneid; 56830209230bSgjelinek char *cp; 56840209230bSgjelinek int err; 56850209230bSgjelinek 56860209230bSgjelinek /* first try looking for active zone by id */ 56870209230bSgjelinek errno = 0; 56880209230bSgjelinek zoneid = (zoneid_t)strtol(str, &cp, 0); 56890209230bSgjelinek if (errno == 0 && cp != str && *cp == '\0' && 56900209230bSgjelinek getzonenamebyid(zoneid, NULL, 0) != -1) { 56910209230bSgjelinek *zip = zoneid; 56920209230bSgjelinek return (0); 56930209230bSgjelinek } 56940209230bSgjelinek 56950209230bSgjelinek /* then look for active zone by name */ 56960209230bSgjelinek if ((zoneid = getzoneidbyname(str)) != -1) { 56970209230bSgjelinek *zip = zoneid; 56980209230bSgjelinek return (0); 56990209230bSgjelinek } 57000209230bSgjelinek 57010209230bSgjelinek /* if in global zone, try looking up name in configuration database */ 57020209230bSgjelinek if (getzoneid() != GLOBAL_ZONEID || 57030209230bSgjelinek (hdl = zonecfg_init_handle()) == NULL) 57040209230bSgjelinek return (-1); 57050209230bSgjelinek 57060209230bSgjelinek if (zonecfg_get_handle(str, hdl) == Z_OK) { 57070209230bSgjelinek /* zone exists but isn't active */ 57080209230bSgjelinek *zip = ZONE_ID_UNDEFINED; 57090209230bSgjelinek err = 0; 57100209230bSgjelinek } else { 57110209230bSgjelinek err = -1; 57120209230bSgjelinek } 57130209230bSgjelinek 57140209230bSgjelinek zonecfg_fini_handle(hdl); 57150209230bSgjelinek return (err); 57160209230bSgjelinek } 57170209230bSgjelinek 57180209230bSgjelinek char * 57190209230bSgjelinek zone_state_str(zone_state_t state_num) 57200209230bSgjelinek { 57210209230bSgjelinek switch (state_num) { 57220209230bSgjelinek case ZONE_STATE_CONFIGURED: 57230209230bSgjelinek return (ZONE_STATE_STR_CONFIGURED); 57240209230bSgjelinek case ZONE_STATE_INCOMPLETE: 57250209230bSgjelinek return (ZONE_STATE_STR_INCOMPLETE); 57260209230bSgjelinek case ZONE_STATE_INSTALLED: 57270209230bSgjelinek return (ZONE_STATE_STR_INSTALLED); 57280209230bSgjelinek case ZONE_STATE_READY: 57290209230bSgjelinek return (ZONE_STATE_STR_READY); 57300209230bSgjelinek case ZONE_STATE_MOUNTED: 57310209230bSgjelinek return (ZONE_STATE_STR_MOUNTED); 57320209230bSgjelinek case ZONE_STATE_RUNNING: 57330209230bSgjelinek return (ZONE_STATE_STR_RUNNING); 57340209230bSgjelinek case ZONE_STATE_SHUTTING_DOWN: 57350209230bSgjelinek return (ZONE_STATE_STR_SHUTTING_DOWN); 57360209230bSgjelinek case ZONE_STATE_DOWN: 57370209230bSgjelinek return (ZONE_STATE_STR_DOWN); 57380209230bSgjelinek default: 57390209230bSgjelinek return ("unknown"); 57400209230bSgjelinek } 57410209230bSgjelinek } 57420209230bSgjelinek 57430209230bSgjelinek /* 57440209230bSgjelinek * Given a UUID value, find an associated zone name. This is intended to be 57450209230bSgjelinek * used by callers who set up some 'default' name (corresponding to the 57460209230bSgjelinek * expected name for the zone) in the zonename buffer, and thus the function 57470209230bSgjelinek * doesn't touch this buffer on failure. 57480209230bSgjelinek */ 57490209230bSgjelinek int 57500209230bSgjelinek zonecfg_get_name_by_uuid(const uuid_t uuidin, char *zonename, size_t namelen) 57510209230bSgjelinek { 57520209230bSgjelinek FILE *fp; 57530209230bSgjelinek struct zoneent *ze; 57540209230bSgjelinek uchar_t *uuid; 57550209230bSgjelinek 57560209230bSgjelinek /* 57570209230bSgjelinek * A small amount of subterfuge via casts is necessary here because 57580209230bSgjelinek * libuuid doesn't use const correctly, but we don't want to export 57590209230bSgjelinek * this brokenness to our clients. 57600209230bSgjelinek */ 57610209230bSgjelinek uuid = (uchar_t *)uuidin; 57620209230bSgjelinek if (uuid_is_null(uuid)) 57630209230bSgjelinek return (Z_NO_ZONE); 57640209230bSgjelinek if ((fp = setzoneent()) == NULL) 57650209230bSgjelinek return (Z_NO_ZONE); 57660209230bSgjelinek while ((ze = getzoneent_private(fp)) != NULL) { 57670209230bSgjelinek if (uuid_compare(uuid, ze->zone_uuid) == 0) 57680209230bSgjelinek break; 57690209230bSgjelinek free(ze); 57700209230bSgjelinek } 57710209230bSgjelinek endzoneent(fp); 57720209230bSgjelinek if (ze != NULL) { 57730209230bSgjelinek (void) strlcpy(zonename, ze->zone_name, namelen); 57740209230bSgjelinek free(ze); 57750209230bSgjelinek return (Z_OK); 57760209230bSgjelinek } else { 57770209230bSgjelinek return (Z_NO_ZONE); 57780209230bSgjelinek } 57790209230bSgjelinek } 57800209230bSgjelinek 57810209230bSgjelinek /* 57820209230bSgjelinek * Given a zone name, get its UUID. Returns a "NULL" UUID value if the zone 57830209230bSgjelinek * exists but the file doesn't have a value set yet. Returns an error if the 57840209230bSgjelinek * zone cannot be located. 57850209230bSgjelinek */ 57860209230bSgjelinek int 57870209230bSgjelinek zonecfg_get_uuid(const char *zonename, uuid_t uuid) 57880209230bSgjelinek { 57890209230bSgjelinek FILE *fp; 57900209230bSgjelinek struct zoneent *ze; 57910209230bSgjelinek 57920209230bSgjelinek if ((fp = setzoneent()) == NULL) 57930209230bSgjelinek return (Z_NO_ZONE); 57940209230bSgjelinek while ((ze = getzoneent_private(fp)) != NULL) { 57950209230bSgjelinek if (strcmp(ze->zone_name, zonename) == 0) 57960209230bSgjelinek break; 57970209230bSgjelinek free(ze); 57980209230bSgjelinek } 57990209230bSgjelinek endzoneent(fp); 58000209230bSgjelinek if (ze != NULL) { 58010209230bSgjelinek uuid_copy(uuid, ze->zone_uuid); 58020209230bSgjelinek free(ze); 58030209230bSgjelinek return (Z_OK); 58040209230bSgjelinek } else { 58050209230bSgjelinek return (Z_NO_ZONE); 58060209230bSgjelinek } 58070209230bSgjelinek } 58080209230bSgjelinek 58090209230bSgjelinek /* 58100209230bSgjelinek * File-system convenience functions. 58110209230bSgjelinek */ 58120209230bSgjelinek boolean_t 58130209230bSgjelinek zonecfg_valid_fs_type(const char *type) 58140209230bSgjelinek { 58150209230bSgjelinek /* 58160209230bSgjelinek * We already know which FS types don't work. 58170209230bSgjelinek */ 58180209230bSgjelinek if (strcmp(type, "proc") == 0 || 58190209230bSgjelinek strcmp(type, "mntfs") == 0 || 58200209230bSgjelinek strcmp(type, "autofs") == 0 || 5821*bd93c05dSAlexander Eremin strncmp(type, "nfs", sizeof ("nfs") - 1) == 0) 58220209230bSgjelinek return (B_FALSE); 58230209230bSgjelinek /* 58240209230bSgjelinek * The caller may do more detailed verification to make sure other 58250209230bSgjelinek * aspects of this filesystem type make sense. 58260209230bSgjelinek */ 58270209230bSgjelinek return (B_TRUE); 58280209230bSgjelinek } 58290209230bSgjelinek 58300209230bSgjelinek /* 58310209230bSgjelinek * Generally uninteresting rctl convenience functions. 58320209230bSgjelinek */ 58330209230bSgjelinek 58340209230bSgjelinek int 58350209230bSgjelinek zonecfg_construct_rctlblk(const struct zone_rctlvaltab *rctlval, 58360209230bSgjelinek rctlblk_t *rctlblk) 58370209230bSgjelinek { 58380209230bSgjelinek unsigned long long ull; 58390209230bSgjelinek char *endp; 58400209230bSgjelinek rctl_priv_t priv; 58410209230bSgjelinek rctl_qty_t limit; 58420209230bSgjelinek uint_t action; 58430209230bSgjelinek 58440209230bSgjelinek /* Get the privilege */ 58450209230bSgjelinek if (strcmp(rctlval->zone_rctlval_priv, "basic") == 0) { 58460209230bSgjelinek priv = RCPRIV_BASIC; 58470209230bSgjelinek } else if (strcmp(rctlval->zone_rctlval_priv, "privileged") == 0) { 58480209230bSgjelinek priv = RCPRIV_PRIVILEGED; 58490209230bSgjelinek } else { 58500209230bSgjelinek /* Invalid privilege */ 58510209230bSgjelinek return (Z_INVAL); 58520209230bSgjelinek } 58530209230bSgjelinek 58540209230bSgjelinek /* deal with negative input; strtoull(3c) doesn't do what we want */ 58550209230bSgjelinek if (rctlval->zone_rctlval_limit[0] == '-') 58560209230bSgjelinek return (Z_INVAL); 58570209230bSgjelinek /* Get the limit */ 58580209230bSgjelinek errno = 0; 58590209230bSgjelinek ull = strtoull(rctlval->zone_rctlval_limit, &endp, 0); 58600209230bSgjelinek if (errno != 0 || *endp != '\0') { 58610209230bSgjelinek /* parse failed */ 58620209230bSgjelinek return (Z_INVAL); 58630209230bSgjelinek } 58640209230bSgjelinek limit = (rctl_qty_t)ull; 58650209230bSgjelinek 58660209230bSgjelinek /* Get the action */ 58670209230bSgjelinek if (strcmp(rctlval->zone_rctlval_action, "none") == 0) { 58680209230bSgjelinek action = RCTL_LOCAL_NOACTION; 58690209230bSgjelinek } else if (strcmp(rctlval->zone_rctlval_action, "signal") == 0) { 58700209230bSgjelinek action = RCTL_LOCAL_SIGNAL; 58710209230bSgjelinek } else if (strcmp(rctlval->zone_rctlval_action, "deny") == 0) { 58720209230bSgjelinek action = RCTL_LOCAL_DENY; 58730209230bSgjelinek } else { 58740209230bSgjelinek /* Invalid Action */ 58750209230bSgjelinek return (Z_INVAL); 58760209230bSgjelinek } 58770209230bSgjelinek rctlblk_set_local_action(rctlblk, action, 0); 58780209230bSgjelinek rctlblk_set_privilege(rctlblk, priv); 58790209230bSgjelinek rctlblk_set_value(rctlblk, limit); 58800209230bSgjelinek return (Z_OK); 58810209230bSgjelinek } 58820209230bSgjelinek 58830209230bSgjelinek static int 58840209230bSgjelinek rctl_check(const char *rctlname, void *arg) 58850209230bSgjelinek { 58860209230bSgjelinek const char *attrname = arg; 58870209230bSgjelinek 58880209230bSgjelinek /* 58890209230bSgjelinek * Returning 1 here is our signal to zonecfg_is_rctl() that it is 58907c478bd9Sstevel@tonic-gate * indeed an rctl name recognized by the system. 58917c478bd9Sstevel@tonic-gate */ 58920209230bSgjelinek return (strcmp(rctlname, attrname) == 0 ? 1 : 0); 58930209230bSgjelinek } 58940209230bSgjelinek 58950209230bSgjelinek boolean_t 58960209230bSgjelinek zonecfg_is_rctl(const char *name) 58970209230bSgjelinek { 58980209230bSgjelinek return (rctl_walk(rctl_check, (void *)name) == 1); 58990209230bSgjelinek } 59000209230bSgjelinek 59010209230bSgjelinek boolean_t 59020209230bSgjelinek zonecfg_valid_rctlname(const char *name) 59030209230bSgjelinek { 59040209230bSgjelinek const char *c; 59050209230bSgjelinek 59060209230bSgjelinek if (strncmp(name, "zone.", sizeof ("zone.") - 1) != 0) 59070209230bSgjelinek return (B_FALSE); 59080209230bSgjelinek if (strlen(name) == sizeof ("zone.") - 1) 59090209230bSgjelinek return (B_FALSE); 59100209230bSgjelinek for (c = name + sizeof ("zone.") - 1; *c != '\0'; c++) { 59110209230bSgjelinek if (!isalpha(*c) && *c != '-') 59120209230bSgjelinek return (B_FALSE); 59130209230bSgjelinek } 59140209230bSgjelinek return (B_TRUE); 59150209230bSgjelinek } 59160209230bSgjelinek 59170209230bSgjelinek boolean_t 59180209230bSgjelinek zonecfg_valid_rctlblk(const rctlblk_t *rctlblk) 59190209230bSgjelinek { 59200209230bSgjelinek rctl_priv_t priv = rctlblk_get_privilege((rctlblk_t *)rctlblk); 59210209230bSgjelinek uint_t action = rctlblk_get_local_action((rctlblk_t *)rctlblk, NULL); 59220209230bSgjelinek 59230209230bSgjelinek if (priv != RCPRIV_PRIVILEGED) 59240209230bSgjelinek return (B_FALSE); 59250209230bSgjelinek if (action != RCTL_LOCAL_NOACTION && action != RCTL_LOCAL_DENY) 59260209230bSgjelinek return (B_FALSE); 59270209230bSgjelinek return (B_TRUE); 59280209230bSgjelinek } 59290209230bSgjelinek 59300209230bSgjelinek boolean_t 59310209230bSgjelinek zonecfg_valid_rctl(const char *name, const rctlblk_t *rctlblk) 59320209230bSgjelinek { 59330209230bSgjelinek rctlblk_t *current, *next; 59340209230bSgjelinek rctl_qty_t limit = rctlblk_get_value((rctlblk_t *)rctlblk); 59350209230bSgjelinek uint_t action = rctlblk_get_local_action((rctlblk_t *)rctlblk, NULL); 59360209230bSgjelinek uint_t global_flags; 59370209230bSgjelinek 59380209230bSgjelinek if (!zonecfg_valid_rctlblk(rctlblk)) 59390209230bSgjelinek return (B_FALSE); 59400209230bSgjelinek if (!zonecfg_valid_rctlname(name)) 59410209230bSgjelinek return (B_FALSE); 59420209230bSgjelinek 59430209230bSgjelinek current = alloca(rctlblk_size()); 59440209230bSgjelinek if (getrctl(name, NULL, current, RCTL_FIRST) != 0) 59450209230bSgjelinek return (B_TRUE); /* not an rctl on this system */ 59460209230bSgjelinek /* 59470209230bSgjelinek * Make sure the proposed value isn't greater than the current system 59480209230bSgjelinek * value. 59490209230bSgjelinek */ 59500209230bSgjelinek next = alloca(rctlblk_size()); 59510209230bSgjelinek while (rctlblk_get_privilege(current) != RCPRIV_SYSTEM) { 59520209230bSgjelinek rctlblk_t *tmp; 59530209230bSgjelinek 59540209230bSgjelinek if (getrctl(name, current, next, RCTL_NEXT) != 0) 59550209230bSgjelinek return (B_FALSE); /* shouldn't happen */ 59560209230bSgjelinek tmp = current; 59570209230bSgjelinek current = next; 59580209230bSgjelinek next = tmp; 59590209230bSgjelinek } 59600209230bSgjelinek if (limit > rctlblk_get_value(current)) 59610209230bSgjelinek return (B_FALSE); 59620209230bSgjelinek 59630209230bSgjelinek /* 59640209230bSgjelinek * Make sure the proposed action is allowed. 59650209230bSgjelinek */ 59660209230bSgjelinek global_flags = rctlblk_get_global_flags(current); 59670209230bSgjelinek if ((global_flags & RCTL_GLOBAL_DENY_NEVER) && 59680209230bSgjelinek action == RCTL_LOCAL_DENY) 59690209230bSgjelinek return (B_FALSE); 59700209230bSgjelinek if ((global_flags & RCTL_GLOBAL_DENY_ALWAYS) && 59710209230bSgjelinek action == RCTL_LOCAL_NOACTION) 59720209230bSgjelinek return (B_FALSE); 59730209230bSgjelinek 59740209230bSgjelinek return (B_TRUE); 59750209230bSgjelinek } 59760209230bSgjelinek 59770209230bSgjelinek /* 59780209230bSgjelinek * There is always a race condition between reading the initial copy of 59790209230bSgjelinek * a zones state and its state changing. We address this by providing 59800209230bSgjelinek * zonecfg_notify_critical_enter and zonecfg_noticy_critical_exit functions. 59810209230bSgjelinek * When zonecfg_critical_enter is called, sets the state field to LOCKED 59820209230bSgjelinek * and aquires biglock. Biglock protects against other threads executing 59830209230bSgjelinek * critical_enter and the state field protects against state changes during 59840209230bSgjelinek * the critical period. 59850209230bSgjelinek * 59860209230bSgjelinek * If any state changes occur, zn_cb will set the failed field of the znotify 59870209230bSgjelinek * structure. This will cause the critical_exit function to re-lock the 59880209230bSgjelinek * channel and return an error. Since evsnts may be delayed, the critical_exit 59890209230bSgjelinek * function "flushes" the queue by putting an event on the queue and waiting for 59900209230bSgjelinek * zn_cb to notify critical_exit that it received the ping event. 59910209230bSgjelinek */ 59920209230bSgjelinek static const char * 59930209230bSgjelinek string_get_tok(const char *in, char delim, int num) 59940209230bSgjelinek { 59950209230bSgjelinek int i = 0; 59960209230bSgjelinek 59970209230bSgjelinek for (; i < num; in++) { 59980209230bSgjelinek if (*in == delim) 59990209230bSgjelinek i++; 60000209230bSgjelinek if (*in == 0) 60010209230bSgjelinek return (NULL); 60020209230bSgjelinek } 60030209230bSgjelinek return (in); 60040209230bSgjelinek } 60050209230bSgjelinek 60060209230bSgjelinek static boolean_t 60070209230bSgjelinek is_ping(sysevent_t *ev) 60080209230bSgjelinek { 60090209230bSgjelinek if (strcmp(sysevent_get_subclass_name(ev), 60100209230bSgjelinek ZONE_EVENT_PING_SUBCLASS) == 0) { 60110209230bSgjelinek return (B_TRUE); 60120209230bSgjelinek } else { 60130209230bSgjelinek return (B_FALSE); 60140209230bSgjelinek } 60150209230bSgjelinek } 60160209230bSgjelinek 60170209230bSgjelinek static boolean_t 60180209230bSgjelinek is_my_ping(sysevent_t *ev) 60190209230bSgjelinek { 60200209230bSgjelinek const char *sender; 60210209230bSgjelinek char mypid[sizeof (pid_t) * 3 + 1]; 60220209230bSgjelinek 60230209230bSgjelinek (void) snprintf(mypid, sizeof (mypid), "%i", getpid()); 60240209230bSgjelinek sender = string_get_tok(sysevent_get_pub(ev), ':', 3); 60250209230bSgjelinek if (sender == NULL) 60260209230bSgjelinek return (B_FALSE); 60270209230bSgjelinek if (strcmp(sender, mypid) != 0) 60280209230bSgjelinek return (B_FALSE); 60290209230bSgjelinek return (B_TRUE); 60300209230bSgjelinek } 60310209230bSgjelinek 60320209230bSgjelinek static int 60330209230bSgjelinek do_callback(struct znotify *zevtchan, sysevent_t *ev) 60340209230bSgjelinek { 60350209230bSgjelinek nvlist_t *l; 60360209230bSgjelinek int zid; 60370209230bSgjelinek char *zonename; 60380209230bSgjelinek char *newstate; 60390209230bSgjelinek char *oldstate; 60400209230bSgjelinek int ret; 60410209230bSgjelinek hrtime_t when; 60420209230bSgjelinek 60430209230bSgjelinek if (strcmp(sysevent_get_subclass_name(ev), 60440209230bSgjelinek ZONE_EVENT_STATUS_SUBCLASS) == 0) { 60450209230bSgjelinek 60460209230bSgjelinek if (sysevent_get_attr_list(ev, &l) != 0) { 60470209230bSgjelinek if (errno == ENOMEM) { 60480209230bSgjelinek zevtchan->zn_failure_count++; 60490209230bSgjelinek return (EAGAIN); 60500209230bSgjelinek } 60510209230bSgjelinek return (0); 60520209230bSgjelinek } 60530209230bSgjelinek ret = 0; 60540209230bSgjelinek 60550209230bSgjelinek if ((nvlist_lookup_string(l, ZONE_CB_NAME, &zonename) == 0) && 60560209230bSgjelinek (nvlist_lookup_string(l, ZONE_CB_NEWSTATE, &newstate) 60570209230bSgjelinek == 0) && 60580209230bSgjelinek (nvlist_lookup_string(l, ZONE_CB_OLDSTATE, &oldstate) 60590209230bSgjelinek == 0) && 60600209230bSgjelinek (nvlist_lookup_uint64(l, ZONE_CB_TIMESTAMP, 60610209230bSgjelinek (uint64_t *)&when) == 0) && 60620209230bSgjelinek (nvlist_lookup_int32(l, ZONE_CB_ZONEID, &zid) == 0)) { 60630209230bSgjelinek ret = zevtchan->zn_callback(zonename, zid, newstate, 60640209230bSgjelinek oldstate, when, zevtchan->zn_private); 60650209230bSgjelinek } 60660209230bSgjelinek 60670209230bSgjelinek zevtchan->zn_failure_count = 0; 60680209230bSgjelinek nvlist_free(l); 60690209230bSgjelinek return (ret); 60700209230bSgjelinek } else { 60710209230bSgjelinek /* 60720209230bSgjelinek * We have received an event in an unknown subclass. Ignore. 60730209230bSgjelinek */ 60740209230bSgjelinek zevtchan->zn_failure_count = 0; 60750209230bSgjelinek return (0); 60760209230bSgjelinek } 60770209230bSgjelinek } 60780209230bSgjelinek 60790209230bSgjelinek static int 60800209230bSgjelinek zn_cb(sysevent_t *ev, void *p) 60810209230bSgjelinek { 60820209230bSgjelinek struct znotify *zevtchan = p; 60830209230bSgjelinek int error; 60840209230bSgjelinek 60850209230bSgjelinek (void) pthread_mutex_lock(&(zevtchan->zn_mutex)); 60860209230bSgjelinek 60870209230bSgjelinek if (is_ping(ev) && !is_my_ping(ev)) { 60880209230bSgjelinek (void) pthread_mutex_unlock((&zevtchan->zn_mutex)); 60890209230bSgjelinek return (0); 60900209230bSgjelinek } 60910209230bSgjelinek 60920209230bSgjelinek if (zevtchan->zn_state == ZN_LOCKED) { 60930209230bSgjelinek assert(!is_ping(ev)); 60940209230bSgjelinek zevtchan->zn_failed = B_TRUE; 60950209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 60960209230bSgjelinek return (0); 60970209230bSgjelinek } 60980209230bSgjelinek 60990209230bSgjelinek if (zevtchan->zn_state == ZN_PING_INFLIGHT) { 61000209230bSgjelinek if (is_ping(ev)) { 61010209230bSgjelinek zevtchan->zn_state = ZN_PING_RECEIVED; 61020209230bSgjelinek (void) pthread_cond_signal(&(zevtchan->zn_cond)); 61030209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61040209230bSgjelinek return (0); 61050209230bSgjelinek } else { 61060209230bSgjelinek zevtchan->zn_failed = B_TRUE; 61070209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61080209230bSgjelinek return (0); 61090209230bSgjelinek } 61100209230bSgjelinek } 61110209230bSgjelinek 61120209230bSgjelinek if (zevtchan->zn_state == ZN_UNLOCKED) { 61130209230bSgjelinek 61140209230bSgjelinek error = do_callback(zevtchan, ev); 61150209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61160209230bSgjelinek /* 61170209230bSgjelinek * Every ENOMEM failure causes do_callback to increment 61180209230bSgjelinek * zn_failure_count and every success causes it to 61190209230bSgjelinek * set zn_failure_count to zero. If we got EAGAIN, 61200209230bSgjelinek * we will sleep for zn_failure_count seconds and return 61210209230bSgjelinek * EAGAIN to gpec to try again. 61220209230bSgjelinek * 61230209230bSgjelinek * After 55 seconds, or 10 try's we give up and drop the 61240209230bSgjelinek * event. 61250209230bSgjelinek */ 61260209230bSgjelinek if (error == EAGAIN) { 61270209230bSgjelinek if (zevtchan->zn_failure_count > ZONE_CB_RETRY_COUNT) { 61280209230bSgjelinek return (0); 61290209230bSgjelinek } 61300209230bSgjelinek (void) sleep(zevtchan->zn_failure_count); 61310209230bSgjelinek } 61320209230bSgjelinek return (error); 61330209230bSgjelinek } 61340209230bSgjelinek 61350209230bSgjelinek if (zevtchan->zn_state == ZN_PING_RECEIVED) { 61360209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61370209230bSgjelinek return (0); 61380209230bSgjelinek } 61390209230bSgjelinek 61400209230bSgjelinek abort(); 61410209230bSgjelinek return (0); 61420209230bSgjelinek } 61430209230bSgjelinek 61440209230bSgjelinek void 61450209230bSgjelinek zonecfg_notify_critical_enter(void *h) 61460209230bSgjelinek { 61470209230bSgjelinek struct znotify *zevtchan = h; 61480209230bSgjelinek 61490209230bSgjelinek (void) pthread_mutex_lock(&(zevtchan->zn_bigmutex)); 61500209230bSgjelinek zevtchan->zn_state = ZN_LOCKED; 61510209230bSgjelinek } 61520209230bSgjelinek 61530209230bSgjelinek int 61540209230bSgjelinek zonecfg_notify_critical_exit(void * h) 61550209230bSgjelinek { 61560209230bSgjelinek 61570209230bSgjelinek struct znotify *zevtchan = h; 61580209230bSgjelinek 61590209230bSgjelinek if (zevtchan->zn_state == ZN_UNLOCKED) 61600209230bSgjelinek return (0); 61610209230bSgjelinek 61620209230bSgjelinek (void) pthread_mutex_lock(&(zevtchan->zn_mutex)); 61630209230bSgjelinek zevtchan->zn_state = ZN_PING_INFLIGHT; 61640209230bSgjelinek 61650209230bSgjelinek (void) sysevent_evc_publish(zevtchan->zn_eventchan, 61660209230bSgjelinek ZONE_EVENT_STATUS_CLASS, 61670209230bSgjelinek ZONE_EVENT_PING_SUBCLASS, ZONE_EVENT_PING_PUBLISHER, 61680209230bSgjelinek zevtchan->zn_subscriber_id, NULL, EVCH_SLEEP); 61690209230bSgjelinek 61700209230bSgjelinek while (zevtchan->zn_state != ZN_PING_RECEIVED) { 61710209230bSgjelinek (void) pthread_cond_wait(&(zevtchan->zn_cond), 61720209230bSgjelinek &(zevtchan->zn_mutex)); 61730209230bSgjelinek } 61740209230bSgjelinek 61750209230bSgjelinek if (zevtchan->zn_failed == B_TRUE) { 61760209230bSgjelinek zevtchan->zn_state = ZN_LOCKED; 61770209230bSgjelinek zevtchan->zn_failed = B_FALSE; 61780209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61790209230bSgjelinek return (1); 61800209230bSgjelinek } 61810209230bSgjelinek 61820209230bSgjelinek zevtchan->zn_state = ZN_UNLOCKED; 61830209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_mutex)); 61840209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_bigmutex)); 61850209230bSgjelinek return (0); 61867c478bd9Sstevel@tonic-gate } 61877c478bd9Sstevel@tonic-gate 61880209230bSgjelinek void 61890209230bSgjelinek zonecfg_notify_critical_abort(void *h) 61907c478bd9Sstevel@tonic-gate { 61910209230bSgjelinek struct znotify *zevtchan = h; 61920209230bSgjelinek 61930209230bSgjelinek zevtchan->zn_state = ZN_UNLOCKED; 61940209230bSgjelinek zevtchan->zn_failed = B_FALSE; 61950209230bSgjelinek /* 61960209230bSgjelinek * Don't do anything about zn_lock. If it is held, it could only be 61970209230bSgjelinek * held by zn_cb and it will be unlocked soon. 61980209230bSgjelinek */ 61990209230bSgjelinek (void) pthread_mutex_unlock(&(zevtchan->zn_bigmutex)); 62007c478bd9Sstevel@tonic-gate } 62017c478bd9Sstevel@tonic-gate 62020209230bSgjelinek void * 62030209230bSgjelinek zonecfg_notify_bind(int(*func)(const char *zonename, zoneid_t zid, 62040209230bSgjelinek const char *newstate, const char *oldstate, hrtime_t when, void *p), 62050209230bSgjelinek void *p) 62067c478bd9Sstevel@tonic-gate { 62070209230bSgjelinek struct znotify *zevtchan; 62080209230bSgjelinek int i = 1; 62090209230bSgjelinek int r; 62107c478bd9Sstevel@tonic-gate 62110209230bSgjelinek zevtchan = malloc(sizeof (struct znotify)); 62120209230bSgjelinek 62130209230bSgjelinek if (zevtchan == NULL) 62140209230bSgjelinek return (NULL); 62150209230bSgjelinek 62160209230bSgjelinek zevtchan->zn_private = p; 62170209230bSgjelinek zevtchan->zn_callback = func; 62180209230bSgjelinek zevtchan->zn_state = ZN_UNLOCKED; 62190209230bSgjelinek zevtchan->zn_failed = B_FALSE; 62200209230bSgjelinek 62210209230bSgjelinek if (pthread_mutex_init(&(zevtchan->zn_mutex), NULL)) 62220209230bSgjelinek goto out3; 62230209230bSgjelinek if (pthread_cond_init(&(zevtchan->zn_cond), NULL)) { 62240209230bSgjelinek (void) pthread_mutex_destroy(&(zevtchan->zn_mutex)); 62250209230bSgjelinek goto out3; 62260209230bSgjelinek } 62270209230bSgjelinek if (pthread_mutex_init(&(zevtchan->zn_bigmutex), NULL)) { 62280209230bSgjelinek (void) pthread_mutex_destroy(&(zevtchan->zn_mutex)); 62290209230bSgjelinek (void) pthread_cond_destroy(&(zevtchan->zn_cond)); 62300209230bSgjelinek goto out3; 62317c478bd9Sstevel@tonic-gate } 62327c478bd9Sstevel@tonic-gate 62330209230bSgjelinek if (sysevent_evc_bind(ZONE_EVENT_CHANNEL, &(zevtchan->zn_eventchan), 62340209230bSgjelinek 0) != 0) 62350209230bSgjelinek goto out2; 62367c478bd9Sstevel@tonic-gate 62370209230bSgjelinek do { 62380209230bSgjelinek /* 62390209230bSgjelinek * At 4 digits the subscriber ID gets too long and we have 62400209230bSgjelinek * no chance of successfully registering. 62410209230bSgjelinek */ 62420209230bSgjelinek if (i > 999) 62430209230bSgjelinek goto out1; 62440209230bSgjelinek 62450209230bSgjelinek (void) sprintf(zevtchan->zn_subscriber_id, "zone_%li_%i", 62460209230bSgjelinek getpid() % 999999l, i); 62470209230bSgjelinek 62480209230bSgjelinek r = sysevent_evc_subscribe(zevtchan->zn_eventchan, 62490209230bSgjelinek zevtchan->zn_subscriber_id, ZONE_EVENT_STATUS_CLASS, zn_cb, 62500209230bSgjelinek zevtchan, 0); 62510209230bSgjelinek 62520209230bSgjelinek i++; 62530209230bSgjelinek 62540209230bSgjelinek } while (r); 62550209230bSgjelinek 62560209230bSgjelinek return (zevtchan); 62570209230bSgjelinek out1: 625849b225e1SGavin Maltby (void) sysevent_evc_unbind(zevtchan->zn_eventchan); 62590209230bSgjelinek out2: 62600209230bSgjelinek (void) pthread_mutex_destroy(&zevtchan->zn_mutex); 62610209230bSgjelinek (void) pthread_cond_destroy(&zevtchan->zn_cond); 62620209230bSgjelinek (void) pthread_mutex_destroy(&(zevtchan->zn_bigmutex)); 62630209230bSgjelinek out3: 62640209230bSgjelinek free(zevtchan); 62650209230bSgjelinek 62660209230bSgjelinek return (NULL); 62677c478bd9Sstevel@tonic-gate } 62687c478bd9Sstevel@tonic-gate 62690209230bSgjelinek void 62700209230bSgjelinek zonecfg_notify_unbind(void *handle) 62717c478bd9Sstevel@tonic-gate { 62727c478bd9Sstevel@tonic-gate 62730209230bSgjelinek int ret; 62747c478bd9Sstevel@tonic-gate 627549b225e1SGavin Maltby (void) sysevent_evc_unbind(((struct znotify *)handle)->zn_eventchan); 62767c478bd9Sstevel@tonic-gate /* 62770209230bSgjelinek * Check that all evc threads have gone away. This should be 62780209230bSgjelinek * enforced by sysevent_evc_unbind. 62797c478bd9Sstevel@tonic-gate */ 62800209230bSgjelinek ret = pthread_mutex_trylock(&((struct znotify *)handle)->zn_mutex); 62817c478bd9Sstevel@tonic-gate 62820209230bSgjelinek if (ret) 62830209230bSgjelinek abort(); 62847c478bd9Sstevel@tonic-gate 62850209230bSgjelinek (void) pthread_mutex_unlock(&((struct znotify *)handle)->zn_mutex); 62860209230bSgjelinek (void) pthread_mutex_destroy(&((struct znotify *)handle)->zn_mutex); 62870209230bSgjelinek (void) pthread_cond_destroy(&((struct znotify *)handle)->zn_cond); 62880209230bSgjelinek (void) pthread_mutex_destroy(&((struct znotify *)handle)->zn_bigmutex); 62897c478bd9Sstevel@tonic-gate 62900209230bSgjelinek free(handle); 62917c478bd9Sstevel@tonic-gate } 6292fa9e4066Sahrens 62930209230bSgjelinek static int 62940209230bSgjelinek zonecfg_add_ds_core(zone_dochandle_t handle, struct zone_dstab *tabptr) 6295cf8f45c7Sdstaff { 62960209230bSgjelinek xmlNodePtr newnode, cur = handle->zone_dh_cur; 62970209230bSgjelinek int err; 6298cf8f45c7Sdstaff 62990209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_DATASET, NULL); 63000209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_NAME, 63010209230bSgjelinek tabptr->zone_dataset_name)) != Z_OK) 63020209230bSgjelinek return (err); 63030209230bSgjelinek return (Z_OK); 6304cf8f45c7Sdstaff } 6305cf8f45c7Sdstaff 63060209230bSgjelinek int 63070209230bSgjelinek zonecfg_add_ds(zone_dochandle_t handle, struct zone_dstab *tabptr) 6308cf8f45c7Sdstaff { 63090209230bSgjelinek int err; 63100209230bSgjelinek 63110209230bSgjelinek if (tabptr == NULL) 63120209230bSgjelinek return (Z_INVAL); 63130209230bSgjelinek 63140209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 63150209230bSgjelinek return (err); 63160209230bSgjelinek 63170209230bSgjelinek if ((err = zonecfg_add_ds_core(handle, tabptr)) != Z_OK) 63180209230bSgjelinek return (err); 63190209230bSgjelinek 63200209230bSgjelinek return (Z_OK); 63210209230bSgjelinek } 63220209230bSgjelinek 63230209230bSgjelinek static int 63240209230bSgjelinek zonecfg_delete_ds_core(zone_dochandle_t handle, struct zone_dstab *tabptr) 63250209230bSgjelinek { 63260209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 63270209230bSgjelinek 63280209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 63290209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_DATASET)) 63300209230bSgjelinek continue; 63310209230bSgjelinek 63320209230bSgjelinek if (match_prop(cur, DTD_ATTR_NAME, 63330209230bSgjelinek tabptr->zone_dataset_name)) { 63340209230bSgjelinek xmlUnlinkNode(cur); 63350209230bSgjelinek xmlFreeNode(cur); 63360209230bSgjelinek return (Z_OK); 63370209230bSgjelinek } 6338cf8f45c7Sdstaff } 63390209230bSgjelinek return (Z_NO_RESOURCE_ID); 63400209230bSgjelinek } 63410209230bSgjelinek 63420209230bSgjelinek int 63430209230bSgjelinek zonecfg_delete_ds(zone_dochandle_t handle, struct zone_dstab *tabptr) 63440209230bSgjelinek { 63450209230bSgjelinek int err; 63460209230bSgjelinek 63470209230bSgjelinek if (tabptr == NULL) 63480209230bSgjelinek return (Z_INVAL); 63490209230bSgjelinek 63500209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 63510209230bSgjelinek return (err); 63520209230bSgjelinek 63530209230bSgjelinek if ((err = zonecfg_delete_ds_core(handle, tabptr)) != Z_OK) 63540209230bSgjelinek return (err); 63550209230bSgjelinek 63560209230bSgjelinek return (Z_OK); 6357cf8f45c7Sdstaff } 6358cf8f45c7Sdstaff 63590209230bSgjelinek int 63600209230bSgjelinek zonecfg_modify_ds( 63610209230bSgjelinek zone_dochandle_t handle, 63620209230bSgjelinek struct zone_dstab *oldtabptr, 63630209230bSgjelinek struct zone_dstab *newtabptr) 63640209230bSgjelinek { 63650209230bSgjelinek int err; 63660209230bSgjelinek 63670209230bSgjelinek if (oldtabptr == NULL || newtabptr == NULL) 63680209230bSgjelinek return (Z_INVAL); 63690209230bSgjelinek 63700209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 63710209230bSgjelinek return (err); 6372cf8f45c7Sdstaff 63730209230bSgjelinek if ((err = zonecfg_delete_ds_core(handle, oldtabptr)) != Z_OK) 63740209230bSgjelinek return (err); 63750209230bSgjelinek 63760209230bSgjelinek if ((err = zonecfg_add_ds_core(handle, newtabptr)) != Z_OK) 63770209230bSgjelinek return (err); 63780209230bSgjelinek 63790209230bSgjelinek return (Z_OK); 6380cf8f45c7Sdstaff } 6381cf8f45c7Sdstaff 63820209230bSgjelinek int 63830209230bSgjelinek zonecfg_lookup_ds(zone_dochandle_t handle, struct zone_dstab *tabptr) 6384cf8f45c7Sdstaff { 63850209230bSgjelinek xmlNodePtr cur, firstmatch; 63860209230bSgjelinek int err; 63870209230bSgjelinek char dataset[MAXNAMELEN]; 6388cf8f45c7Sdstaff 63890209230bSgjelinek if (tabptr == NULL) 63900209230bSgjelinek return (Z_INVAL); 6391cf8f45c7Sdstaff 63920209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 63930209230bSgjelinek return (err); 63940209230bSgjelinek 63950209230bSgjelinek cur = handle->zone_dh_cur; 63960209230bSgjelinek firstmatch = NULL; 63970209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 63980209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_DATASET)) 63990209230bSgjelinek continue; 64000209230bSgjelinek if (strlen(tabptr->zone_dataset_name) > 0) { 64010209230bSgjelinek if ((fetchprop(cur, DTD_ATTR_NAME, dataset, 64020209230bSgjelinek sizeof (dataset)) == Z_OK) && 64030209230bSgjelinek (strcmp(tabptr->zone_dataset_name, 64040209230bSgjelinek dataset) == 0)) { 64050209230bSgjelinek if (firstmatch == NULL) 64060209230bSgjelinek firstmatch = cur; 64070209230bSgjelinek else 64080209230bSgjelinek return (Z_INSUFFICIENT_SPEC); 6409cf8f45c7Sdstaff } 6410cf8f45c7Sdstaff } 64110209230bSgjelinek } 64120209230bSgjelinek if (firstmatch == NULL) 64130209230bSgjelinek return (Z_NO_RESOURCE_ID); 6414cf8f45c7Sdstaff 64150209230bSgjelinek cur = firstmatch; 6416cf8f45c7Sdstaff 64170209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_dataset_name, 64180209230bSgjelinek sizeof (tabptr->zone_dataset_name))) != Z_OK) 64190209230bSgjelinek return (err); 64200209230bSgjelinek 64210209230bSgjelinek return (Z_OK); 6422cf8f45c7Sdstaff } 6423cf8f45c7Sdstaff 64240209230bSgjelinek int 64250209230bSgjelinek zonecfg_setdsent(zone_dochandle_t handle) 6426cf8f45c7Sdstaff { 64270209230bSgjelinek return (zonecfg_setent(handle)); 64280209230bSgjelinek } 6429cf8f45c7Sdstaff 64300209230bSgjelinek int 64310209230bSgjelinek zonecfg_getdsent(zone_dochandle_t handle, struct zone_dstab *tabptr) 64320209230bSgjelinek { 64330209230bSgjelinek xmlNodePtr cur; 64340209230bSgjelinek int err; 6435cf8f45c7Sdstaff 64360209230bSgjelinek if (handle == NULL) 64370209230bSgjelinek return (Z_INVAL); 6438cf8f45c7Sdstaff 64390209230bSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 64400209230bSgjelinek return (Z_NO_ENTRY); 6441cf8f45c7Sdstaff 64420209230bSgjelinek for (; cur != NULL; cur = cur->next) 64430209230bSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_DATASET)) 64440209230bSgjelinek break; 64450209230bSgjelinek if (cur == NULL) { 64460209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 64470209230bSgjelinek return (Z_NO_ENTRY); 6448cf8f45c7Sdstaff } 6449cf8f45c7Sdstaff 64500209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_dataset_name, 64510209230bSgjelinek sizeof (tabptr->zone_dataset_name))) != Z_OK) { 64520209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 64530209230bSgjelinek return (err); 6454cf8f45c7Sdstaff } 6455cf8f45c7Sdstaff 64560209230bSgjelinek handle->zone_dh_cur = cur->next; 64570209230bSgjelinek return (Z_OK); 6458cf8f45c7Sdstaff } 6459cf8f45c7Sdstaff 64600209230bSgjelinek int 64610209230bSgjelinek zonecfg_enddsent(zone_dochandle_t handle) 6462cf8f45c7Sdstaff { 64630209230bSgjelinek return (zonecfg_endent(handle)); 6464cf8f45c7Sdstaff } 6465cf8f45c7Sdstaff 64660209230bSgjelinek /* 64670209230bSgjelinek * Support for aliased rctls; that is, rctls that have simplified names in 64680209230bSgjelinek * zonecfg. For example, max-lwps is an alias for a well defined zone.max-lwps 64690209230bSgjelinek * rctl. If there are multiple existing values for one of these rctls or if 64700209230bSgjelinek * there is a single value that does not match the well defined template (i.e. 64710209230bSgjelinek * it has a different action) then we cannot treat the rctl as having an alias 64720209230bSgjelinek * so we return Z_ALIAS_DISALLOW. That means that the rctl cannot be 64730209230bSgjelinek * managed in zonecfg via an alias and that the standard rctl syntax must be 64740209230bSgjelinek * used. 64750209230bSgjelinek * 64760209230bSgjelinek * The possible return values are: 64770209230bSgjelinek * Z_NO_PROPERTY_ID - invalid alias name 64780209230bSgjelinek * Z_ALIAS_DISALLOW - pre-existing, incompatible rctl definition 64790209230bSgjelinek * Z_NO_ENTRY - no rctl is configured for this alias 64800209230bSgjelinek * Z_OK - we got a valid rctl for the specified alias 64810209230bSgjelinek */ 6482cf8f45c7Sdstaff int 64830209230bSgjelinek zonecfg_get_aliased_rctl(zone_dochandle_t handle, char *name, uint64_t *rval) 6484cf8f45c7Sdstaff { 64850209230bSgjelinek boolean_t found = B_FALSE; 64860209230bSgjelinek boolean_t found_val = B_FALSE; 64870209230bSgjelinek xmlNodePtr cur, val; 64880209230bSgjelinek char savedname[MAXNAMELEN]; 64890209230bSgjelinek struct zone_rctlvaltab rctl; 64900209230bSgjelinek int i; 64910209230bSgjelinek int err; 6492cf8f45c7Sdstaff 64930209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 64940209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 64950209230bSgjelinek break; 6496cf8f45c7Sdstaff 64970209230bSgjelinek if (aliases[i].shortname == NULL) 64980209230bSgjelinek return (Z_NO_PROPERTY_ID); 6499cf8f45c7Sdstaff 65000209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 65010209230bSgjelinek return (err); 6502cf8f45c7Sdstaff 65030209230bSgjelinek cur = handle->zone_dh_cur; 65040209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 65050209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_RCTL) != 0) 65060209230bSgjelinek continue; 65070209230bSgjelinek if ((fetchprop(cur, DTD_ATTR_NAME, savedname, 65080209230bSgjelinek sizeof (savedname)) == Z_OK) && 65090209230bSgjelinek (strcmp(savedname, aliases[i].realname) == 0)) { 6510cf8f45c7Sdstaff 65110209230bSgjelinek /* 65120209230bSgjelinek * If we already saw one of these, we can't have an 65130209230bSgjelinek * alias since we just found another. 65140209230bSgjelinek */ 65150209230bSgjelinek if (found) 65160209230bSgjelinek return (Z_ALIAS_DISALLOW); 65170209230bSgjelinek found = B_TRUE; 65180209230bSgjelinek 65190209230bSgjelinek for (val = cur->xmlChildrenNode; val != NULL; 65200209230bSgjelinek val = val->next) { 65210209230bSgjelinek /* 65220209230bSgjelinek * If we already have one value, we can't have 65230209230bSgjelinek * an alias since we just found another. 65240209230bSgjelinek */ 65250209230bSgjelinek if (found_val) 65260209230bSgjelinek return (Z_ALIAS_DISALLOW); 65270209230bSgjelinek found_val = B_TRUE; 65280209230bSgjelinek 65290209230bSgjelinek if ((fetchprop(val, DTD_ATTR_PRIV, 65300209230bSgjelinek rctl.zone_rctlval_priv, 65310209230bSgjelinek sizeof (rctl.zone_rctlval_priv)) != Z_OK)) 65320209230bSgjelinek break; 65330209230bSgjelinek if ((fetchprop(val, DTD_ATTR_LIMIT, 65340209230bSgjelinek rctl.zone_rctlval_limit, 65350209230bSgjelinek sizeof (rctl.zone_rctlval_limit)) != Z_OK)) 65360209230bSgjelinek break; 65370209230bSgjelinek if ((fetchprop(val, DTD_ATTR_ACTION, 65380209230bSgjelinek rctl.zone_rctlval_action, 65390209230bSgjelinek sizeof (rctl.zone_rctlval_action)) != Z_OK)) 65400209230bSgjelinek break; 65410209230bSgjelinek } 65420209230bSgjelinek 65430209230bSgjelinek /* check priv and action match the expected vals */ 65440209230bSgjelinek if (strcmp(rctl.zone_rctlval_priv, 65450209230bSgjelinek aliases[i].priv) != 0 || 65460209230bSgjelinek strcmp(rctl.zone_rctlval_action, 65470209230bSgjelinek aliases[i].action) != 0) 65480209230bSgjelinek return (Z_ALIAS_DISALLOW); 65490209230bSgjelinek } 6550cf8f45c7Sdstaff } 6551cf8f45c7Sdstaff 65520209230bSgjelinek if (found) { 65530209230bSgjelinek *rval = strtoull(rctl.zone_rctlval_limit, NULL, 10); 65540209230bSgjelinek return (Z_OK); 6555cf8f45c7Sdstaff } 6556cf8f45c7Sdstaff 65570209230bSgjelinek return (Z_NO_ENTRY); 6558cf8f45c7Sdstaff } 6559cf8f45c7Sdstaff 65600209230bSgjelinek int 65610209230bSgjelinek zonecfg_rm_aliased_rctl(zone_dochandle_t handle, char *name) 6562cf8f45c7Sdstaff { 65630209230bSgjelinek int i; 65640209230bSgjelinek uint64_t val; 65650209230bSgjelinek struct zone_rctltab rctltab; 6566cf8f45c7Sdstaff 6567cf8f45c7Sdstaff /* 65680209230bSgjelinek * First check that we have a valid aliased rctl to remove. 65690209230bSgjelinek * This will catch an rctl entry with non-standard values or 65700209230bSgjelinek * multiple rctl values for this name. We need to ignore those 65710209230bSgjelinek * rctl entries. 6572cf8f45c7Sdstaff */ 65730209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, name, &val) != Z_OK) 65740209230bSgjelinek return (Z_OK); 65750209230bSgjelinek 65760209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 65770209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 65780209230bSgjelinek break; 65790209230bSgjelinek 65800209230bSgjelinek if (aliases[i].shortname == NULL) 65810209230bSgjelinek return (Z_NO_RESOURCE_ID); 65820209230bSgjelinek 65830209230bSgjelinek (void) strlcpy(rctltab.zone_rctl_name, aliases[i].realname, 65840209230bSgjelinek sizeof (rctltab.zone_rctl_name)); 65850209230bSgjelinek 65860209230bSgjelinek return (zonecfg_delete_rctl(handle, &rctltab)); 65870209230bSgjelinek } 65880209230bSgjelinek 65890209230bSgjelinek boolean_t 65900209230bSgjelinek zonecfg_aliased_rctl_ok(zone_dochandle_t handle, char *name) 65910209230bSgjelinek { 65920209230bSgjelinek uint64_t tmp_val; 65930209230bSgjelinek 65940209230bSgjelinek switch (zonecfg_get_aliased_rctl(handle, name, &tmp_val)) { 65950209230bSgjelinek case Z_OK: 65960209230bSgjelinek /*FALLTHRU*/ 65970209230bSgjelinek case Z_NO_ENTRY: 65980209230bSgjelinek return (B_TRUE); 65990209230bSgjelinek default: 66000209230bSgjelinek return (B_FALSE); 66010209230bSgjelinek } 6602cf8f45c7Sdstaff } 6603cf8f45c7Sdstaff 66040209230bSgjelinek int 66050209230bSgjelinek zonecfg_set_aliased_rctl(zone_dochandle_t handle, char *name, uint64_t val) 6606cf8f45c7Sdstaff { 66070209230bSgjelinek int i; 66080209230bSgjelinek int err; 66090209230bSgjelinek struct zone_rctltab rctltab; 66100209230bSgjelinek struct zone_rctlvaltab *rctlvaltab; 66110209230bSgjelinek char buf[128]; 6612cf8f45c7Sdstaff 66130209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, name)) 66140209230bSgjelinek return (Z_ALIAS_DISALLOW); 6615cf8f45c7Sdstaff 66160209230bSgjelinek for (i = 0; aliases[i].shortname != NULL; i++) 66170209230bSgjelinek if (strcmp(name, aliases[i].shortname) == 0) 66180209230bSgjelinek break; 6619cf8f45c7Sdstaff 66200209230bSgjelinek if (aliases[i].shortname == NULL) 66210209230bSgjelinek return (Z_NO_RESOURCE_ID); 6622cf8f45c7Sdstaff 66230209230bSgjelinek /* remove any pre-existing definition for this rctl */ 66240209230bSgjelinek (void) zonecfg_rm_aliased_rctl(handle, name); 6625cf8f45c7Sdstaff 66260209230bSgjelinek (void) strlcpy(rctltab.zone_rctl_name, aliases[i].realname, 66270209230bSgjelinek sizeof (rctltab.zone_rctl_name)); 6628cf8f45c7Sdstaff 66290209230bSgjelinek rctltab.zone_rctl_valptr = NULL; 6630cf8f45c7Sdstaff 66310209230bSgjelinek if ((rctlvaltab = calloc(1, sizeof (struct zone_rctlvaltab))) == NULL) 66320209230bSgjelinek return (Z_NOMEM); 6633cf8f45c7Sdstaff 66340209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", (long long)val); 6635cf8f45c7Sdstaff 66360209230bSgjelinek (void) strlcpy(rctlvaltab->zone_rctlval_priv, aliases[i].priv, 66370209230bSgjelinek sizeof (rctlvaltab->zone_rctlval_priv)); 66380209230bSgjelinek (void) strlcpy(rctlvaltab->zone_rctlval_limit, buf, 66390209230bSgjelinek sizeof (rctlvaltab->zone_rctlval_limit)); 66400209230bSgjelinek (void) strlcpy(rctlvaltab->zone_rctlval_action, aliases[i].action, 66410209230bSgjelinek sizeof (rctlvaltab->zone_rctlval_action)); 6642cf8f45c7Sdstaff 66430209230bSgjelinek rctlvaltab->zone_rctlval_next = NULL; 6644cf8f45c7Sdstaff 66450209230bSgjelinek if ((err = zonecfg_add_rctl_value(&rctltab, rctlvaltab)) != Z_OK) 66460209230bSgjelinek return (err); 6647cf8f45c7Sdstaff 66480209230bSgjelinek return (zonecfg_add_rctl(handle, &rctltab)); 6649cf8f45c7Sdstaff } 6650cf8f45c7Sdstaff 66510209230bSgjelinek static int 66520209230bSgjelinek delete_tmp_pool(zone_dochandle_t handle) 6653cf8f45c7Sdstaff { 66540209230bSgjelinek int err; 66550209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 6656cf8f45c7Sdstaff 66570209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 66580209230bSgjelinek return (err); 6659cf8f45c7Sdstaff 66600209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 66610209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_TMPPOOL) == 0) { 66620209230bSgjelinek xmlUnlinkNode(cur); 66630209230bSgjelinek xmlFreeNode(cur); 66640209230bSgjelinek return (Z_OK); 66650209230bSgjelinek } 66660209230bSgjelinek } 6667cf8f45c7Sdstaff 66680209230bSgjelinek return (Z_NO_RESOURCE_ID); 66690209230bSgjelinek } 6670cf8f45c7Sdstaff 66710209230bSgjelinek static int 66720209230bSgjelinek modify_tmp_pool(zone_dochandle_t handle, char *pool_importance) 66730209230bSgjelinek { 66740209230bSgjelinek int err; 66750209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 66760209230bSgjelinek xmlNodePtr newnode; 6677cf8f45c7Sdstaff 66780209230bSgjelinek err = delete_tmp_pool(handle); 66790209230bSgjelinek if (err != Z_OK && err != Z_NO_RESOURCE_ID) 66800209230bSgjelinek return (err); 66810209230bSgjelinek 66820209230bSgjelinek if (*pool_importance != '\0') { 66830209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 66840209230bSgjelinek return (err); 66850209230bSgjelinek 66860209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_TMPPOOL, NULL); 66870209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_IMPORTANCE, 66880209230bSgjelinek pool_importance)) != Z_OK) 66890209230bSgjelinek return (err); 66900209230bSgjelinek } 66910209230bSgjelinek 66920209230bSgjelinek return (Z_OK); 6693cf8f45c7Sdstaff } 6694cf8f45c7Sdstaff 6695fa9e4066Sahrens static int 66960209230bSgjelinek add_pset_core(zone_dochandle_t handle, struct zone_psettab *tabptr) 6697fa9e4066Sahrens { 6698fa9e4066Sahrens xmlNodePtr newnode, cur = handle->zone_dh_cur; 6699fa9e4066Sahrens int err; 6700fa9e4066Sahrens 67010209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_PSET, NULL); 67020209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_NCPU_MIN, 67030209230bSgjelinek tabptr->zone_ncpu_min)) != Z_OK) 67040209230bSgjelinek return (err); 67050209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_NCPU_MAX, 67060209230bSgjelinek tabptr->zone_ncpu_max)) != Z_OK) 67070209230bSgjelinek return (err); 67080209230bSgjelinek 67090209230bSgjelinek if ((err = modify_tmp_pool(handle, tabptr->zone_importance)) != Z_OK) 6710fa9e4066Sahrens return (err); 67110209230bSgjelinek 6712fa9e4066Sahrens return (Z_OK); 6713fa9e4066Sahrens } 6714fa9e4066Sahrens 6715fa9e4066Sahrens int 67160209230bSgjelinek zonecfg_add_pset(zone_dochandle_t handle, struct zone_psettab *tabptr) 6717fa9e4066Sahrens { 6718fa9e4066Sahrens int err; 6719fa9e4066Sahrens 6720fa9e4066Sahrens if (tabptr == NULL) 6721fa9e4066Sahrens return (Z_INVAL); 6722fa9e4066Sahrens 6723fa9e4066Sahrens if ((err = operation_prep(handle)) != Z_OK) 6724fa9e4066Sahrens return (err); 6725fa9e4066Sahrens 67260209230bSgjelinek if ((err = add_pset_core(handle, tabptr)) != Z_OK) 6727fa9e4066Sahrens return (err); 6728fa9e4066Sahrens 6729fa9e4066Sahrens return (Z_OK); 6730fa9e4066Sahrens } 6731fa9e4066Sahrens 67320209230bSgjelinek int 67330209230bSgjelinek zonecfg_delete_pset(zone_dochandle_t handle) 6734fa9e4066Sahrens { 67350209230bSgjelinek int err; 67360209230bSgjelinek int res = Z_NO_RESOURCE_ID; 6737fa9e4066Sahrens xmlNodePtr cur = handle->zone_dh_cur; 6738fa9e4066Sahrens 67390209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 67400209230bSgjelinek return (err); 6741fa9e4066Sahrens 67420209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 67430209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_PSET) == 0) { 6744fa9e4066Sahrens xmlUnlinkNode(cur); 6745fa9e4066Sahrens xmlFreeNode(cur); 67460209230bSgjelinek res = Z_OK; 67470209230bSgjelinek break; 6748fa9e4066Sahrens } 6749fa9e4066Sahrens } 67500209230bSgjelinek 67510209230bSgjelinek /* 67520209230bSgjelinek * Once we have msets, we should check that a mset 67530209230bSgjelinek * do not exist before we delete the tmp_pool data. 67540209230bSgjelinek */ 67550209230bSgjelinek err = delete_tmp_pool(handle); 67560209230bSgjelinek if (err != Z_OK && err != Z_NO_RESOURCE_ID) 67570209230bSgjelinek return (err); 67580209230bSgjelinek 67590209230bSgjelinek return (res); 6760fa9e4066Sahrens } 6761fa9e4066Sahrens 6762fa9e4066Sahrens int 67630209230bSgjelinek zonecfg_modify_pset(zone_dochandle_t handle, struct zone_psettab *tabptr) 6764fa9e4066Sahrens { 6765fa9e4066Sahrens int err; 6766fa9e4066Sahrens 6767fa9e4066Sahrens if (tabptr == NULL) 6768fa9e4066Sahrens return (Z_INVAL); 6769fa9e4066Sahrens 67700209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 6771fa9e4066Sahrens return (err); 6772fa9e4066Sahrens 67730209230bSgjelinek if ((err = add_pset_core(handle, tabptr)) != Z_OK) 6774fa9e4066Sahrens return (err); 6775fa9e4066Sahrens 6776fa9e4066Sahrens return (Z_OK); 6777fa9e4066Sahrens } 6778fa9e4066Sahrens 6779fa9e4066Sahrens int 67800209230bSgjelinek zonecfg_lookup_pset(zone_dochandle_t handle, struct zone_psettab *tabptr) 6781fa9e4066Sahrens { 67820209230bSgjelinek xmlNodePtr cur; 6783fa9e4066Sahrens int err; 67840209230bSgjelinek int res = Z_NO_ENTRY; 6785fa9e4066Sahrens 67860209230bSgjelinek if (tabptr == NULL) 6787fa9e4066Sahrens return (Z_INVAL); 6788fa9e4066Sahrens 6789fa9e4066Sahrens if ((err = operation_prep(handle)) != Z_OK) 6790fa9e4066Sahrens return (err); 6791fa9e4066Sahrens 67920209230bSgjelinek /* this is an optional component */ 67930209230bSgjelinek tabptr->zone_importance[0] = '\0'; 67940209230bSgjelinek 67950209230bSgjelinek cur = handle->zone_dh_cur; 67960209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 67970209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_PSET) == 0) { 67980209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NCPU_MIN, 67990209230bSgjelinek tabptr->zone_ncpu_min, 68000209230bSgjelinek sizeof (tabptr->zone_ncpu_min))) != Z_OK) { 68010209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 68020209230bSgjelinek return (err); 68030209230bSgjelinek } 68040209230bSgjelinek 68050209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NCPU_MAX, 68060209230bSgjelinek tabptr->zone_ncpu_max, 68070209230bSgjelinek sizeof (tabptr->zone_ncpu_max))) != Z_OK) { 68080209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 68090209230bSgjelinek return (err); 68100209230bSgjelinek } 68110209230bSgjelinek 68120209230bSgjelinek res = Z_OK; 68130209230bSgjelinek 68140209230bSgjelinek } else if (xmlStrcmp(cur->name, DTD_ELEM_TMPPOOL) == 0) { 68150209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_IMPORTANCE, 68160209230bSgjelinek tabptr->zone_importance, 68170209230bSgjelinek sizeof (tabptr->zone_importance))) != Z_OK) { 68180209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 68190209230bSgjelinek return (err); 68200209230bSgjelinek } 68210209230bSgjelinek } 68220209230bSgjelinek } 68230209230bSgjelinek 68240209230bSgjelinek return (res); 68250209230bSgjelinek } 68260209230bSgjelinek 68270209230bSgjelinek int 68280209230bSgjelinek zonecfg_getpsetent(zone_dochandle_t handle, struct zone_psettab *tabptr) 68290209230bSgjelinek { 68300209230bSgjelinek int err; 68310209230bSgjelinek 68320209230bSgjelinek if ((err = zonecfg_setent(handle)) != Z_OK) 6833fa9e4066Sahrens return (err); 6834fa9e4066Sahrens 68350209230bSgjelinek err = zonecfg_lookup_pset(handle, tabptr); 68360209230bSgjelinek 68370209230bSgjelinek (void) zonecfg_endent(handle); 68380209230bSgjelinek 68390209230bSgjelinek return (err); 68400209230bSgjelinek } 68410209230bSgjelinek 68420209230bSgjelinek static int 68430209230bSgjelinek add_mcap(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 68440209230bSgjelinek { 68450209230bSgjelinek xmlNodePtr newnode, cur = handle->zone_dh_cur; 68460209230bSgjelinek int err; 68470209230bSgjelinek 68480209230bSgjelinek newnode = xmlNewTextChild(cur, NULL, DTD_ELEM_MCAP, NULL); 68490209230bSgjelinek if ((err = newprop(newnode, DTD_ATTR_PHYSCAP, tabptr->zone_physmem_cap)) 68500209230bSgjelinek != Z_OK) 6851fa9e4066Sahrens return (err); 6852fa9e4066Sahrens 6853fa9e4066Sahrens return (Z_OK); 6854fa9e4066Sahrens } 6855fa9e4066Sahrens 6856fa9e4066Sahrens int 68570209230bSgjelinek zonecfg_delete_mcap(zone_dochandle_t handle) 6858fa9e4066Sahrens { 6859fa9e4066Sahrens int err; 68600209230bSgjelinek xmlNodePtr cur = handle->zone_dh_cur; 6861fa9e4066Sahrens 6862fa9e4066Sahrens if ((err = operation_prep(handle)) != Z_OK) 6863fa9e4066Sahrens return (err); 6864fa9e4066Sahrens 6865fa9e4066Sahrens for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 68660209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_MCAP) != 0) 6867fa9e4066Sahrens continue; 68680209230bSgjelinek 68690209230bSgjelinek xmlUnlinkNode(cur); 68700209230bSgjelinek xmlFreeNode(cur); 68710209230bSgjelinek return (Z_OK); 6872fa9e4066Sahrens } 68730209230bSgjelinek return (Z_NO_RESOURCE_ID); 68740209230bSgjelinek } 6875fa9e4066Sahrens 68760209230bSgjelinek int 68770209230bSgjelinek zonecfg_modify_mcap(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 68780209230bSgjelinek { 68790209230bSgjelinek int err; 6880fa9e4066Sahrens 68810209230bSgjelinek if (tabptr == NULL) 68820209230bSgjelinek return (Z_INVAL); 68830209230bSgjelinek 68840209230bSgjelinek err = zonecfg_delete_mcap(handle); 68850209230bSgjelinek /* it is ok if there is no mcap entry */ 68860209230bSgjelinek if (err != Z_OK && err != Z_NO_RESOURCE_ID) 68870209230bSgjelinek return (err); 68880209230bSgjelinek 68890209230bSgjelinek if ((err = add_mcap(handle, tabptr)) != Z_OK) 6890fa9e4066Sahrens return (err); 6891fa9e4066Sahrens 6892fa9e4066Sahrens return (Z_OK); 6893fa9e4066Sahrens } 6894fa9e4066Sahrens 6895fa9e4066Sahrens int 68960209230bSgjelinek zonecfg_lookup_mcap(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 6897fa9e4066Sahrens { 68980209230bSgjelinek xmlNodePtr cur; 68990209230bSgjelinek int err; 69000209230bSgjelinek 69010209230bSgjelinek if (tabptr == NULL) 69020209230bSgjelinek return (Z_INVAL); 69030209230bSgjelinek 69040209230bSgjelinek if ((err = operation_prep(handle)) != Z_OK) 69050209230bSgjelinek return (err); 69060209230bSgjelinek 69070209230bSgjelinek cur = handle->zone_dh_cur; 69080209230bSgjelinek for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 69090209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_MCAP) != 0) 69100209230bSgjelinek continue; 69110209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_PHYSCAP, 69120209230bSgjelinek tabptr->zone_physmem_cap, 69130209230bSgjelinek sizeof (tabptr->zone_physmem_cap))) != Z_OK) { 69140209230bSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 69150209230bSgjelinek return (err); 69160209230bSgjelinek } 69170209230bSgjelinek 69180209230bSgjelinek return (Z_OK); 69190209230bSgjelinek } 69200209230bSgjelinek 69210209230bSgjelinek return (Z_NO_ENTRY); 6922fa9e4066Sahrens } 6923fa9e4066Sahrens 69240209230bSgjelinek static int 69250209230bSgjelinek getmcapent_core(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 6926fa9e4066Sahrens { 6927fa9e4066Sahrens xmlNodePtr cur; 6928fa9e4066Sahrens int err; 6929fa9e4066Sahrens 6930fa9e4066Sahrens if (handle == NULL) 6931fa9e4066Sahrens return (Z_INVAL); 6932fa9e4066Sahrens 6933fa9e4066Sahrens if ((cur = handle->zone_dh_cur) == NULL) 6934fa9e4066Sahrens return (Z_NO_ENTRY); 6935fa9e4066Sahrens 6936fa9e4066Sahrens for (; cur != NULL; cur = cur->next) 69370209230bSgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_MCAP) == 0) 6938fa9e4066Sahrens break; 6939fa9e4066Sahrens if (cur == NULL) { 6940fa9e4066Sahrens handle->zone_dh_cur = handle->zone_dh_top; 6941fa9e4066Sahrens return (Z_NO_ENTRY); 6942fa9e4066Sahrens } 6943fa9e4066Sahrens 69440209230bSgjelinek if ((err = fetchprop(cur, DTD_ATTR_PHYSCAP, tabptr->zone_physmem_cap, 69450209230bSgjelinek sizeof (tabptr->zone_physmem_cap))) != Z_OK) { 6946fa9e4066Sahrens handle->zone_dh_cur = handle->zone_dh_top; 6947fa9e4066Sahrens return (err); 6948fa9e4066Sahrens } 6949fa9e4066Sahrens 6950fa9e4066Sahrens handle->zone_dh_cur = cur->next; 6951fa9e4066Sahrens return (Z_OK); 6952fa9e4066Sahrens } 6953fa9e4066Sahrens 6954fa9e4066Sahrens int 69550209230bSgjelinek zonecfg_getmcapent(zone_dochandle_t handle, struct zone_mcaptab *tabptr) 6956fa9e4066Sahrens { 69570209230bSgjelinek int err; 69580209230bSgjelinek 69590209230bSgjelinek if ((err = zonecfg_setent(handle)) != Z_OK) 69600209230bSgjelinek return (err); 69610209230bSgjelinek 69620209230bSgjelinek err = getmcapent_core(handle, tabptr); 69630209230bSgjelinek 69640209230bSgjelinek (void) zonecfg_endent(handle); 69650209230bSgjelinek 69660209230bSgjelinek return (err); 6967fa9e4066Sahrens } 6968ee519a1fSgjelinek 69696cfd72c6Sgjelinek /* 69704656d474SGarrett D'Amore * Get the full tree of pkg metadata in a set of nested AVL trees. 69714656d474SGarrett D'Amore * pkgs_avl is an AVL tree of pkgs. 69726cfd72c6Sgjelinek * 69734656d474SGarrett D'Amore * The zone xml data contains DTD_ELEM_PACKAGE elements. 69746cfd72c6Sgjelinek */ 6975ee519a1fSgjelinek int 69766cfd72c6Sgjelinek zonecfg_getpkgdata(zone_dochandle_t handle, uu_avl_pool_t *pkg_pool, 69776cfd72c6Sgjelinek uu_avl_t *pkgs_avl) 6978ee519a1fSgjelinek { 6979ee519a1fSgjelinek xmlNodePtr cur; 69806cfd72c6Sgjelinek int res; 69816cfd72c6Sgjelinek zone_pkg_entry_t *pkg; 69826cfd72c6Sgjelinek char name[MAXNAMELEN]; 69836cfd72c6Sgjelinek char version[ZONE_PKG_VERSMAX]; 6984ee519a1fSgjelinek 6985ee519a1fSgjelinek if (handle == NULL) 6986ee519a1fSgjelinek return (Z_INVAL); 6987ee519a1fSgjelinek 69886cfd72c6Sgjelinek if ((res = zonecfg_setent(handle)) != Z_OK) 69896cfd72c6Sgjelinek return (res); 6990ee519a1fSgjelinek 69916cfd72c6Sgjelinek if ((cur = handle->zone_dh_cur) == NULL) { 69926cfd72c6Sgjelinek res = Z_NO_ENTRY; 69936cfd72c6Sgjelinek goto done; 6994ee519a1fSgjelinek } 6995ee519a1fSgjelinek 69966cfd72c6Sgjelinek for (; cur != NULL; cur = cur->next) { 69976cfd72c6Sgjelinek if (xmlStrcmp(cur->name, DTD_ELEM_PACKAGE) == 0) { 69986cfd72c6Sgjelinek uu_avl_index_t where; 6999ee519a1fSgjelinek 70006cfd72c6Sgjelinek if ((res = fetchprop(cur, DTD_ATTR_NAME, name, 70016cfd72c6Sgjelinek sizeof (name))) != Z_OK) 70026cfd72c6Sgjelinek goto done; 7003ee519a1fSgjelinek 70046cfd72c6Sgjelinek if ((res = fetchprop(cur, DTD_ATTR_VERSION, version, 70056cfd72c6Sgjelinek sizeof (version))) != Z_OK) 70066cfd72c6Sgjelinek goto done; 7007ee519a1fSgjelinek 70086cfd72c6Sgjelinek if ((pkg = (zone_pkg_entry_t *) 70096cfd72c6Sgjelinek malloc(sizeof (zone_pkg_entry_t))) == NULL) { 70106cfd72c6Sgjelinek res = Z_NOMEM; 70116cfd72c6Sgjelinek goto done; 70126cfd72c6Sgjelinek } 7013ee519a1fSgjelinek 70146cfd72c6Sgjelinek if ((pkg->zpe_name = strdup(name)) == NULL) { 70156cfd72c6Sgjelinek free(pkg); 70166cfd72c6Sgjelinek res = Z_NOMEM; 70176cfd72c6Sgjelinek goto done; 70186cfd72c6Sgjelinek } 7019ee519a1fSgjelinek 70206cfd72c6Sgjelinek if ((pkg->zpe_vers = strdup(version)) == NULL) { 70216cfd72c6Sgjelinek free(pkg->zpe_name); 70226cfd72c6Sgjelinek free(pkg); 70236cfd72c6Sgjelinek res = Z_NOMEM; 70246cfd72c6Sgjelinek goto done; 70256cfd72c6Sgjelinek } 7026ee519a1fSgjelinek 70276cfd72c6Sgjelinek uu_avl_node_init(pkg, &pkg->zpe_entry, pkg_pool); 70286cfd72c6Sgjelinek if (uu_avl_find(pkgs_avl, pkg, NULL, &where) != NULL) { 70296cfd72c6Sgjelinek free(pkg->zpe_name); 70306cfd72c6Sgjelinek free(pkg->zpe_vers); 70316cfd72c6Sgjelinek free(pkg); 70326cfd72c6Sgjelinek } else { 70336cfd72c6Sgjelinek uu_avl_insert(pkgs_avl, pkg, where); 70346cfd72c6Sgjelinek } 70356cfd72c6Sgjelinek } 70366cfd72c6Sgjelinek } 70376cfd72c6Sgjelinek 70386cfd72c6Sgjelinek done: 70396cfd72c6Sgjelinek (void) zonecfg_endent(handle); 70406cfd72c6Sgjelinek return (res); 7041ee519a1fSgjelinek } 7042ee519a1fSgjelinek 7043ee519a1fSgjelinek int 7044ee519a1fSgjelinek zonecfg_setdevperment(zone_dochandle_t handle) 7045ee519a1fSgjelinek { 7046ee519a1fSgjelinek return (zonecfg_setent(handle)); 7047ee519a1fSgjelinek } 7048ee519a1fSgjelinek 7049ee519a1fSgjelinek int 7050ee519a1fSgjelinek zonecfg_getdevperment(zone_dochandle_t handle, struct zone_devpermtab *tabptr) 7051ee519a1fSgjelinek { 7052ee519a1fSgjelinek xmlNodePtr cur; 7053ee519a1fSgjelinek int err; 7054ee519a1fSgjelinek char buf[128]; 7055ee519a1fSgjelinek 7056ee519a1fSgjelinek tabptr->zone_devperm_acl = NULL; 7057ee519a1fSgjelinek 7058ee519a1fSgjelinek if (handle == NULL) 7059ee519a1fSgjelinek return (Z_INVAL); 7060ee519a1fSgjelinek 7061ee519a1fSgjelinek if ((cur = handle->zone_dh_cur) == NULL) 7062ee519a1fSgjelinek return (Z_NO_ENTRY); 7063ee519a1fSgjelinek 7064ee519a1fSgjelinek for (; cur != NULL; cur = cur->next) 7065ee519a1fSgjelinek if (!xmlStrcmp(cur->name, DTD_ELEM_DEV_PERM)) 7066ee519a1fSgjelinek break; 7067ee519a1fSgjelinek if (cur == NULL) { 7068ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7069ee519a1fSgjelinek return (Z_NO_ENTRY); 7070ee519a1fSgjelinek } 7071ee519a1fSgjelinek 7072ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_NAME, tabptr->zone_devperm_name, 7073ee519a1fSgjelinek sizeof (tabptr->zone_devperm_name))) != Z_OK) { 7074ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7075ee519a1fSgjelinek return (err); 7076ee519a1fSgjelinek } 7077ee519a1fSgjelinek 7078ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_UID, buf, sizeof (buf))) != Z_OK) { 7079ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7080ee519a1fSgjelinek return (err); 7081ee519a1fSgjelinek } 7082ee519a1fSgjelinek tabptr->zone_devperm_uid = (uid_t)atol(buf); 7083ee519a1fSgjelinek 7084ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_GID, buf, sizeof (buf))) != Z_OK) { 7085ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7086ee519a1fSgjelinek return (err); 7087ee519a1fSgjelinek } 7088ee519a1fSgjelinek tabptr->zone_devperm_gid = (gid_t)atol(buf); 7089ee519a1fSgjelinek 7090ee519a1fSgjelinek if ((err = fetchprop(cur, DTD_ATTR_MODE, buf, sizeof (buf))) != Z_OK) { 7091ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7092ee519a1fSgjelinek return (err); 7093ee519a1fSgjelinek } 7094ee519a1fSgjelinek tabptr->zone_devperm_mode = (mode_t)strtol(buf, (char **)NULL, 8); 7095ee519a1fSgjelinek 7096ee519a1fSgjelinek if ((err = fetch_alloc_prop(cur, DTD_ATTR_ACL, 7097ee519a1fSgjelinek &(tabptr->zone_devperm_acl))) != Z_OK) { 7098ee519a1fSgjelinek handle->zone_dh_cur = handle->zone_dh_top; 7099ee519a1fSgjelinek return (err); 7100ee519a1fSgjelinek } 7101ee519a1fSgjelinek 7102ee519a1fSgjelinek handle->zone_dh_cur = cur->next; 7103ee519a1fSgjelinek return (Z_OK); 7104ee519a1fSgjelinek } 7105ee519a1fSgjelinek 7106ee519a1fSgjelinek int 7107ee519a1fSgjelinek zonecfg_enddevperment(zone_dochandle_t handle) 7108ee519a1fSgjelinek { 7109ee519a1fSgjelinek return (zonecfg_endent(handle)); 7110ee519a1fSgjelinek } 7111ee519a1fSgjelinek 7112ff17c8bfSgjelinek /* PRINTFLIKE1 */ 7113ff17c8bfSgjelinek static void 7114ff17c8bfSgjelinek zerror(const char *zone_name, const char *fmt, ...) 711539935be5Sgjelinek { 7116ff17c8bfSgjelinek va_list alist; 711739935be5Sgjelinek 7118ff17c8bfSgjelinek va_start(alist, fmt); 7119ff17c8bfSgjelinek (void) fprintf(stderr, "zone '%s': ", zone_name); 7120ff17c8bfSgjelinek (void) vfprintf(stderr, fmt, alist); 7121ff17c8bfSgjelinek (void) fprintf(stderr, "\n"); 7122ff17c8bfSgjelinek va_end(alist); 7123ff17c8bfSgjelinek } 712439935be5Sgjelinek 7125ff17c8bfSgjelinek static void 7126ff17c8bfSgjelinek zperror(const char *str) 7127ff17c8bfSgjelinek { 7128ff17c8bfSgjelinek (void) fprintf(stderr, "%s: %s\n", str, strerror(errno)); 712939935be5Sgjelinek } 713039935be5Sgjelinek 7131ee519a1fSgjelinek /* 7132ff17c8bfSgjelinek * The following three routines implement a simple locking mechanism to 7133ff17c8bfSgjelinek * ensure that only one instance of zoneadm at a time is able to manipulate 7134ff17c8bfSgjelinek * a given zone. The lock is built on top of an fcntl(2) lock of 7135ff17c8bfSgjelinek * [<altroot>]/var/run/zones/<zonename>.zoneadm.lock. If a zoneadm instance 7136ff17c8bfSgjelinek * can grab that lock, it is allowed to manipulate the zone. 7137ff17c8bfSgjelinek * 7138ff17c8bfSgjelinek * Since zoneadm may call external applications which in turn invoke 7139ff17c8bfSgjelinek * zoneadm again, we introduce the notion of "lock inheritance". Any 7140ff17c8bfSgjelinek * instance of zoneadm that has another instance in its ancestry is assumed 7141ff17c8bfSgjelinek * to be acting on behalf of the original zoneadm, and is thus allowed to 7142ff17c8bfSgjelinek * manipulate its zone. 7143ee519a1fSgjelinek * 7144ff17c8bfSgjelinek * This inheritance is implemented via the _ZONEADM_LOCK_HELD environment 7145ff17c8bfSgjelinek * variable. When zoneadm is granted a lock on its zone, this environment 7146ff17c8bfSgjelinek * variable is set to 1. When it releases the lock, the variable is set to 7147ff17c8bfSgjelinek * 0. Since a child process inherits its parent's environment, checking 7148ff17c8bfSgjelinek * the state of this variable indicates whether or not any ancestor owns 7149ff17c8bfSgjelinek * the lock. 7150ee519a1fSgjelinek */ 7151ff17c8bfSgjelinek void 7152ff17c8bfSgjelinek zonecfg_init_lock_file(const char *zone_name, char **lock_env) 7153ff17c8bfSgjelinek { 7154ff17c8bfSgjelinek *lock_env = getenv(LOCK_ENV_VAR); 7155ff17c8bfSgjelinek if (*lock_env == NULL) { 7156ff17c8bfSgjelinek if (putenv(zoneadm_lock_not_held) != 0) { 7157ff17c8bfSgjelinek zerror(zone_name, gettext("could not set env: %s"), 7158ff17c8bfSgjelinek strerror(errno)); 7159ff17c8bfSgjelinek exit(1); 7160ee519a1fSgjelinek } 7161ff17c8bfSgjelinek } else { 7162ff17c8bfSgjelinek if (atoi(*lock_env) == 1) 7163ff17c8bfSgjelinek zone_lock_cnt = 1; 7164ff17c8bfSgjelinek } 7165ff17c8bfSgjelinek } 7166ee519a1fSgjelinek 7167ff17c8bfSgjelinek void 7168ff17c8bfSgjelinek zonecfg_release_lock_file(const char *zone_name, int lockfd) 7169ff17c8bfSgjelinek { 7170ff17c8bfSgjelinek /* 7171ff17c8bfSgjelinek * If we are cleaning up from a failed attempt to lock the zone for 7172ff17c8bfSgjelinek * the first time, we might have a zone_lock_cnt of 0. In that 7173ff17c8bfSgjelinek * error case, we don't want to do anything but close the lock 7174ff17c8bfSgjelinek * file. 7175ff17c8bfSgjelinek */ 7176ff17c8bfSgjelinek assert(zone_lock_cnt >= 0); 7177ff17c8bfSgjelinek if (zone_lock_cnt > 0) { 7178ff17c8bfSgjelinek assert(getenv(LOCK_ENV_VAR) != NULL); 7179ff17c8bfSgjelinek assert(atoi(getenv(LOCK_ENV_VAR)) == 1); 7180ff17c8bfSgjelinek if (--zone_lock_cnt > 0) { 7181ff17c8bfSgjelinek assert(lockfd == -1); 7182ff17c8bfSgjelinek return; 7183ee519a1fSgjelinek } 7184ff17c8bfSgjelinek if (putenv(zoneadm_lock_not_held) != 0) { 7185ff17c8bfSgjelinek zerror(zone_name, gettext("could not set env: %s"), 7186ff17c8bfSgjelinek strerror(errno)); 7187ff17c8bfSgjelinek exit(1); 7188ee519a1fSgjelinek } 7189ee519a1fSgjelinek } 7190ff17c8bfSgjelinek assert(lockfd >= 0); 7191ff17c8bfSgjelinek (void) close(lockfd); 7192ee519a1fSgjelinek } 7193ee519a1fSgjelinek 7194ff17c8bfSgjelinek int 7195ff17c8bfSgjelinek zonecfg_grab_lock_file(const char *zone_name, int *lockfd) 7196ee519a1fSgjelinek { 7197ff17c8bfSgjelinek char pathbuf[PATH_MAX]; 7198ff17c8bfSgjelinek struct flock flock; 7199ee519a1fSgjelinek 7200ff17c8bfSgjelinek /* 7201ff17c8bfSgjelinek * If we already have the lock, we can skip this expensive song 7202ff17c8bfSgjelinek * and dance. 7203ff17c8bfSgjelinek */ 7204ff17c8bfSgjelinek assert(zone_lock_cnt >= 0); 7205ff17c8bfSgjelinek assert(getenv(LOCK_ENV_VAR) != NULL); 7206ff17c8bfSgjelinek if (zone_lock_cnt > 0) { 7207ff17c8bfSgjelinek assert(atoi(getenv(LOCK_ENV_VAR)) == 1); 7208ff17c8bfSgjelinek zone_lock_cnt++; 7209ff17c8bfSgjelinek *lockfd = -1; 7210ee519a1fSgjelinek return (Z_OK); 721139935be5Sgjelinek } 7212ff17c8bfSgjelinek assert(getenv(LOCK_ENV_VAR) != NULL); 7213ff17c8bfSgjelinek assert(atoi(getenv(LOCK_ENV_VAR)) == 0); 7214ee519a1fSgjelinek 7215ff17c8bfSgjelinek if (snprintf(pathbuf, sizeof (pathbuf), "%s%s", zonecfg_get_root(), 7216ff17c8bfSgjelinek ZONES_TMPDIR) >= sizeof (pathbuf)) { 7217ff17c8bfSgjelinek zerror(zone_name, gettext("alternate root path is too long")); 7218ff17c8bfSgjelinek return (-1); 7219ff17c8bfSgjelinek } 7220ff17c8bfSgjelinek if (mkdir(pathbuf, S_IRWXU) < 0 && errno != EEXIST) { 7221ff17c8bfSgjelinek zerror(zone_name, gettext("could not mkdir %s: %s"), pathbuf, 7222ff17c8bfSgjelinek strerror(errno)); 7223ff17c8bfSgjelinek return (-1); 7224ff17c8bfSgjelinek } 7225ff17c8bfSgjelinek (void) chmod(pathbuf, S_IRWXU); 722607b574eeSgjelinek 722739935be5Sgjelinek /* 7228ff17c8bfSgjelinek * One of these lock files is created for each zone (when needed). 7229ff17c8bfSgjelinek * The lock files are not cleaned up (except on system reboot), 7230ff17c8bfSgjelinek * but since there is only one per zone, there is no resource 7231ff17c8bfSgjelinek * starvation issue. 723239935be5Sgjelinek */ 7233ff17c8bfSgjelinek if (snprintf(pathbuf, sizeof (pathbuf), "%s%s/%s.zoneadm.lock", 7234ff17c8bfSgjelinek zonecfg_get_root(), ZONES_TMPDIR, zone_name) >= sizeof (pathbuf)) { 7235ff17c8bfSgjelinek zerror(zone_name, gettext("alternate root path is too long")); 7236ff17c8bfSgjelinek return (-1); 7237ff17c8bfSgjelinek } 7238ff17c8bfSgjelinek if ((*lockfd = open(pathbuf, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR)) < 0) { 7239ff17c8bfSgjelinek zerror(zone_name, gettext("could not open %s: %s"), pathbuf, 7240ff17c8bfSgjelinek strerror(errno)); 7241ff17c8bfSgjelinek return (-1); 7242ee519a1fSgjelinek } 724339935be5Sgjelinek /* 7244ff17c8bfSgjelinek * Lock the file to synchronize with other zoneadmds 724539935be5Sgjelinek */ 7246ff17c8bfSgjelinek flock.l_type = F_WRLCK; 7247ff17c8bfSgjelinek flock.l_whence = SEEK_SET; 7248ff17c8bfSgjelinek flock.l_start = (off_t)0; 7249ff17c8bfSgjelinek flock.l_len = (off_t)0; 7250ff17c8bfSgjelinek if ((fcntl(*lockfd, F_SETLKW, &flock) < 0) || 7251ff17c8bfSgjelinek (putenv(zoneadm_lock_held) != 0)) { 7252ff17c8bfSgjelinek zerror(zone_name, gettext("unable to lock %s: %s"), pathbuf, 7253ff17c8bfSgjelinek strerror(errno)); 7254ff17c8bfSgjelinek zonecfg_release_lock_file(zone_name, *lockfd); 7255ff17c8bfSgjelinek return (-1); 7256ff17c8bfSgjelinek } 7257ff17c8bfSgjelinek zone_lock_cnt = 1; 7258ff17c8bfSgjelinek return (Z_OK); 7259ff17c8bfSgjelinek } 726039935be5Sgjelinek 7261edfa49ffS boolean_t 7262edfa49ffS zonecfg_lock_file_held(int *lockfd) 7263edfa49ffS { 7264edfa49ffS if (*lockfd >= 0 || zone_lock_cnt > 0) 7265edfa49ffS return (B_TRUE); 7266edfa49ffS return (B_FALSE); 7267edfa49ffS } 7268edfa49ffS 7269ff17c8bfSgjelinek static boolean_t 7270ff17c8bfSgjelinek get_doorname(const char *zone_name, char *buffer) 7271ff17c8bfSgjelinek { 7272ff17c8bfSgjelinek return (snprintf(buffer, PATH_MAX, "%s" ZONE_DOOR_PATH, 7273ff17c8bfSgjelinek zonecfg_get_root(), zone_name) < PATH_MAX); 7274ee519a1fSgjelinek } 7275ee519a1fSgjelinek 7276ee519a1fSgjelinek /* 7277ff17c8bfSgjelinek * system daemons are not audited. For the global zone, this occurs 7278ff17c8bfSgjelinek * "naturally" since init is started with the default audit 7279ff17c8bfSgjelinek * characteristics. Since zoneadmd is a system daemon and it starts 7280ff17c8bfSgjelinek * init for a zone, it is necessary to clear out the audit 7281ff17c8bfSgjelinek * characteristics inherited from whomever started zoneadmd. This is 7282ff17c8bfSgjelinek * indicated by the audit id, which is set from the ruid parameter of 7283ff17c8bfSgjelinek * adt_set_user(), below. 7284ee519a1fSgjelinek */ 7285ee519a1fSgjelinek 7286ff17c8bfSgjelinek static void 7287ff17c8bfSgjelinek prepare_audit_context(const char *zone_name) 7288ff17c8bfSgjelinek { 7289ff17c8bfSgjelinek adt_session_data_t *ah; 7290ff17c8bfSgjelinek char *failure = gettext("audit failure: %s"); 7291ee519a1fSgjelinek 7292ff17c8bfSgjelinek if (adt_start_session(&ah, NULL, 0)) { 7293ff17c8bfSgjelinek zerror(zone_name, failure, strerror(errno)); 7294ff17c8bfSgjelinek return; 7295ee519a1fSgjelinek } 7296ff17c8bfSgjelinek if (adt_set_user(ah, ADT_NO_AUDIT, ADT_NO_AUDIT, 7297ff17c8bfSgjelinek ADT_NO_AUDIT, ADT_NO_AUDIT, NULL, ADT_NEW)) { 7298ff17c8bfSgjelinek zerror(zone_name, failure, strerror(errno)); 7299ff17c8bfSgjelinek (void) adt_end_session(ah); 7300ff17c8bfSgjelinek return; 7301ee519a1fSgjelinek } 7302ff17c8bfSgjelinek if (adt_set_proc(ah)) 7303ff17c8bfSgjelinek zerror(zone_name, failure, strerror(errno)); 7304ee519a1fSgjelinek 7305ff17c8bfSgjelinek (void) adt_end_session(ah); 7306ee519a1fSgjelinek } 7307ee519a1fSgjelinek 7308ee519a1fSgjelinek static int 7309ff17c8bfSgjelinek start_zoneadmd(const char *zone_name, boolean_t lock) 7310ff17c8bfSgjelinek { 7311ff17c8bfSgjelinek char doorpath[PATH_MAX]; 7312ff17c8bfSgjelinek pid_t child_pid; 7313ff17c8bfSgjelinek int error = -1; 7314ff17c8bfSgjelinek int doorfd, lockfd; 7315ff17c8bfSgjelinek struct door_info info; 7316ee519a1fSgjelinek 7317ff17c8bfSgjelinek if (!get_doorname(zone_name, doorpath)) 7318ff17c8bfSgjelinek return (-1); 7319ee519a1fSgjelinek 7320ff17c8bfSgjelinek if (lock) 7321ff17c8bfSgjelinek if (zonecfg_grab_lock_file(zone_name, &lockfd) != Z_OK) 7322ff17c8bfSgjelinek return (-1); 7323ee519a1fSgjelinek 7324ff17c8bfSgjelinek /* 7325ff17c8bfSgjelinek * Now that we have the lock, re-confirm that the daemon is 7326ff17c8bfSgjelinek * *not* up and working fine. If it is still down, we have a green 7327ff17c8bfSgjelinek * light to start it. 7328ff17c8bfSgjelinek */ 7329ff17c8bfSgjelinek if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 7330ff17c8bfSgjelinek if (errno != ENOENT) { 7331ff17c8bfSgjelinek zperror(doorpath); 7332ff17c8bfSgjelinek goto out; 7333ee519a1fSgjelinek } 7334ff17c8bfSgjelinek } else { 7335ff17c8bfSgjelinek if (door_info(doorfd, &info) == 0 && 7336ff17c8bfSgjelinek ((info.di_attributes & DOOR_REVOKED) == 0)) { 7337ff17c8bfSgjelinek error = Z_OK; 7338ff17c8bfSgjelinek (void) close(doorfd); 7339ff17c8bfSgjelinek goto out; 7340ee519a1fSgjelinek } 7341ff17c8bfSgjelinek (void) close(doorfd); 7342ff17c8bfSgjelinek } 7343ee519a1fSgjelinek 7344ff17c8bfSgjelinek if ((child_pid = fork()) == -1) { 7345ff17c8bfSgjelinek zperror(gettext("could not fork")); 7346ff17c8bfSgjelinek goto out; 734739935be5Sgjelinek } 734839935be5Sgjelinek 7349ff17c8bfSgjelinek if (child_pid == 0) { 7350ff17c8bfSgjelinek const char *argv[6], **ap; 735139935be5Sgjelinek 7352ff17c8bfSgjelinek /* child process */ 7353ff17c8bfSgjelinek prepare_audit_context(zone_name); 735439935be5Sgjelinek 7355ff17c8bfSgjelinek ap = argv; 7356ff17c8bfSgjelinek *ap++ = "zoneadmd"; 7357ff17c8bfSgjelinek *ap++ = "-z"; 7358ff17c8bfSgjelinek *ap++ = zone_name; 7359ff17c8bfSgjelinek if (zonecfg_in_alt_root()) { 7360ff17c8bfSgjelinek *ap++ = "-R"; 7361ff17c8bfSgjelinek *ap++ = zonecfg_get_root(); 7362ee519a1fSgjelinek } 7363ff17c8bfSgjelinek *ap = NULL; 7364ee519a1fSgjelinek 7365ff17c8bfSgjelinek (void) execv("/usr/lib/zones/zoneadmd", (char * const *)argv); 7366ff17c8bfSgjelinek /* 7367ff17c8bfSgjelinek * TRANSLATION_NOTE 7368ff17c8bfSgjelinek * zoneadmd is a literal that should not be translated. 7369ff17c8bfSgjelinek */ 7370ff17c8bfSgjelinek zperror(gettext("could not exec zoneadmd")); 7371ff17c8bfSgjelinek _exit(1); 7372ff17c8bfSgjelinek } else { 7373ff17c8bfSgjelinek /* parent process */ 7374ff17c8bfSgjelinek pid_t retval; 7375ff17c8bfSgjelinek int pstatus = 0; 7376ff17c8bfSgjelinek 7377ff17c8bfSgjelinek do { 7378ff17c8bfSgjelinek retval = waitpid(child_pid, &pstatus, 0); 7379ff17c8bfSgjelinek } while (retval != child_pid); 7380ff17c8bfSgjelinek if (WIFSIGNALED(pstatus) || (WIFEXITED(pstatus) && 7381ff17c8bfSgjelinek WEXITSTATUS(pstatus) != 0)) { 7382ff17c8bfSgjelinek zerror(zone_name, gettext("could not start %s"), 7383ff17c8bfSgjelinek "zoneadmd"); 7384ff17c8bfSgjelinek goto out; 738539935be5Sgjelinek } 7386ee519a1fSgjelinek } 7387ff17c8bfSgjelinek error = Z_OK; 7388ff17c8bfSgjelinek out: 7389ff17c8bfSgjelinek if (lock) 7390ff17c8bfSgjelinek zonecfg_release_lock_file(zone_name, lockfd); 7391ff17c8bfSgjelinek return (error); 739239935be5Sgjelinek } 7393ee519a1fSgjelinek 7394ff17c8bfSgjelinek int 7395ff17c8bfSgjelinek zonecfg_ping_zoneadmd(const char *zone_name) 739639935be5Sgjelinek { 7397ff17c8bfSgjelinek char doorpath[PATH_MAX]; 7398ff17c8bfSgjelinek int doorfd; 7399ff17c8bfSgjelinek struct door_info info; 740039935be5Sgjelinek 7401ff17c8bfSgjelinek if (!get_doorname(zone_name, doorpath)) 7402ff17c8bfSgjelinek return (-1); 740339935be5Sgjelinek 7404ff17c8bfSgjelinek if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 7405ff17c8bfSgjelinek return (-1); 7406ff17c8bfSgjelinek } 7407ff17c8bfSgjelinek if (door_info(doorfd, &info) == 0 && 7408ff17c8bfSgjelinek ((info.di_attributes & DOOR_REVOKED) == 0)) { 7409ff17c8bfSgjelinek (void) close(doorfd); 7410ff17c8bfSgjelinek return (Z_OK); 7411ee519a1fSgjelinek } 7412ff17c8bfSgjelinek (void) close(doorfd); 7413ff17c8bfSgjelinek return (-1); 7414ff17c8bfSgjelinek } 7415ee519a1fSgjelinek 7416ff17c8bfSgjelinek int 7417ff17c8bfSgjelinek zonecfg_call_zoneadmd(const char *zone_name, zone_cmd_arg_t *arg, char *locale, 7418ff17c8bfSgjelinek boolean_t lock) 7419ff17c8bfSgjelinek { 7420ff17c8bfSgjelinek char doorpath[PATH_MAX]; 7421ff17c8bfSgjelinek int doorfd, result; 7422ff17c8bfSgjelinek door_arg_t darg; 7423ee519a1fSgjelinek 7424ff17c8bfSgjelinek zoneid_t zoneid; 7425ff17c8bfSgjelinek uint64_t uniqid = 0; 7426ee519a1fSgjelinek 7427ff17c8bfSgjelinek zone_cmd_rval_t *rvalp; 7428ff17c8bfSgjelinek size_t rlen; 7429ff17c8bfSgjelinek char *cp, *errbuf; 7430ee519a1fSgjelinek 7431ff17c8bfSgjelinek rlen = getpagesize(); 7432ff17c8bfSgjelinek if ((rvalp = malloc(rlen)) == NULL) { 7433ff17c8bfSgjelinek zerror(zone_name, gettext("failed to allocate %lu bytes: %s"), 7434ff17c8bfSgjelinek rlen, strerror(errno)); 7435ff17c8bfSgjelinek return (-1); 7436ff17c8bfSgjelinek } 743739935be5Sgjelinek 7438ff17c8bfSgjelinek if ((zoneid = getzoneidbyname(zone_name)) != ZONE_ID_UNDEFINED) { 7439ff17c8bfSgjelinek (void) zone_getattr(zoneid, ZONE_ATTR_UNIQID, &uniqid, 7440ff17c8bfSgjelinek sizeof (uniqid)); 7441ff17c8bfSgjelinek } 7442ff17c8bfSgjelinek arg->uniqid = uniqid; 7443ff17c8bfSgjelinek (void) strlcpy(arg->locale, locale, sizeof (arg->locale)); 7444ff17c8bfSgjelinek if (!get_doorname(zone_name, doorpath)) { 7445ff17c8bfSgjelinek zerror(zone_name, gettext("alternate root path is too long")); 7446ff17c8bfSgjelinek free(rvalp); 7447ff17c8bfSgjelinek return (-1); 7448ee519a1fSgjelinek } 7449ee519a1fSgjelinek 7450ff17c8bfSgjelinek /* 7451ff17c8bfSgjelinek * Loop trying to start zoneadmd; if something goes seriously 7452ff17c8bfSgjelinek * wrong we break out and fail. 7453ff17c8bfSgjelinek */ 7454ff17c8bfSgjelinek for (;;) { 7455ff17c8bfSgjelinek if (start_zoneadmd(zone_name, lock) != Z_OK) 7456ff17c8bfSgjelinek break; 7457ee519a1fSgjelinek 7458ff17c8bfSgjelinek if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 7459ff17c8bfSgjelinek zperror(gettext("failed to open zone door")); 7460ff17c8bfSgjelinek break; 7461ff17c8bfSgjelinek } 746239935be5Sgjelinek 7463ff17c8bfSgjelinek darg.data_ptr = (char *)arg; 7464ff17c8bfSgjelinek darg.data_size = sizeof (*arg); 7465ff17c8bfSgjelinek darg.desc_ptr = NULL; 7466ff17c8bfSgjelinek darg.desc_num = 0; 7467ff17c8bfSgjelinek darg.rbuf = (char *)rvalp; 7468ff17c8bfSgjelinek darg.rsize = rlen; 7469ff17c8bfSgjelinek if (door_call(doorfd, &darg) != 0) { 7470ff17c8bfSgjelinek (void) close(doorfd); 7471ff17c8bfSgjelinek /* 7472ff17c8bfSgjelinek * We'll get EBADF if the door has been revoked. 7473ff17c8bfSgjelinek */ 7474ff17c8bfSgjelinek if (errno != EBADF) { 7475ff17c8bfSgjelinek zperror(gettext("door_call failed")); 7476ff17c8bfSgjelinek break; 7477ff17c8bfSgjelinek } 7478ff17c8bfSgjelinek continue; /* take another lap */ 7479ff17c8bfSgjelinek } 7480ff17c8bfSgjelinek (void) close(doorfd); 7481ee519a1fSgjelinek 7482ff17c8bfSgjelinek if (darg.data_size == 0) { 7483ff17c8bfSgjelinek /* Door server is going away; kick it again. */ 74846cfd72c6Sgjelinek continue; 74856cfd72c6Sgjelinek } 74866cfd72c6Sgjelinek 7487ff17c8bfSgjelinek errbuf = rvalp->errbuf; 7488ff17c8bfSgjelinek while (*errbuf != '\0') { 74896cfd72c6Sgjelinek /* 7490ff17c8bfSgjelinek * Remove any newlines since zerror() 7491ff17c8bfSgjelinek * will append one automatically. 74926cfd72c6Sgjelinek */ 7493ff17c8bfSgjelinek cp = strchr(errbuf, '\n'); 7494ff17c8bfSgjelinek if (cp != NULL) 7495ff17c8bfSgjelinek *cp = '\0'; 7496ff17c8bfSgjelinek zerror(zone_name, "%s", errbuf); 7497ff17c8bfSgjelinek if (cp == NULL) 7498ff17c8bfSgjelinek break; 7499ff17c8bfSgjelinek errbuf = cp + 1; 7500ee519a1fSgjelinek } 7501ff17c8bfSgjelinek result = rvalp->rval == 0 ? 0 : -1; 7502ff17c8bfSgjelinek free(rvalp); 7503ff17c8bfSgjelinek return (result); 7504ee519a1fSgjelinek } 7505ee519a1fSgjelinek 7506ff17c8bfSgjelinek free(rvalp); 7507ff17c8bfSgjelinek return (-1); 7508ee519a1fSgjelinek } 7509cb8a054bSGlenn Faden 7510cb8a054bSGlenn Faden boolean_t 7511cb8a054bSGlenn Faden zonecfg_valid_auths(const char *auths, const char *zonename) 7512cb8a054bSGlenn Faden { 7513cb8a054bSGlenn Faden char *right; 7514cb8a054bSGlenn Faden char *tmpauths; 7515cb8a054bSGlenn Faden char *lasts; 7516cb8a054bSGlenn Faden char authname[MAXAUTHS]; 7517cb8a054bSGlenn Faden boolean_t status = B_TRUE; 7518cb8a054bSGlenn Faden 7519cb8a054bSGlenn Faden tmpauths = strdup(auths); 7520cb8a054bSGlenn Faden if (tmpauths == NULL) { 7521cb8a054bSGlenn Faden zerror(zonename, gettext("Out of memory")); 7522cb8a054bSGlenn Faden return (B_FALSE); 7523cb8a054bSGlenn Faden } 7524cb8a054bSGlenn Faden right = strtok_r(tmpauths, ",", &lasts); 7525cb8a054bSGlenn Faden while (right != NULL) { 7526cb8a054bSGlenn Faden (void) snprintf(authname, MAXAUTHS, "%s%s", 7527cb8a054bSGlenn Faden ZONE_AUTH_PREFIX, right); 7528cb8a054bSGlenn Faden if (getauthnam(authname) == NULL) { 7529cb8a054bSGlenn Faden status = B_FALSE; 7530a20ee416SGlenn Faden zerror(zonename, 7531d77d83efSGlenn Faden gettext("'%s' is not a valid authorization"), 7532cb8a054bSGlenn Faden right); 7533cb8a054bSGlenn Faden } 7534cb8a054bSGlenn Faden right = strtok_r(NULL, ",", &lasts); 7535cb8a054bSGlenn Faden } 7536cb8a054bSGlenn Faden free(tmpauths); 7537cb8a054bSGlenn Faden return (status); 7538cb8a054bSGlenn Faden } 7539cb8a054bSGlenn Faden 7540cb8a054bSGlenn Faden int 7541cb8a054bSGlenn Faden zonecfg_delete_admins(zone_dochandle_t handle, char *zonename) 7542cb8a054bSGlenn Faden { 7543cb8a054bSGlenn Faden int err; 7544cb8a054bSGlenn Faden struct zone_admintab admintab; 7545cb8a054bSGlenn Faden boolean_t changed = B_FALSE; 7546cb8a054bSGlenn Faden 7547cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 7548cb8a054bSGlenn Faden return (err); 7549cb8a054bSGlenn Faden } 7550cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 7551cb8a054bSGlenn Faden err = zonecfg_delete_admin(handle, &admintab, 7552cb8a054bSGlenn Faden zonename); 7553cb8a054bSGlenn Faden if (err != Z_OK) { 7554cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 7555cb8a054bSGlenn Faden return (err); 7556cb8a054bSGlenn Faden } else { 7557cb8a054bSGlenn Faden changed = B_TRUE; 7558cb8a054bSGlenn Faden } 7559cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 7560cb8a054bSGlenn Faden return (err); 7561cb8a054bSGlenn Faden } 7562cb8a054bSGlenn Faden } 7563cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 7564cb8a054bSGlenn Faden return (changed? Z_OK:Z_NO_ENTRY); 7565cb8a054bSGlenn Faden } 7566cb8a054bSGlenn Faden 7567cb8a054bSGlenn Faden /* 7568cb8a054bSGlenn Faden * Checks if a long authorization applies to this zone. 7569cb8a054bSGlenn Faden * If so, it returns true, after destructively stripping 7570cb8a054bSGlenn Faden * the authorization of its prefix and zone suffix. 7571cb8a054bSGlenn Faden */ 7572cb8a054bSGlenn Faden static boolean_t 7573cb8a054bSGlenn Faden is_zone_auth(char **auth, char *zonename, char *oldzonename) 7574cb8a054bSGlenn Faden { 7575cb8a054bSGlenn Faden char *suffix; 7576cb8a054bSGlenn Faden size_t offset; 7577cb8a054bSGlenn Faden 7578cb8a054bSGlenn Faden offset = strlen(ZONE_AUTH_PREFIX); 7579cb8a054bSGlenn Faden if ((strncmp(*auth, ZONE_AUTH_PREFIX, offset) == 0) && 7580cb8a054bSGlenn Faden ((suffix = strchr(*auth, '/')) != NULL)) { 7581d77d83efSGlenn Faden if (strcmp(suffix + 1, zonename) == 0) { 7582cb8a054bSGlenn Faden *auth += offset; 7583cb8a054bSGlenn Faden suffix[0] = '\0'; 7584cb8a054bSGlenn Faden return (B_TRUE); 7585cb8a054bSGlenn Faden } else if ((oldzonename != NULL) && 7586d77d83efSGlenn Faden (strcmp(suffix + 1, oldzonename) == 0)) { 7587cb8a054bSGlenn Faden *auth += offset; 7588cb8a054bSGlenn Faden suffix[0] = '\0'; 7589cb8a054bSGlenn Faden return (B_TRUE); 7590cb8a054bSGlenn Faden } 7591cb8a054bSGlenn Faden } 7592cb8a054bSGlenn Faden return (B_FALSE); 7593cb8a054bSGlenn Faden } 7594cb8a054bSGlenn Faden 7595cb8a054bSGlenn Faden /* 7596cb8a054bSGlenn Faden * This function determines whether the zone-specific authorization 7597cb8a054bSGlenn Faden * assignments in /etc/user_attr have been changed more recently 7598cb8a054bSGlenn Faden * than the equivalent data stored in the zone's configuration file. 7599cb8a054bSGlenn Faden * This should only happen if the zone-specific authorizations in 7600cb8a054bSGlenn Faden * the user_attr file were modified using a tool other than zonecfg. 7601cb8a054bSGlenn Faden * If the configuration file is out-of-date with respect to these 7602cb8a054bSGlenn Faden * authorization assignments, it is updated to match those specified 7603cb8a054bSGlenn Faden * in /etc/user_attr. 7604cb8a054bSGlenn Faden */ 7605cb8a054bSGlenn Faden 7606cb8a054bSGlenn Faden int 7607cb8a054bSGlenn Faden zonecfg_update_userauths(zone_dochandle_t handle, char *zonename) 7608cb8a054bSGlenn Faden { 7609cb8a054bSGlenn Faden userattr_t *ua_ptr; 7610cb8a054bSGlenn Faden char *authlist; 7611cb8a054bSGlenn Faden char *lasts; 7612cb8a054bSGlenn Faden FILE *uaf; 7613cb8a054bSGlenn Faden struct zone_admintab admintab; 7614cb8a054bSGlenn Faden struct stat config_st, ua_st; 7615cb8a054bSGlenn Faden char config_file[MAXPATHLEN]; 7616cb8a054bSGlenn Faden boolean_t changed = B_FALSE; 7617cb8a054bSGlenn Faden int err; 7618cb8a054bSGlenn Faden 7619cb8a054bSGlenn Faden if ((uaf = fopen(USERATTR_FILENAME, "r")) == NULL) { 7620cb8a054bSGlenn Faden zerror(zonename, gettext("could not open file %s: %s"), 7621cb8a054bSGlenn Faden USERATTR_FILENAME, strerror(errno)); 7622cb8a054bSGlenn Faden if (errno == EACCES) 7623cb8a054bSGlenn Faden return (Z_ACCES); 7624cb8a054bSGlenn Faden if (errno == ENOENT) 7625cb8a054bSGlenn Faden return (Z_NO_ZONE); 7626cb8a054bSGlenn Faden return (Z_MISC_FS); 7627cb8a054bSGlenn Faden } 7628cb8a054bSGlenn Faden if ((err = fstat(fileno(uaf), &ua_st)) != 0) { 7629cb8a054bSGlenn Faden zerror(zonename, gettext("could not stat file %s: %s"), 7630cb8a054bSGlenn Faden USERATTR_FILENAME, strerror(errno)); 7631cb8a054bSGlenn Faden (void) fclose(uaf); 7632cb8a054bSGlenn Faden return (Z_MISC_FS); 7633cb8a054bSGlenn Faden } 7634cb8a054bSGlenn Faden if (!config_file_path(zonename, config_file)) { 7635cb8a054bSGlenn Faden (void) fclose(uaf); 7636cb8a054bSGlenn Faden return (Z_MISC_FS); 7637cb8a054bSGlenn Faden } 7638cb8a054bSGlenn Faden 7639cb8a054bSGlenn Faden if ((err = stat(config_file, &config_st)) != 0) { 7640cb8a054bSGlenn Faden zerror(zonename, gettext("could not stat file %s: %s"), 7641cb8a054bSGlenn Faden config_file, strerror(errno)); 7642cb8a054bSGlenn Faden (void) fclose(uaf); 7643cb8a054bSGlenn Faden return (Z_MISC_FS); 7644cb8a054bSGlenn Faden } 7645cb8a054bSGlenn Faden if (config_st.st_mtime >= ua_st.st_mtime) { 7646cb8a054bSGlenn Faden (void) fclose(uaf); 7647cb8a054bSGlenn Faden return (Z_NO_ENTRY); 7648cb8a054bSGlenn Faden } 7649cb8a054bSGlenn Faden if ((err = zonecfg_delete_admins(handle, zonename)) == Z_OK) { 7650cb8a054bSGlenn Faden changed = B_TRUE; 7651cb8a054bSGlenn Faden } else if (err != Z_NO_ENTRY) { 7652cb8a054bSGlenn Faden (void) fclose(uaf); 7653cb8a054bSGlenn Faden return (err); 7654cb8a054bSGlenn Faden } 7655cb8a054bSGlenn Faden while ((ua_ptr = fgetuserattr(uaf)) != NULL) { 7656cb8a054bSGlenn Faden if (ua_ptr->name[0] == '#') { 7657cb8a054bSGlenn Faden continue; 7658cb8a054bSGlenn Faden } 7659cb8a054bSGlenn Faden authlist = kva_match(ua_ptr->attr, USERATTR_AUTHS_KW); 7660cb8a054bSGlenn Faden if (authlist != NULL) { 7661cb8a054bSGlenn Faden char *cur_auth; 7662cb8a054bSGlenn Faden boolean_t first; 7663cb8a054bSGlenn Faden 7664cb8a054bSGlenn Faden first = B_TRUE; 7665cb8a054bSGlenn Faden bzero(&admintab.zone_admin_auths, MAXAUTHS); 7666cb8a054bSGlenn Faden cur_auth = strtok_r(authlist, ",", &lasts); 7667cb8a054bSGlenn Faden while (cur_auth != NULL) { 7668cb8a054bSGlenn Faden if (is_zone_auth(&cur_auth, zonename, 7669cb8a054bSGlenn Faden NULL)) { 7670cb8a054bSGlenn Faden /* 7671cb8a054bSGlenn Faden * Add auths for this zone 7672cb8a054bSGlenn Faden */ 7673cb8a054bSGlenn Faden if (first) { 7674cb8a054bSGlenn Faden first = B_FALSE; 7675cb8a054bSGlenn Faden } else { 7676cb8a054bSGlenn Faden (void) strlcat( 7677cb8a054bSGlenn Faden admintab.zone_admin_auths, 7678cb8a054bSGlenn Faden ",", MAXAUTHS); 7679cb8a054bSGlenn Faden } 7680cb8a054bSGlenn Faden (void) strlcat( 7681cb8a054bSGlenn Faden admintab.zone_admin_auths, 7682cb8a054bSGlenn Faden cur_auth, MAXAUTHS); 7683cb8a054bSGlenn Faden } 7684cb8a054bSGlenn Faden cur_auth = strtok_r(NULL, ",", &lasts); 7685cb8a054bSGlenn Faden } 7686cb8a054bSGlenn Faden if (!first) { 7687cb8a054bSGlenn Faden /* 7688cb8a054bSGlenn Faden * Add this right to config file 7689cb8a054bSGlenn Faden */ 7690cb8a054bSGlenn Faden (void) strlcpy(admintab.zone_admin_user, 7691cb8a054bSGlenn Faden ua_ptr->name, 7692cb8a054bSGlenn Faden sizeof (admintab.zone_admin_user)); 7693cb8a054bSGlenn Faden err = zonecfg_add_admin(handle, 7694cb8a054bSGlenn Faden &admintab, zonename); 7695cb8a054bSGlenn Faden if (err != Z_OK) { 7696cb8a054bSGlenn Faden (void) fclose(uaf); 7697cb8a054bSGlenn Faden return (err); 7698cb8a054bSGlenn Faden } else { 7699cb8a054bSGlenn Faden changed = B_TRUE; 7700cb8a054bSGlenn Faden } 7701cb8a054bSGlenn Faden } 7702cb8a054bSGlenn Faden } 7703cb8a054bSGlenn Faden } /* end-of-while-loop */ 7704cb8a054bSGlenn Faden (void) fclose(uaf); 7705cb8a054bSGlenn Faden return (changed? Z_OK: Z_NO_ENTRY); 7706cb8a054bSGlenn Faden } 7707cb8a054bSGlenn Faden 7708cb8a054bSGlenn Faden static void 7709cb8a054bSGlenn Faden update_profiles(char *rbac_profs, boolean_t add) 7710cb8a054bSGlenn Faden { 7711cb8a054bSGlenn Faden char new_profs[MAXPROFS]; 7712cb8a054bSGlenn Faden char *cur_prof; 7713cb8a054bSGlenn Faden boolean_t first = B_TRUE; 7714cb8a054bSGlenn Faden boolean_t found = B_FALSE; 7715cb8a054bSGlenn Faden char *lasts; 7716cb8a054bSGlenn Faden 7717cb8a054bSGlenn Faden cur_prof = strtok_r(rbac_profs, ",", &lasts); 7718cb8a054bSGlenn Faden while (cur_prof != NULL) { 7719cb8a054bSGlenn Faden if (strcmp(cur_prof, ZONE_MGMT_PROF) == 0) { 7720cb8a054bSGlenn Faden found = B_TRUE; 7721cb8a054bSGlenn Faden if (!add) { 7722cb8a054bSGlenn Faden cur_prof = strtok_r(NULL, ",", &lasts); 7723cb8a054bSGlenn Faden continue; 7724cb8a054bSGlenn Faden } 7725cb8a054bSGlenn Faden } 7726cb8a054bSGlenn Faden if (first) { 7727cb8a054bSGlenn Faden first = B_FALSE; 7728cb8a054bSGlenn Faden } else { 7729cb8a054bSGlenn Faden (void) strlcat(new_profs, ",", 7730cb8a054bSGlenn Faden MAXPROFS); 7731cb8a054bSGlenn Faden } 7732cb8a054bSGlenn Faden (void) strlcat(new_profs, cur_prof, 7733cb8a054bSGlenn Faden MAXPROFS); 7734cb8a054bSGlenn Faden cur_prof = strtok_r(NULL, ",", &lasts); 7735cb8a054bSGlenn Faden } 7736cb8a054bSGlenn Faden /* 7737cb8a054bSGlenn Faden * Now prepend the Zone Management profile at the beginning 7738cb8a054bSGlenn Faden * of the list if it is needed, and append the rest. 7739cb8a054bSGlenn Faden * Return the updated list in the original buffer. 7740cb8a054bSGlenn Faden */ 7741cb8a054bSGlenn Faden if (add && !found) { 7742cb8a054bSGlenn Faden first = B_FALSE; 7743cb8a054bSGlenn Faden (void) strlcpy(rbac_profs, ZONE_MGMT_PROF, MAXPROFS); 7744cb8a054bSGlenn Faden } else { 7745cb8a054bSGlenn Faden first = B_TRUE; 7746cb8a054bSGlenn Faden rbac_profs[0] = '\0'; 7747cb8a054bSGlenn Faden } 7748cb8a054bSGlenn Faden if (strlen(new_profs) > 0) { 7749cb8a054bSGlenn Faden if (!first) 7750cb8a054bSGlenn Faden (void) strlcat(rbac_profs, ",", MAXPROFS); 7751cb8a054bSGlenn Faden (void) strlcat(rbac_profs, new_profs, MAXPROFS); 7752cb8a054bSGlenn Faden } 7753cb8a054bSGlenn Faden } 7754cb8a054bSGlenn Faden 7755cb8a054bSGlenn Faden #define MAX_CMD_LEN 1024 7756cb8a054bSGlenn Faden 7757cb8a054bSGlenn Faden static int 7758cb8a054bSGlenn Faden do_subproc(char *zonename, char *cmdbuf) 7759cb8a054bSGlenn Faden { 7760cb8a054bSGlenn Faden char inbuf[MAX_CMD_LEN]; 7761cb8a054bSGlenn Faden FILE *file; 7762cb8a054bSGlenn Faden int status; 7763cb8a054bSGlenn Faden 7764cb8a054bSGlenn Faden file = popen(cmdbuf, "r"); 7765cb8a054bSGlenn Faden if (file == NULL) { 7766cb8a054bSGlenn Faden zerror(zonename, gettext("Could not launch: %s"), cmdbuf); 7767cb8a054bSGlenn Faden return (-1); 7768cb8a054bSGlenn Faden } 7769cb8a054bSGlenn Faden 7770cb8a054bSGlenn Faden while (fgets(inbuf, sizeof (inbuf), file) != NULL) 7771cb8a054bSGlenn Faden (void) fprintf(stderr, "%s", inbuf); 7772cb8a054bSGlenn Faden status = pclose(file); 7773cb8a054bSGlenn Faden 7774cb8a054bSGlenn Faden if (WIFSIGNALED(status)) { 7775cb8a054bSGlenn Faden zerror(zonename, gettext("%s unexpectedly terminated " 7776cb8a054bSGlenn Faden "due to signal %d"), 7777cb8a054bSGlenn Faden cmdbuf, WTERMSIG(status)); 7778cb8a054bSGlenn Faden return (-1); 7779cb8a054bSGlenn Faden } 7780cb8a054bSGlenn Faden assert(WIFEXITED(status)); 7781cb8a054bSGlenn Faden return (WEXITSTATUS(status)); 7782cb8a054bSGlenn Faden } 7783cb8a054bSGlenn Faden 7784cb8a054bSGlenn Faden /* 7785cb8a054bSGlenn Faden * This function updates the local /etc/user_attr file to 7786cb8a054bSGlenn Faden * correspond to the admin settings that are currently being 7787cb8a054bSGlenn Faden * committed. The updates are done via usermod and/or rolemod 7788cb8a054bSGlenn Faden * depending on the type of the specified user. It is also 7789cb8a054bSGlenn Faden * invoked to remove entries from user_attr corresponding to 7790cb8a054bSGlenn Faden * removed admin assignments, using an empty auths string. 7791cb8a054bSGlenn Faden * 7792cb8a054bSGlenn Faden * Because the removed entries are no longer included in the 7793cb8a054bSGlenn Faden * cofiguration that is being committed, a linked list of 7794cb8a054bSGlenn Faden * removed admin entries is maintained to keep track of such 7795cb8a054bSGlenn Faden * transactions. The head of the list is stored in the zone_dh_userauths 7796cb8a054bSGlenn Faden * element of the handle strcture. 7797cb8a054bSGlenn Faden */ 7798cb8a054bSGlenn Faden static int 7799cb8a054bSGlenn Faden zonecfg_authorize_user_impl(zone_dochandle_t handle, char *user, 7800cb8a054bSGlenn Faden char *auths, char *zonename) 7801cb8a054bSGlenn Faden { 7802cb8a054bSGlenn Faden char *right; 7803cb8a054bSGlenn Faden char old_auths[MAXAUTHS]; 7804cb8a054bSGlenn Faden char new_auths[MAXAUTHS]; 7805cb8a054bSGlenn Faden char rbac_profs[MAXPROFS]; 7806cb8a054bSGlenn Faden char *lasts; 7807cb8a054bSGlenn Faden userattr_t *u; 7808cb8a054bSGlenn Faden boolean_t first = B_TRUE; 7809cb8a054bSGlenn Faden boolean_t is_zone_admin = B_FALSE; 7810cb8a054bSGlenn Faden char user_cmd[] = "/usr/sbin/usermod"; 7811cb8a054bSGlenn Faden char role_cmd[] = "/usr/sbin/rolemod"; 7812d77d83efSGlenn Faden char *auths_cmd = user_cmd; /* either usermod or rolemod */ 7813d77d83efSGlenn Faden char *new_auth_start; /* string containing the new auths */ 7814d77d83efSGlenn Faden int new_auth_cnt = 0; /* delta of changed authorizations */ 7815cb8a054bSGlenn Faden 7816cb8a054bSGlenn Faden /* 7817cb8a054bSGlenn Faden * First get the existing authorizations for this user 7818cb8a054bSGlenn Faden */ 7819cb8a054bSGlenn Faden 7820cb8a054bSGlenn Faden bzero(&old_auths, sizeof (old_auths)); 7821cb8a054bSGlenn Faden bzero(&new_auths, sizeof (new_auths)); 7822cb8a054bSGlenn Faden bzero(&rbac_profs, sizeof (rbac_profs)); 7823cb8a054bSGlenn Faden if ((u = getusernam(user)) != NULL) { 7824cb8a054bSGlenn Faden char *current_auths; 7825cb8a054bSGlenn Faden char *current_profs; 7826cb8a054bSGlenn Faden char *type; 7827cb8a054bSGlenn Faden 7828cb8a054bSGlenn Faden type = kva_match(u->attr, USERATTR_TYPE_KW); 7829cb8a054bSGlenn Faden if (type != NULL) { 7830cb8a054bSGlenn Faden if (strcmp(type, USERATTR_TYPE_NONADMIN_KW) == 0) 7831cb8a054bSGlenn Faden auths_cmd = role_cmd; 7832cb8a054bSGlenn Faden } 7833cb8a054bSGlenn Faden 7834cb8a054bSGlenn Faden current_auths = kva_match(u->attr, USERATTR_AUTHS_KW); 7835cb8a054bSGlenn Faden if (current_auths != NULL) { 7836cb8a054bSGlenn Faden char *cur_auth; 7837cb8a054bSGlenn Faden char *delete_name; 7838cb8a054bSGlenn Faden size_t offset; 7839cb8a054bSGlenn Faden 7840cb8a054bSGlenn Faden offset = strlen(ZONE_AUTH_PREFIX); 7841cb8a054bSGlenn Faden 7842cb8a054bSGlenn Faden (void) strlcpy(old_auths, current_auths, MAXAUTHS); 7843cb8a054bSGlenn Faden cur_auth = strtok_r(current_auths, ",", &lasts); 7844cb8a054bSGlenn Faden 7845cb8a054bSGlenn Faden /* 7846cb8a054bSGlenn Faden * Next, remove any existing authorizations 7847cb8a054bSGlenn Faden * for this zone, and determine if the 7848cb8a054bSGlenn Faden * user still needs the Zone Management Profile. 7849cb8a054bSGlenn Faden */ 7850cb8a054bSGlenn Faden if (is_renaming(handle)) 7851cb8a054bSGlenn Faden delete_name = handle->zone_dh_delete_name; 7852cb8a054bSGlenn Faden else 7853cb8a054bSGlenn Faden delete_name = NULL; 7854cb8a054bSGlenn Faden while (cur_auth != NULL) { 7855cb8a054bSGlenn Faden if (!is_zone_auth(&cur_auth, zonename, 7856cb8a054bSGlenn Faden delete_name)) { 7857cb8a054bSGlenn Faden if (first) { 7858cb8a054bSGlenn Faden first = B_FALSE; 7859cb8a054bSGlenn Faden } else { 7860cb8a054bSGlenn Faden (void) strlcat(new_auths, ",", 7861cb8a054bSGlenn Faden MAXAUTHS); 7862cb8a054bSGlenn Faden } 7863cb8a054bSGlenn Faden (void) strlcat(new_auths, cur_auth, 7864cb8a054bSGlenn Faden MAXAUTHS); 7865cb8a054bSGlenn Faden /* 7866cb8a054bSGlenn Faden * If the user has authorizations 7867cb8a054bSGlenn Faden * for other zones, then set a 7868cb8a054bSGlenn Faden * flag indicate that the Zone 7869cb8a054bSGlenn Faden * Management profile should be 7870cb8a054bSGlenn Faden * preserved in user_attr. 7871cb8a054bSGlenn Faden */ 7872cb8a054bSGlenn Faden if (strncmp(cur_auth, 7873cb8a054bSGlenn Faden ZONE_AUTH_PREFIX, offset) == 0) 7874cb8a054bSGlenn Faden is_zone_admin = B_TRUE; 7875d77d83efSGlenn Faden } else { 7876d77d83efSGlenn Faden new_auth_cnt++; 7877cb8a054bSGlenn Faden } 7878cb8a054bSGlenn Faden cur_auth = strtok_r(NULL, ",", &lasts); 7879cb8a054bSGlenn Faden } 7880cb8a054bSGlenn Faden } 7881cb8a054bSGlenn Faden current_profs = kva_match(u->attr, USERATTR_PROFILES_KW); 7882cb8a054bSGlenn Faden if (current_profs != NULL) { 7883cb8a054bSGlenn Faden (void) strlcpy(rbac_profs, current_profs, MAXPROFS); 7884cb8a054bSGlenn Faden } 7885cb8a054bSGlenn Faden free_userattr(u); 7886cb8a054bSGlenn Faden } 7887cb8a054bSGlenn Faden /* 7888cb8a054bSGlenn Faden * The following is done to avoid revisiting the 7889cb8a054bSGlenn Faden * user_attr entry for this user 7890cb8a054bSGlenn Faden */ 7891cb8a054bSGlenn Faden (void) zonecfg_remove_userauths(handle, user, "", B_FALSE); 7892cb8a054bSGlenn Faden 7893cb8a054bSGlenn Faden /* 7894cb8a054bSGlenn Faden * Convert each right into a properly formatted authorization 7895cb8a054bSGlenn Faden */ 7896d77d83efSGlenn Faden new_auth_start = new_auths + strlen(new_auths); 7897d77d83efSGlenn Faden if (!first) 7898d77d83efSGlenn Faden new_auth_start++; 7899cb8a054bSGlenn Faden right = strtok_r(auths, ",", &lasts); 7900cb8a054bSGlenn Faden while (right != NULL) { 7901cb8a054bSGlenn Faden char auth[MAXAUTHS]; 7902cb8a054bSGlenn Faden 7903cb8a054bSGlenn Faden (void) snprintf(auth, MAXAUTHS, "%s%s/%s", 7904cb8a054bSGlenn Faden ZONE_AUTH_PREFIX, right, zonename); 7905cb8a054bSGlenn Faden if (first) { 7906cb8a054bSGlenn Faden first = B_FALSE; 7907cb8a054bSGlenn Faden } else { 7908cb8a054bSGlenn Faden (void) strlcat(new_auths, ",", MAXAUTHS); 7909cb8a054bSGlenn Faden } 7910cb8a054bSGlenn Faden (void) strlcat(new_auths, auth, MAXAUTHS); 7911cb8a054bSGlenn Faden is_zone_admin = B_TRUE; 7912d77d83efSGlenn Faden new_auth_cnt--; 7913cb8a054bSGlenn Faden right = strtok_r(NULL, ",", &lasts); 7914cb8a054bSGlenn Faden } 7915cb8a054bSGlenn Faden 7916cb8a054bSGlenn Faden /* 7917d77d83efSGlenn Faden * Need to update the authorizations in user_attr unless 7918d77d83efSGlenn Faden * the number of old and new authorizations is unchanged 7919d77d83efSGlenn Faden * and the new auths are a substrings of the old auths. 7920d77d83efSGlenn Faden * 7921cb8a054bSGlenn Faden * If the user's previous authorizations have changed 7922d77d83efSGlenn Faden * execute the usermod progam to update them in user_attr. 7923cb8a054bSGlenn Faden */ 7924d77d83efSGlenn Faden if ((new_auth_cnt != 0) || 7925d77d83efSGlenn Faden (strstr(old_auths, new_auth_start) == NULL)) { 7926cb8a054bSGlenn Faden char *cmdbuf; 7927cb8a054bSGlenn Faden size_t cmd_len; 7928cb8a054bSGlenn Faden 7929cb8a054bSGlenn Faden update_profiles(rbac_profs, is_zone_admin); 7930cb8a054bSGlenn Faden cmd_len = snprintf(NULL, 0, "%s -A \"%s\" -P \"%s\" %s", 7931cb8a054bSGlenn Faden auths_cmd, new_auths, rbac_profs, user) + 1; 7932cb8a054bSGlenn Faden if ((cmdbuf = malloc(cmd_len)) == NULL) { 7933cb8a054bSGlenn Faden return (Z_NOMEM); 7934cb8a054bSGlenn Faden } 7935cb8a054bSGlenn Faden (void) snprintf(cmdbuf, cmd_len, "%s -A \"%s\" -P \"%s\" %s", 7936cb8a054bSGlenn Faden auths_cmd, new_auths, rbac_profs, user); 7937cb8a054bSGlenn Faden if (do_subproc(zonename, cmdbuf) != 0) { 7938cb8a054bSGlenn Faden free(cmdbuf); 7939cb8a054bSGlenn Faden return (Z_SYSTEM); 7940cb8a054bSGlenn Faden } 7941cb8a054bSGlenn Faden free(cmdbuf); 7942cb8a054bSGlenn Faden } 7943cb8a054bSGlenn Faden 7944cb8a054bSGlenn Faden return (Z_OK); 7945cb8a054bSGlenn Faden } 7946cb8a054bSGlenn Faden 7947cb8a054bSGlenn Faden int 7948cb8a054bSGlenn Faden zonecfg_authorize_users(zone_dochandle_t handle, char *zonename) 7949cb8a054bSGlenn Faden { 7950cb8a054bSGlenn Faden xmlNodePtr cur; 7951cb8a054bSGlenn Faden int err; 7952cb8a054bSGlenn Faden char user[MAXUSERNAME]; 7953cb8a054bSGlenn Faden char auths[MAXAUTHS]; 7954cb8a054bSGlenn Faden 7955cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 7956cb8a054bSGlenn Faden return (err); 7957cb8a054bSGlenn Faden 7958cb8a054bSGlenn Faden cur = handle->zone_dh_cur; 7959cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 7960cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 7961cb8a054bSGlenn Faden continue; 7962cb8a054bSGlenn Faden if (fetchprop(cur, DTD_ATTR_USER, user, 7963cb8a054bSGlenn Faden sizeof (user)) != Z_OK) 7964cb8a054bSGlenn Faden continue; 7965cb8a054bSGlenn Faden if (fetchprop(cur, DTD_ATTR_AUTHS, auths, 7966cb8a054bSGlenn Faden sizeof (auths)) != Z_OK) 7967cb8a054bSGlenn Faden continue; 7968cb8a054bSGlenn Faden if (zonecfg_authorize_user_impl(handle, user, auths, zonename) 7969cb8a054bSGlenn Faden != Z_OK) 7970cb8a054bSGlenn Faden return (Z_SYSTEM); 7971cb8a054bSGlenn Faden } 7972cb8a054bSGlenn Faden (void) zonecfg_remove_userauths(handle, "", "", B_TRUE); 7973cb8a054bSGlenn Faden 7974cb8a054bSGlenn Faden return (Z_OK); 7975cb8a054bSGlenn Faden } 7976cb8a054bSGlenn Faden 7977cb8a054bSGlenn Faden int 7978cb8a054bSGlenn Faden zonecfg_deauthorize_user(zone_dochandle_t handle, char *user, char *zonename) 7979cb8a054bSGlenn Faden { 7980cb8a054bSGlenn Faden return (zonecfg_authorize_user_impl(handle, user, "", zonename)); 7981cb8a054bSGlenn Faden } 7982cb8a054bSGlenn Faden 7983cb8a054bSGlenn Faden int 7984cb8a054bSGlenn Faden zonecfg_deauthorize_users(zone_dochandle_t handle, char *zonename) 7985cb8a054bSGlenn Faden { 7986cb8a054bSGlenn Faden xmlNodePtr cur; 7987cb8a054bSGlenn Faden int err; 7988cb8a054bSGlenn Faden char user[MAXUSERNAME]; 7989cb8a054bSGlenn Faden 7990cb8a054bSGlenn Faden if ((err = operation_prep(handle)) != Z_OK) 7991cb8a054bSGlenn Faden return (err); 7992cb8a054bSGlenn Faden 7993cb8a054bSGlenn Faden cur = handle->zone_dh_cur; 7994cb8a054bSGlenn Faden for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) { 7995cb8a054bSGlenn Faden if (xmlStrcmp(cur->name, DTD_ELEM_ADMIN)) 7996cb8a054bSGlenn Faden continue; 7997cb8a054bSGlenn Faden if (fetchprop(cur, DTD_ATTR_USER, user, 7998cb8a054bSGlenn Faden sizeof (user)) != Z_OK) 7999cb8a054bSGlenn Faden continue; 8000cb8a054bSGlenn Faden if ((err = zonecfg_deauthorize_user(handle, user, 8001cb8a054bSGlenn Faden zonename)) != Z_OK) 8002cb8a054bSGlenn Faden return (err); 8003cb8a054bSGlenn Faden } 8004cb8a054bSGlenn Faden return (Z_OK); 8005cb8a054bSGlenn Faden } 8006cb8a054bSGlenn Faden 8007cb8a054bSGlenn Faden int 8008cb8a054bSGlenn Faden zonecfg_insert_userauths(zone_dochandle_t handle, char *user, char *zonename) 8009cb8a054bSGlenn Faden { 8010cb8a054bSGlenn Faden zone_userauths_t *new, **prev, *next; 8011cb8a054bSGlenn Faden 8012cb8a054bSGlenn Faden prev = &handle->zone_dh_userauths; 8013cb8a054bSGlenn Faden next = *prev; 8014cb8a054bSGlenn Faden while (next) { 8015cb8a054bSGlenn Faden if ((strncmp(next->user, user, MAXUSERNAME) == 0) && 8016cb8a054bSGlenn Faden (strncmp(next->zonename, zonename, 8017cb8a054bSGlenn Faden ZONENAME_MAX) == 0)) { 8018cb8a054bSGlenn Faden /* 8019cb8a054bSGlenn Faden * user is already in list 8020cb8a054bSGlenn Faden * which isn't supposed to happen! 8021cb8a054bSGlenn Faden */ 8022cb8a054bSGlenn Faden return (Z_OK); 8023cb8a054bSGlenn Faden } 8024cb8a054bSGlenn Faden prev = &next->next; 8025cb8a054bSGlenn Faden next = *prev; 8026cb8a054bSGlenn Faden } 8027cb8a054bSGlenn Faden new = (zone_userauths_t *)malloc(sizeof (zone_userauths_t)); 8028cb8a054bSGlenn Faden if (new == NULL) 8029cb8a054bSGlenn Faden return (Z_NOMEM); 8030cb8a054bSGlenn Faden 8031cb8a054bSGlenn Faden (void) strlcpy(new->user, user, sizeof (new->user)); 8032cb8a054bSGlenn Faden (void) strlcpy(new->zonename, zonename, sizeof (new->zonename)); 8033cb8a054bSGlenn Faden new->next = NULL; 8034cb8a054bSGlenn Faden *prev = new; 8035cb8a054bSGlenn Faden return (Z_OK); 8036cb8a054bSGlenn Faden } 8037cb8a054bSGlenn Faden 8038cb8a054bSGlenn Faden int 8039cb8a054bSGlenn Faden zonecfg_remove_userauths(zone_dochandle_t handle, char *user, char *zonename, 8040cb8a054bSGlenn Faden boolean_t deauthorize) 8041cb8a054bSGlenn Faden { 8042cb8a054bSGlenn Faden zone_userauths_t *new, **prev, *next; 8043cb8a054bSGlenn Faden 8044cb8a054bSGlenn Faden prev = &handle->zone_dh_userauths; 8045cb8a054bSGlenn Faden next = *prev; 8046cb8a054bSGlenn Faden 8047cb8a054bSGlenn Faden while (next) { 8048cb8a054bSGlenn Faden if ((strlen(user) == 0 || 8049cb8a054bSGlenn Faden strncmp(next->user, user, MAXUSERNAME) == 0) && 8050cb8a054bSGlenn Faden (strlen(zonename) == 0 || 8051cb8a054bSGlenn Faden (strncmp(next->zonename, zonename, ZONENAME_MAX) == 0))) { 8052cb8a054bSGlenn Faden new = next; 8053cb8a054bSGlenn Faden *prev = next->next; 8054cb8a054bSGlenn Faden next = *prev; 8055cb8a054bSGlenn Faden if (deauthorize) 8056cb8a054bSGlenn Faden (void) zonecfg_deauthorize_user(handle, 8057cb8a054bSGlenn Faden new->user, new->zonename); 8058cb8a054bSGlenn Faden free(new); 8059cb8a054bSGlenn Faden continue; 8060cb8a054bSGlenn Faden } 8061cb8a054bSGlenn Faden prev = &next->next; 8062cb8a054bSGlenn Faden next = *prev; 8063cb8a054bSGlenn Faden } 8064cb8a054bSGlenn Faden return (Z_OK); 8065cb8a054bSGlenn Faden } 8066