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 5fb03efaaSdp * Common Development and Distribution License (the "License"). 6fb03efaaSdp * 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 */ 217e362f58Scomay 227c478bd9Sstevel@tonic-gate /* 23fb03efaaSdp * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * zonecfg is a lex/yacc based command interpreter used to manage zone 317c478bd9Sstevel@tonic-gate * configurations. The lexer (see zonecfg_lex.l) builds up tokens, which 327c478bd9Sstevel@tonic-gate * the grammar (see zonecfg_grammar.y) builds up into commands, some of 337c478bd9Sstevel@tonic-gate * which takes resources and/or properties as arguments. See the block 347c478bd9Sstevel@tonic-gate * comments near the end of zonecfg_grammar.y for how the data structures 357c478bd9Sstevel@tonic-gate * which keep track of these resources and properties are built up. 367c478bd9Sstevel@tonic-gate * 377c478bd9Sstevel@tonic-gate * The resource/property data structures are inserted into a command 387c478bd9Sstevel@tonic-gate * structure (see zonecfg.h), which also keeps track of command names, 397c478bd9Sstevel@tonic-gate * miscellaneous arguments, and function handlers. The grammar selects 407c478bd9Sstevel@tonic-gate * the appropriate function handler, each of which takes a pointer to a 417c478bd9Sstevel@tonic-gate * command structure as its sole argument, and invokes it. The grammar 427c478bd9Sstevel@tonic-gate * itself is "entered" (a la the Matrix) by yyparse(), which is called 437c478bd9Sstevel@tonic-gate * from read_input(), our main driving function. That in turn is called 447c478bd9Sstevel@tonic-gate * by one of do_interactive(), cmd_file() or one_command_at_a_time(), each 457c478bd9Sstevel@tonic-gate * of which is called from main() depending on how the program was invoked. 467c478bd9Sstevel@tonic-gate * 477c478bd9Sstevel@tonic-gate * The rest of this module consists of the various function handlers and 487c478bd9Sstevel@tonic-gate * their helper functions. Some of these functions, particularly the 497c478bd9Sstevel@tonic-gate * X_to_str() functions, which maps command, resource and property numbers 507c478bd9Sstevel@tonic-gate * to strings, are used quite liberally, as doing so results in a better 517c478bd9Sstevel@tonic-gate * program w/rt I18N, reducing the need for translation notes. 527c478bd9Sstevel@tonic-gate */ 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 557c478bd9Sstevel@tonic-gate #include <sys/varargs.h> 567c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate #include <errno.h> 597c478bd9Sstevel@tonic-gate #include <strings.h> 607c478bd9Sstevel@tonic-gate #include <unistd.h> 617c478bd9Sstevel@tonic-gate #include <ctype.h> 627c478bd9Sstevel@tonic-gate #include <stdlib.h> 637c478bd9Sstevel@tonic-gate #include <assert.h> 647c478bd9Sstevel@tonic-gate #include <sys/stat.h> 657c478bd9Sstevel@tonic-gate #include <zone.h> 667c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 677c478bd9Sstevel@tonic-gate #include <netdb.h> 687c478bd9Sstevel@tonic-gate #include <locale.h> 697c478bd9Sstevel@tonic-gate #include <libintl.h> 707c478bd9Sstevel@tonic-gate #include <alloca.h> 717c478bd9Sstevel@tonic-gate #include <signal.h> 727c478bd9Sstevel@tonic-gate #include <libtecla.h> 73fa9e4066Sahrens #include <libzfs.h> 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 767c478bd9Sstevel@tonic-gate #include "zonecfg.h" 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* should be defined by cc -D */ 797c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 807c478bd9Sstevel@tonic-gate #endif 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate #define PAGER "/usr/bin/more" 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate struct help { 857c478bd9Sstevel@tonic-gate uint_t cmd_num; 867c478bd9Sstevel@tonic-gate char *cmd_name; 877c478bd9Sstevel@tonic-gate uint_t flags; 887c478bd9Sstevel@tonic-gate char *short_usage; 897c478bd9Sstevel@tonic-gate }; 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate extern int yyparse(void); 927c478bd9Sstevel@tonic-gate extern int lex_lineno; 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate #define MAX_LINE_LEN 1024 957c478bd9Sstevel@tonic-gate #define MAX_CMD_HIST 1024 967c478bd9Sstevel@tonic-gate 977c478bd9Sstevel@tonic-gate /* 987c478bd9Sstevel@tonic-gate * Each SHELP_ should be a simple string. 997c478bd9Sstevel@tonic-gate */ 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate #define SHELP_ADD "add <resource-type>\n\t(global scope)\n" \ 1027c478bd9Sstevel@tonic-gate "add <property-name> <property-value>\n\t(resource scope)" 1037c478bd9Sstevel@tonic-gate #define SHELP_CANCEL "cancel" 1047c478bd9Sstevel@tonic-gate #define SHELP_COMMIT "commit" 105ee519a1fSgjelinek #define SHELP_CREATE "create [-F] [ -a <path> | -b | -t <template> ]" 1067c478bd9Sstevel@tonic-gate #define SHELP_DELETE "delete [-F]" 1077c478bd9Sstevel@tonic-gate #define SHELP_END "end" 1087c478bd9Sstevel@tonic-gate #define SHELP_EXIT "exit [-F]" 1097c478bd9Sstevel@tonic-gate #define SHELP_EXPORT "export [-f output-file]" 1107c478bd9Sstevel@tonic-gate #define SHELP_HELP "help [commands] [syntax] [usage] [<command-name>]" 1117c478bd9Sstevel@tonic-gate #define SHELP_INFO "info [<resource-type> [property-name=property-value]*]" 1127c478bd9Sstevel@tonic-gate #define SHELP_REMOVE "remove <resource-type> { <property-name>=<property-" \ 113ffbafc53Scomay "value> }\n\t(global scope)\nremove <property-name> <property-value>" \ 1147c478bd9Sstevel@tonic-gate "\n\t(resource scope)" 1157c478bd9Sstevel@tonic-gate #define SHELP_REVERT "revert [-F]" 1167c478bd9Sstevel@tonic-gate #define SHELP_SELECT "select <resource-type> { <property-name>=" \ 1177c478bd9Sstevel@tonic-gate "<property-value> }" 1187c478bd9Sstevel@tonic-gate #define SHELP_SET "set <property-name>=<property-value>" 1197c478bd9Sstevel@tonic-gate #define SHELP_VERIFY "verify" 1207c478bd9Sstevel@tonic-gate 1217c478bd9Sstevel@tonic-gate static struct help helptab[] = { 1227c478bd9Sstevel@tonic-gate { CMD_ADD, "add", HELP_RES_PROPS, SHELP_ADD, }, 1237c478bd9Sstevel@tonic-gate { CMD_CANCEL, "cancel", 0, SHELP_CANCEL, }, 1247c478bd9Sstevel@tonic-gate { CMD_COMMIT, "commit", 0, SHELP_COMMIT, }, 1257c478bd9Sstevel@tonic-gate { CMD_CREATE, "create", 0, SHELP_CREATE, }, 1267c478bd9Sstevel@tonic-gate { CMD_DELETE, "delete", 0, SHELP_DELETE, }, 1277c478bd9Sstevel@tonic-gate { CMD_END, "end", 0, SHELP_END, }, 1287c478bd9Sstevel@tonic-gate { CMD_EXIT, "exit", 0, SHELP_EXIT, }, 1297c478bd9Sstevel@tonic-gate { CMD_EXPORT, "export", 0, SHELP_EXPORT, }, 1307c478bd9Sstevel@tonic-gate { CMD_HELP, "help", 0, SHELP_HELP }, 1317c478bd9Sstevel@tonic-gate { CMD_INFO, "info", HELP_RES_PROPS, SHELP_INFO, }, 1327c478bd9Sstevel@tonic-gate { CMD_REMOVE, "remove", HELP_RES_PROPS, SHELP_REMOVE, }, 1337c478bd9Sstevel@tonic-gate { CMD_REVERT, "revert", 0, SHELP_REVERT, }, 1347c478bd9Sstevel@tonic-gate { CMD_SELECT, "select", HELP_RES_PROPS, SHELP_SELECT, }, 1357c478bd9Sstevel@tonic-gate { CMD_SET, "set", HELP_PROPS, SHELP_SET, }, 1367c478bd9Sstevel@tonic-gate { CMD_VERIFY, "verify", 0, SHELP_VERIFY, }, 1377c478bd9Sstevel@tonic-gate { 0 }, 1387c478bd9Sstevel@tonic-gate }; 1397c478bd9Sstevel@tonic-gate 1407c478bd9Sstevel@tonic-gate #define MAX_RT_STRLEN 16 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate /* These *must* match the order of the RT_ define's from zonecfg.h */ 1437c478bd9Sstevel@tonic-gate static char *res_types[] = { 1447c478bd9Sstevel@tonic-gate "unknown", 145087719fdSdp "zonename", 1467c478bd9Sstevel@tonic-gate "zonepath", 1477c478bd9Sstevel@tonic-gate "autoboot", 1487c478bd9Sstevel@tonic-gate "pool", 1497c478bd9Sstevel@tonic-gate "fs", 1507c478bd9Sstevel@tonic-gate "inherit-pkg-dir", 1517c478bd9Sstevel@tonic-gate "net", 1527c478bd9Sstevel@tonic-gate "device", 1537c478bd9Sstevel@tonic-gate "rctl", 1547c478bd9Sstevel@tonic-gate "attr", 155fa9e4066Sahrens "dataset", 156ffbafc53Scomay "limitpriv", 1573f2f09c1Sdp "bootargs", 1587c478bd9Sstevel@tonic-gate NULL 1597c478bd9Sstevel@tonic-gate }; 1607c478bd9Sstevel@tonic-gate 1617c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 1627c478bd9Sstevel@tonic-gate static char *prop_types[] = { 1637c478bd9Sstevel@tonic-gate "unknown", 164087719fdSdp "zonename", 1657c478bd9Sstevel@tonic-gate "zonepath", 1667c478bd9Sstevel@tonic-gate "autoboot", 1677c478bd9Sstevel@tonic-gate "pool", 1687c478bd9Sstevel@tonic-gate "dir", 1697c478bd9Sstevel@tonic-gate "special", 1707c478bd9Sstevel@tonic-gate "type", 1717c478bd9Sstevel@tonic-gate "options", 1727c478bd9Sstevel@tonic-gate "address", 1737c478bd9Sstevel@tonic-gate "physical", 1747c478bd9Sstevel@tonic-gate "name", 1757c478bd9Sstevel@tonic-gate "value", 1767c478bd9Sstevel@tonic-gate "match", 1777c478bd9Sstevel@tonic-gate "priv", 1787c478bd9Sstevel@tonic-gate "limit", 1797c478bd9Sstevel@tonic-gate "action", 1807c478bd9Sstevel@tonic-gate "raw", 181ffbafc53Scomay "limitpriv", 1823f2f09c1Sdp "bootargs", 1837c478bd9Sstevel@tonic-gate NULL 1847c478bd9Sstevel@tonic-gate }; 1857c478bd9Sstevel@tonic-gate 186ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 1877c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 1887c478bd9Sstevel@tonic-gate "simple", 1897c478bd9Sstevel@tonic-gate "complex", 1907c478bd9Sstevel@tonic-gate "list", 1917c478bd9Sstevel@tonic-gate }; 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate /* 1947c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 1957c478bd9Sstevel@tonic-gate */ 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate /* 1987c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 1997c478bd9Sstevel@tonic-gate * that have qualifiers (add, select and set) don't need a space here because 2007c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2017c478bd9Sstevel@tonic-gate */ 2027c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2037c478bd9Sstevel@tonic-gate "add", 2047c478bd9Sstevel@tonic-gate "commit", 2057c478bd9Sstevel@tonic-gate "create", 2067c478bd9Sstevel@tonic-gate "delete", 2077c478bd9Sstevel@tonic-gate "exit", 2087c478bd9Sstevel@tonic-gate "export", 2097c478bd9Sstevel@tonic-gate "help", 2107c478bd9Sstevel@tonic-gate "info", 2117c478bd9Sstevel@tonic-gate "remove ", 2127c478bd9Sstevel@tonic-gate "revert", 2137c478bd9Sstevel@tonic-gate "select", 2147c478bd9Sstevel@tonic-gate "set", 2157c478bd9Sstevel@tonic-gate "verify", 2167c478bd9Sstevel@tonic-gate NULL 2177c478bd9Sstevel@tonic-gate }; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2207c478bd9Sstevel@tonic-gate "add fs", 2217c478bd9Sstevel@tonic-gate "add inherit-pkg-dir", 2227c478bd9Sstevel@tonic-gate "add net", 2237c478bd9Sstevel@tonic-gate "add device", 2247c478bd9Sstevel@tonic-gate "add rctl", 2257c478bd9Sstevel@tonic-gate "add attr", 226fa9e4066Sahrens "add dataset", 2277c478bd9Sstevel@tonic-gate NULL 2287c478bd9Sstevel@tonic-gate }; 2297c478bd9Sstevel@tonic-gate 230*9e7542f4Sdp static const char *remove_cmds[] = { 231*9e7542f4Sdp "remove fs ", 232*9e7542f4Sdp "remove inherit-pkg-dir ", 233*9e7542f4Sdp "remove net ", 234*9e7542f4Sdp "remove device ", 235*9e7542f4Sdp "remove rctl ", 236*9e7542f4Sdp "remove attr ", 237*9e7542f4Sdp "remove dataset ", 238*9e7542f4Sdp NULL 239*9e7542f4Sdp }; 240*9e7542f4Sdp 2417c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 242087719fdSdp "select fs ", 243087719fdSdp "select inherit-pkg-dir ", 244087719fdSdp "select net ", 245087719fdSdp "select device ", 246087719fdSdp "select rctl ", 247087719fdSdp "select attr ", 248fa9e4066Sahrens "select dataset ", 2497c478bd9Sstevel@tonic-gate NULL 2507c478bd9Sstevel@tonic-gate }; 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 253087719fdSdp "set zonename=", 254087719fdSdp "set zonepath=", 255087719fdSdp "set autoboot=", 256087719fdSdp "set pool=", 257ffbafc53Scomay "set limitpriv=", 2583f2f09c1Sdp "set bootargs=", 2597c478bd9Sstevel@tonic-gate NULL 2607c478bd9Sstevel@tonic-gate }; 2617c478bd9Sstevel@tonic-gate 262*9e7542f4Sdp static const char *info_cmds[] = { 263*9e7542f4Sdp "info fs ", 264*9e7542f4Sdp "info inherit-pkg-dir ", 265*9e7542f4Sdp "info net ", 266*9e7542f4Sdp "info device ", 267*9e7542f4Sdp "info rctl ", 268*9e7542f4Sdp "info attr ", 269*9e7542f4Sdp "info dataset ", 270*9e7542f4Sdp "info zonename", 271*9e7542f4Sdp "info zonepath", 272*9e7542f4Sdp "info autoboot", 273*9e7542f4Sdp "info pool", 274*9e7542f4Sdp "info limitpriv", 275*9e7542f4Sdp "info bootargs", 276*9e7542f4Sdp NULL 277*9e7542f4Sdp }; 278*9e7542f4Sdp 2797c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 2807c478bd9Sstevel@tonic-gate "add options ", 2817c478bd9Sstevel@tonic-gate "cancel", 2827c478bd9Sstevel@tonic-gate "end", 2837c478bd9Sstevel@tonic-gate "exit", 2847c478bd9Sstevel@tonic-gate "help", 2857c478bd9Sstevel@tonic-gate "info", 286ffbafc53Scomay "remove options ", 2877c478bd9Sstevel@tonic-gate "set dir=", 2887c478bd9Sstevel@tonic-gate "set raw=", 2897c478bd9Sstevel@tonic-gate "set special=", 2907c478bd9Sstevel@tonic-gate "set type=", 2917c478bd9Sstevel@tonic-gate NULL 2927c478bd9Sstevel@tonic-gate }; 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 2957c478bd9Sstevel@tonic-gate "cancel", 2967c478bd9Sstevel@tonic-gate "end", 2977c478bd9Sstevel@tonic-gate "exit", 2987c478bd9Sstevel@tonic-gate "help", 2997c478bd9Sstevel@tonic-gate "info", 3007c478bd9Sstevel@tonic-gate "set address=", 3017c478bd9Sstevel@tonic-gate "set physical=", 3027c478bd9Sstevel@tonic-gate NULL 3037c478bd9Sstevel@tonic-gate }; 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate static const char *ipd_res_scope_cmds[] = { 3067c478bd9Sstevel@tonic-gate "cancel", 3077c478bd9Sstevel@tonic-gate "end", 3087c478bd9Sstevel@tonic-gate "exit", 3097c478bd9Sstevel@tonic-gate "help", 3107c478bd9Sstevel@tonic-gate "info", 3117c478bd9Sstevel@tonic-gate "set dir=", 3127c478bd9Sstevel@tonic-gate NULL 3137c478bd9Sstevel@tonic-gate }; 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 3167c478bd9Sstevel@tonic-gate "cancel", 3177c478bd9Sstevel@tonic-gate "end", 3187c478bd9Sstevel@tonic-gate "exit", 3197c478bd9Sstevel@tonic-gate "help", 3207c478bd9Sstevel@tonic-gate "info", 3217c478bd9Sstevel@tonic-gate "set match=", 3227c478bd9Sstevel@tonic-gate NULL 3237c478bd9Sstevel@tonic-gate }; 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate static const char *attr_res_scope_cmds[] = { 3267c478bd9Sstevel@tonic-gate "cancel", 3277c478bd9Sstevel@tonic-gate "end", 3287c478bd9Sstevel@tonic-gate "exit", 3297c478bd9Sstevel@tonic-gate "help", 3307c478bd9Sstevel@tonic-gate "info", 3317c478bd9Sstevel@tonic-gate "set name=", 3327c478bd9Sstevel@tonic-gate "set type=", 3337c478bd9Sstevel@tonic-gate "set value=", 3347c478bd9Sstevel@tonic-gate NULL 3357c478bd9Sstevel@tonic-gate }; 3367c478bd9Sstevel@tonic-gate 3377c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 3387c478bd9Sstevel@tonic-gate "add value ", 3397c478bd9Sstevel@tonic-gate "cancel", 3407c478bd9Sstevel@tonic-gate "end", 3417c478bd9Sstevel@tonic-gate "exit", 3427c478bd9Sstevel@tonic-gate "help", 3437c478bd9Sstevel@tonic-gate "info", 344ffbafc53Scomay "remove value ", 3457c478bd9Sstevel@tonic-gate "set name=", 3467c478bd9Sstevel@tonic-gate NULL 3477c478bd9Sstevel@tonic-gate }; 3487c478bd9Sstevel@tonic-gate 349fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 350fa9e4066Sahrens "cancel", 351fa9e4066Sahrens "end", 352fa9e4066Sahrens "exit", 353fa9e4066Sahrens "help", 354fa9e4066Sahrens "info", 355fa9e4066Sahrens "set name=", 356fa9e4066Sahrens NULL 357fa9e4066Sahrens }; 358fa9e4066Sahrens 3597c478bd9Sstevel@tonic-gate /* Global variables */ 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 3627c478bd9Sstevel@tonic-gate static char *execname; 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 3657c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate /* used all over the place */ 368087719fdSdp static char zone[ZONENAME_MAX]; 369087719fdSdp static char revert_zone[ZONENAME_MAX]; 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 3727c478bd9Sstevel@tonic-gate static bool need_to_commit = FALSE; 3737c478bd9Sstevel@tonic-gate bool saw_error; 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 3767c478bd9Sstevel@tonic-gate bool newline_terminated; 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 3797c478bd9Sstevel@tonic-gate bool cmd_file_mode; 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 3827c478bd9Sstevel@tonic-gate static bool time_to_exit = FALSE, force_exit = FALSE; 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 3857c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 3887c478bd9Sstevel@tonic-gate static bool ok_to_prompt = FALSE; 3897c478bd9Sstevel@tonic-gate 3907c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 3917c478bd9Sstevel@tonic-gate static bool got_handle = FALSE; 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 3947c478bd9Sstevel@tonic-gate static bool interactive_mode; 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 3977c478bd9Sstevel@tonic-gate static bool read_only_mode; 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate static bool global_scope = TRUE; /* scope is outer/global or inner/resource */ 4007c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 4017c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 4027c478bd9Sstevel@tonic-gate 4037c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate /* 4067c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 4077c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 4087c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 4117c478bd9Sstevel@tonic-gate static struct zone_fstab old_ipdtab, in_progress_ipdtab; 4127c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 4137c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 4147c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 4157c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 416fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate /* Functions begin here */ 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate static bool 4237c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 4247c478bd9Sstevel@tonic-gate { 4257c478bd9Sstevel@tonic-gate if (word_end <= 0) 4267c478bd9Sstevel@tonic-gate return (TRUE); 4277c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate static int 4317c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 4327c478bd9Sstevel@tonic-gate int word_end) 4337c478bd9Sstevel@tonic-gate { 4347c478bd9Sstevel@tonic-gate int i, err; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 4377c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 4387c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 4397c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 4407c478bd9Sstevel@tonic-gate if (err != 0) 4417c478bd9Sstevel@tonic-gate return (err); 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate } 4447c478bd9Sstevel@tonic-gate return (0); 4457c478bd9Sstevel@tonic-gate } 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate static 4487c478bd9Sstevel@tonic-gate /* ARGSUSED */ 4497c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 4507c478bd9Sstevel@tonic-gate { 4517c478bd9Sstevel@tonic-gate if (global_scope) { 4527c478bd9Sstevel@tonic-gate /* 4537c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 4547c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 4557c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 4567c478bd9Sstevel@tonic-gate */ 4577c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 4587c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 4597c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 4607c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 4617c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 4627c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 463*9e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 464*9e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 465*9e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 466*9e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 4677c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 4687c478bd9Sstevel@tonic-gate } 4697c478bd9Sstevel@tonic-gate switch (resource_scope) { 4707c478bd9Sstevel@tonic-gate case RT_FS: 4717c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 4727c478bd9Sstevel@tonic-gate case RT_IPD: 4737c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end)); 4747c478bd9Sstevel@tonic-gate case RT_NET: 4757c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 4767c478bd9Sstevel@tonic-gate case RT_DEVICE: 4777c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 4787c478bd9Sstevel@tonic-gate case RT_RCTL: 4797c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 4807c478bd9Sstevel@tonic-gate case RT_ATTR: 4817c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 482fa9e4066Sahrens case RT_DATASET: 483fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 4847c478bd9Sstevel@tonic-gate } 4857c478bd9Sstevel@tonic-gate return (0); 4867c478bd9Sstevel@tonic-gate } 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate /* 4897c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 4907c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 4917c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 4927c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 4937c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 4947c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 4957c478bd9Sstevel@tonic-gate */ 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate cmd_t * 4987c478bd9Sstevel@tonic-gate alloc_cmd(void) 4997c478bd9Sstevel@tonic-gate { 5007c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate void 5047c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 5057c478bd9Sstevel@tonic-gate { 5067c478bd9Sstevel@tonic-gate int i; 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 5097c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 5107c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 5117c478bd9Sstevel@tonic-gate 5127c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 5137c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 5147c478bd9Sstevel@tonic-gate free(pp->pv_simple); 5157c478bd9Sstevel@tonic-gate break; 5167c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 5177c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 5187c478bd9Sstevel@tonic-gate break; 5197c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 5207c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 5217c478bd9Sstevel@tonic-gate break; 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate } 5247c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 5257c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 5267c478bd9Sstevel@tonic-gate free(cmd); 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate complex_property_ptr_t 5307c478bd9Sstevel@tonic-gate alloc_complex(void) 5317c478bd9Sstevel@tonic-gate { 5327c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate void 5367c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 5377c478bd9Sstevel@tonic-gate { 5387c478bd9Sstevel@tonic-gate if (complex == NULL) 5397c478bd9Sstevel@tonic-gate return; 5407c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 5417c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 5427c478bd9Sstevel@tonic-gate free(complex->cp_value); 5437c478bd9Sstevel@tonic-gate free(complex); 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate list_property_ptr_t 5477c478bd9Sstevel@tonic-gate alloc_list(void) 5487c478bd9Sstevel@tonic-gate { 5497c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate void 5537c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 5547c478bd9Sstevel@tonic-gate { 5557c478bd9Sstevel@tonic-gate if (list == NULL) 5567c478bd9Sstevel@tonic-gate return; 5577c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 5587c478bd9Sstevel@tonic-gate free(list->lp_simple); 5597c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 5607c478bd9Sstevel@tonic-gate free_list(list->lp_next); 5617c478bd9Sstevel@tonic-gate free(list); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate void 5657c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 5667c478bd9Sstevel@tonic-gate { 5677c478bd9Sstevel@tonic-gate if (list == NULL) 5687c478bd9Sstevel@tonic-gate return; 5697c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 5707c478bd9Sstevel@tonic-gate free(list); 5717c478bd9Sstevel@tonic-gate } 5727c478bd9Sstevel@tonic-gate 5737c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 5747c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 5757c478bd9Sstevel@tonic-gate { 5767c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate static char * 5807c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 5817c478bd9Sstevel@tonic-gate { 5827c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 5837c478bd9Sstevel@tonic-gate return (res_types[res_type]); 5847c478bd9Sstevel@tonic-gate } 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate static char * 5877c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 5887c478bd9Sstevel@tonic-gate { 5897c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 5907c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 5917c478bd9Sstevel@tonic-gate } 5927c478bd9Sstevel@tonic-gate 5937c478bd9Sstevel@tonic-gate static char * 5947c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 5957c478bd9Sstevel@tonic-gate { 5967c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 5977c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 5987c478bd9Sstevel@tonic-gate } 5997c478bd9Sstevel@tonic-gate 6007c478bd9Sstevel@tonic-gate static char * 6017c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 6027c478bd9Sstevel@tonic-gate { 6037c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 6047c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate /* 6087c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 6097c478bd9Sstevel@tonic-gate * gettext() wrapping. 6107c478bd9Sstevel@tonic-gate */ 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate /* 6137c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 6147c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 6157c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 6167c478bd9Sstevel@tonic-gate */ 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate static char * 6197c478bd9Sstevel@tonic-gate long_help(int cmd_num) 6207c478bd9Sstevel@tonic-gate { 6217c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 6247c478bd9Sstevel@tonic-gate switch (cmd_num) { 6257c478bd9Sstevel@tonic-gate case CMD_HELP: 6267c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 6277c478bd9Sstevel@tonic-gate case CMD_CREATE: 6287c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 6297c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 6307c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 6317c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 6327c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 6337c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 6347c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 6357c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 6369e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 6379e518655Sgjelinek "creates a configuration from a\n\tdetached " 6389e518655Sgjelinek "zonepath. '%s -b' results in a blank " 6399e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 6409e518655Sgjelinek "the Sun default settings."), 6417c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 6429e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 6437c478bd9Sstevel@tonic-gate return (line); 6447c478bd9Sstevel@tonic-gate case CMD_EXIT: 6457c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 6467c478bd9Sstevel@tonic-gate "be used to force the action.")); 6477c478bd9Sstevel@tonic-gate case CMD_EXPORT: 6487c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 6497c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 6507c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 6517c478bd9Sstevel@tonic-gate case CMD_ADD: 6527c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 6537c478bd9Sstevel@tonic-gate "configuration.")); 6547c478bd9Sstevel@tonic-gate case CMD_DELETE: 6557c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 6567c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 6577c478bd9Sstevel@tonic-gate case CMD_REMOVE: 6587c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 6597c478bd9Sstevel@tonic-gate "configuration. Note that the curly\n\tbraces " 6607c478bd9Sstevel@tonic-gate "('{', '}') mean one or more of whatever " 6617c478bd9Sstevel@tonic-gate "is between them.")); 6627c478bd9Sstevel@tonic-gate case CMD_SELECT: 6637c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 6647c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 6657c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 6667c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 6677c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 6687c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 6697c478bd9Sstevel@tonic-gate "of whatever is between them."), 6707c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 6717c478bd9Sstevel@tonic-gate return (line); 6727c478bd9Sstevel@tonic-gate case CMD_SET: 6737c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 6747c478bd9Sstevel@tonic-gate case CMD_INFO: 6757c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 6767c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 6777c478bd9Sstevel@tonic-gate "specified, displays only information about " 6787c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 6797c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 6807c478bd9Sstevel@tonic-gate "about that resource.")); 6817c478bd9Sstevel@tonic-gate case CMD_VERIFY: 6827c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 6837c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 6847c478bd9Sstevel@tonic-gate "required properties).")); 6857c478bd9Sstevel@tonic-gate case CMD_COMMIT: 6867c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 6877c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 6887c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 6897c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 6907c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 6917c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 6927c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 6937c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 6947c478bd9Sstevel@tonic-gate "zonecfg"); 6957c478bd9Sstevel@tonic-gate return (line); 6967c478bd9Sstevel@tonic-gate case CMD_REVERT: 6977c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 6987c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 6997c478bd9Sstevel@tonic-gate "used to force the action.")); 7007c478bd9Sstevel@tonic-gate case CMD_CANCEL: 7017c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 7027c478bd9Sstevel@tonic-gate "specification.")); 7037c478bd9Sstevel@tonic-gate case CMD_END: 7047c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 7057c478bd9Sstevel@tonic-gate "specification.")); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate /* NOTREACHED */ 7087e362f58Scomay return (NULL); 7097c478bd9Sstevel@tonic-gate } 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate /* 7127c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 7137c478bd9Sstevel@tonic-gate * unexpected errors. 7147c478bd9Sstevel@tonic-gate */ 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate void 7177c478bd9Sstevel@tonic-gate usage(bool verbose, uint_t flags) 7187c478bd9Sstevel@tonic-gate { 7197c478bd9Sstevel@tonic-gate FILE *fp = verbose ? stdout : stderr, *newfp; 7207c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 7217c478bd9Sstevel@tonic-gate char *pager; 7227c478bd9Sstevel@tonic-gate int i; 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate /* don't page error output */ 7257c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 7267c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 7277c478bd9Sstevel@tonic-gate pager = PAGER; 7287c478bd9Sstevel@tonic-gate if ((newfp = popen(pager, "w")) != NULL) { 7297c478bd9Sstevel@tonic-gate need_to_close = TRUE; 7307c478bd9Sstevel@tonic-gate fp = newfp; 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 7347c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 7357c478bd9Sstevel@tonic-gate "following:\n")); 7367c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 7377c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 7387c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 7397c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 7407c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 7417c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 7427c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 7437c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 7447c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 7477c478bd9Sstevel@tonic-gate switch (resource_scope) { 7487c478bd9Sstevel@tonic-gate case RT_FS: 7497c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 7507c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 7517c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 7527c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 7537c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7547c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 7557c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7567c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 7577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7587c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 7597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7607c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 7617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 7627c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 7637c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 764ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 765ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 766ffbafc53Scomay gettext("<file-system options>")); 7677c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 7687c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 7697c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 7707c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 7717c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 7727c478bd9Sstevel@tonic-gate /*CSTYLED*/ 7737c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 7747c478bd9Sstevel@tonic-gate break; 7757c478bd9Sstevel@tonic-gate case RT_IPD: 7767c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 7777c478bd9Sstevel@tonic-gate "used to configure a directory\ninherited from the " 7787c478bd9Sstevel@tonic-gate "global zone into a non-global zone in read-only " 7797c478bd9Sstevel@tonic-gate "mode.\n"), rt_to_str(resource_scope)); 7807c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 7817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7827c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 7837c478bd9Sstevel@tonic-gate break; 7847c478bd9Sstevel@tonic-gate case RT_NET: 7857c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 7867c478bd9Sstevel@tonic-gate "used to configure a network interface.\n"), 7877c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 7887c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 7897c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7907c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), gettext("<IP-address>")); 7917c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 7927c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 7937c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 7947c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 7957c478bd9Sstevel@tonic-gate break; 7967c478bd9Sstevel@tonic-gate case RT_DEVICE: 7977c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 7987c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 7997c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 8007c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 8017c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8027c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 8037c478bd9Sstevel@tonic-gate break; 8047c478bd9Sstevel@tonic-gate case RT_RCTL: 8057c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 8067c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 8077c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 8087c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 8097c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8107c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 8117c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 8127c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 8137c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 8147c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 8157c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 816ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 817ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 818ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 819ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 820ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 8217c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 8227c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 8237c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 8247c478bd9Sstevel@tonic-gate break; 8257c478bd9Sstevel@tonic-gate case RT_ATTR: 8267c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 8277c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\n"), 8287c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 8297c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 8307c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8317c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<name>")); 8327c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 8337c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 8347c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 8357c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 8367c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 8377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 8387c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 8397c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8407c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 8417c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 8427c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 8437c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 8447c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8457c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 8467c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 8477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 8487c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 8497c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8507c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<unsigned integer>")); 8517c478bd9Sstevel@tonic-gate break; 852fa9e4066Sahrens case RT_DATASET: 853fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 854fa9e4066Sahrens "used to export ZFS datasets.\n"), 855fa9e4066Sahrens rt_to_str(resource_scope)); 856fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 857fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 858fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 859fa9e4066Sahrens break; 8607c478bd9Sstevel@tonic-gate } 8617c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 8627c478bd9Sstevel@tonic-gate "can:\n")); 8637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 8647c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 8657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 8667c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 8677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 8687c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 8697c478bd9Sstevel@tonic-gate } 8707c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 8717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 8727c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 8737c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 8747c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 8757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 8767c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 8777c478bd9Sstevel@tonic-gate execname); 8787c478bd9Sstevel@tonic-gate } 8797c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 8807c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 8817c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 8827c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 8837c478bd9Sstevel@tonic-gate if (verbose) 8847c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 8857c478bd9Sstevel@tonic-gate } 8867c478bd9Sstevel@tonic-gate } 8877c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 8887c478bd9Sstevel@tonic-gate if (!verbose) 8897c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 8907c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 8917c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 8927c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 8937c478bd9Sstevel@tonic-gate "SUNW"); 8947c478bd9Sstevel@tonic-gate (void) fprintf(fp, 8957c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 8967c478bd9Sstevel@tonic-gate ZONENAME_MAX); 8977c478bd9Sstevel@tonic-gate if (verbose) 8987c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 8997c478bd9Sstevel@tonic-gate } 9007c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 9017c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 9027c478bd9Sstevel@tonic-gate (void) fprintf(fp, 9037c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 9047c478bd9Sstevel@tonic-gate (void) fprintf(fp, 9057c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 9067c478bd9Sstevel@tonic-gate (void) fprintf(fp, 9077c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 9087c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 9097c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 9107c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 9117c478bd9Sstevel@tonic-gate (void) fprintf(fp, 9127c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 9137c478bd9Sstevel@tonic-gate (void) fprintf(fp, 9147c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 9157c478bd9Sstevel@tonic-gate } 9167c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 917*9e7542f4Sdp (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s | %s |\n\t" 918*9e7542f4Sdp "%s\n\n", 9197c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 9207c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 921*9e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 922*9e7542f4Sdp rt_to_str(RT_DATASET)); 9237c478bd9Sstevel@tonic-gate } 9247c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 9257c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 9267c478bd9Sstevel@tonic-gate "property types ...:\n")); 927087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 928087719fdSdp pt_to_str(PT_ZONENAME)); 9297c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 9307c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 9317c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 9327c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 9333f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 9343f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 9357c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 9367c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 937ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 938ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 9397c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s\n", rt_to_str(RT_FS), 9407c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), pt_to_str(PT_SPECIAL), 9417c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), pt_to_str(PT_TYPE), 9427c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS)); 9437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_IPD), 9447c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR)); 9457c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_NET), 9467c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), pt_to_str(PT_PHYSICAL)); 9477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 9487c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 9497c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 9507c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 9517c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 9527c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 9537c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 954fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 955fa9e4066Sahrens pt_to_str(PT_NAME)); 9567c478bd9Sstevel@tonic-gate } 9577c478bd9Sstevel@tonic-gate if (need_to_close) 9587c478bd9Sstevel@tonic-gate (void) pclose(fp); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate /* PRINTFLIKE1 */ 9627c478bd9Sstevel@tonic-gate static void 9637c478bd9Sstevel@tonic-gate zerr(const char *fmt, ...) 9647c478bd9Sstevel@tonic-gate { 9657c478bd9Sstevel@tonic-gate va_list alist; 9667c478bd9Sstevel@tonic-gate static int last_lineno; 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 9697c478bd9Sstevel@tonic-gate if (cmd_file_mode && lex_lineno > last_lineno) { 9707c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 9717c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d:\n"), 9727c478bd9Sstevel@tonic-gate lex_lineno - 1); 9737c478bd9Sstevel@tonic-gate else 9747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d of %s:\n"), 9757c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 9767c478bd9Sstevel@tonic-gate last_lineno = lex_lineno; 9777c478bd9Sstevel@tonic-gate } 9787c478bd9Sstevel@tonic-gate va_start(alist, fmt); 9797c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, alist); 9807c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\n"); 9817c478bd9Sstevel@tonic-gate va_end(alist); 9827c478bd9Sstevel@tonic-gate } 9837c478bd9Sstevel@tonic-gate 9847c478bd9Sstevel@tonic-gate static void 9857c478bd9Sstevel@tonic-gate zone_perror(char *prefix, int err, bool set_saw) 9867c478bd9Sstevel@tonic-gate { 9877c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 9887c478bd9Sstevel@tonic-gate if (set_saw) 9897c478bd9Sstevel@tonic-gate saw_error = TRUE; 9907c478bd9Sstevel@tonic-gate } 9917c478bd9Sstevel@tonic-gate 9927c478bd9Sstevel@tonic-gate /* 9937c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 9947c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 9957c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 9967c478bd9Sstevel@tonic-gate */ 9977c478bd9Sstevel@tonic-gate 9987c478bd9Sstevel@tonic-gate static void 9997c478bd9Sstevel@tonic-gate z_cmd_rt_perror(int cmd_num, int res_num, int err, bool set_saw) 10007c478bd9Sstevel@tonic-gate { 10017c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 10027c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 10037c478bd9Sstevel@tonic-gate if (set_saw) 10047c478bd9Sstevel@tonic-gate saw_error = TRUE; 10057c478bd9Sstevel@tonic-gate } 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 10087c478bd9Sstevel@tonic-gate static int 10097c478bd9Sstevel@tonic-gate initialize(bool handle_expected) 10107c478bd9Sstevel@tonic-gate { 10117c478bd9Sstevel@tonic-gate int err; 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 10147c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 10157c478bd9Sstevel@tonic-gate got_handle = TRUE; 10167c478bd9Sstevel@tonic-gate } else { 10177c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 10187c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 10197c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 10207c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 10217c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 10227c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 10237c478bd9Sstevel@tonic-gate return (err); 10247c478bd9Sstevel@tonic-gate } 10257c478bd9Sstevel@tonic-gate } 10267c478bd9Sstevel@tonic-gate return (Z_OK); 10277c478bd9Sstevel@tonic-gate } 10287c478bd9Sstevel@tonic-gate 1029087719fdSdp static bool 1030087719fdSdp state_atleast(zone_state_t state) 1031087719fdSdp { 1032087719fdSdp zone_state_t state_num; 1033087719fdSdp int err; 1034087719fdSdp 1035087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1036087719fdSdp /* all states are greater than "non-existent" */ 1037087719fdSdp if (err == Z_NO_ZONE) 1038087719fdSdp return (B_FALSE); 1039087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1040087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1041087719fdSdp exit(Z_ERR); 1042087719fdSdp } 1043087719fdSdp return (state_num >= state); 1044087719fdSdp } 1045087719fdSdp 10467c478bd9Sstevel@tonic-gate /* 10477c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 10487c478bd9Sstevel@tonic-gate */ 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate void 10517c478bd9Sstevel@tonic-gate short_usage(int command) 10527c478bd9Sstevel@tonic-gate { 10537c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 10547c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 10557c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 10567c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10577c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 10587c478bd9Sstevel@tonic-gate lex_lineno - 1); 10597c478bd9Sstevel@tonic-gate else 10607c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10617c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 10627c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 10657c478bd9Sstevel@tonic-gate helptab[command].short_usage); 10667c478bd9Sstevel@tonic-gate saw_error = TRUE; 10677c478bd9Sstevel@tonic-gate } 10687c478bd9Sstevel@tonic-gate 10697c478bd9Sstevel@tonic-gate /* 10707c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 10717c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 10727c478bd9Sstevel@tonic-gate */ 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate void 10757c478bd9Sstevel@tonic-gate long_usage(uint_t cmd_num, bool set_saw) 10767c478bd9Sstevel@tonic-gate { 10777c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 10787c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 10797c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 10807c478bd9Sstevel@tonic-gate if (set_saw) 10817c478bd9Sstevel@tonic-gate saw_error = TRUE; 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 10847c478bd9Sstevel@tonic-gate /* 10857c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 10867c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 10877c478bd9Sstevel@tonic-gate */ 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate void 10907c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 10917c478bd9Sstevel@tonic-gate { 10927c478bd9Sstevel@tonic-gate long_usage(cmd_num, FALSE); 10937c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 10947c478bd9Sstevel@tonic-gate (void) printf("\n"); 10957c478bd9Sstevel@tonic-gate usage(TRUE, helptab[cmd_num].flags); 10967c478bd9Sstevel@tonic-gate } 10977c478bd9Sstevel@tonic-gate } 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate /* 11007c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 11017c478bd9Sstevel@tonic-gate */ 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate static void 11047c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 11057c478bd9Sstevel@tonic-gate { 11067c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 11077c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 11087c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 11097c478bd9Sstevel@tonic-gate saw_error = TRUE; 11107c478bd9Sstevel@tonic-gate } 11117c478bd9Sstevel@tonic-gate 11127c478bd9Sstevel@tonic-gate /* 11137c478bd9Sstevel@tonic-gate * On input, TRUE => yes, FALSE => no. 11147c478bd9Sstevel@tonic-gate * On return, TRUE => 1, FALSE => no, could not ask => -1. 11157c478bd9Sstevel@tonic-gate */ 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate static int 11187c478bd9Sstevel@tonic-gate ask_yesno(bool default_answer, const char *question) 11197c478bd9Sstevel@tonic-gate { 11207c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 11237c478bd9Sstevel@tonic-gate saw_error = TRUE; 11247c478bd9Sstevel@tonic-gate return (-1); 11257c478bd9Sstevel@tonic-gate } 11267c478bd9Sstevel@tonic-gate for (;;) { 1127087719fdSdp if (printf("%s (%s)? ", question, 1128087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1129087719fdSdp return (-1); 1130087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1131087719fdSdp return (-1); 1132087719fdSdp 1133087719fdSdp if (line[0] == '\n') 11347c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 11357c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 11367c478bd9Sstevel@tonic-gate return (1); 11377c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 11387c478bd9Sstevel@tonic-gate return (0); 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate } 11417c478bd9Sstevel@tonic-gate 11427c478bd9Sstevel@tonic-gate /* 11437c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 11447c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 11457c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 11467c478bd9Sstevel@tonic-gate * 11477c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 11487c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 11497c478bd9Sstevel@tonic-gate */ 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate static int 11527c478bd9Sstevel@tonic-gate check_if_zone_already_exists(bool force) 11537c478bd9Sstevel@tonic-gate { 11547c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 11557c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 11567c478bd9Sstevel@tonic-gate int res, answer; 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 11597c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 11607c478bd9Sstevel@tonic-gate exit(Z_ERR); 11617c478bd9Sstevel@tonic-gate } 11627c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 11637c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1164087719fdSdp if (res != Z_OK) 11657c478bd9Sstevel@tonic-gate return (Z_OK); 1166087719fdSdp 1167087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 11687c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 11697c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 11707c478bd9Sstevel@tonic-gate return (Z_ERR); 11717c478bd9Sstevel@tonic-gate } 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate if (force) { 11747c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 11757c478bd9Sstevel@tonic-gate zone); 11767c478bd9Sstevel@tonic-gate return (Z_OK); 11777c478bd9Sstevel@tonic-gate } 11787c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 11797c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 11807c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 11817c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 11827c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 11837c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 11847c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 11857c478bd9Sstevel@tonic-gate exit(Z_ERR); 11867c478bd9Sstevel@tonic-gate } 11877c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate static bool 11917c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 11927c478bd9Sstevel@tonic-gate { 11937c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 11947c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 11957c478bd9Sstevel@tonic-gate zone); 11967c478bd9Sstevel@tonic-gate saw_error = TRUE; 11977c478bd9Sstevel@tonic-gate return (TRUE); 11987c478bd9Sstevel@tonic-gate } 11997c478bd9Sstevel@tonic-gate if (read_only_mode) { 12007c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 12017c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 12027c478bd9Sstevel@tonic-gate saw_error = TRUE; 12037c478bd9Sstevel@tonic-gate return (TRUE); 12047c478bd9Sstevel@tonic-gate } 12057c478bd9Sstevel@tonic-gate return (FALSE); 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate 12087c478bd9Sstevel@tonic-gate /* 12097c478bd9Sstevel@tonic-gate * Create a new configuration. 12107c478bd9Sstevel@tonic-gate */ 12117c478bd9Sstevel@tonic-gate void 12127c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 12137c478bd9Sstevel@tonic-gate { 12147c478bd9Sstevel@tonic-gate int err, arg; 12157c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1216ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 12177c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 12187c478bd9Sstevel@tonic-gate bool force = FALSE; 1219ee519a1fSgjelinek bool attach = FALSE; 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate assert(cmd != NULL); 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 12247c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate optind = 0; 1227ee519a1fSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) != EOF) { 12287c478bd9Sstevel@tonic-gate switch (arg) { 12297c478bd9Sstevel@tonic-gate case '?': 12307c478bd9Sstevel@tonic-gate if (optopt == '?') 12317c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 12327c478bd9Sstevel@tonic-gate else 12337c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 12347c478bd9Sstevel@tonic-gate return; 1235ee519a1fSgjelinek case 'a': 1236ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1237ee519a1fSgjelinek sizeof (attach_path)); 1238ee519a1fSgjelinek attach = TRUE; 1239ee519a1fSgjelinek break; 12407c478bd9Sstevel@tonic-gate case 'b': 12417c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 12427c478bd9Sstevel@tonic-gate sizeof (zone_template)); 12437c478bd9Sstevel@tonic-gate break; 12447c478bd9Sstevel@tonic-gate case 'F': 12457c478bd9Sstevel@tonic-gate force = TRUE; 12467c478bd9Sstevel@tonic-gate break; 12477c478bd9Sstevel@tonic-gate case 't': 12487c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 12497c478bd9Sstevel@tonic-gate sizeof (zone_template)); 12507c478bd9Sstevel@tonic-gate break; 12517c478bd9Sstevel@tonic-gate default: 12527c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 12537c478bd9Sstevel@tonic-gate return; 12547c478bd9Sstevel@tonic-gate } 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 12577c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 12587c478bd9Sstevel@tonic-gate return; 12597c478bd9Sstevel@tonic-gate } 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 12627c478bd9Sstevel@tonic-gate return; 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 12657c478bd9Sstevel@tonic-gate return; 12667c478bd9Sstevel@tonic-gate 12677c478bd9Sstevel@tonic-gate /* 12687c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 12697c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 12707c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 12717c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 12727c478bd9Sstevel@tonic-gate * create -[b|t] works. 12737c478bd9Sstevel@tonic-gate */ 12747c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 12757c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 12767c478bd9Sstevel@tonic-gate exit(Z_ERR); 12777c478bd9Sstevel@tonic-gate } 1278ee519a1fSgjelinek 1279ee519a1fSgjelinek if (attach) 1280ee519a1fSgjelinek err = zonecfg_get_attach_handle(attach_path, zone, B_FALSE, 1281ee519a1fSgjelinek tmphandle); 1282ee519a1fSgjelinek else 1283ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1284ee519a1fSgjelinek tmphandle); 1285ee519a1fSgjelinek 1286ee519a1fSgjelinek if (err != Z_OK) { 12877c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1288ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1289ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1290ee519a1fSgjelinek "detached zone\n")); 1291ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1292ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1293ee519a1fSgjelinek "earlier release of the operating system\n")); 1294ee519a1fSgjelinek else 1295ee519a1fSgjelinek zone_perror(zone_template, err, TRUE); 12967c478bd9Sstevel@tonic-gate return; 12977c478bd9Sstevel@tonic-gate } 1298087719fdSdp 1299087719fdSdp need_to_commit = TRUE; 13007c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 13017c478bd9Sstevel@tonic-gate handle = tmphandle; 1302087719fdSdp got_handle = TRUE; 13037c478bd9Sstevel@tonic-gate } 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate /* 13067c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 13077c478bd9Sstevel@tonic-gate */ 13087c478bd9Sstevel@tonic-gate static char * 13097c478bd9Sstevel@tonic-gate quoteit(char *instr) 13107c478bd9Sstevel@tonic-gate { 13117c478bd9Sstevel@tonic-gate char *outstr; 13127c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 13137c478bd9Sstevel@tonic-gate 13147c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 13157c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, FALSE); 13167c478bd9Sstevel@tonic-gate exit(Z_ERR); 13177c478bd9Sstevel@tonic-gate } 13187c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 13197c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 13207c478bd9Sstevel@tonic-gate return (outstr); 13217c478bd9Sstevel@tonic-gate } 13227c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 13237c478bd9Sstevel@tonic-gate return (outstr); 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate static void 13277c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 13287c478bd9Sstevel@tonic-gate { 13297c478bd9Sstevel@tonic-gate char *quote_str; 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 13327c478bd9Sstevel@tonic-gate return; 13337c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 13347c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 13357c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 13367c478bd9Sstevel@tonic-gate free(quote_str); 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate 13397c478bd9Sstevel@tonic-gate void 13407c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 13417c478bd9Sstevel@tonic-gate { 13427c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 13437c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 13447c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 13457c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 13467c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1347fa9e4066Sahrens struct zone_dstab dstab; 13487c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 13497c478bd9Sstevel@tonic-gate int err, arg; 13507c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 13513f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 1352ffbafc53Scomay char *limitpriv; 13537c478bd9Sstevel@tonic-gate FILE *of; 13547c478bd9Sstevel@tonic-gate boolean_t autoboot; 13557c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate assert(cmd != NULL); 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 13607c478bd9Sstevel@tonic-gate optind = 0; 13617c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 13627c478bd9Sstevel@tonic-gate switch (arg) { 13637c478bd9Sstevel@tonic-gate case '?': 13647c478bd9Sstevel@tonic-gate if (optopt == '?') 13657c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 13667c478bd9Sstevel@tonic-gate else 13677c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 13687c478bd9Sstevel@tonic-gate return; 13697c478bd9Sstevel@tonic-gate case 'f': 13707c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 13717c478bd9Sstevel@tonic-gate break; 13727c478bd9Sstevel@tonic-gate default: 13737c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 13747c478bd9Sstevel@tonic-gate return; 13757c478bd9Sstevel@tonic-gate } 13767c478bd9Sstevel@tonic-gate } 13777c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 13787c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 13797c478bd9Sstevel@tonic-gate return; 13807c478bd9Sstevel@tonic-gate } 13817c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 13827c478bd9Sstevel@tonic-gate of = stdout; 13837c478bd9Sstevel@tonic-gate } else { 13847c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 13857c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 13867c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 13877c478bd9Sstevel@tonic-gate goto done; 13887c478bd9Sstevel@tonic-gate } 13897c478bd9Sstevel@tonic-gate setbuf(of, NULL); 13907c478bd9Sstevel@tonic-gate need_to_close = TRUE; 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate 13937c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 13947c478bd9Sstevel@tonic-gate goto done; 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 13997c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 14007c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 14017c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 14047c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 14057c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 14067c478bd9Sstevel@tonic-gate 14073f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 14083f2f09c1Sdp strlen(bootargs) > 0) { 14093f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 14103f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 14113f2f09c1Sdp } 14123f2f09c1Sdp 14137c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 14147c478bd9Sstevel@tonic-gate strlen(pool) > 0) 14157c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 14167c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 14177c478bd9Sstevel@tonic-gate 1418ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1419ffbafc53Scomay strlen(limitpriv) > 0) { 1420ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1421ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1422ffbafc53Scomay free(limitpriv); 1423ffbafc53Scomay } 1424ffbafc53Scomay 14253f2f09c1Sdp 14267c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 14277c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 14287c478bd9Sstevel@tonic-gate goto done; 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 14317c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 14327c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 14337c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 14347c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 14357c478bd9Sstevel@tonic-gate } 14367c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 14397c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 14407c478bd9Sstevel@tonic-gate goto done; 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 14437c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 14447c478bd9Sstevel@tonic-gate 14457c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 14467c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 14477c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 14487c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 14497c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 14507c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 14517c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 14527c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 14537c478bd9Sstevel@tonic-gate /* 14547c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 14557c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 14567c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 14577c478bd9Sstevel@tonic-gate */ 14587c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 14597c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 14607c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 14617c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 14627c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 14637c478bd9Sstevel@tonic-gate else 14647c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 14657c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 14667c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 14677c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 14687c478bd9Sstevel@tonic-gate } 14697c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 14707c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 14717c478bd9Sstevel@tonic-gate } 14727c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 14757c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 14767c478bd9Sstevel@tonic-gate goto done; 14777c478bd9Sstevel@tonic-gate } 14787c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 14797c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 14807c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 14817c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 14827c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 14837c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 14847c478bd9Sstevel@tonic-gate } 14857c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 14887c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 14897c478bd9Sstevel@tonic-gate goto done; 14907c478bd9Sstevel@tonic-gate } 14917c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 14927c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 14937c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 14947c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 14957c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 14967c478bd9Sstevel@tonic-gate } 14977c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 15007c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 15017c478bd9Sstevel@tonic-gate goto done; 15027c478bd9Sstevel@tonic-gate } 15037c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 15047c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 15057c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 15067c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 15077c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 15087c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 15097c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 15107c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 15117c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 15127c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 15137c478bd9Sstevel@tonic-gate } 15147c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 15157c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 15167c478bd9Sstevel@tonic-gate } 15177c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 15207c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 15217c478bd9Sstevel@tonic-gate goto done; 15227c478bd9Sstevel@tonic-gate } 15237c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 15247c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 15257c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 15267c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 15277c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 15287c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 15297c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 15307c478bd9Sstevel@tonic-gate } 15317c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 15327c478bd9Sstevel@tonic-gate 1533fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1534fa9e4066Sahrens zone_perror(zone, err, FALSE); 1535fa9e4066Sahrens goto done; 1536fa9e4066Sahrens } 1537fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1538fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1539fa9e4066Sahrens rt_to_str(RT_DATASET)); 1540fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1541fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1542fa9e4066Sahrens } 1543fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1544fa9e4066Sahrens 15457c478bd9Sstevel@tonic-gate done: 15467c478bd9Sstevel@tonic-gate if (need_to_close) 15477c478bd9Sstevel@tonic-gate (void) fclose(of); 15487c478bd9Sstevel@tonic-gate } 15497c478bd9Sstevel@tonic-gate 15507c478bd9Sstevel@tonic-gate void 15517c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 15527c478bd9Sstevel@tonic-gate { 15537c478bd9Sstevel@tonic-gate int arg, answer; 15547c478bd9Sstevel@tonic-gate 15557c478bd9Sstevel@tonic-gate optind = 0; 15567c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 15577c478bd9Sstevel@tonic-gate switch (arg) { 15587c478bd9Sstevel@tonic-gate case '?': 15597c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 15607c478bd9Sstevel@tonic-gate return; 15617c478bd9Sstevel@tonic-gate case 'F': 15627c478bd9Sstevel@tonic-gate force_exit = TRUE; 15637c478bd9Sstevel@tonic-gate break; 15647c478bd9Sstevel@tonic-gate default: 15657c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 15667c478bd9Sstevel@tonic-gate return; 15677c478bd9Sstevel@tonic-gate } 15687c478bd9Sstevel@tonic-gate } 15697c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 15707c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 15717c478bd9Sstevel@tonic-gate return; 15727c478bd9Sstevel@tonic-gate } 15737c478bd9Sstevel@tonic-gate 15747c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 15757c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 15767c478bd9Sstevel@tonic-gate return; 15777c478bd9Sstevel@tonic-gate } 15787c478bd9Sstevel@tonic-gate 15797c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, "Resource incomplete; really quit"); 15807c478bd9Sstevel@tonic-gate if (answer == -1) { 15817c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 15827c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 15837c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 15847c478bd9Sstevel@tonic-gate exit(Z_ERR); 15857c478bd9Sstevel@tonic-gate } else if (answer == 1) { 15867c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 15877c478bd9Sstevel@tonic-gate } 15887c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 15897c478bd9Sstevel@tonic-gate } 15907c478bd9Sstevel@tonic-gate 15917c478bd9Sstevel@tonic-gate static int 15927c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 15937c478bd9Sstevel@tonic-gate { 15947c478bd9Sstevel@tonic-gate if (path[0] != '/') { 15957c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 15967c478bd9Sstevel@tonic-gate return (Z_ERR); 15977c478bd9Sstevel@tonic-gate } 15987c478bd9Sstevel@tonic-gate if (strcmp(path, "/") == 0) { 15997c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 16007c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 16017c478bd9Sstevel@tonic-gate return (Z_ERR); 16027c478bd9Sstevel@tonic-gate } 16037c478bd9Sstevel@tonic-gate return (Z_OK); 16047c478bd9Sstevel@tonic-gate } 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate static void 16077c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 16087c478bd9Sstevel@tonic-gate { 16097c478bd9Sstevel@tonic-gate int type; 16107c478bd9Sstevel@tonic-gate 16117c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 16127c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 16137c478bd9Sstevel@tonic-gate goto bad; 16147c478bd9Sstevel@tonic-gate } 16157c478bd9Sstevel@tonic-gate 16167c478bd9Sstevel@tonic-gate switch (type) { 16177c478bd9Sstevel@tonic-gate case RT_FS: 16187c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 16197c478bd9Sstevel@tonic-gate return; 16207c478bd9Sstevel@tonic-gate case RT_IPD: 1621087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 16227c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 16237c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_ADD), 16247c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 16257c478bd9Sstevel@tonic-gate goto bad; 16267c478bd9Sstevel@tonic-gate } 16277c478bd9Sstevel@tonic-gate bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 16287c478bd9Sstevel@tonic-gate return; 16297c478bd9Sstevel@tonic-gate case RT_NET: 16307c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 16317c478bd9Sstevel@tonic-gate return; 16327c478bd9Sstevel@tonic-gate case RT_DEVICE: 16337c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 16347c478bd9Sstevel@tonic-gate return; 16357c478bd9Sstevel@tonic-gate case RT_RCTL: 16367c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 16377c478bd9Sstevel@tonic-gate return; 16387c478bd9Sstevel@tonic-gate case RT_ATTR: 16397c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 16407c478bd9Sstevel@tonic-gate return; 1641fa9e4066Sahrens case RT_DATASET: 1642fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 1643fa9e4066Sahrens return; 16447c478bd9Sstevel@tonic-gate default: 16457c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 16467c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 16477c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate bad: 16507c478bd9Sstevel@tonic-gate global_scope = TRUE; 16517c478bd9Sstevel@tonic-gate end_op = -1; 16527c478bd9Sstevel@tonic-gate } 16537c478bd9Sstevel@tonic-gate 16547c478bd9Sstevel@tonic-gate static void 16557c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 16567c478bd9Sstevel@tonic-gate { 16577c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 16587c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 16597c478bd9Sstevel@tonic-gate bool seen_priv = FALSE, seen_limit = FALSE, seen_action = FALSE; 16607c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 16617c478bd9Sstevel@tonic-gate int err; 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 16647c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 16657c478bd9Sstevel@tonic-gate exit(Z_ERR); 16667c478bd9Sstevel@tonic-gate } 16677c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 16687c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 16697c478bd9Sstevel@tonic-gate case PT_PRIV: 16707c478bd9Sstevel@tonic-gate if (seen_priv) { 16717c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 16727c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 16737c478bd9Sstevel@tonic-gate goto bad; 16747c478bd9Sstevel@tonic-gate } 16757c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 16767c478bd9Sstevel@tonic-gate cx->cp_value, 16777c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 16787c478bd9Sstevel@tonic-gate seen_priv = TRUE; 16797c478bd9Sstevel@tonic-gate break; 16807c478bd9Sstevel@tonic-gate case PT_LIMIT: 16817c478bd9Sstevel@tonic-gate if (seen_limit) { 16827c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 16837c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 16847c478bd9Sstevel@tonic-gate goto bad; 16857c478bd9Sstevel@tonic-gate } 16867c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 16877c478bd9Sstevel@tonic-gate cx->cp_value, 16887c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 16897c478bd9Sstevel@tonic-gate seen_limit = TRUE; 16907c478bd9Sstevel@tonic-gate break; 16917c478bd9Sstevel@tonic-gate case PT_ACTION: 16927c478bd9Sstevel@tonic-gate if (seen_action) { 16937c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 16947c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 16957c478bd9Sstevel@tonic-gate goto bad; 16967c478bd9Sstevel@tonic-gate } 16977c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 16987c478bd9Sstevel@tonic-gate cx->cp_value, 16997c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 17007c478bd9Sstevel@tonic-gate seen_action = TRUE; 17017c478bd9Sstevel@tonic-gate break; 17027c478bd9Sstevel@tonic-gate default: 17037c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 17047c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 17057c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 17067c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 17077c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 17087c478bd9Sstevel@tonic-gate return; 17097c478bd9Sstevel@tonic-gate } 17107c478bd9Sstevel@tonic-gate } 17117c478bd9Sstevel@tonic-gate if (!seen_priv) 17127c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 17137c478bd9Sstevel@tonic-gate if (!seen_limit) 17147c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 17157c478bd9Sstevel@tonic-gate if (!seen_action) 17167c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 17177c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 17187c478bd9Sstevel@tonic-gate goto bad; 17197c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 17207c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 17217c478bd9Sstevel@tonic-gate /* 17227c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 17237c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 17247c478bd9Sstevel@tonic-gate * system. 17257c478bd9Sstevel@tonic-gate */ 17267c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 17277c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 17287c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 17297c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 17307c478bd9Sstevel@tonic-gate goto bad; 17317c478bd9Sstevel@tonic-gate } 17327c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 17337c478bd9Sstevel@tonic-gate if (err != Z_OK) 17347c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), err, TRUE); 17357c478bd9Sstevel@tonic-gate return; 17367c478bd9Sstevel@tonic-gate 17377c478bd9Sstevel@tonic-gate bad: 17387c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate static void 17427c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 17437c478bd9Sstevel@tonic-gate { 17447c478bd9Sstevel@tonic-gate char *prop_id; 17457c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 17467c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 17477c478bd9Sstevel@tonic-gate list_property_ptr_t l; 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate res_type = resource_scope; 17507c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 17517c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 17527c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 17537c478bd9Sstevel@tonic-gate return; 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 17577c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 17587c478bd9Sstevel@tonic-gate return; 17597c478bd9Sstevel@tonic-gate } 17607c478bd9Sstevel@tonic-gate 17617c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 17627c478bd9Sstevel@tonic-gate return; 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate switch (res_type) { 17657c478bd9Sstevel@tonic-gate case RT_FS: 17667c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 17677c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 17687c478bd9Sstevel@tonic-gate TRUE); 17697c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 17707c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 17717c478bd9Sstevel@tonic-gate return; 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 17747c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 17757c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 17767c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 17777c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 17787c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 17797c478bd9Sstevel@tonic-gate saw_error = TRUE; 17807c478bd9Sstevel@tonic-gate return; 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 17837c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 17847c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 17857c478bd9Sstevel@tonic-gate return; 17867c478bd9Sstevel@tonic-gate } 17877c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 17887c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 17897c478bd9Sstevel@tonic-gate prop_id); 17907c478bd9Sstevel@tonic-gate if (err != Z_OK) 17917c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 17927c478bd9Sstevel@tonic-gate } else { 17937c478bd9Sstevel@tonic-gate list_property_ptr_t list; 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 17967c478bd9Sstevel@tonic-gate list = list->lp_next) { 17977c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 17987c478bd9Sstevel@tonic-gate if (prop_id == NULL) 17997c478bd9Sstevel@tonic-gate break; 18007c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 18017c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 18027c478bd9Sstevel@tonic-gate if (err != Z_OK) 18037c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 18047c478bd9Sstevel@tonic-gate TRUE); 18057c478bd9Sstevel@tonic-gate } 18067c478bd9Sstevel@tonic-gate } 18077c478bd9Sstevel@tonic-gate return; 18087c478bd9Sstevel@tonic-gate case RT_RCTL: 18097c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 18107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 18117c478bd9Sstevel@tonic-gate TRUE); 18127c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 18137c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 18147c478bd9Sstevel@tonic-gate return; 18157c478bd9Sstevel@tonic-gate } 18167c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 18177c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 18187c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 18197c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 18207c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 18217c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 18227c478bd9Sstevel@tonic-gate saw_error = TRUE; 18237c478bd9Sstevel@tonic-gate return; 18247c478bd9Sstevel@tonic-gate } 18257c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 18267c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 18277c478bd9Sstevel@tonic-gate return; 18287c478bd9Sstevel@tonic-gate } 18297c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 18307c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 18317c478bd9Sstevel@tonic-gate return; 18327c478bd9Sstevel@tonic-gate default: 18337c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 18347c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 18357c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 18367c478bd9Sstevel@tonic-gate return; 18377c478bd9Sstevel@tonic-gate } 18387c478bd9Sstevel@tonic-gate } 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate void 18417c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 18427c478bd9Sstevel@tonic-gate { 18437c478bd9Sstevel@tonic-gate int arg; 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate assert(cmd != NULL); 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate optind = 0; 18487c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 18497c478bd9Sstevel@tonic-gate switch (arg) { 18507c478bd9Sstevel@tonic-gate case '?': 18517c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 18527c478bd9Sstevel@tonic-gate return; 18537c478bd9Sstevel@tonic-gate default: 18547c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 18557c478bd9Sstevel@tonic-gate return; 18567c478bd9Sstevel@tonic-gate } 18577c478bd9Sstevel@tonic-gate } 18587c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 18597c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 18607c478bd9Sstevel@tonic-gate return; 18617c478bd9Sstevel@tonic-gate } 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 18647c478bd9Sstevel@tonic-gate return; 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 18677c478bd9Sstevel@tonic-gate return; 18687c478bd9Sstevel@tonic-gate if (global_scope) { 18697c478bd9Sstevel@tonic-gate global_scope = FALSE; 18707c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 18717c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 18727c478bd9Sstevel@tonic-gate add_resource(cmd); 18737c478bd9Sstevel@tonic-gate } else 18747c478bd9Sstevel@tonic-gate add_property(cmd); 18757c478bd9Sstevel@tonic-gate } 18767c478bd9Sstevel@tonic-gate 1877087719fdSdp /* 1878087719fdSdp * This routine has an unusual implementation, because it tries very 1879087719fdSdp * hard to succeed in the face of a variety of failure modes. 1880087719fdSdp * The most common and most vexing occurs when the index file and 1881087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 1882087719fdSdp * this case, delete must eradicate as much of the zone state as is left 1883087719fdSdp * so that the user can later create a new zone with the same name. 1884087719fdSdp */ 18857c478bd9Sstevel@tonic-gate void 18867c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 18877c478bd9Sstevel@tonic-gate { 18887c478bd9Sstevel@tonic-gate int err, arg, answer; 18897c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 18907c478bd9Sstevel@tonic-gate bool force = FALSE; 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate optind = 0; 18937c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 18947c478bd9Sstevel@tonic-gate switch (arg) { 18957c478bd9Sstevel@tonic-gate case '?': 18967c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 18977c478bd9Sstevel@tonic-gate return; 18987c478bd9Sstevel@tonic-gate case 'F': 18997c478bd9Sstevel@tonic-gate force = TRUE; 19007c478bd9Sstevel@tonic-gate break; 19017c478bd9Sstevel@tonic-gate default: 19027c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 19037c478bd9Sstevel@tonic-gate return; 19047c478bd9Sstevel@tonic-gate } 19057c478bd9Sstevel@tonic-gate } 19067c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 19077c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 19087c478bd9Sstevel@tonic-gate return; 19097c478bd9Sstevel@tonic-gate } 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 19127c478bd9Sstevel@tonic-gate return; 19137c478bd9Sstevel@tonic-gate 19147c478bd9Sstevel@tonic-gate if (!force) { 1915087719fdSdp /* 1916087719fdSdp * Initialize sets up the global called "handle" and warns the 1917087719fdSdp * user if the zone is not configured. In force mode, we don't 1918087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 1919087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 1920087719fdSdp * zonename). However, we also have to take care to emulate the 1921087719fdSdp * messages spit out by initialize; see below. 1922087719fdSdp */ 1923087719fdSdp if (initialize(TRUE) != Z_OK) 1924087719fdSdp return; 1925087719fdSdp 19267c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 19277c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 19287c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 1929087719fdSdp zerr(gettext("Input not from terminal and -F not " 1930087719fdSdp "specified:\n%s command ignored, exiting."), 1931087719fdSdp cmd_to_str(CMD_DELETE)); 19327c478bd9Sstevel@tonic-gate exit(Z_ERR); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate if (answer != 1) 19357c478bd9Sstevel@tonic-gate return; 19367c478bd9Sstevel@tonic-gate } 19377c478bd9Sstevel@tonic-gate 1938087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 1939087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 1940087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 1941087719fdSdp "allowed. Use -F to force %s."), 1942087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 1943087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 1944087719fdSdp } else { 1945087719fdSdp zone_perror(zone, err, TRUE); 1946087719fdSdp } 19477c478bd9Sstevel@tonic-gate } 19487c478bd9Sstevel@tonic-gate need_to_commit = FALSE; 1949087719fdSdp 1950087719fdSdp /* 1951087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 1952087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 1953087719fdSdp * times. So we emit a message. 1954087719fdSdp * 1955087719fdSdp * We only do this in the 'force' case because normally, initialize() 1956087719fdSdp * takes care of this for us. 1957087719fdSdp */ 1958087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 1959087719fdSdp (void) printf(gettext("Use '%s' to begin " 1960087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate /* 19637c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 19647c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 19657c478bd9Sstevel@tonic-gate */ 1966087719fdSdp if (got_handle) { 1967087719fdSdp zonecfg_fini_handle(handle); 1968087719fdSdp if ((handle = zonecfg_init_handle()) == NULL) { 1969087719fdSdp zone_perror(execname, Z_NOMEM, TRUE); 1970087719fdSdp exit(Z_ERR); 1971087719fdSdp } 1972087719fdSdp if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 1973087719fdSdp /* If there was no zone before, that's OK */ 1974087719fdSdp if (err != Z_NO_ZONE) 1975087719fdSdp zone_perror(zone, err, TRUE); 1976087719fdSdp got_handle = FALSE; 1977087719fdSdp } 19787c478bd9Sstevel@tonic-gate } 19797c478bd9Sstevel@tonic-gate } 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate static int 19827c478bd9Sstevel@tonic-gate fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, bool fill_in_only) 19837c478bd9Sstevel@tonic-gate { 19847c478bd9Sstevel@tonic-gate int err, i; 19857c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 19867c478bd9Sstevel@tonic-gate 19877c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 19887c478bd9Sstevel@tonic-gate return (err); 19897c478bd9Sstevel@tonic-gate 1990e193d1e6Svp bzero(fstab, sizeof (*fstab)); 19917c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 19927c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 19937c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 19947c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 19957c478bd9Sstevel@tonic-gate saw_error = TRUE; 19967c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 19977c478bd9Sstevel@tonic-gate } 19987c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 19997c478bd9Sstevel@tonic-gate case PT_DIR: 20007c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 20017c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 20027c478bd9Sstevel@tonic-gate break; 20037c478bd9Sstevel@tonic-gate case PT_SPECIAL: 20047c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 20057c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 20067c478bd9Sstevel@tonic-gate break; 20077c478bd9Sstevel@tonic-gate case PT_RAW: 20087c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 20097c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 20107c478bd9Sstevel@tonic-gate break; 20117c478bd9Sstevel@tonic-gate case PT_TYPE: 20127c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 20137c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 20147c478bd9Sstevel@tonic-gate break; 20157c478bd9Sstevel@tonic-gate default: 20167c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 20177c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 20187c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 20197c478bd9Sstevel@tonic-gate } 20207c478bd9Sstevel@tonic-gate } 20217c478bd9Sstevel@tonic-gate if (fill_in_only) 20227c478bd9Sstevel@tonic-gate return (Z_OK); 20237c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 20247c478bd9Sstevel@tonic-gate } 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate static int 20277c478bd9Sstevel@tonic-gate fill_in_ipdtab(cmd_t *cmd, struct zone_fstab *ipdtab, bool fill_in_only) 20287c478bd9Sstevel@tonic-gate { 20297c478bd9Sstevel@tonic-gate int err, i; 20307c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 20317c478bd9Sstevel@tonic-gate 20327c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 20337c478bd9Sstevel@tonic-gate return (err); 20347c478bd9Sstevel@tonic-gate 2035e193d1e6Svp bzero(ipdtab, sizeof (*ipdtab)); 20367c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 20377c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 20387c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 20397c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 20407c478bd9Sstevel@tonic-gate saw_error = TRUE; 20417c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 20427c478bd9Sstevel@tonic-gate } 20437c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 20447c478bd9Sstevel@tonic-gate case PT_DIR: 20457c478bd9Sstevel@tonic-gate (void) strlcpy(ipdtab->zone_fs_dir, pp->pv_simple, 20467c478bd9Sstevel@tonic-gate sizeof (ipdtab->zone_fs_dir)); 20477c478bd9Sstevel@tonic-gate break; 20487c478bd9Sstevel@tonic-gate default: 20497c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 20507c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 20517c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 20527c478bd9Sstevel@tonic-gate } 20537c478bd9Sstevel@tonic-gate } 20547c478bd9Sstevel@tonic-gate if (fill_in_only) 20557c478bd9Sstevel@tonic-gate return (Z_OK); 20567c478bd9Sstevel@tonic-gate return (zonecfg_lookup_ipd(handle, ipdtab)); 20577c478bd9Sstevel@tonic-gate } 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate static int 20607c478bd9Sstevel@tonic-gate fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, bool fill_in_only) 20617c478bd9Sstevel@tonic-gate { 20627c478bd9Sstevel@tonic-gate int err, i; 20637c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 20667c478bd9Sstevel@tonic-gate return (err); 20677c478bd9Sstevel@tonic-gate 2068e193d1e6Svp bzero(nwiftab, sizeof (*nwiftab)); 20697c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 20707c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 20717c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 20727c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 20737c478bd9Sstevel@tonic-gate saw_error = TRUE; 20747c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 20757c478bd9Sstevel@tonic-gate } 20767c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 20777c478bd9Sstevel@tonic-gate case PT_ADDRESS: 20787c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 20797c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 20807c478bd9Sstevel@tonic-gate break; 20817c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 20827c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 20837c478bd9Sstevel@tonic-gate pp->pv_simple, 20847c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 20857c478bd9Sstevel@tonic-gate break; 20867c478bd9Sstevel@tonic-gate default: 20877c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 20887c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 20897c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 20907c478bd9Sstevel@tonic-gate } 20917c478bd9Sstevel@tonic-gate } 20927c478bd9Sstevel@tonic-gate if (fill_in_only) 20937c478bd9Sstevel@tonic-gate return (Z_OK); 20947c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 20957c478bd9Sstevel@tonic-gate return (err); 20967c478bd9Sstevel@tonic-gate } 20977c478bd9Sstevel@tonic-gate 20987c478bd9Sstevel@tonic-gate static int 20997c478bd9Sstevel@tonic-gate fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, bool fill_in_only) 21007c478bd9Sstevel@tonic-gate { 21017c478bd9Sstevel@tonic-gate int err, i; 21027c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 21057c478bd9Sstevel@tonic-gate return (err); 21067c478bd9Sstevel@tonic-gate 2107e193d1e6Svp bzero(devtab, sizeof (*devtab)); 21087c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 21097c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 21107c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 21117c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 21127c478bd9Sstevel@tonic-gate saw_error = TRUE; 21137c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 21147c478bd9Sstevel@tonic-gate } 21157c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 21167c478bd9Sstevel@tonic-gate case PT_MATCH: 21177c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 21187c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 21197c478bd9Sstevel@tonic-gate break; 21207c478bd9Sstevel@tonic-gate default: 21217c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 21227c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 21237c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 21247c478bd9Sstevel@tonic-gate } 21257c478bd9Sstevel@tonic-gate } 21267c478bd9Sstevel@tonic-gate if (fill_in_only) 21277c478bd9Sstevel@tonic-gate return (Z_OK); 21287c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 21297c478bd9Sstevel@tonic-gate return (err); 21307c478bd9Sstevel@tonic-gate } 21317c478bd9Sstevel@tonic-gate 21327c478bd9Sstevel@tonic-gate static int 21337c478bd9Sstevel@tonic-gate fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, bool fill_in_only) 21347c478bd9Sstevel@tonic-gate { 21357c478bd9Sstevel@tonic-gate int err, i; 21367c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 21377c478bd9Sstevel@tonic-gate 21387c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 21397c478bd9Sstevel@tonic-gate return (err); 21407c478bd9Sstevel@tonic-gate 2141e193d1e6Svp bzero(rctltab, sizeof (*rctltab)); 21427c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 21437c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 21447c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 21457c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 21467c478bd9Sstevel@tonic-gate saw_error = TRUE; 21477c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 21487c478bd9Sstevel@tonic-gate } 21497c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 21507c478bd9Sstevel@tonic-gate case PT_NAME: 21517c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 21527c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 21537c478bd9Sstevel@tonic-gate break; 21547c478bd9Sstevel@tonic-gate default: 21557c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 21567c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 21577c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 21587c478bd9Sstevel@tonic-gate } 21597c478bd9Sstevel@tonic-gate } 21607c478bd9Sstevel@tonic-gate if (fill_in_only) 21617c478bd9Sstevel@tonic-gate return (Z_OK); 21627c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 21637c478bd9Sstevel@tonic-gate return (err); 21647c478bd9Sstevel@tonic-gate } 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate static int 21677c478bd9Sstevel@tonic-gate fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, bool fill_in_only) 21687c478bd9Sstevel@tonic-gate { 21697c478bd9Sstevel@tonic-gate int err, i; 21707c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 21737c478bd9Sstevel@tonic-gate return (err); 21747c478bd9Sstevel@tonic-gate 2175e193d1e6Svp bzero(attrtab, sizeof (*attrtab)); 21767c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 21777c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 21787c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 21797c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 21807c478bd9Sstevel@tonic-gate saw_error = TRUE; 21817c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 21827c478bd9Sstevel@tonic-gate } 21837c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 21847c478bd9Sstevel@tonic-gate case PT_NAME: 21857c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 21867c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 21877c478bd9Sstevel@tonic-gate break; 21887c478bd9Sstevel@tonic-gate case PT_TYPE: 21897c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 21907c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 21917c478bd9Sstevel@tonic-gate break; 21927c478bd9Sstevel@tonic-gate case PT_VALUE: 21937c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 21947c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 21957c478bd9Sstevel@tonic-gate break; 21967c478bd9Sstevel@tonic-gate default: 21977c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 21987c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 21997c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 22007c478bd9Sstevel@tonic-gate } 22017c478bd9Sstevel@tonic-gate } 22027c478bd9Sstevel@tonic-gate if (fill_in_only) 22037c478bd9Sstevel@tonic-gate return (Z_OK); 22047c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 22057c478bd9Sstevel@tonic-gate return (err); 22067c478bd9Sstevel@tonic-gate } 22077c478bd9Sstevel@tonic-gate 2208fa9e4066Sahrens static int 2209fa9e4066Sahrens fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, bool fill_in_only) 2210fa9e4066Sahrens { 2211fa9e4066Sahrens int err, i; 2212fa9e4066Sahrens property_value_ptr_t pp; 2213fa9e4066Sahrens 2214fa9e4066Sahrens if ((err = initialize(TRUE)) != Z_OK) 2215fa9e4066Sahrens return (err); 2216fa9e4066Sahrens 2217fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2218fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2219fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2220fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2221fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2222fa9e4066Sahrens saw_error = TRUE; 2223fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2224fa9e4066Sahrens } 2225fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2226fa9e4066Sahrens case PT_NAME: 2227fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2228fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2229fa9e4066Sahrens break; 2230fa9e4066Sahrens default: 2231fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2232fa9e4066Sahrens Z_NO_PROPERTY_TYPE, TRUE); 2233fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2234fa9e4066Sahrens } 2235fa9e4066Sahrens } 2236fa9e4066Sahrens if (fill_in_only) 2237fa9e4066Sahrens return (Z_OK); 2238fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2239fa9e4066Sahrens } 2240fa9e4066Sahrens 22417c478bd9Sstevel@tonic-gate static void 22427c478bd9Sstevel@tonic-gate remove_resource(cmd_t *cmd) 22437c478bd9Sstevel@tonic-gate { 22447c478bd9Sstevel@tonic-gate int err, type; 22457c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 22467c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 22477c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 22487c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 22497c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 2250fa9e4066Sahrens struct zone_dstab dstab; 22517c478bd9Sstevel@tonic-gate 22527c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 22537c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 22547c478bd9Sstevel@tonic-gate return; 22557c478bd9Sstevel@tonic-gate } 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 22587c478bd9Sstevel@tonic-gate return; 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate switch (type) { 22617c478bd9Sstevel@tonic-gate case RT_FS: 22627c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &fstab, FALSE)) != Z_OK) { 22637c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 22647c478bd9Sstevel@tonic-gate return; 22657c478bd9Sstevel@tonic-gate } 22667c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 22677c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 22687c478bd9Sstevel@tonic-gate else 22697c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 22707c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 22717c478bd9Sstevel@tonic-gate return; 22727c478bd9Sstevel@tonic-gate case RT_IPD: 2273087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 22747c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 22757c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_REMOVE), 22767c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 22777c478bd9Sstevel@tonic-gate return; 22787c478bd9Sstevel@tonic-gate } 22797c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &fstab, FALSE)) != Z_OK) { 22807c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 22817c478bd9Sstevel@tonic-gate return; 22827c478bd9Sstevel@tonic-gate } 22837c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd(handle, &fstab)) != Z_OK) 22847c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 22857c478bd9Sstevel@tonic-gate else 22867c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 22877c478bd9Sstevel@tonic-gate return; 22887c478bd9Sstevel@tonic-gate case RT_NET: 22897c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &nwiftab, FALSE)) != Z_OK) { 22907c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 22917c478bd9Sstevel@tonic-gate return; 22927c478bd9Sstevel@tonic-gate } 22937c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 22947c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 22957c478bd9Sstevel@tonic-gate else 22967c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 22977c478bd9Sstevel@tonic-gate return; 22987c478bd9Sstevel@tonic-gate case RT_DEVICE: 22997c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &devtab, FALSE)) != Z_OK) { 23007c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 23017c478bd9Sstevel@tonic-gate return; 23027c478bd9Sstevel@tonic-gate } 23037c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 23047c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 23057c478bd9Sstevel@tonic-gate else 23067c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 23077c478bd9Sstevel@tonic-gate return; 23087c478bd9Sstevel@tonic-gate case RT_RCTL: 23097c478bd9Sstevel@tonic-gate if ((err = fill_in_rctltab(cmd, &rctltab, FALSE)) != Z_OK) { 23107c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 23117c478bd9Sstevel@tonic-gate return; 23127c478bd9Sstevel@tonic-gate } 23137c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 23147c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 23157c478bd9Sstevel@tonic-gate else 23167c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 23177c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 23187c478bd9Sstevel@tonic-gate return; 23197c478bd9Sstevel@tonic-gate case RT_ATTR: 23207c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &attrtab, FALSE)) != Z_OK) { 23217c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 23227c478bd9Sstevel@tonic-gate return; 23237c478bd9Sstevel@tonic-gate } 23247c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 23257c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 23267c478bd9Sstevel@tonic-gate else 23277c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 23287c478bd9Sstevel@tonic-gate return; 2329fa9e4066Sahrens case RT_DATASET: 2330fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &dstab, FALSE)) != Z_OK) { 2331fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2332fa9e4066Sahrens return; 2333fa9e4066Sahrens } 2334fa9e4066Sahrens if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 2335fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2336fa9e4066Sahrens else 2337fa9e4066Sahrens need_to_commit = TRUE; 2338fa9e4066Sahrens return; 23397c478bd9Sstevel@tonic-gate default: 23407c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 23417c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 23427c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 23437c478bd9Sstevel@tonic-gate return; 23447c478bd9Sstevel@tonic-gate } 23457c478bd9Sstevel@tonic-gate } 23467c478bd9Sstevel@tonic-gate 23477c478bd9Sstevel@tonic-gate static void 23487c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 23497c478bd9Sstevel@tonic-gate { 23507c478bd9Sstevel@tonic-gate char *prop_id; 23517c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 23527c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 23537c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 23547c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 23557c478bd9Sstevel@tonic-gate 23567c478bd9Sstevel@tonic-gate res_type = resource_scope; 23577c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 23587c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 23597c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 23607c478bd9Sstevel@tonic-gate return; 23617c478bd9Sstevel@tonic-gate } 23627c478bd9Sstevel@tonic-gate 23637c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 23647c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 23657c478bd9Sstevel@tonic-gate return; 23667c478bd9Sstevel@tonic-gate } 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 23697c478bd9Sstevel@tonic-gate return; 23707c478bd9Sstevel@tonic-gate 23717c478bd9Sstevel@tonic-gate switch (res_type) { 23727c478bd9Sstevel@tonic-gate case RT_FS: 23737c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 23747c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 23757c478bd9Sstevel@tonic-gate TRUE); 23767c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 23777c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 23787c478bd9Sstevel@tonic-gate return; 23797c478bd9Sstevel@tonic-gate } 23807c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23817c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 23827c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23837c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 23847c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 23857c478bd9Sstevel@tonic-gate saw_error = TRUE; 23867c478bd9Sstevel@tonic-gate return; 23877c478bd9Sstevel@tonic-gate } 23887c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 23897c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 23907c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 23917c478bd9Sstevel@tonic-gate return; 23927c478bd9Sstevel@tonic-gate } 23937c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 23947c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 23957c478bd9Sstevel@tonic-gate prop_id); 23967c478bd9Sstevel@tonic-gate if (err != Z_OK) 23977c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 23987c478bd9Sstevel@tonic-gate } else { 23997c478bd9Sstevel@tonic-gate list_property_ptr_t list; 24007c478bd9Sstevel@tonic-gate 24017c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 24027c478bd9Sstevel@tonic-gate list = list->lp_next) { 24037c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 24047c478bd9Sstevel@tonic-gate if (prop_id == NULL) 24057c478bd9Sstevel@tonic-gate break; 24067c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 24077c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 24087c478bd9Sstevel@tonic-gate if (err != Z_OK) 24097c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 24107c478bd9Sstevel@tonic-gate TRUE); 24117c478bd9Sstevel@tonic-gate } 24127c478bd9Sstevel@tonic-gate } 24137c478bd9Sstevel@tonic-gate return; 24147c478bd9Sstevel@tonic-gate case RT_RCTL: 24157c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 24167c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 24177c478bd9Sstevel@tonic-gate TRUE); 24187c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 24197c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 24207c478bd9Sstevel@tonic-gate return; 24217c478bd9Sstevel@tonic-gate } 24227c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 24237c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 24247c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 24257c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 24267c478bd9Sstevel@tonic-gate saw_error = TRUE; 24277c478bd9Sstevel@tonic-gate return; 24287c478bd9Sstevel@tonic-gate } 24297c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 24307c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 24317c478bd9Sstevel@tonic-gate exit(Z_ERR); 24327c478bd9Sstevel@tonic-gate } 24337c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 24347c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 24357c478bd9Sstevel@tonic-gate case PT_PRIV: 24367c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 24377c478bd9Sstevel@tonic-gate cx->cp_value, 24387c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 24397c478bd9Sstevel@tonic-gate break; 24407c478bd9Sstevel@tonic-gate case PT_LIMIT: 24417c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 24427c478bd9Sstevel@tonic-gate cx->cp_value, 24437c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 24447c478bd9Sstevel@tonic-gate break; 24457c478bd9Sstevel@tonic-gate case PT_ACTION: 24467c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 24477c478bd9Sstevel@tonic-gate cx->cp_value, 24487c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 24497c478bd9Sstevel@tonic-gate break; 24507c478bd9Sstevel@tonic-gate default: 24517c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 24527c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24537c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 24547c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 24557c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 24567c478bd9Sstevel@tonic-gate return; 24577c478bd9Sstevel@tonic-gate } 24587c478bd9Sstevel@tonic-gate } 24597c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 24607c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 24617c478bd9Sstevel@tonic-gate rctlvaltab); 24627c478bd9Sstevel@tonic-gate if (err != Z_OK) 24637c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 24647c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 24657c478bd9Sstevel@tonic-gate return; 24667c478bd9Sstevel@tonic-gate default: 24677c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 24687c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 24697c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 24707c478bd9Sstevel@tonic-gate return; 24717c478bd9Sstevel@tonic-gate } 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate void 24757c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 24767c478bd9Sstevel@tonic-gate { 24777c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 24787c478bd9Sstevel@tonic-gate return; 24797c478bd9Sstevel@tonic-gate 24807c478bd9Sstevel@tonic-gate assert(cmd != NULL); 24817c478bd9Sstevel@tonic-gate 24827c478bd9Sstevel@tonic-gate if (global_scope) 24837c478bd9Sstevel@tonic-gate remove_resource(cmd); 24847c478bd9Sstevel@tonic-gate else 24857c478bd9Sstevel@tonic-gate remove_property(cmd); 24867c478bd9Sstevel@tonic-gate } 24877c478bd9Sstevel@tonic-gate 24887c478bd9Sstevel@tonic-gate void 24897c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 24907c478bd9Sstevel@tonic-gate { 24917c478bd9Sstevel@tonic-gate int type, err; 24927c478bd9Sstevel@tonic-gate 24937c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 24947c478bd9Sstevel@tonic-gate return; 24957c478bd9Sstevel@tonic-gate 24967c478bd9Sstevel@tonic-gate assert(cmd != NULL); 24977c478bd9Sstevel@tonic-gate 24987c478bd9Sstevel@tonic-gate if (global_scope) { 24997c478bd9Sstevel@tonic-gate global_scope = FALSE; 25007c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 25017c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 25027c478bd9Sstevel@tonic-gate } else { 25037c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 25047c478bd9Sstevel@tonic-gate return; 25057c478bd9Sstevel@tonic-gate } 25067c478bd9Sstevel@tonic-gate 25077c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 25087c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 25097c478bd9Sstevel@tonic-gate return; 25107c478bd9Sstevel@tonic-gate } 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 25137c478bd9Sstevel@tonic-gate return; 25147c478bd9Sstevel@tonic-gate 25157c478bd9Sstevel@tonic-gate switch (type) { 25167c478bd9Sstevel@tonic-gate case RT_FS: 25177c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &old_fstab, FALSE)) != Z_OK) { 25187c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_FS, err, TRUE); 25197c478bd9Sstevel@tonic-gate global_scope = TRUE; 25207c478bd9Sstevel@tonic-gate } 25217c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 25227c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 25237c478bd9Sstevel@tonic-gate return; 25247c478bd9Sstevel@tonic-gate case RT_IPD: 2525087719fdSdp if (state_atleast(ZONE_STATE_INCOMPLETE)) { 25267c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s not in %s state; %s %s not " 25277c478bd9Sstevel@tonic-gate "allowed."), zone, 25287c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED), 25297c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SELECT), rt_to_str(RT_IPD)); 25307c478bd9Sstevel@tonic-gate global_scope = TRUE; 25317c478bd9Sstevel@tonic-gate end_op = -1; 25327c478bd9Sstevel@tonic-gate return; 25337c478bd9Sstevel@tonic-gate } 25347c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &old_ipdtab, FALSE)) != Z_OK) { 25357c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_IPD, err, TRUE); 25367c478bd9Sstevel@tonic-gate global_scope = TRUE; 25377c478bd9Sstevel@tonic-gate } 25387c478bd9Sstevel@tonic-gate bcopy(&old_ipdtab, &in_progress_ipdtab, 25397c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 25407c478bd9Sstevel@tonic-gate return; 25417c478bd9Sstevel@tonic-gate case RT_NET: 25427c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &old_nwiftab, FALSE)) != Z_OK) { 25437c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_NET, err, TRUE); 25447c478bd9Sstevel@tonic-gate global_scope = TRUE; 25457c478bd9Sstevel@tonic-gate } 25467c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 25477c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 25487c478bd9Sstevel@tonic-gate return; 25497c478bd9Sstevel@tonic-gate case RT_DEVICE: 25507c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &old_devtab, FALSE)) != Z_OK) { 25517c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, TRUE); 25527c478bd9Sstevel@tonic-gate global_scope = TRUE; 25537c478bd9Sstevel@tonic-gate } 25547c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 25557c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 25567c478bd9Sstevel@tonic-gate return; 25577c478bd9Sstevel@tonic-gate case RT_RCTL: 25587c478bd9Sstevel@tonic-gate if ((err = fill_in_rctltab(cmd, &old_rctltab, FALSE)) != Z_OK) { 25597c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, TRUE); 25607c478bd9Sstevel@tonic-gate global_scope = TRUE; 25617c478bd9Sstevel@tonic-gate } 25627c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 25637c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 25647c478bd9Sstevel@tonic-gate return; 25657c478bd9Sstevel@tonic-gate case RT_ATTR: 25667c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &old_attrtab, FALSE)) != Z_OK) { 25677c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, TRUE); 25687c478bd9Sstevel@tonic-gate global_scope = TRUE; 25697c478bd9Sstevel@tonic-gate } 25707c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 25717c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 25727c478bd9Sstevel@tonic-gate return; 2573fa9e4066Sahrens case RT_DATASET: 2574fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &old_dstab, FALSE)) != Z_OK) { 2575fa9e4066Sahrens z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, TRUE); 2576fa9e4066Sahrens global_scope = TRUE; 2577fa9e4066Sahrens } 2578fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 2579fa9e4066Sahrens sizeof (struct zone_dstab)); 2580fa9e4066Sahrens return; 25817c478bd9Sstevel@tonic-gate default: 25827c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 25837c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 25847c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 25857c478bd9Sstevel@tonic-gate return; 25867c478bd9Sstevel@tonic-gate } 25877c478bd9Sstevel@tonic-gate } 25887c478bd9Sstevel@tonic-gate 25897c478bd9Sstevel@tonic-gate /* 25907c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 25917c478bd9Sstevel@tonic-gate * <IPv4 address> 25927c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 25937c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 25947c478bd9Sstevel@tonic-gate * <host name> 25957c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 25967c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 25977c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 25987c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 25997c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 26007c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 26017c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 26027c478bd9Sstevel@tonic-gate */ 26037c478bd9Sstevel@tonic-gate 26047c478bd9Sstevel@tonic-gate static int 26057c478bd9Sstevel@tonic-gate validate_net_address_syntax(char *address) 26067c478bd9Sstevel@tonic-gate { 26077c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 26087c478bd9Sstevel@tonic-gate struct in6_addr in6; 26097c478bd9Sstevel@tonic-gate struct in_addr in4; 26107c478bd9Sstevel@tonic-gate int prefixlen, i; 26117c478bd9Sstevel@tonic-gate 26127c478bd9Sstevel@tonic-gate /* 26137c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 26147c478bd9Sstevel@tonic-gate * thing if there is no '/'. 26157c478bd9Sstevel@tonic-gate */ 26167c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 26177c478bd9Sstevel@tonic-gate *slashp = '\0'; 26187c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 26197c478bd9Sstevel@tonic-gate *slashp = '/'; 26207c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 26217c478bd9Sstevel@tonic-gate } else { 26227c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 26237c478bd9Sstevel@tonic-gate } 26247c478bd9Sstevel@tonic-gate 26257c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 26267c478bd9Sstevel@tonic-gate if (slashp == NULL) { 26277c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 26287c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 26297c478bd9Sstevel@tonic-gate return (Z_ERR); 26307c478bd9Sstevel@tonic-gate } 26317c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 26327c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 26337c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 26347c478bd9Sstevel@tonic-gate return (Z_ERR); 26357c478bd9Sstevel@tonic-gate } 26367c478bd9Sstevel@tonic-gate return (Z_OK); 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate 26397c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 26407c478bd9Sstevel@tonic-gate if (slashp != NULL) { 26417c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 26427c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 26437c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 26447c478bd9Sstevel@tonic-gate return (Z_ERR); 26457c478bd9Sstevel@tonic-gate } 26467c478bd9Sstevel@tonic-gate } 26477c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 26487c478bd9Sstevel@tonic-gate return (Z_OK); 26497c478bd9Sstevel@tonic-gate 26507c478bd9Sstevel@tonic-gate /* address may also be a host name */ 26517c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 26527c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 26537c478bd9Sstevel@tonic-gate part1); 26547c478bd9Sstevel@tonic-gate saw_error = TRUE; 26557c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 26567c478bd9Sstevel@tonic-gate return (Z_ERR); 26577c478bd9Sstevel@tonic-gate } 26587c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 26597c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 26607c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 26617c478bd9Sstevel@tonic-gate "network address syntax"), part1); 26627c478bd9Sstevel@tonic-gate saw_error = TRUE; 26637c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 26647c478bd9Sstevel@tonic-gate return (Z_ERR); 26657c478bd9Sstevel@tonic-gate } 26667c478bd9Sstevel@tonic-gate return (Z_OK); 26677c478bd9Sstevel@tonic-gate } 26687c478bd9Sstevel@tonic-gate 26697c478bd9Sstevel@tonic-gate static int 26707c478bd9Sstevel@tonic-gate validate_net_physical_syntax(char *ifname) 26717c478bd9Sstevel@tonic-gate { 26727c478bd9Sstevel@tonic-gate if (strchr(ifname, ':') == NULL) 26737c478bd9Sstevel@tonic-gate return (Z_OK); 26747c478bd9Sstevel@tonic-gate zerr(gettext("%s: physical interface name required; " 26757c478bd9Sstevel@tonic-gate "logical interface name not allowed"), ifname); 26767c478bd9Sstevel@tonic-gate return (Z_ERR); 26777c478bd9Sstevel@tonic-gate } 26787c478bd9Sstevel@tonic-gate 26797c478bd9Sstevel@tonic-gate static boolean_t 26807c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 26817c478bd9Sstevel@tonic-gate { 26827c478bd9Sstevel@tonic-gate /* 26837c478bd9Sstevel@tonic-gate * Is this a valid path component? 26847c478bd9Sstevel@tonic-gate */ 26857c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 26867c478bd9Sstevel@tonic-gate return (B_FALSE); 26877c478bd9Sstevel@tonic-gate /* 26887c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 26897c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 26907c478bd9Sstevel@tonic-gate */ 26917c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 26927c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 2693087719fdSdp return (B_FALSE); 26947c478bd9Sstevel@tonic-gate /* 26957c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 26967c478bd9Sstevel@tonic-gate */ 26977c478bd9Sstevel@tonic-gate return (B_TRUE); 26987c478bd9Sstevel@tonic-gate } 26997c478bd9Sstevel@tonic-gate 27007c478bd9Sstevel@tonic-gate void 27017c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 27027c478bd9Sstevel@tonic-gate { 27037c478bd9Sstevel@tonic-gate char *prop_id; 2704555afedfScarlsonj int arg, err, res_type, prop_type; 27057c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27067c478bd9Sstevel@tonic-gate boolean_t autoboot; 2707555afedfScarlsonj boolean_t force_set = FALSE; 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 27107c478bd9Sstevel@tonic-gate return; 27117c478bd9Sstevel@tonic-gate 27127c478bd9Sstevel@tonic-gate assert(cmd != NULL); 27137c478bd9Sstevel@tonic-gate 2714555afedfScarlsonj optind = opterr = 0; 2715555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 2716555afedfScarlsonj switch (arg) { 2717555afedfScarlsonj case 'F': 2718555afedfScarlsonj force_set = TRUE; 2719555afedfScarlsonj break; 2720555afedfScarlsonj default: 2721555afedfScarlsonj if (optopt == '?') 2722555afedfScarlsonj longer_usage(CMD_SET); 2723555afedfScarlsonj else 2724555afedfScarlsonj short_usage(CMD_SET); 2725555afedfScarlsonj return; 2726555afedfScarlsonj } 2727555afedfScarlsonj } 2728555afedfScarlsonj 27297c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 27307c478bd9Sstevel@tonic-gate if (global_scope) { 2731087719fdSdp if (prop_type == PT_ZONENAME) { 2732087719fdSdp res_type = RT_ZONENAME; 2733087719fdSdp } else if (prop_type == PT_ZONEPATH) { 27347c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 27357c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 27367c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 27377c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 27387c478bd9Sstevel@tonic-gate res_type = RT_POOL; 2739ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 2740ffbafc53Scomay res_type = RT_LIMITPRIV; 27413f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 27423f2f09c1Sdp res_type = RT_BOOTARGS; 27437c478bd9Sstevel@tonic-gate } else { 27447c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 27457c478bd9Sstevel@tonic-gate "from the global scope.")); 27467c478bd9Sstevel@tonic-gate saw_error = TRUE; 27477c478bd9Sstevel@tonic-gate return; 27487c478bd9Sstevel@tonic-gate } 27497c478bd9Sstevel@tonic-gate } else { 27507c478bd9Sstevel@tonic-gate res_type = resource_scope; 27517c478bd9Sstevel@tonic-gate } 27527c478bd9Sstevel@tonic-gate 2753555afedfScarlsonj if (force_set) { 2754555afedfScarlsonj if (res_type != RT_ZONEPATH) { 2755555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 2756555afedfScarlsonj saw_error = TRUE; 2757555afedfScarlsonj return; 2758555afedfScarlsonj } 2759555afedfScarlsonj if (!zonecfg_in_alt_root()) { 2760555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 2761555afedfScarlsonj "alternate root.")); 2762555afedfScarlsonj saw_error = TRUE; 2763555afedfScarlsonj return; 2764555afedfScarlsonj } 2765555afedfScarlsonj } 2766555afedfScarlsonj 27677c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 27687c478bd9Sstevel@tonic-gate /* 27697c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 27707c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 27717c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 27727c478bd9Sstevel@tonic-gate * Anything else should be simple. 27737c478bd9Sstevel@tonic-gate */ 27747c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 27757c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 27767c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 27777c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 27787c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 27797c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 27807c478bd9Sstevel@tonic-gate saw_error = TRUE; 27817c478bd9Sstevel@tonic-gate return; 27827c478bd9Sstevel@tonic-gate } 27837c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 27847c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 27857c478bd9Sstevel@tonic-gate return; 27867c478bd9Sstevel@tonic-gate } 27877c478bd9Sstevel@tonic-gate 2788087719fdSdp /* 2789087719fdSdp * Special case: the user can change the zone name prior to 'create'; 2790087719fdSdp * if the zone already exists, we fall through letting initialize() 2791087719fdSdp * and the rest of the logic run. 2792087719fdSdp */ 2793087719fdSdp if (res_type == RT_ZONENAME && got_handle == FALSE && 2794087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 2795fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 2796fb03efaaSdp zone_perror(prop_id, err, TRUE); 2797fb03efaaSdp usage(FALSE, HELP_SYNTAX); 2798fb03efaaSdp return; 2799fb03efaaSdp } 2800087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 2801087719fdSdp return; 2802087719fdSdp } 2803087719fdSdp 28047c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 28057c478bd9Sstevel@tonic-gate return; 28067c478bd9Sstevel@tonic-gate 28077c478bd9Sstevel@tonic-gate switch (res_type) { 2808087719fdSdp case RT_ZONENAME: 2809087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 2810087719fdSdp /* 2811087719fdSdp * Use prop_id instead of 'zone' here, since we're 2812087719fdSdp * reporting a problem about the *new* zonename. 2813087719fdSdp */ 2814087719fdSdp zone_perror(prop_id, err, TRUE); 2815fb03efaaSdp usage(FALSE, HELP_SYNTAX); 2816087719fdSdp } else { 2817087719fdSdp need_to_commit = TRUE; 2818087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 2819087719fdSdp } 2820087719fdSdp return; 28217c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 2822555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 28237c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 28247c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 28257c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 28267c478bd9Sstevel@tonic-gate return; 28277c478bd9Sstevel@tonic-gate } 28287c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 28297c478bd9Sstevel@tonic-gate saw_error = TRUE; 28307c478bd9Sstevel@tonic-gate return; 28317c478bd9Sstevel@tonic-gate } 28327c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 28337c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 28347c478bd9Sstevel@tonic-gate else 28357c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28367c478bd9Sstevel@tonic-gate return; 28377c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 28387c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 28397c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 28407c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 28417c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 28427c478bd9Sstevel@tonic-gate } else { 28437c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 28447c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 28457c478bd9Sstevel@tonic-gate saw_error = TRUE; 28467c478bd9Sstevel@tonic-gate return; 28477c478bd9Sstevel@tonic-gate } 28487c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 28497c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 28507c478bd9Sstevel@tonic-gate else 28517c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28527c478bd9Sstevel@tonic-gate return; 28537c478bd9Sstevel@tonic-gate case RT_POOL: 28547c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 28557c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 28567c478bd9Sstevel@tonic-gate else 28577c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28587c478bd9Sstevel@tonic-gate return; 2859ffbafc53Scomay case RT_LIMITPRIV: 2860ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 2861ffbafc53Scomay zone_perror(zone, err, TRUE); 2862ffbafc53Scomay else 2863ffbafc53Scomay need_to_commit = TRUE; 2864ffbafc53Scomay return; 28653f2f09c1Sdp case RT_BOOTARGS: 28663f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 28673f2f09c1Sdp zone_perror(zone, err, TRUE); 28683f2f09c1Sdp else 28693f2f09c1Sdp need_to_commit = TRUE; 28703f2f09c1Sdp return; 28717c478bd9Sstevel@tonic-gate case RT_FS: 28727c478bd9Sstevel@tonic-gate switch (prop_type) { 28737c478bd9Sstevel@tonic-gate case PT_DIR: 28747c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 28757c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 28767c478bd9Sstevel@tonic-gate return; 28777c478bd9Sstevel@tonic-gate case PT_SPECIAL: 28787c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 28797c478bd9Sstevel@tonic-gate prop_id, 28807c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 28817c478bd9Sstevel@tonic-gate return; 28827c478bd9Sstevel@tonic-gate case PT_RAW: 28837c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 28847c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 28857c478bd9Sstevel@tonic-gate return; 28867c478bd9Sstevel@tonic-gate case PT_TYPE: 28877c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 28887c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 28897c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 28907c478bd9Sstevel@tonic-gate saw_error = TRUE; 28917c478bd9Sstevel@tonic-gate return; 28927c478bd9Sstevel@tonic-gate } 28937c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 28947c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 28957c478bd9Sstevel@tonic-gate return; 28967c478bd9Sstevel@tonic-gate case PT_OPTIONS: 28977c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 28987c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 28997c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 29007c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 29017c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 29027c478bd9Sstevel@tonic-gate saw_error = TRUE; 29037c478bd9Sstevel@tonic-gate return; 29047c478bd9Sstevel@tonic-gate } 29057c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 29067c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 29077c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 29087c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 29097c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 29107c478bd9Sstevel@tonic-gate add_property(cmd); 29117c478bd9Sstevel@tonic-gate return; 29127c478bd9Sstevel@tonic-gate default: 29137c478bd9Sstevel@tonic-gate break; 29147c478bd9Sstevel@tonic-gate } 29157c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 29167c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 29177c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 29187c478bd9Sstevel@tonic-gate return; 29197c478bd9Sstevel@tonic-gate case RT_IPD: 29207c478bd9Sstevel@tonic-gate switch (prop_type) { 29217c478bd9Sstevel@tonic-gate case PT_DIR: 29227c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_ipdtab.zone_fs_dir, prop_id, 29237c478bd9Sstevel@tonic-gate sizeof (in_progress_ipdtab.zone_fs_dir)); 29247c478bd9Sstevel@tonic-gate return; 29257c478bd9Sstevel@tonic-gate default: 29267c478bd9Sstevel@tonic-gate break; 29277c478bd9Sstevel@tonic-gate } 29287c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 29297c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 29307c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 29317c478bd9Sstevel@tonic-gate return; 29327c478bd9Sstevel@tonic-gate case RT_NET: 29337c478bd9Sstevel@tonic-gate switch (prop_type) { 29347c478bd9Sstevel@tonic-gate case PT_ADDRESS: 29357c478bd9Sstevel@tonic-gate if (validate_net_address_syntax(prop_id) != Z_OK) { 29367c478bd9Sstevel@tonic-gate saw_error = TRUE; 29377c478bd9Sstevel@tonic-gate return; 29387c478bd9Sstevel@tonic-gate } 29397c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_address, 29407c478bd9Sstevel@tonic-gate prop_id, 29417c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_address)); 29427c478bd9Sstevel@tonic-gate break; 29437c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 29447c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 29457c478bd9Sstevel@tonic-gate saw_error = TRUE; 29467c478bd9Sstevel@tonic-gate return; 29477c478bd9Sstevel@tonic-gate } 29487c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 29497c478bd9Sstevel@tonic-gate prop_id, 29507c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 29517c478bd9Sstevel@tonic-gate break; 29527c478bd9Sstevel@tonic-gate default: 29537c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 29547c478bd9Sstevel@tonic-gate TRUE); 29557c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 29567c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 29577c478bd9Sstevel@tonic-gate return; 29587c478bd9Sstevel@tonic-gate } 29597c478bd9Sstevel@tonic-gate return; 29607c478bd9Sstevel@tonic-gate case RT_DEVICE: 29617c478bd9Sstevel@tonic-gate switch (prop_type) { 29627c478bd9Sstevel@tonic-gate case PT_MATCH: 29637c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 29647c478bd9Sstevel@tonic-gate prop_id, 29657c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 29667c478bd9Sstevel@tonic-gate break; 29677c478bd9Sstevel@tonic-gate default: 29687c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 29697c478bd9Sstevel@tonic-gate TRUE); 29707c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 29717c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 29727c478bd9Sstevel@tonic-gate return; 29737c478bd9Sstevel@tonic-gate } 29747c478bd9Sstevel@tonic-gate return; 29757c478bd9Sstevel@tonic-gate case RT_RCTL: 29767c478bd9Sstevel@tonic-gate switch (prop_type) { 29777c478bd9Sstevel@tonic-gate case PT_NAME: 29787c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 29797c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 29807c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 29817c478bd9Sstevel@tonic-gate return; 29827c478bd9Sstevel@tonic-gate } 29837c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 29847c478bd9Sstevel@tonic-gate prop_id, 29857c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 29867c478bd9Sstevel@tonic-gate break; 29877c478bd9Sstevel@tonic-gate case PT_VALUE: 29887c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 29897c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 29907c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 29917c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 29927c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 29937c478bd9Sstevel@tonic-gate saw_error = TRUE; 29947c478bd9Sstevel@tonic-gate return; 29957c478bd9Sstevel@tonic-gate } 29967c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 29977c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 29987c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 29997c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 30007c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 30017c478bd9Sstevel@tonic-gate add_property(cmd); 30027c478bd9Sstevel@tonic-gate break; 30037c478bd9Sstevel@tonic-gate default: 30047c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 30057c478bd9Sstevel@tonic-gate TRUE); 30067c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 30077c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 30087c478bd9Sstevel@tonic-gate return; 30097c478bd9Sstevel@tonic-gate } 30107c478bd9Sstevel@tonic-gate return; 30117c478bd9Sstevel@tonic-gate case RT_ATTR: 30127c478bd9Sstevel@tonic-gate switch (prop_type) { 30137c478bd9Sstevel@tonic-gate case PT_NAME: 30147c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 30157c478bd9Sstevel@tonic-gate prop_id, 30167c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 30177c478bd9Sstevel@tonic-gate break; 30187c478bd9Sstevel@tonic-gate case PT_TYPE: 30197c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 30207c478bd9Sstevel@tonic-gate prop_id, 30217c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 30227c478bd9Sstevel@tonic-gate break; 30237c478bd9Sstevel@tonic-gate case PT_VALUE: 30247c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 30257c478bd9Sstevel@tonic-gate prop_id, 30267c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 30277c478bd9Sstevel@tonic-gate break; 30287c478bd9Sstevel@tonic-gate default: 30297c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 30307c478bd9Sstevel@tonic-gate TRUE); 30317c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 30327c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 30337c478bd9Sstevel@tonic-gate return; 30347c478bd9Sstevel@tonic-gate } 30357c478bd9Sstevel@tonic-gate return; 3036fa9e4066Sahrens case RT_DATASET: 3037fa9e4066Sahrens switch (prop_type) { 3038fa9e4066Sahrens case PT_NAME: 3039fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 3040fa9e4066Sahrens prop_id, 3041fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 3042fa9e4066Sahrens return; 3043fa9e4066Sahrens default: 3044fa9e4066Sahrens break; 3045fa9e4066Sahrens } 3046fa9e4066Sahrens zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 3047fa9e4066Sahrens long_usage(CMD_SET, TRUE); 3048fa9e4066Sahrens usage(FALSE, HELP_PROPS); 3049fa9e4066Sahrens return; 30507c478bd9Sstevel@tonic-gate default: 30517c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 30527c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 30537c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 30547c478bd9Sstevel@tonic-gate return; 30557c478bd9Sstevel@tonic-gate } 30567c478bd9Sstevel@tonic-gate } 30577c478bd9Sstevel@tonic-gate 30587c478bd9Sstevel@tonic-gate static void 30597c478bd9Sstevel@tonic-gate output_prop(FILE *fp, int pnum, char *pval, bool print_notspec) 30607c478bd9Sstevel@tonic-gate { 30617c478bd9Sstevel@tonic-gate char *qstr; 30627c478bd9Sstevel@tonic-gate 30637c478bd9Sstevel@tonic-gate if (*pval != '\0') { 30647c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 30657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 30667c478bd9Sstevel@tonic-gate free(qstr); 30677c478bd9Sstevel@tonic-gate } else if (print_notspec) 3068087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 3069087719fdSdp pt_to_str(pnum)); 3070087719fdSdp } 3071087719fdSdp 3072087719fdSdp static void 3073087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 3074087719fdSdp { 3075087719fdSdp char zonename[ZONENAME_MAX]; 3076087719fdSdp 3077087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 3078087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 3079087719fdSdp zonename); 3080087719fdSdp else 3081087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 3082087719fdSdp pt_to_str(PT_ZONENAME)); 30837c478bd9Sstevel@tonic-gate } 30847c478bd9Sstevel@tonic-gate 30857c478bd9Sstevel@tonic-gate static void 30867c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 30877c478bd9Sstevel@tonic-gate { 30887c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 30897c478bd9Sstevel@tonic-gate 30907c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 30917c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 30927c478bd9Sstevel@tonic-gate zonepath); 3093087719fdSdp else { 3094087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 3095087719fdSdp pt_to_str(PT_ZONEPATH)); 3096087719fdSdp } 30977c478bd9Sstevel@tonic-gate } 30987c478bd9Sstevel@tonic-gate 30997c478bd9Sstevel@tonic-gate static void 31007c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 31017c478bd9Sstevel@tonic-gate { 31027c478bd9Sstevel@tonic-gate boolean_t autoboot; 31037c478bd9Sstevel@tonic-gate int err; 31047c478bd9Sstevel@tonic-gate 31057c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 31067c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 31077c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 31087c478bd9Sstevel@tonic-gate else 31097c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 31107c478bd9Sstevel@tonic-gate } 31117c478bd9Sstevel@tonic-gate 31127c478bd9Sstevel@tonic-gate static void 31137c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 31147c478bd9Sstevel@tonic-gate { 31157c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 31167c478bd9Sstevel@tonic-gate int err; 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 31197c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 31207c478bd9Sstevel@tonic-gate else 31217c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 31227c478bd9Sstevel@tonic-gate } 31237c478bd9Sstevel@tonic-gate 3124ffbafc53Scomay static void 3125ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 3126ffbafc53Scomay { 3127ffbafc53Scomay char *limitpriv; 3128ffbafc53Scomay int err; 3129ffbafc53Scomay 3130ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 3131ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 3132ffbafc53Scomay limitpriv); 3133ffbafc53Scomay free(limitpriv); 3134ffbafc53Scomay } else { 3135ffbafc53Scomay zone_perror(zone, err, TRUE); 3136ffbafc53Scomay } 3137ffbafc53Scomay } 3138ffbafc53Scomay 31393f2f09c1Sdp static void 31403f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 31413f2f09c1Sdp { 31423f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 31433f2f09c1Sdp int err; 31443f2f09c1Sdp 31453f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 31463f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 31473f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 31483f2f09c1Sdp bootargs); 31493f2f09c1Sdp } else { 31503f2f09c1Sdp zone_perror(zone, err, TRUE); 31513f2f09c1Sdp } 31523f2f09c1Sdp } 31533f2f09c1Sdp 31547c478bd9Sstevel@tonic-gate static void 31557c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 31567c478bd9Sstevel@tonic-gate { 31577c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 31587c478bd9Sstevel@tonic-gate 31597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 31607c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 31617c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 31627c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 31637c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 31647c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 31657c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 31667c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 31677c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 31687c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 31697c478bd9Sstevel@tonic-gate else 31707c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 31717c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 31727c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 31737c478bd9Sstevel@tonic-gate } 31747c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 31757c478bd9Sstevel@tonic-gate } 31767c478bd9Sstevel@tonic-gate 31777c478bd9Sstevel@tonic-gate static void 31787c478bd9Sstevel@tonic-gate output_ipd(FILE *fp, struct zone_fstab *ipdtab) 31797c478bd9Sstevel@tonic-gate { 31807c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_IPD)); 31817c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, ipdtab->zone_fs_dir, B_TRUE); 31827c478bd9Sstevel@tonic-gate } 31837c478bd9Sstevel@tonic-gate 31847c478bd9Sstevel@tonic-gate static void 31857c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 31867c478bd9Sstevel@tonic-gate { 31877c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 31887c478bd9Sstevel@tonic-gate bool output = FALSE; 31897c478bd9Sstevel@tonic-gate 31907c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 31917c478bd9Sstevel@tonic-gate return; 31927c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 31937c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 31947c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 31957c478bd9Sstevel@tonic-gate goto loopend; 31967c478bd9Sstevel@tonic-gate } 31977c478bd9Sstevel@tonic-gate if (fill_in_fstab(cmd, &user, TRUE) != Z_OK) 31987c478bd9Sstevel@tonic-gate goto loopend; 31997c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 32007c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 32017c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 32027c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 32037c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 32047c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 32057c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 32067c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 32077c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 32087c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 32097c478bd9Sstevel@tonic-gate output = TRUE; 32107c478bd9Sstevel@tonic-gate loopend: 32117c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 32127c478bd9Sstevel@tonic-gate } 32137c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 32147c478bd9Sstevel@tonic-gate /* 32157c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 32167c478bd9Sstevel@tonic-gate * nothing to output. 32177c478bd9Sstevel@tonic-gate */ 32187c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 32197c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 32207c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 32217c478bd9Sstevel@tonic-gate } 32227c478bd9Sstevel@tonic-gate 32237c478bd9Sstevel@tonic-gate static void 32247c478bd9Sstevel@tonic-gate info_ipd(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 32257c478bd9Sstevel@tonic-gate { 32267c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 32277c478bd9Sstevel@tonic-gate bool output = FALSE; 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate if (zonecfg_setipdent(handle) != Z_OK) 32307c478bd9Sstevel@tonic-gate return; 32317c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &lookup) == Z_OK) { 32327c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 32337c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 32347c478bd9Sstevel@tonic-gate continue; 32357c478bd9Sstevel@tonic-gate } 32367c478bd9Sstevel@tonic-gate if (fill_in_ipdtab(cmd, &user, TRUE) != Z_OK) 32377c478bd9Sstevel@tonic-gate continue; 32387c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 32397c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 32407c478bd9Sstevel@tonic-gate continue; /* no match */ 32417c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 32427c478bd9Sstevel@tonic-gate output = TRUE; 32437c478bd9Sstevel@tonic-gate } 32447c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 32457c478bd9Sstevel@tonic-gate /* 32467c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 32477c478bd9Sstevel@tonic-gate * nothing to output. 32487c478bd9Sstevel@tonic-gate */ 32497c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 32507c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 32517c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 32527c478bd9Sstevel@tonic-gate } 32537c478bd9Sstevel@tonic-gate 32547c478bd9Sstevel@tonic-gate static void 32557c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 32567c478bd9Sstevel@tonic-gate { 32577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 32587c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 32597c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 32607c478bd9Sstevel@tonic-gate } 32617c478bd9Sstevel@tonic-gate 32627c478bd9Sstevel@tonic-gate static void 32637c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 32647c478bd9Sstevel@tonic-gate { 32657c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 32667c478bd9Sstevel@tonic-gate bool output = FALSE; 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 32697c478bd9Sstevel@tonic-gate return; 32707c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 32717c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 32727c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 32737c478bd9Sstevel@tonic-gate continue; 32747c478bd9Sstevel@tonic-gate } 32757c478bd9Sstevel@tonic-gate if (fill_in_nwiftab(cmd, &user, TRUE) != Z_OK) 32767c478bd9Sstevel@tonic-gate continue; 32777c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 32787c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 32797c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 32807c478bd9Sstevel@tonic-gate continue; /* no match */ 32817c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 32827c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 32837c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 32847c478bd9Sstevel@tonic-gate continue; /* no match */ 32857c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 32867c478bd9Sstevel@tonic-gate output = TRUE; 32877c478bd9Sstevel@tonic-gate } 32887c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 32897c478bd9Sstevel@tonic-gate /* 32907c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 32917c478bd9Sstevel@tonic-gate * nothing to output. 32927c478bd9Sstevel@tonic-gate */ 32937c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 32947c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 32957c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 32967c478bd9Sstevel@tonic-gate } 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate static void 32997c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 33007c478bd9Sstevel@tonic-gate { 33017c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", rt_to_str(RT_DEVICE)); 33027c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 33037c478bd9Sstevel@tonic-gate } 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate static void 33067c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 33077c478bd9Sstevel@tonic-gate { 33087c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 33097c478bd9Sstevel@tonic-gate bool output = FALSE; 33107c478bd9Sstevel@tonic-gate 33117c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 33127c478bd9Sstevel@tonic-gate return; 33137c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 33147c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 33157c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 33167c478bd9Sstevel@tonic-gate continue; 33177c478bd9Sstevel@tonic-gate } 33187c478bd9Sstevel@tonic-gate if (fill_in_devtab(cmd, &user, TRUE) != Z_OK) 33197c478bd9Sstevel@tonic-gate continue; 33207c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 33217c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 33227c478bd9Sstevel@tonic-gate continue; /* no match */ 33237c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 33247c478bd9Sstevel@tonic-gate output = TRUE; 33257c478bd9Sstevel@tonic-gate } 33267c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 33277c478bd9Sstevel@tonic-gate /* 33287c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 33297c478bd9Sstevel@tonic-gate * nothing to output. 33307c478bd9Sstevel@tonic-gate */ 33317c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 33327c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 33337c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 33347c478bd9Sstevel@tonic-gate } 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate static void 33377c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 33387c478bd9Sstevel@tonic-gate { 33397c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 33407c478bd9Sstevel@tonic-gate 33417c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 33427c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 33437c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 33447c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 33457c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 33467c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 33477c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 33487c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 33497c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 33507c478bd9Sstevel@tonic-gate } 33517c478bd9Sstevel@tonic-gate } 33527c478bd9Sstevel@tonic-gate 33537c478bd9Sstevel@tonic-gate static void 33547c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 33557c478bd9Sstevel@tonic-gate { 33567c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 33577c478bd9Sstevel@tonic-gate bool output = FALSE; 33587c478bd9Sstevel@tonic-gate 33597c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 33607c478bd9Sstevel@tonic-gate return; 33617c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 33627c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 33637c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 33647c478bd9Sstevel@tonic-gate } else if (fill_in_rctltab(cmd, &user, TRUE) == Z_OK && 33657c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 33667c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 33677c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 33687c478bd9Sstevel@tonic-gate output = TRUE; 33697c478bd9Sstevel@tonic-gate } 33707c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 33717c478bd9Sstevel@tonic-gate } 33727c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 33737c478bd9Sstevel@tonic-gate /* 33747c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 33757c478bd9Sstevel@tonic-gate * nothing to output. 33767c478bd9Sstevel@tonic-gate */ 33777c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 33787c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 33797c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 33807c478bd9Sstevel@tonic-gate } 33817c478bd9Sstevel@tonic-gate 33827c478bd9Sstevel@tonic-gate static void 33837c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 33847c478bd9Sstevel@tonic-gate { 33857c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 33867c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 33877c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 33887c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 33897c478bd9Sstevel@tonic-gate } 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate static void 33927c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 33937c478bd9Sstevel@tonic-gate { 33947c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 33957c478bd9Sstevel@tonic-gate bool output = FALSE; 33967c478bd9Sstevel@tonic-gate 33977c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 33987c478bd9Sstevel@tonic-gate return; 33997c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 34007c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 34017c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 34027c478bd9Sstevel@tonic-gate continue; 34037c478bd9Sstevel@tonic-gate } 34047c478bd9Sstevel@tonic-gate if (fill_in_attrtab(cmd, &user, TRUE) != Z_OK) 34057c478bd9Sstevel@tonic-gate continue; 34067c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 34077c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 34087c478bd9Sstevel@tonic-gate continue; /* no match */ 34097c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 34107c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 34117c478bd9Sstevel@tonic-gate continue; /* no match */ 34127c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 34137c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 34147c478bd9Sstevel@tonic-gate continue; /* no match */ 34157c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 34167c478bd9Sstevel@tonic-gate output = TRUE; 34177c478bd9Sstevel@tonic-gate } 34187c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 34197c478bd9Sstevel@tonic-gate /* 34207c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 34217c478bd9Sstevel@tonic-gate * nothing to output. 34227c478bd9Sstevel@tonic-gate */ 34237c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 34247c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 34257c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 34267c478bd9Sstevel@tonic-gate } 34277c478bd9Sstevel@tonic-gate 3428fa9e4066Sahrens static void 3429fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 3430fa9e4066Sahrens { 3431fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 3432fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 3433fa9e4066Sahrens } 3434fa9e4066Sahrens 3435fa9e4066Sahrens static void 3436fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 3437fa9e4066Sahrens { 3438fa9e4066Sahrens struct zone_dstab lookup, user; 3439fa9e4066Sahrens bool output = FALSE; 3440fa9e4066Sahrens 3441fa9e4066Sahrens if (zonecfg_setdevent(handle) != Z_OK) 3442fa9e4066Sahrens return; 3443fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 3444fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 3445fa9e4066Sahrens output_ds(fp, &lookup); 3446fa9e4066Sahrens continue; 3447fa9e4066Sahrens } 3448fa9e4066Sahrens if (fill_in_dstab(cmd, &user, TRUE) != Z_OK) 3449fa9e4066Sahrens continue; 3450fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 3451fa9e4066Sahrens strcmp(user.zone_dataset_name, 3452fa9e4066Sahrens lookup.zone_dataset_name) != 0) 3453fa9e4066Sahrens continue; /* no match */ 3454fa9e4066Sahrens output_ds(fp, &lookup); 3455fa9e4066Sahrens output = TRUE; 3456fa9e4066Sahrens } 3457fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3458fa9e4066Sahrens /* 3459fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 3460fa9e4066Sahrens * nothing to output. 3461fa9e4066Sahrens */ 3462fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 3463fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 3464fa9e4066Sahrens rt_to_str(RT_DATASET)); 3465fa9e4066Sahrens } 3466fa9e4066Sahrens 3467fa9e4066Sahrens 34687c478bd9Sstevel@tonic-gate void 34697c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 34707c478bd9Sstevel@tonic-gate { 34717c478bd9Sstevel@tonic-gate FILE *fp = stdout; 34727c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 34737c478bd9Sstevel@tonic-gate char *pager; 34747c478bd9Sstevel@tonic-gate 34757c478bd9Sstevel@tonic-gate assert(cmd != NULL); 34767c478bd9Sstevel@tonic-gate 34777c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 34787c478bd9Sstevel@tonic-gate return; 34797c478bd9Sstevel@tonic-gate 34807c478bd9Sstevel@tonic-gate /* don't page error output */ 34817c478bd9Sstevel@tonic-gate if (interactive_mode) { 34827c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 34837c478bd9Sstevel@tonic-gate pager = PAGER; 34847c478bd9Sstevel@tonic-gate if ((fp = popen(pager, "w")) != NULL) 34857c478bd9Sstevel@tonic-gate need_to_close = TRUE; 34867c478bd9Sstevel@tonic-gate else 34877c478bd9Sstevel@tonic-gate fp = stdout; 34887c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 34897c478bd9Sstevel@tonic-gate } 34907c478bd9Sstevel@tonic-gate 34917c478bd9Sstevel@tonic-gate if (!global_scope) { 34927c478bd9Sstevel@tonic-gate switch (resource_scope) { 34937c478bd9Sstevel@tonic-gate case RT_FS: 34947c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 34957c478bd9Sstevel@tonic-gate break; 34967c478bd9Sstevel@tonic-gate case RT_IPD: 34977c478bd9Sstevel@tonic-gate output_ipd(fp, &in_progress_ipdtab); 34987c478bd9Sstevel@tonic-gate break; 34997c478bd9Sstevel@tonic-gate case RT_NET: 35007c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 35017c478bd9Sstevel@tonic-gate break; 35027c478bd9Sstevel@tonic-gate case RT_DEVICE: 35037c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 35047c478bd9Sstevel@tonic-gate break; 35057c478bd9Sstevel@tonic-gate case RT_RCTL: 35067c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 35077c478bd9Sstevel@tonic-gate break; 35087c478bd9Sstevel@tonic-gate case RT_ATTR: 35097c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 35107c478bd9Sstevel@tonic-gate break; 3511fa9e4066Sahrens case RT_DATASET: 3512fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 3513fa9e4066Sahrens break; 35147c478bd9Sstevel@tonic-gate } 35157c478bd9Sstevel@tonic-gate goto cleanup; 35167c478bd9Sstevel@tonic-gate } 35177c478bd9Sstevel@tonic-gate 35187c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 35197c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 3520087719fdSdp info_zonename(handle, fp); 35217c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 35227c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 35233f2f09c1Sdp info_bootargs(handle, fp); 35247c478bd9Sstevel@tonic-gate info_pool(handle, fp); 3525ffbafc53Scomay info_limitpriv(handle, fp); 35267c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 35277c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 35287c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 35297c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 35307c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 35317c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 3532fa9e4066Sahrens info_ds(handle, fp, cmd); 35337c478bd9Sstevel@tonic-gate break; 3534087719fdSdp case RT_ZONENAME: 3535087719fdSdp info_zonename(handle, fp); 3536087719fdSdp break; 35377c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 35387c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 35397c478bd9Sstevel@tonic-gate break; 35407c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 35417c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 35427c478bd9Sstevel@tonic-gate break; 35437c478bd9Sstevel@tonic-gate case RT_POOL: 35447c478bd9Sstevel@tonic-gate info_pool(handle, fp); 35457c478bd9Sstevel@tonic-gate break; 3546ffbafc53Scomay case RT_LIMITPRIV: 3547ffbafc53Scomay info_limitpriv(handle, fp); 3548ffbafc53Scomay break; 35493f2f09c1Sdp case RT_BOOTARGS: 35503f2f09c1Sdp info_bootargs(handle, fp); 35513f2f09c1Sdp break; 35527c478bd9Sstevel@tonic-gate case RT_FS: 35537c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 35547c478bd9Sstevel@tonic-gate break; 35557c478bd9Sstevel@tonic-gate case RT_IPD: 35567c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 35577c478bd9Sstevel@tonic-gate break; 35587c478bd9Sstevel@tonic-gate case RT_NET: 35597c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 35607c478bd9Sstevel@tonic-gate break; 35617c478bd9Sstevel@tonic-gate case RT_DEVICE: 35627c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 35637c478bd9Sstevel@tonic-gate break; 35647c478bd9Sstevel@tonic-gate case RT_RCTL: 35657c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 35667c478bd9Sstevel@tonic-gate break; 35677c478bd9Sstevel@tonic-gate case RT_ATTR: 35687c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 35697c478bd9Sstevel@tonic-gate break; 3570fa9e4066Sahrens case RT_DATASET: 3571fa9e4066Sahrens info_ds(handle, fp, cmd); 3572fa9e4066Sahrens break; 35737c478bd9Sstevel@tonic-gate default: 35747c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 35757c478bd9Sstevel@tonic-gate TRUE); 35767c478bd9Sstevel@tonic-gate } 35777c478bd9Sstevel@tonic-gate 35787c478bd9Sstevel@tonic-gate cleanup: 35797c478bd9Sstevel@tonic-gate if (need_to_close) 35807c478bd9Sstevel@tonic-gate (void) pclose(fp); 35817c478bd9Sstevel@tonic-gate } 35827c478bd9Sstevel@tonic-gate 3583087719fdSdp /* 3584087719fdSdp * Helper function for verify-- checks that a required string property 3585087719fdSdp * exists. 3586087719fdSdp */ 3587087719fdSdp static void 3588087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 35897c478bd9Sstevel@tonic-gate { 3590087719fdSdp if (strlen(attr) == 0) { 3591087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 3592087719fdSdp pt_to_str(pt)); 3593087719fdSdp saw_error = TRUE; 3594087719fdSdp if (*ret_val == Z_OK) 3595087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 35967c478bd9Sstevel@tonic-gate } 35977c478bd9Sstevel@tonic-gate } 35987c478bd9Sstevel@tonic-gate 35997c478bd9Sstevel@tonic-gate /* 36007c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 36017c478bd9Sstevel@tonic-gate * 36027c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 36037c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 36047c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 36057c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 36067c478bd9Sstevel@tonic-gate * that a save is needed. 36077c478bd9Sstevel@tonic-gate */ 36087c478bd9Sstevel@tonic-gate void 36097c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 36107c478bd9Sstevel@tonic-gate { 36117c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 36127c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 36137c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 36147c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 3615fa9e4066Sahrens struct zone_dstab dstab; 36167c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 36177c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 36187c478bd9Sstevel@tonic-gate bool save = FALSE; 36197c478bd9Sstevel@tonic-gate 36207c478bd9Sstevel@tonic-gate optind = 0; 36217c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 36227c478bd9Sstevel@tonic-gate switch (arg) { 36237c478bd9Sstevel@tonic-gate case '?': 36247c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 36257c478bd9Sstevel@tonic-gate return; 36267c478bd9Sstevel@tonic-gate default: 36277c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 36287c478bd9Sstevel@tonic-gate return; 36297c478bd9Sstevel@tonic-gate } 36307c478bd9Sstevel@tonic-gate } 36317c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 36327c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 36337c478bd9Sstevel@tonic-gate return; 36347c478bd9Sstevel@tonic-gate } 36357c478bd9Sstevel@tonic-gate 36367c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 36377c478bd9Sstevel@tonic-gate return; 36387c478bd9Sstevel@tonic-gate 36397c478bd9Sstevel@tonic-gate assert(cmd != NULL); 36407c478bd9Sstevel@tonic-gate 36417c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 36427c478bd9Sstevel@tonic-gate save = TRUE; 36437c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 36447c478bd9Sstevel@tonic-gate return; 36457c478bd9Sstevel@tonic-gate 36467c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK) { 3647087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 36487c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 36497c478bd9Sstevel@tonic-gate saw_error = TRUE; 36507c478bd9Sstevel@tonic-gate } 36517c478bd9Sstevel@tonic-gate if (strlen(zonepath) == 0) { 3652087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 36537c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 36547c478bd9Sstevel@tonic-gate saw_error = TRUE; 36557c478bd9Sstevel@tonic-gate } 36567c478bd9Sstevel@tonic-gate 36577c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 36587c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 36597c478bd9Sstevel@tonic-gate return; 36607c478bd9Sstevel@tonic-gate } 36617c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 3662087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_IPD, PT_DIR, &ret_val); 36637c478bd9Sstevel@tonic-gate } 36647c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 36657c478bd9Sstevel@tonic-gate 36667c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 36677c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 36687c478bd9Sstevel@tonic-gate return; 36697c478bd9Sstevel@tonic-gate } 36707c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 3671087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 3672087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 3673087719fdSdp &ret_val); 3674087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 3675087719fdSdp 36767c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 36777c478bd9Sstevel@tonic-gate } 36787c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 36797c478bd9Sstevel@tonic-gate 36807c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 36817c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 36827c478bd9Sstevel@tonic-gate return; 36837c478bd9Sstevel@tonic-gate } 36847c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 3685087719fdSdp check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 3686087719fdSdp PT_ADDRESS, &ret_val); 3687087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 3688087719fdSdp PT_PHYSICAL, &ret_val); 36897c478bd9Sstevel@tonic-gate } 36907c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 36917c478bd9Sstevel@tonic-gate 36927c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 36937c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 36947c478bd9Sstevel@tonic-gate return; 36957c478bd9Sstevel@tonic-gate } 36967c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 3697087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 3698087719fdSdp &ret_val); 3699087719fdSdp 37007c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 37017c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 37027c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 37037c478bd9Sstevel@tonic-gate saw_error = TRUE; 37047c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 37057c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 37067c478bd9Sstevel@tonic-gate } else { 37077c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 37087c478bd9Sstevel@tonic-gate } 37097c478bd9Sstevel@tonic-gate } 37107c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 37117c478bd9Sstevel@tonic-gate 37127c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 37137c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 37147c478bd9Sstevel@tonic-gate return; 37157c478bd9Sstevel@tonic-gate } 37167c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 3717087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 3718087719fdSdp &ret_val); 3719087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 3720087719fdSdp &ret_val); 3721087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 3722087719fdSdp &ret_val); 37237c478bd9Sstevel@tonic-gate } 37247c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 37257c478bd9Sstevel@tonic-gate 3726fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 3727fa9e4066Sahrens zone_perror(zone, err, TRUE); 3728fa9e4066Sahrens return; 3729fa9e4066Sahrens } 3730fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 3731fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 3732fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 3733fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 3734fa9e4066Sahrens saw_error = TRUE; 3735fa9e4066Sahrens if (ret_val == Z_OK) 3736fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 3737fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 3738fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 3739fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 3740fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 3741fa9e4066Sahrens saw_error = TRUE; 3742fa9e4066Sahrens if (ret_val == Z_OK) 3743fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 3744fa9e4066Sahrens } 3745fa9e4066Sahrens 3746fa9e4066Sahrens } 3747fa9e4066Sahrens (void) zonecfg_enddsent(handle); 3748fa9e4066Sahrens 37497c478bd9Sstevel@tonic-gate if (!global_scope) { 37507c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 37517c478bd9Sstevel@tonic-gate saw_error = TRUE; 37527c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 37537c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 37547c478bd9Sstevel@tonic-gate } 37557c478bd9Sstevel@tonic-gate 37567c478bd9Sstevel@tonic-gate if (save) { 3757087719fdSdp if (ret_val == Z_OK) { 3758087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 3759087719fdSdp need_to_commit = FALSE; 3760087719fdSdp (void) strlcpy(revert_zone, zone, 3761087719fdSdp sizeof (revert_zone)); 3762087719fdSdp } 3763087719fdSdp } else { 3764087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 3765087719fdSdp } 37667c478bd9Sstevel@tonic-gate } 37677c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 37687c478bd9Sstevel@tonic-gate zone_perror(zone, ret_val, TRUE); 37697c478bd9Sstevel@tonic-gate } 37707c478bd9Sstevel@tonic-gate 37717c478bd9Sstevel@tonic-gate void 37727c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 37737c478bd9Sstevel@tonic-gate { 37747c478bd9Sstevel@tonic-gate int arg; 37757c478bd9Sstevel@tonic-gate 37767c478bd9Sstevel@tonic-gate assert(cmd != NULL); 37777c478bd9Sstevel@tonic-gate 37787c478bd9Sstevel@tonic-gate optind = 0; 37797c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 37807c478bd9Sstevel@tonic-gate switch (arg) { 37817c478bd9Sstevel@tonic-gate case '?': 37827c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 37837c478bd9Sstevel@tonic-gate return; 37847c478bd9Sstevel@tonic-gate default: 37857c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 37867c478bd9Sstevel@tonic-gate return; 37877c478bd9Sstevel@tonic-gate } 37887c478bd9Sstevel@tonic-gate } 37897c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 37907c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 37917c478bd9Sstevel@tonic-gate return; 37927c478bd9Sstevel@tonic-gate } 37937c478bd9Sstevel@tonic-gate 37947c478bd9Sstevel@tonic-gate if (global_scope) 37957c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 37967c478bd9Sstevel@tonic-gate global_scope = TRUE; 37977c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 37987c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 37997c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 3800fa9e4066Sahrens bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 38017c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 38027c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 38037c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 38047c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 3805fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 38067c478bd9Sstevel@tonic-gate } 38077c478bd9Sstevel@tonic-gate 38087c478bd9Sstevel@tonic-gate static int 38097c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 38107c478bd9Sstevel@tonic-gate { 38117c478bd9Sstevel@tonic-gate int i; 38127c478bd9Sstevel@tonic-gate 38137c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 38147c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 38157c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 38167c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 38177c478bd9Sstevel@tonic-gate return (Z_INVAL); 38187c478bd9Sstevel@tonic-gate } 38197c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 38207c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 38217c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 38227c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 38237c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 38247c478bd9Sstevel@tonic-gate return (Z_INVAL); 38257c478bd9Sstevel@tonic-gate } 38267c478bd9Sstevel@tonic-gate return (Z_OK); 38277c478bd9Sstevel@tonic-gate } 38287c478bd9Sstevel@tonic-gate 38297c478bd9Sstevel@tonic-gate static int 38307c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 38317c478bd9Sstevel@tonic-gate { 38327c478bd9Sstevel@tonic-gate boolean_t boolval; 38337c478bd9Sstevel@tonic-gate int64_t intval; 38347c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 38357c478bd9Sstevel@tonic-gate uint64_t uintval; 38367c478bd9Sstevel@tonic-gate 38377c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 38387c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 38397c478bd9Sstevel@tonic-gate return (Z_OK); 38407c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 38417c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 38427c478bd9Sstevel@tonic-gate return (Z_ERR); 38437c478bd9Sstevel@tonic-gate } 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 38467c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 38477c478bd9Sstevel@tonic-gate return (Z_OK); 38487c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 38497c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 38507c478bd9Sstevel@tonic-gate return (Z_ERR); 38517c478bd9Sstevel@tonic-gate } 38527c478bd9Sstevel@tonic-gate 38537c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 38547c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 38557c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 38567c478bd9Sstevel@tonic-gate return (Z_OK); 38577c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 38587c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 38597c478bd9Sstevel@tonic-gate return (Z_ERR); 38607c478bd9Sstevel@tonic-gate } 38617c478bd9Sstevel@tonic-gate 38627c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 38637c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 38647c478bd9Sstevel@tonic-gate return (Z_OK); 38657c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 38667c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 38677c478bd9Sstevel@tonic-gate return (Z_ERR); 38687c478bd9Sstevel@tonic-gate } 38697c478bd9Sstevel@tonic-gate 38707c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 38717c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 38727c478bd9Sstevel@tonic-gate return (Z_ERR); 38737c478bd9Sstevel@tonic-gate } 38747c478bd9Sstevel@tonic-gate 3875087719fdSdp /* 3876087719fdSdp * Helper function for end_func-- checks the existence of a given property 3877087719fdSdp * and emits a message if not specified. 3878087719fdSdp */ 3879087719fdSdp static int 3880087719fdSdp end_check_reqd(char *attr, int pt, bool *validation_failed) 3881087719fdSdp { 3882087719fdSdp if (strlen(attr) == 0) { 3883087719fdSdp *validation_failed = TRUE; 3884087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 3885087719fdSdp return (Z_ERR); 3886087719fdSdp } 3887087719fdSdp return (Z_OK); 3888087719fdSdp } 3889087719fdSdp 38907c478bd9Sstevel@tonic-gate void 38917c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 38927c478bd9Sstevel@tonic-gate { 38937c478bd9Sstevel@tonic-gate bool validation_failed = FALSE; 38947c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 38957c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 38967c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 38977c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 38987c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 3899fa9e4066Sahrens struct zone_dstab tmp_dstab; 39007c478bd9Sstevel@tonic-gate int err, arg; 39017c478bd9Sstevel@tonic-gate 39027c478bd9Sstevel@tonic-gate assert(cmd != NULL); 39037c478bd9Sstevel@tonic-gate 39047c478bd9Sstevel@tonic-gate optind = 0; 39057c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 39067c478bd9Sstevel@tonic-gate switch (arg) { 39077c478bd9Sstevel@tonic-gate case '?': 39087c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 39097c478bd9Sstevel@tonic-gate return; 39107c478bd9Sstevel@tonic-gate default: 39117c478bd9Sstevel@tonic-gate short_usage(CMD_END); 39127c478bd9Sstevel@tonic-gate return; 39137c478bd9Sstevel@tonic-gate } 39147c478bd9Sstevel@tonic-gate } 39157c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 39167c478bd9Sstevel@tonic-gate short_usage(CMD_END); 39177c478bd9Sstevel@tonic-gate return; 39187c478bd9Sstevel@tonic-gate } 39197c478bd9Sstevel@tonic-gate 39207c478bd9Sstevel@tonic-gate if (global_scope) { 39217c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 39227c478bd9Sstevel@tonic-gate return; 39237c478bd9Sstevel@tonic-gate } 39247c478bd9Sstevel@tonic-gate 39257c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 39267c478bd9Sstevel@tonic-gate 39277c478bd9Sstevel@tonic-gate switch (resource_scope) { 39287c478bd9Sstevel@tonic-gate case RT_FS: 39297c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 3930087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 3931087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 3932087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 3933087719fdSdp zerr(gettext("%s %s is not an absolute path."), 3934087719fdSdp pt_to_str(PT_DIR), 3935087719fdSdp in_progress_fstab.zone_fs_dir); 3936087719fdSdp validation_failed = TRUE; 3937087719fdSdp } 39387c478bd9Sstevel@tonic-gate } 3939087719fdSdp 3940087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 3941087719fdSdp PT_SPECIAL, &validation_failed); 3942087719fdSdp 39437c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 39447c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 3945087719fdSdp zerr(gettext("%s %s is not an absolute path."), 3946087719fdSdp pt_to_str(PT_RAW), 3947087719fdSdp in_progress_fstab.zone_fs_raw); 39487c478bd9Sstevel@tonic-gate validation_failed = TRUE; 39497c478bd9Sstevel@tonic-gate } 3950087719fdSdp 3951087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 3952087719fdSdp &validation_failed); 3953087719fdSdp 3954087719fdSdp if (validation_failed) { 39557c478bd9Sstevel@tonic-gate saw_error = TRUE; 39567c478bd9Sstevel@tonic-gate return; 3957087719fdSdp } 3958087719fdSdp 39597c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 39607c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 39617c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 39627c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 39637c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 39647c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 39657c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 39667c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 39677c478bd9Sstevel@tonic-gate if (err == Z_OK) { 39687c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 39697c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 39707c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 39717c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 39727c478bd9Sstevel@tonic-gate saw_error = TRUE; 39737c478bd9Sstevel@tonic-gate return; 39747c478bd9Sstevel@tonic-gate } 39757c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 39767c478bd9Sstevel@tonic-gate &in_progress_fstab); 39777c478bd9Sstevel@tonic-gate } else { 39787c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 39797c478bd9Sstevel@tonic-gate &in_progress_fstab); 39807c478bd9Sstevel@tonic-gate } 39817c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 39827c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 39837c478bd9Sstevel@tonic-gate break; 3984087719fdSdp 39857c478bd9Sstevel@tonic-gate case RT_IPD: 39867c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 3987087719fdSdp if (end_check_reqd(in_progress_ipdtab.zone_fs_dir, PT_DIR, 3988087719fdSdp &validation_failed) == Z_OK) { 3989087719fdSdp if (in_progress_ipdtab.zone_fs_dir[0] != '/') { 3990087719fdSdp zerr(gettext("%s %s is not an absolute path."), 3991087719fdSdp pt_to_str(PT_DIR), 3992087719fdSdp in_progress_ipdtab.zone_fs_dir); 3993087719fdSdp validation_failed = TRUE; 3994087719fdSdp } 39957c478bd9Sstevel@tonic-gate } 3996087719fdSdp if (validation_failed) { 3997087719fdSdp saw_error = TRUE; 39987c478bd9Sstevel@tonic-gate return; 3999087719fdSdp } 4000087719fdSdp 40017c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 40027c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 40037c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 40047c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 40057c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir, 40067c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 40077c478bd9Sstevel@tonic-gate err = zonecfg_lookup_ipd(handle, &tmp_fstab); 40087c478bd9Sstevel@tonic-gate if (err == Z_OK) { 40097c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 40107c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 40117c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), pt_to_str(PT_DIR), 40127c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir); 40137c478bd9Sstevel@tonic-gate saw_error = TRUE; 40147c478bd9Sstevel@tonic-gate return; 40157c478bd9Sstevel@tonic-gate } 40167c478bd9Sstevel@tonic-gate err = zonecfg_add_ipd(handle, &in_progress_ipdtab); 40177c478bd9Sstevel@tonic-gate } else { 40187c478bd9Sstevel@tonic-gate err = zonecfg_modify_ipd(handle, &old_ipdtab, 40197c478bd9Sstevel@tonic-gate &in_progress_ipdtab); 40207c478bd9Sstevel@tonic-gate } 40217c478bd9Sstevel@tonic-gate break; 40227c478bd9Sstevel@tonic-gate case RT_NET: 40237c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 4024087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 4025087719fdSdp PT_PHYSICAL, &validation_failed); 4026087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_address, 4027087719fdSdp PT_ADDRESS, &validation_failed); 4028087719fdSdp 4029087719fdSdp if (validation_failed) { 40307c478bd9Sstevel@tonic-gate saw_error = TRUE; 40317c478bd9Sstevel@tonic-gate return; 4032087719fdSdp } 4033087719fdSdp 40347c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 40357c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 40367c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 40377c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 40387c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 40397c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 40407c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 40417c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 40427c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 40437c478bd9Sstevel@tonic-gate rt_to_str(RT_NET), pt_to_str(PT_ADDRESS), 40447c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address); 40457c478bd9Sstevel@tonic-gate saw_error = TRUE; 40467c478bd9Sstevel@tonic-gate return; 40477c478bd9Sstevel@tonic-gate } 40487c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 40497c478bd9Sstevel@tonic-gate } else { 40507c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 40517c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 40527c478bd9Sstevel@tonic-gate } 40537c478bd9Sstevel@tonic-gate break; 4054087719fdSdp 40557c478bd9Sstevel@tonic-gate case RT_DEVICE: 40567c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 4057087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 4058087719fdSdp PT_MATCH, &validation_failed); 4059087719fdSdp 4060087719fdSdp if (validation_failed) { 40617c478bd9Sstevel@tonic-gate saw_error = TRUE; 40627c478bd9Sstevel@tonic-gate return; 4063087719fdSdp } 4064087719fdSdp 40657c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 40667c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 40677c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 40687c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 40697c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 40707c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 40717c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 40727c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 40737c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 40747c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 40757c478bd9Sstevel@tonic-gate saw_error = TRUE; 40767c478bd9Sstevel@tonic-gate return; 40777c478bd9Sstevel@tonic-gate } 40787c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 40797c478bd9Sstevel@tonic-gate } else { 40807c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 40817c478bd9Sstevel@tonic-gate &in_progress_devtab); 40827c478bd9Sstevel@tonic-gate } 40837c478bd9Sstevel@tonic-gate break; 4084087719fdSdp 40857c478bd9Sstevel@tonic-gate case RT_RCTL: 40867c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 4087087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 4088087719fdSdp PT_NAME, &validation_failed); 4089087719fdSdp 40907c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 40917c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 40927c478bd9Sstevel@tonic-gate validation_failed = TRUE; 40937c478bd9Sstevel@tonic-gate } 4094087719fdSdp 4095087719fdSdp if (validation_failed) { 4096087719fdSdp saw_error = TRUE; 40977c478bd9Sstevel@tonic-gate return; 4098087719fdSdp } 4099087719fdSdp 41007c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 41017c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 41027c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 41037c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 41047c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 41057c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 41067c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 41077c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 41087c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 41097c478bd9Sstevel@tonic-gate if (err == Z_OK) { 41107c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 41117c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 41127c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 41137c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 41147c478bd9Sstevel@tonic-gate saw_error = TRUE; 41157c478bd9Sstevel@tonic-gate return; 41167c478bd9Sstevel@tonic-gate } 41177c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 41187c478bd9Sstevel@tonic-gate } else { 41197c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 41207c478bd9Sstevel@tonic-gate &in_progress_rctltab); 41217c478bd9Sstevel@tonic-gate } 41227c478bd9Sstevel@tonic-gate if (err == Z_OK) { 41237c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 41247c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 41257c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 41267c478bd9Sstevel@tonic-gate } 41277c478bd9Sstevel@tonic-gate break; 4128087719fdSdp 41297c478bd9Sstevel@tonic-gate case RT_ATTR: 41307c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 4131087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 4132087719fdSdp PT_NAME, &validation_failed); 4133087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 4134087719fdSdp PT_TYPE, &validation_failed); 4135087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 4136087719fdSdp PT_VALUE, &validation_failed); 4137087719fdSdp 41387c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 4139087719fdSdp Z_OK) 41407c478bd9Sstevel@tonic-gate validation_failed = TRUE; 4141087719fdSdp 4142087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 41437c478bd9Sstevel@tonic-gate validation_failed = TRUE; 4144087719fdSdp 4145087719fdSdp if (validation_failed) { 4146087719fdSdp saw_error = TRUE; 41477c478bd9Sstevel@tonic-gate return; 4148087719fdSdp } 41497c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 41507c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 41517c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 41527c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 41537c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 41547c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 41557c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 41567c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 41577c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 41587c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 41597c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 41607c478bd9Sstevel@tonic-gate saw_error = TRUE; 41617c478bd9Sstevel@tonic-gate return; 41627c478bd9Sstevel@tonic-gate } 41637c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 41647c478bd9Sstevel@tonic-gate } else { 41657c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 41667c478bd9Sstevel@tonic-gate &in_progress_attrtab); 41677c478bd9Sstevel@tonic-gate } 41687c478bd9Sstevel@tonic-gate break; 4169fa9e4066Sahrens case RT_DATASET: 4170fa9e4066Sahrens /* First make sure everything was filled in. */ 4171fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 4172fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 4173fa9e4066Sahrens gettext("not specified")); 4174fa9e4066Sahrens saw_error = TRUE; 4175fa9e4066Sahrens validation_failed = TRUE; 4176fa9e4066Sahrens } 4177fa9e4066Sahrens if (validation_failed) 4178fa9e4066Sahrens return; 4179fa9e4066Sahrens if (end_op == CMD_ADD) { 4180fa9e4066Sahrens /* Make sure there isn't already one like this. */ 4181fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 4182fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 4183fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 4184fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 4185fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 4186fa9e4066Sahrens if (err == Z_OK) { 4187fa9e4066Sahrens zerr(gettext("A %s resource " 4188fa9e4066Sahrens "with the %s '%s' already exists."), 4189fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 4190fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 4191fa9e4066Sahrens saw_error = TRUE; 4192fa9e4066Sahrens return; 4193fa9e4066Sahrens } 4194fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 4195fa9e4066Sahrens } else { 4196fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 4197fa9e4066Sahrens &in_progress_dstab); 4198fa9e4066Sahrens } 4199fa9e4066Sahrens break; 42007c478bd9Sstevel@tonic-gate default: 42017c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 42027c478bd9Sstevel@tonic-gate TRUE); 42037c478bd9Sstevel@tonic-gate saw_error = TRUE; 42047c478bd9Sstevel@tonic-gate return; 42057c478bd9Sstevel@tonic-gate } 42067c478bd9Sstevel@tonic-gate 42077c478bd9Sstevel@tonic-gate if (err != Z_OK) { 42087c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 42097c478bd9Sstevel@tonic-gate } else { 42107c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 42117c478bd9Sstevel@tonic-gate global_scope = TRUE; 42127c478bd9Sstevel@tonic-gate end_op = -1; 42137c478bd9Sstevel@tonic-gate } 42147c478bd9Sstevel@tonic-gate } 42157c478bd9Sstevel@tonic-gate 42167c478bd9Sstevel@tonic-gate void 42177c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 42187c478bd9Sstevel@tonic-gate { 42197c478bd9Sstevel@tonic-gate int arg; 42207c478bd9Sstevel@tonic-gate 42217c478bd9Sstevel@tonic-gate optind = 0; 42227c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 42237c478bd9Sstevel@tonic-gate switch (arg) { 42247c478bd9Sstevel@tonic-gate case '?': 42257c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 42267c478bd9Sstevel@tonic-gate return; 42277c478bd9Sstevel@tonic-gate default: 42287c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 42297c478bd9Sstevel@tonic-gate return; 42307c478bd9Sstevel@tonic-gate } 42317c478bd9Sstevel@tonic-gate } 42327c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 42337c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 42347c478bd9Sstevel@tonic-gate return; 42357c478bd9Sstevel@tonic-gate } 42367c478bd9Sstevel@tonic-gate 42377c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 42387c478bd9Sstevel@tonic-gate return; 42397c478bd9Sstevel@tonic-gate 42407c478bd9Sstevel@tonic-gate assert(cmd != NULL); 42417c478bd9Sstevel@tonic-gate 42427c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 42437c478bd9Sstevel@tonic-gate /* 42447c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 42457c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 42467c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 42477c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 42487c478bd9Sstevel@tonic-gate * something that can't be. 42497c478bd9Sstevel@tonic-gate */ 42507c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 42517c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 42527c478bd9Sstevel@tonic-gate exit(Z_ERR); 42537c478bd9Sstevel@tonic-gate } 42547c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 42557c478bd9Sstevel@tonic-gate verify_func(cmd); 42567c478bd9Sstevel@tonic-gate } 42577c478bd9Sstevel@tonic-gate 42587c478bd9Sstevel@tonic-gate void 42597c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 42607c478bd9Sstevel@tonic-gate { 42617c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 42627c478bd9Sstevel@tonic-gate bool force = FALSE; 42637c478bd9Sstevel@tonic-gate int err, arg, answer; 42647c478bd9Sstevel@tonic-gate 42657c478bd9Sstevel@tonic-gate optind = 0; 42667c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 42677c478bd9Sstevel@tonic-gate switch (arg) { 42687c478bd9Sstevel@tonic-gate case '?': 42697c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 42707c478bd9Sstevel@tonic-gate return; 42717c478bd9Sstevel@tonic-gate case 'F': 42727c478bd9Sstevel@tonic-gate force = TRUE; 42737c478bd9Sstevel@tonic-gate break; 42747c478bd9Sstevel@tonic-gate default: 42757c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 42767c478bd9Sstevel@tonic-gate return; 42777c478bd9Sstevel@tonic-gate } 42787c478bd9Sstevel@tonic-gate } 42797c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 42807c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 42817c478bd9Sstevel@tonic-gate return; 42827c478bd9Sstevel@tonic-gate } 42837c478bd9Sstevel@tonic-gate 42847c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 42857c478bd9Sstevel@tonic-gate return; 42867c478bd9Sstevel@tonic-gate 42877c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 42887c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 42897c478bd9Sstevel@tonic-gate saw_error = TRUE; 42907c478bd9Sstevel@tonic-gate return; 42917c478bd9Sstevel@tonic-gate } 42927c478bd9Sstevel@tonic-gate 42937c478bd9Sstevel@tonic-gate if (!force) { 42947c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 42957c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 42967c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 42977c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 42987c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 42997c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 43007c478bd9Sstevel@tonic-gate exit(Z_ERR); 43017c478bd9Sstevel@tonic-gate } 43027c478bd9Sstevel@tonic-gate if (answer != 1) 43037c478bd9Sstevel@tonic-gate return; 43047c478bd9Sstevel@tonic-gate } 43057c478bd9Sstevel@tonic-gate 43067c478bd9Sstevel@tonic-gate /* 43077c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 43087c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 43097c478bd9Sstevel@tonic-gate */ 43107c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 43117c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 43127c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 43137c478bd9Sstevel@tonic-gate exit(Z_ERR); 43147c478bd9Sstevel@tonic-gate } 4315087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 43167c478bd9Sstevel@tonic-gate saw_error = TRUE; 43177c478bd9Sstevel@tonic-gate got_handle = FALSE; 43187c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 43197c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 4320087719fdSdp revert_zone); 43217c478bd9Sstevel@tonic-gate else 43227c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 43237c478bd9Sstevel@tonic-gate } 4324087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 43257c478bd9Sstevel@tonic-gate } 43267c478bd9Sstevel@tonic-gate 43277c478bd9Sstevel@tonic-gate void 43287c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 43297c478bd9Sstevel@tonic-gate { 43307c478bd9Sstevel@tonic-gate int i; 43317c478bd9Sstevel@tonic-gate 43327c478bd9Sstevel@tonic-gate assert(cmd != NULL); 43337c478bd9Sstevel@tonic-gate 43347c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 43357c478bd9Sstevel@tonic-gate usage(TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 43367c478bd9Sstevel@tonic-gate return; 43377c478bd9Sstevel@tonic-gate } 43387c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 43397c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE); 43407c478bd9Sstevel@tonic-gate return; 43417c478bd9Sstevel@tonic-gate } 43427c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 43437c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SUBCMDS); 43447c478bd9Sstevel@tonic-gate return; 43457c478bd9Sstevel@tonic-gate } 43467c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 43477c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SYNTAX | HELP_RES_PROPS); 43487c478bd9Sstevel@tonic-gate return; 43497c478bd9Sstevel@tonic-gate } 43507c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 43517c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 43527c478bd9Sstevel@tonic-gate return; 43537c478bd9Sstevel@tonic-gate } 43547c478bd9Sstevel@tonic-gate 43557c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 43567c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 43577c478bd9Sstevel@tonic-gate longer_usage(i); 43587c478bd9Sstevel@tonic-gate return; 43597c478bd9Sstevel@tonic-gate } 43607c478bd9Sstevel@tonic-gate } 43617c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 43627c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 43637c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 43647c478bd9Sstevel@tonic-gate usage(FALSE, HELP_META); 43657c478bd9Sstevel@tonic-gate } 43667c478bd9Sstevel@tonic-gate 43677c478bd9Sstevel@tonic-gate static int 43687c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 43697c478bd9Sstevel@tonic-gate { 43707c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 43717c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 43727c478bd9Sstevel@tonic-gate return (Z_ERR); 43737c478bd9Sstevel@tonic-gate } 43747c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 43757c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 43767c478bd9Sstevel@tonic-gate return (Z_ERR); 43777c478bd9Sstevel@tonic-gate } 43787c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 43797c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 43807c478bd9Sstevel@tonic-gate return (Z_ERR); 43817c478bd9Sstevel@tonic-gate } 43827c478bd9Sstevel@tonic-gate return (Z_OK); 43837c478bd9Sstevel@tonic-gate } 43847c478bd9Sstevel@tonic-gate 43857c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 43867c478bd9Sstevel@tonic-gate 43877c478bd9Sstevel@tonic-gate static int 43887c478bd9Sstevel@tonic-gate cleanup() 43897c478bd9Sstevel@tonic-gate { 43907c478bd9Sstevel@tonic-gate int answer; 43917c478bd9Sstevel@tonic-gate cmd_t *cmd; 43927c478bd9Sstevel@tonic-gate 43937c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 43947c478bd9Sstevel@tonic-gate /* 43957c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 43967c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 43977c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 43987c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 43997c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 44007c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 44017c478bd9Sstevel@tonic-gate * context. So disable prompting. 44027c478bd9Sstevel@tonic-gate */ 44037c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 44047c478bd9Sstevel@tonic-gate } 44057c478bd9Sstevel@tonic-gate if (!global_scope) { 44067c478bd9Sstevel@tonic-gate if (!time_to_exit) { 44077c478bd9Sstevel@tonic-gate /* 44087c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 44097c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 44107c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 44117c478bd9Sstevel@tonic-gate */ 44127c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 44137c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 44147c478bd9Sstevel@tonic-gate if (answer == -1) { 44157c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 44167c478bd9Sstevel@tonic-gate return (Z_ERR); 44177c478bd9Sstevel@tonic-gate } 44187c478bd9Sstevel@tonic-gate if (answer != 1) { 44197c478bd9Sstevel@tonic-gate yyin = stdin; 44207c478bd9Sstevel@tonic-gate return (Z_REPEAT); 44217c478bd9Sstevel@tonic-gate } 44227c478bd9Sstevel@tonic-gate } else { 44237c478bd9Sstevel@tonic-gate saw_error = TRUE; 44247c478bd9Sstevel@tonic-gate } 44257c478bd9Sstevel@tonic-gate } 44267c478bd9Sstevel@tonic-gate /* 44277c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 44287c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 44297c478bd9Sstevel@tonic-gate */ 44307c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 44317c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 44327c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 44337c478bd9Sstevel@tonic-gate return (Z_ERR); 44347c478bd9Sstevel@tonic-gate } 44357c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 44367c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 44377c478bd9Sstevel@tonic-gate commit_func(cmd); 44387c478bd9Sstevel@tonic-gate free_cmd(cmd); 44397c478bd9Sstevel@tonic-gate /* 44407c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 44417c478bd9Sstevel@tonic-gate * configuration is saved successfully. 44427c478bd9Sstevel@tonic-gate */ 44437c478bd9Sstevel@tonic-gate if (need_to_commit) { 44447c478bd9Sstevel@tonic-gate if (force_exit) { 44457c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 44467c478bd9Sstevel@tonic-gate return (Z_ERR); 44477c478bd9Sstevel@tonic-gate } 44487c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 44497c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 44507c478bd9Sstevel@tonic-gate if (answer == -1) { 44517c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 44527c478bd9Sstevel@tonic-gate return (Z_ERR); 44537c478bd9Sstevel@tonic-gate } 44547c478bd9Sstevel@tonic-gate if (answer != 1) { 44557c478bd9Sstevel@tonic-gate time_to_exit = FALSE; 44567c478bd9Sstevel@tonic-gate yyin = stdin; 44577c478bd9Sstevel@tonic-gate return (Z_REPEAT); 44587c478bd9Sstevel@tonic-gate } 44597c478bd9Sstevel@tonic-gate } 44607c478bd9Sstevel@tonic-gate } 44617c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 44627c478bd9Sstevel@tonic-gate } 44637c478bd9Sstevel@tonic-gate 44647c478bd9Sstevel@tonic-gate /* 44657c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 44667c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 44677c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 44687c478bd9Sstevel@tonic-gate * helper function]. 44697c478bd9Sstevel@tonic-gate * 44707c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 44717c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 44727c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 44737c478bd9Sstevel@tonic-gate */ 44747c478bd9Sstevel@tonic-gate static int 44757c478bd9Sstevel@tonic-gate read_input() 44767c478bd9Sstevel@tonic-gate { 44777c478bd9Sstevel@tonic-gate bool yyin_is_a_tty = isatty(fileno(yyin)); 44787c478bd9Sstevel@tonic-gate /* 44797c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 44807c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 44817c478bd9Sstevel@tonic-gate */ 44827c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 44837c478bd9Sstevel@tonic-gate 44847c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 44857c478bd9Sstevel@tonic-gate newline_terminated = TRUE; 44867c478bd9Sstevel@tonic-gate for (;;) { 44877c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 44887c478bd9Sstevel@tonic-gate if (newline_terminated) { 44897c478bd9Sstevel@tonic-gate if (global_scope) 44907c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 44917c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 44927c478bd9Sstevel@tonic-gate else 44937c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 44947c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 44957c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 44967c478bd9Sstevel@tonic-gate } 44977c478bd9Sstevel@tonic-gate /* 44987c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 44997c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 45007c478bd9Sstevel@tonic-gate * bail out. 45017c478bd9Sstevel@tonic-gate */ 45027c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 45037c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 45047c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 45057c478bd9Sstevel@tonic-gate continue; 45067c478bd9Sstevel@tonic-gate } 45077c478bd9Sstevel@tonic-gate if (line == NULL) 45087c478bd9Sstevel@tonic-gate break; 45097c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 45107c478bd9Sstevel@tonic-gate while (!feof(yyin)) 45117c478bd9Sstevel@tonic-gate yyparse(); 45127c478bd9Sstevel@tonic-gate } else { 45137c478bd9Sstevel@tonic-gate yyparse(); 45147c478bd9Sstevel@tonic-gate } 45157c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 45167c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 45177c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 45187c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 45197c478bd9Sstevel@tonic-gate break; 45207c478bd9Sstevel@tonic-gate } 45217c478bd9Sstevel@tonic-gate return (cleanup()); 45227c478bd9Sstevel@tonic-gate } 45237c478bd9Sstevel@tonic-gate 45247c478bd9Sstevel@tonic-gate /* 45257c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 45267c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 45277c478bd9Sstevel@tonic-gate */ 45287c478bd9Sstevel@tonic-gate 45297c478bd9Sstevel@tonic-gate static int 45307c478bd9Sstevel@tonic-gate do_interactive(void) 45317c478bd9Sstevel@tonic-gate { 45327c478bd9Sstevel@tonic-gate int err; 45337c478bd9Sstevel@tonic-gate 45347c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 45357c478bd9Sstevel@tonic-gate if (!read_only_mode) { 45367c478bd9Sstevel@tonic-gate /* 45377c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 45387c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 45397c478bd9Sstevel@tonic-gate * provide the user with a clue. 45407c478bd9Sstevel@tonic-gate */ 45417c478bd9Sstevel@tonic-gate (void) initialize(FALSE); 45427c478bd9Sstevel@tonic-gate } 4543087719fdSdp do { 45447c478bd9Sstevel@tonic-gate err = read_input(); 4545087719fdSdp } while (err == Z_REPEAT); 45467c478bd9Sstevel@tonic-gate return (err); 45477c478bd9Sstevel@tonic-gate } 45487c478bd9Sstevel@tonic-gate 45497c478bd9Sstevel@tonic-gate /* 45507c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 45517c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 45527c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 45537c478bd9Sstevel@tonic-gate */ 45547c478bd9Sstevel@tonic-gate 45557c478bd9Sstevel@tonic-gate static int 45567c478bd9Sstevel@tonic-gate cmd_file(char *file) 45577c478bd9Sstevel@tonic-gate { 45587c478bd9Sstevel@tonic-gate FILE *infile; 45597c478bd9Sstevel@tonic-gate int err; 45607c478bd9Sstevel@tonic-gate struct stat statbuf; 45617c478bd9Sstevel@tonic-gate bool using_real_file = (strcmp(file, "-") != 0); 45627c478bd9Sstevel@tonic-gate 45637c478bd9Sstevel@tonic-gate if (using_real_file) { 45647c478bd9Sstevel@tonic-gate /* 45657c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 45667c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 45677c478bd9Sstevel@tonic-gate */ 45687c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 45697c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 45707c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 45717c478bd9Sstevel@tonic-gate file, strerror(errno)); 45727c478bd9Sstevel@tonic-gate return (Z_ERR); 45737c478bd9Sstevel@tonic-gate } 45747c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 45757c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 45767c478bd9Sstevel@tonic-gate file, strerror(errno)); 45777c478bd9Sstevel@tonic-gate err = Z_ERR; 45787c478bd9Sstevel@tonic-gate goto done; 45797c478bd9Sstevel@tonic-gate } 45807c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 45817c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 45827c478bd9Sstevel@tonic-gate err = Z_ERR; 45837c478bd9Sstevel@tonic-gate goto done; 45847c478bd9Sstevel@tonic-gate } 45857c478bd9Sstevel@tonic-gate yyin = infile; 45867c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 45877c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 45887c478bd9Sstevel@tonic-gate } else { 45897c478bd9Sstevel@tonic-gate /* 45907c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 45917c478bd9Sstevel@tonic-gate * so treat it that way. 45927c478bd9Sstevel@tonic-gate */ 45937c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 45947c478bd9Sstevel@tonic-gate } 45957c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 45967c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 45977c478bd9Sstevel@tonic-gate err = Z_ERR; 45987c478bd9Sstevel@tonic-gate done: 45997c478bd9Sstevel@tonic-gate if (using_real_file) 46007c478bd9Sstevel@tonic-gate (void) fclose(infile); 46017c478bd9Sstevel@tonic-gate return (err); 46027c478bd9Sstevel@tonic-gate } 46037c478bd9Sstevel@tonic-gate 46047c478bd9Sstevel@tonic-gate /* 46057c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 46067c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 46077c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 46087c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 46097c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 46107c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 46117c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 46127c478bd9Sstevel@tonic-gate */ 46137c478bd9Sstevel@tonic-gate 46147c478bd9Sstevel@tonic-gate static int 46157c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 46167c478bd9Sstevel@tonic-gate { 46177c478bd9Sstevel@tonic-gate char *command; 46187c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 46197c478bd9Sstevel@tonic-gate int i, err; 46207c478bd9Sstevel@tonic-gate 46217c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 46227c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 46237c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 46247c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 46257c478bd9Sstevel@tonic-gate return (Z_ERR); 46267c478bd9Sstevel@tonic-gate } 46277c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 46287c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 46297c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 46307c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 46317c478bd9Sstevel@tonic-gate } 46327c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 46337c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 46347c478bd9Sstevel@tonic-gate free(command); 46357c478bd9Sstevel@tonic-gate if (err != Z_OK) 46367c478bd9Sstevel@tonic-gate return (err); 46377c478bd9Sstevel@tonic-gate while (!feof(yyin)) 46387c478bd9Sstevel@tonic-gate yyparse(); 46397c478bd9Sstevel@tonic-gate return (cleanup()); 46407c478bd9Sstevel@tonic-gate } 46417c478bd9Sstevel@tonic-gate 46427c478bd9Sstevel@tonic-gate static char * 46437c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 46447c478bd9Sstevel@tonic-gate { 46457c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 46467c478bd9Sstevel@tonic-gate 46477c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 46487c478bd9Sstevel@tonic-gate for (;;) { 46497c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 46507c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 46517c478bd9Sstevel@tonic-gate execbasename = execfullname; 46527c478bd9Sstevel@tonic-gate break; 46537c478bd9Sstevel@tonic-gate } else { 46547c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 46557c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 46567c478bd9Sstevel@tonic-gate *last_slash = '\0'; 46577c478bd9Sstevel@tonic-gate continue; 46587c478bd9Sstevel@tonic-gate } 46597c478bd9Sstevel@tonic-gate break; 46607c478bd9Sstevel@tonic-gate } 46617c478bd9Sstevel@tonic-gate } 46627c478bd9Sstevel@tonic-gate return (execbasename); 46637c478bd9Sstevel@tonic-gate } 46647c478bd9Sstevel@tonic-gate 46657c478bd9Sstevel@tonic-gate int 46667c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 46677c478bd9Sstevel@tonic-gate { 46687c478bd9Sstevel@tonic-gate int err, arg; 4669555afedfScarlsonj struct stat st; 46707c478bd9Sstevel@tonic-gate 46717c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 46727c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 46737c478bd9Sstevel@tonic-gate 46747c478bd9Sstevel@tonic-gate saw_error = FALSE; 46757c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 46767c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 46777c478bd9Sstevel@tonic-gate 46787c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 46797c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 46807c478bd9Sstevel@tonic-gate 46817c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 46827c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 46837c478bd9Sstevel@tonic-gate execname); 46847c478bd9Sstevel@tonic-gate exit(Z_ERR); 46857c478bd9Sstevel@tonic-gate } 46867c478bd9Sstevel@tonic-gate 46877c478bd9Sstevel@tonic-gate if (argc < 2) { 46887c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE | HELP_SUBCMDS); 46897c478bd9Sstevel@tonic-gate exit(Z_USAGE); 46907c478bd9Sstevel@tonic-gate } 46917c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 46927c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 46937c478bd9Sstevel@tonic-gate exit(Z_OK); 46947c478bd9Sstevel@tonic-gate } 46957c478bd9Sstevel@tonic-gate 4696555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 46977c478bd9Sstevel@tonic-gate switch (arg) { 46987c478bd9Sstevel@tonic-gate case '?': 46997c478bd9Sstevel@tonic-gate if (optopt == '?') 47007c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE | HELP_SUBCMDS); 47017c478bd9Sstevel@tonic-gate else 47027c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 47037c478bd9Sstevel@tonic-gate exit(Z_USAGE); 47047c478bd9Sstevel@tonic-gate /* NOTREACHED */ 47057c478bd9Sstevel@tonic-gate case 'f': 47067c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 47077c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 47087c478bd9Sstevel@tonic-gate break; 4709555afedfScarlsonj case 'R': 4710555afedfScarlsonj if (*optarg != '/') { 4711555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 4712555afedfScarlsonj optarg); 4713555afedfScarlsonj exit(Z_USAGE); 4714555afedfScarlsonj } 4715555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 4716555afedfScarlsonj zerr(gettext( 4717555afedfScarlsonj "root path must be a directory: %s"), 4718555afedfScarlsonj optarg); 4719555afedfScarlsonj exit(Z_USAGE); 4720555afedfScarlsonj } 4721555afedfScarlsonj zonecfg_set_root(optarg); 4722555afedfScarlsonj break; 47237c478bd9Sstevel@tonic-gate case 'z': 4724087719fdSdp if (zonecfg_validate_zonename(optarg) != Z_OK) { 4725087719fdSdp zone_perror(optarg, Z_BOGUS_ZONE_NAME, TRUE); 4726087719fdSdp usage(FALSE, HELP_SYNTAX); 4727087719fdSdp exit(Z_USAGE); 4728087719fdSdp } 4729087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 4730087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 47317c478bd9Sstevel@tonic-gate break; 47327c478bd9Sstevel@tonic-gate default: 47337c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 47347c478bd9Sstevel@tonic-gate exit(Z_USAGE); 47357c478bd9Sstevel@tonic-gate } 47367c478bd9Sstevel@tonic-gate } 47377c478bd9Sstevel@tonic-gate 4738087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 47397c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 47407c478bd9Sstevel@tonic-gate exit(Z_USAGE); 47417c478bd9Sstevel@tonic-gate } 47427c478bd9Sstevel@tonic-gate 4743087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 47447c478bd9Sstevel@tonic-gate read_only_mode = FALSE; 4745087719fdSdp } else if (err == Z_ACCES) { 47467c478bd9Sstevel@tonic-gate read_only_mode = TRUE; 47477c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 47487c478bd9Sstevel@tonic-gate if (optind == argc) 47497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 47507c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 47517c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 4752087719fdSdp } else { 4753087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 4754087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 4755087719fdSdp exit(Z_ERR); 47567c478bd9Sstevel@tonic-gate } 47577c478bd9Sstevel@tonic-gate 47587c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 47597c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 47607c478bd9Sstevel@tonic-gate exit(Z_ERR); 47617c478bd9Sstevel@tonic-gate } 47627c478bd9Sstevel@tonic-gate 47637c478bd9Sstevel@tonic-gate /* 47647c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 47657c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 47667c478bd9Sstevel@tonic-gate */ 47677c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 47687c478bd9Sstevel@tonic-gate ok_to_prompt = TRUE; 47697c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 47707c478bd9Sstevel@tonic-gate exit(Z_ERR); 47717c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 47727c478bd9Sstevel@tonic-gate exit(Z_ERR); 47737c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 47747c478bd9Sstevel@tonic-gate if (optind == argc) { 47757c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 47767c478bd9Sstevel@tonic-gate err = do_interactive(); 47777c478bd9Sstevel@tonic-gate else 47787c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 47797c478bd9Sstevel@tonic-gate } else { 47807c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 47817c478bd9Sstevel@tonic-gate } 47827c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 47837c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 47847c478bd9Sstevel@tonic-gate return (err); 47857c478bd9Sstevel@tonic-gate } 4786