xref: /opensolaris-onvv-gate/usr/src/cmd/svr4pkg/pkgcond/main.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * Program:	pkgcond
 *
 * Function:	Implements the package command suite public utility pkgcond(1M)
 *
 * Usage:	pkgcond [-nv] [-O debug] condition [ argument ]
 *
 *		command options:
 *			-n - negate results of condition test
 *			-v - verbose output of condition testing
 *
 *		<condition> may be any one of:
 *			can_add_driver [path]
 *			can_remove_driver [path]
 *			can_update_driver [path]
 *			is_alternative_root [path]
 *			is_boot_environment [path]
 *			is_diskless_client [path]
 *			is_global_zone [path]
 *			is_mounted_miniroot [path]
 *			is_netinstall_image [path]
 *			is_nonglobal_zone [path]
 *			is_path_writable path
 *			is_running_system [path]
 *			is_sparse_root_nonglobal_zone [path]
 *			is_what [path]
 *			is_whole_root_nonglobal_zone [path]
 *
 *		<option(s)> are specific to the condition used
 *
 * Input:	depends on command
 *
 * Output:	depends on command
 *
 * Exit status:	If the -n option is not specified:
 *		== 0 - the specified condition is true (or exists).
 *		== 1 - the specified condition is false (or does not exist).
 *		== 2 - command line usage errors (including bad keywords)
 *		== 3 - command failed to perform the test due to a fatal error
 *
 *		If the -n option is specified:
 *		== 0 - the specified condition is false (or does not exist).
 *		== 1 - the specified condition is true (or exists).
 *		== 2 - command line usage errors (including bad keywords)
 *		== 3 - command failed to perform the test due to a fatal error
 */

#include <stdio.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <fcntl.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <locale.h>
#include <errno.h>
#include <sys/param.h>
#include <assert.h>

#include <instzones_api.h>
#include <pkglib.h>
#include <install.h>
#include <libinst.h>
#include <libadm.h>
#include <messages.h>
#include "pkgcond.h"
#include "pkgcond_msgs.h"

/* Should be defined by cc -D */

#if	!defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif

/* commands to execute */

#define	LS_CMD		"/usr/bin/ls"

/*
 * type definition and "types" for testPath()
 */

typedef enum {
	TEST_EXISTS = 0x01,
	TEST_NOT_EXISTS = 0x02,
	TEST_IS_DIRECTORY = 0x04,
	TEST_IS_FILE = 0x08,
	TEST_NOT_DIRECTORY = 0x10,
	TEST_NOT_FILE = 0x20,
	TEST_IS_SYMBOLIC_LINK = 0x40,
	TEST_NOT_SYMBOLIC_LINK = 0x80,
	TEST_GLOBAL_TOKEN_IN_FILE = 0x100
} TEST_TYPES;

/* holds file system info */

struct fsi_t {
	char	*fsi_mntOptions;
	char	*fsi_fsType;
	char	*fsi_mntPoint;
};
typedef struct fsi_t	FSI_T;

/* holds parsed global data */

struct globalData_t {
		/* sparse root (are any file systems mounted read-only)? */
	boolean_t gd_srFsMountedRO;
		/* initial install: PKG_INIT_INSTALL=true */
	boolean_t gd_initialInstall;
		/* global zone install: SUNW_PKG_INSTALL_ZONENAME=global */
	boolean_t gd_globalZoneInstall;
		/* non-global zone install: SUNW_PKG_INSTALL_ZONENAME!=global */
	boolean_t gd_nonglobalZoneInstall;
		/* non-global zone is in a mounted state */
	boolean_t inMountedState;
		/* sorted list of all mounted file systems */
	FSI_T	*gd_fileSystemConfig;
		/* number of mounted file systems in list */
	long	gd_fileSystemConfigLen;
		/* current zone name */
	char	*gd_zoneName;
		/* version of target: PATCH_CLIENT_VERSION */
	char	*gd_patchClientVersion;
		/* SUNW_PKGCOND_GLOBAL_DATA:parentZone:zoneName */
	char	*gd_parentZoneName;
		/* SUNW_PKGCOND_GLOBAL_DATA:parentZone:zoneType */
	char	*gd_parentZoneType;
		/* root path to target: PKG_INSTALL_ROOT */
	char	*gd_installRoot;
		/* SUNW_PKGCOND_GLOBAL_DATA:currentZone:zoneName */
	char	*gd_currentZoneName;
		/* SUNW_PKGCOND_GLOBAL_DATA:currentZone:zoneType */
	char	*gd_currentZoneType;
		/* list of inherited file systems */
	char	**gd_inheritedFileSystems;
		/* path provided on command line */
	char	*gd_cmdline_path;
};
typedef struct globalData_t	GLOBALDATA_T;

/* holds subcommands and their definitions */

struct cmd_t {
	char		*c_name;
	char		*c_args;
	int		(*c_func)(int argc, char **argv, GLOBALDATA_T *a_gdt);
};
typedef struct cmd_t	CMD_T;

/* Command function prototypes */

static int		cmd_can_add_driver(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_can_remove_driver(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_can_update_driver(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_alternative_root(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_boot_environment(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_diskless_client(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_global_zone(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_mounted_miniroot(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_netinstall_image(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_nonglobal_zone(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_path_writable(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_running_system(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_sparse_root_ng_zone(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_what(int argc, char **argv,
				GLOBALDATA_T *a_gdt);
static int		cmd_is_whole_root_ng_zone(int argc, char **argv,
				GLOBALDATA_T *a_gdt);

/* Utility function Prototypes */

static boolean_t	getNegateResults(void);
static boolean_t	recursionCheck(int *r_recursion, char *a_function);
static boolean_t	checkForReadOnlyMount(GLOBALDATA_T *a_gdt,
    char *a_mntPoint, char *a_fsType, char *a_mntOptions);
static int		adjustResults(int a_result);
static int		calculateFileSystemConfig(GLOBALDATA_T *a_gdt);
static int		getRootPath(char **r_rootPath);
static int		getZoneName(char **r_zoneName);
static int		mountOptionPresent(char *a_mntOptions, char *a_opt);
static int		parseGlobalData(char *a_envVar, GLOBALDATA_T **a_gdt);
static int		resolvePath(char **r_path);
static int		setRootPath(char *a_path, char *a_envVar,
    boolean_t a_mustExist);
static int		testPath(TEST_TYPES a_tt, char *format, ...);
static int		usage(char *a_format, ...);
static int		findToken(char *path, char *token);
static char		*getMountOption(char **p);
static void		dumpGlobalData(GLOBALDATA_T *a_gdt);
static void		removeLeadingWhitespace(char **a_str);
static void		setNegateResults(boolean_t setting);
static void		setVerbose(boolean_t);
static void		sortedInsert(FSI_T **r_list, long *a_listSize,
    char *a_mntPoint, char *a_fsType, char *a_mntOptions);
static void		setCmdLinePath(char **a_path, char **args,
    int num_args);

/* local static data */

static boolean_t	_negateResults = B_FALSE;
static char		*_rootPath = "/";

/* define subcommand data structure */

static CMD_T cmds[] = {
	{ "can_add_driver",		" [path]",
		cmd_can_add_driver },
	{ "can_remove_driver",		" [path]",
		cmd_can_remove_driver },
	{ "can_update_driver",		" [path]",
		cmd_can_update_driver },
	{ "is_alternative_root",	" [path]",
		cmd_is_alternative_root },
	{ "is_boot_environment",	" [path]",
		cmd_is_boot_environment },
	{ "is_diskless_client",		" [path]",
		cmd_is_diskless_client },
	{ "is_global_zone",		" [path]",
		cmd_is_global_zone },
	{ "is_mounted_miniroot",	" [path]",
		cmd_is_mounted_miniroot },
	{ "is_netinstall_image",	" [path]",
		cmd_is_netinstall_image },
	{ "is_nonglobal_zone",		" [path]",
		cmd_is_nonglobal_zone },
	{ "is_path_writable",		" path",
		cmd_is_path_writable },
	{ "is_running_system",		" [path]",
		cmd_is_running_system },
	{ "is_sparse_root_nonglobal_zone", " [path]",
		cmd_is_sparse_root_ng_zone },
	{ "is_what", " [path]",
		cmd_is_what },
	{ "is_whole_root_nonglobal_zone", " [path]",
		cmd_is_whole_root_ng_zone },
	/* last one must be all NULLs */
	{ NULL, NULL }
};

/*
 * *****************************************************************************
 * main
 * *****************************************************************************
 */

/*
 * Name:	main
 * Description:	main processing loop for pkgcond *
 * Return:	0 - condition is satisfied (true)
 *		1 - condition is not satisfied (false)
 *		2 - command line usage errors
 *		3 - failure to determine condition
 */

int
main(int argc, char **argv)
{
	GLOBALDATA_T	*gdt = NULL;
	char		**newargv;
	char		*p;
	int		cur_cmd;
	int		i;
	int		newargc;

	/* make standard output non-buffered */

	setbuf(stdout, NULL);

	/* set the default text domain for messaging */

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	/* remember command name */

	set_prog_name(argv[0]);

	/* tell spmi zones interface how to access package output functions */

	z_set_output_functions(echo, echoDebug, progerr);

	/* set verbose mode if appropriate environment variable is set */

	if (getenv(ENV_VAR_VERBOSE)) {
		/* same as -v */
		setVerbose(B_TRUE);
	}

	/* set debug mode if appropriate environment variable is set */

	if (getenv(ENV_VAR_DEBUG)) {
		/* same as -O debug */

		/* set sml tracing (sml.c) */
		smlSetVerbose(B_TRUE);

		/* set log and echo (interactive) message tracing */
		setVerbose(B_TRUE);

		/* enable echoDebug debugging messages */
		echoDebugSetFlag(B_TRUE);
	}

	/* generate usage if no options or arguments specified */

	if (argc <= 1) {
		(void) usage(MSG_NO_ARGUMENTS_SPECIFIED);
		return (R_USAGE);
	}

	/*
	 * process any arguments that can appear before the subcommand
	 */

	while ((i = getopt(argc, argv, ":O:vn?")) != EOF) {
		switch (i) {
		/*
		 * Not a public interface: the -O option allows the behavior
		 * of the package tools to be modified. Recognized options:
		 * -> debug
		 * ---> enable debugging output
		 */

		case 'O':
			for (p = strtok(optarg, ","); p != NULL;
				p = strtok(NULL, ",")) {

				/* debug - enable all tracing */

				if (strcmp(p, "debug") == 0) {
					/* set sml tracing */
					smlSetVerbose(B_TRUE);
					/* set log/echo tracing */
					setVerbose(B_TRUE);
					/* enable debugging messages */
					echoDebugSetFlag(B_TRUE);
					continue;
				}

				progerr(ERR_INVALID_O_OPTION, p);
				return (adjustResults(R_USAGE));
			}
			break;

		/*
		 * Public interface: enable verbose (debug) output.
		 */

		case 'v':	/* verbose mode enabled */
			/* set command tracing only */
			setVerbose(B_TRUE);
			break;

		/*
		 * Public interface: negate output results.
		 */

		case 'n':
			setNegateResults(B_TRUE);
			break;

		/*
		 * unrecognized option
		 */

		case '?':
		default:
			(void) usage(MSG_INVALID_OPTION_SPECIFIED, optopt);
			return (R_USAGE);
		}
	}

	/*
	 * done processing options that can preceed subcommand
	 */

	/* error if no subcommand specified */

	if ((argc-optind) <= 0) {
		(void) usage(MSG_NO_ARGUMENTS_SPECIFIED);
		return (R_USAGE);
	}

	/* parse global data if environment variable set */

	if (parseGlobalData(PKGCOND_GLOBAL_VARIABLE, &gdt) != R_SUCCESS) {
		log_msg(LOG_MSG_ERR, ERR_CANNOT_USE_GLOBAL_DATA,
			PKGCOND_GLOBAL_VARIABLE);
		return (R_ERROR);
	}

	if (setRootPath(gdt->gd_installRoot,
	    (strcmp(gdt->gd_installRoot, "/") == 0) ? NULL :
	    ENV_VAR_SET, B_TRUE) != R_SUCCESS) {
		log_msg(LOG_MSG_ERR, ERR_CANNOT_SET_ROOT_PATH,
			ENV_VAR_PKGROOT);
		return (R_ERROR);
	}

	/* set path provided on the command line */

	setCmdLinePath(&(gdt->gd_cmdline_path), argv, argc);
	echoDebug(DBG_CMDLINE_PATH,
	    gdt->gd_cmdline_path == NULL ? "" : gdt->gd_cmdline_path);

	/* determine how file systems are layered in this zone */

	if (calculateFileSystemConfig(gdt) != R_SUCCESS) {
		log_msg(LOG_MSG_ERR, ERR_CANNOT_CALC_FS_CONFIG);
		return (R_ERROR);
	}

	/* dump global data read in (only if debugging) */

	dumpGlobalData(gdt);

	/* search for specified subcommand and execute if found */

	for (cur_cmd = 0; cmds[cur_cmd].c_name != NULL; cur_cmd++) {
		if (ci_streq(argv[optind], cmds[cur_cmd].c_name)) {
			int	result;

			/* make subcommand the first option */

			newargc = argc - optind;
			newargv = argv + optind;
			opterr = optind = 1; optopt = 0;


			/* call subcommand with its own argc/argv */

			result = cmds[cur_cmd].c_func(newargc, newargv, gdt);

			/* process result code and exit */

			result = adjustResults(result);
			log_msg(LOG_MSG_DEBUG, DBG_RESULTS, result);
			return (result);
		}
	}

	/* subcommand not found - output error message and exit with error */

	log_msg(LOG_MSG_ERR, ERR_BAD_SUB, argv[optind]);
	(void) usage(MSG_UNRECOGNIZED_CONDITION_SPECIFIED);
	return (R_USAGE);
}

/*
 * *****************************************************************************
 * command implementation functions
 * *****************************************************************************
 */

/*
 * Name:	cmd_is_diskless_client
 * Description:	determine if target is a diskless client
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must not be initial installation to the install root
 *  - must not be installation of a zone
 *  - must not be a whole root non-global zone
 *  - must not be a non-global zone
 *  - must not be a mounted mini-root
 *  - must not be a netinstall image
 *  - must not be a boot environment
 *  - The package "SUNWdclnt" must be installed at "/"
 *  - The root path must not be "/"
 *  - The path "/export/exec/Solaris_\*\/usr" must exist at "/"
 *  - The directory "$ROOTDIR/../templates" must exist
 */

static int
cmd_is_diskless_client(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	char	cmd[MAXPATHLEN+1];
	int	c;
	int	r;
	int	rc;
static	char	*cmdName = "is_diskless_client";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/*
		 * a diskless client cannot be any of the following
		 */

		/* cannot be whole root non-global zone */

		r = cmd_is_whole_root_ng_zone(argc, argv, a_gdt);

		/* cannot be nonglobal zone */

		if (r != R_SUCCESS) {
			r = cmd_is_nonglobal_zone(argc, argv, a_gdt);
		}

		/* cannot be mounted miniroot */

		if (r != R_SUCCESS) {
			r = cmd_is_mounted_miniroot(argc, argv, a_gdt);
		}

		/* cannot be a netinstall image */

		if (r != R_SUCCESS) {
			r = cmd_is_netinstall_image(argc, argv, a_gdt);
		}

		/* cannot be a boot environment */

		if (r != R_SUCCESS) {
			r = cmd_is_boot_environment(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		/* return failure if any of the preceeding are true */

		switch (r) {
			case R_SUCCESS:
				return (R_FAILURE);
			case R_FAILURE:
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* SUNWdclnt must be installed */

	if (pkgTestInstalled("SUNWdclnt", "/") != B_TRUE) {
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_PKG_NOT_INSTALLED,
			rootPath, "SUNWdclnt", "/");
		return (R_FAILURE);
	}

	/*   - $ROOTDIR must not be "/" */

	if (strcmp(rootPath, "/") == 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_ROOTPATH_BAD, rootPath, "/");
		return (R_FAILURE);
	}

	/*   - zone name must be global */

	if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_ZONE_BAD, rootPath,
			GLOBAL_ZONENAME);
		return (R_FAILURE);
	}

	/*
	 * /export/exec/Solaris_"*"/usr must exist;
	 * create ls command to test:
	 * /usr/bin/ls /export/exec/Solaris_"*"/usr
	 */

	(void) snprintf(cmd, sizeof (cmd), "%s %s >/dev/null 2>&1",
		LS_CMD, "/export/exec/Solaris_*/usr");

	/* execute command */

	rc = system(cmd);

	/* return error if ls returns something other than "0" */

	if (rc != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_PATH_MISSING,
			rootPath, "/export/exec/Solaris_*/usr");
		return (R_FAILURE);
	}

	/*
	 * /usr must be empty on a diskless client:
	 * create ls command to test:
	 * /usr/bin/ls -d1 $ROOTDIR/usr/\*
	 */
	(void) snprintf(cmd, sizeof (cmd), "%s %s %s/%s >/dev/null 2>&1",
		LS_CMD, "-1d", rootPath, "usr/*");

	/* execute command */

	rc = system(cmd);

	/* return error if ls returns "0" */

	if (rc == 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_USR_IS_NOT_EMPTY,
			rootPath);
		return (R_FAILURE);
	}

	/* there must be a templates directory at ${ROOTPATH}/../templates */

	r = testPath(TEST_EXISTS|TEST_IS_DIRECTORY,
		"%s/%s", rootPath, "../templates");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_NO_TEMPLATES_PATH,
			rootPath, rootPath, "../templates");
		return (R_FAILURE);
	}

	/* must not be initial installation to the install root */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		/* initial install: install root cannot be diskless client */
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial zone install: no path can be diskless client */
		log_msg(LOG_MSG_DEBUG, DBG_IDLC_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* the path is a diskless client */

	log_msg(LOG_MSG_DEBUG, DBG_IDLC_PATH_IS_DISKLESS_CLIENT, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_global_zone
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must not be initial installation to the install root
 *  - must not be installation of a non-global zone
 *  - must not be a non-global zone
 *  - must not be a mounted mini-root
 *  - must not be a netinstall image
 *  - must not be a diskless client
 *  - if $ROOTDIR is "/":
 *  -- if zone name is "GLOBAL", then is a global zone;
 *  -- else not a global zone.
 *  - $ROOTDIR/etc/zones must exist and be a directory
 *  - $ROOTDIR/.tmp_proto must not exist
 *  - $ROOTDIR/var must exist and must not be a symbolic link
 */

static int
cmd_is_global_zone(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_global_zone";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/*
		 * a global zone cannot be any of the following
		 */

		/* cannot be a non-global zone */

		r = cmd_is_nonglobal_zone(argc, argv, a_gdt);

		/* cannot be a mounted miniroot */

		if (r != R_SUCCESS) {
			r = cmd_is_mounted_miniroot(argc, argv, a_gdt);
		}

		/* cannot be a netinstall image */

		if (r != R_SUCCESS) {
			r = cmd_is_netinstall_image(argc, argv, a_gdt);
		}

		/* cannot be a diskless client */

		if (r != R_SUCCESS) {
			r = cmd_is_diskless_client(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		/* return failure if any of the preceeding are true */

		switch (r) {
			case R_SUCCESS:
				return (R_FAILURE);
			case R_FAILURE:
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* must not be initial installation to the install root */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		/* initial install: install root cannot be global zone */
		log_msg(LOG_MSG_DEBUG, DBG_ISGZ_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a non-global zone */

	if (a_gdt->gd_nonglobalZoneInstall == B_TRUE) {
		/* initial nonglobal zone install: no path can be global zone */
		log_msg(LOG_MSG_DEBUG, DBG_ISGZ_NGZ_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* handle if global zone installation to the install root */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
			/* the path is a global zone */

			log_msg(LOG_MSG_DEBUG, DBG_ISGZ_PATH_IS_GLOBAL_ZONE,
				rootPath);

			return (R_SUCCESS);
	}

	/* true if current root is "/" and zone name is GLOBAL_ZONENAME */

	if (strcmp(rootPath, "/") == 0) {
		if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) == 0) {
			/* the path is a global zone */

			log_msg(LOG_MSG_DEBUG, DBG_ISGZ_PATH_IS_GLOBAL_ZONE,
				rootPath);

			return (R_SUCCESS);
		}

		/* inside a non-global zone */

		log_msg(LOG_MSG_DEBUG, DBG_ISGZ_ZONENAME_ISNT_GLOBAL,
			rootPath, a_gdt->gd_zoneName);

		return (R_FAILURE);
	}

	/*
	 * current root is not "/" - see if target looks like a global zone
	 *
	 * - rootpath is not "/"
	 * - and $ROOTDIR/etc/zones exists
	 * - and $ROOTDIR/.tmp_proto does not exist
	 * - and $ROOTDIR/var is not a symbolic link
	 */

	/* not global zone if /etc/zones does not exist */

	r = testPath(TEST_EXISTS|TEST_IS_DIRECTORY,
		"%s/%s", rootPath, "/etc/zones");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_ISGZ_PATH_ISNT_DIRECTORY,
			rootPath, "/etc/zones");
		return (R_FAILURE);
	}

	/* .tmp_proto must not exist */

	r = testPath(TEST_NOT_EXISTS,
		"%s/%s", rootPath, ".tmp_proto");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_ISGZ_PATH_EXISTS,
			rootPath, "/.tmp_proto");
		return (R_FAILURE);
	}

	/* /var must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/var");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_ISGZ_PATH_IS_SYMLINK,
			rootPath, "/var");
		return (R_FAILURE);
	}

	/* the path is a global zone */

	log_msg(LOG_MSG_DEBUG, DBG_ISGZ_PATH_IS_GLOBAL_ZONE, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_netinstall_image
 * Description:	determine if target is a net install image
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must not be initial installation to the install root
 *  - must not be installation of a zone
 *  - must not be a global zone
 *  - must not be a mounted mini-root
 *  - zone name must be "global"
 *  - $ROOTDIR/.tmp_proto must exist and must be a directory
 *  - $ROOTDIR/var must exist and must be a symbolic link
 *  - $ROOTDIR/tmp/kernel must exist and must be a directory
 *  - $ROOTDIR/.tmp_proto/kernel must exist and must be a symbolic link
 */

static int
cmd_is_netinstall_image(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_netinstall_image";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* a netinstall image cannot be a global zone */

		r = cmd_is_global_zone(argc, argv, a_gdt);

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				return (R_FAILURE);
			case R_FAILURE:
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* current zone name must be "global" */

	if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_INIM_BAD_CURRENT_ZONE,
			rootPath, GLOBAL_ZONENAME);
		return (R_FAILURE);
	}

	/* cannot be a mounted_miniroot */

	if (cmd_is_mounted_miniroot(argc, argv, a_gdt) == R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_IMRT_PATH_IS_MOUNTED_MINIROOT,
			rootPath);
		return (R_FAILURE);
	}

	/* $ROOTDIR/.tmp_proto exists */

	r = testPath(TEST_EXISTS|TEST_IS_DIRECTORY,
		"%s/%s", rootPath, ".tmp_proto");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_INIM_PATH_ISNT_DIRECTORY,
			rootPath, "/.tmp_proto");
		return (R_FAILURE);
	}

	/* $ROOTDIR/var is a symbolic link */

	r = testPath(TEST_IS_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/var");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_INIM_PATH_ISNT_SYMLINK,
			rootPath, "/var");
		return (R_FAILURE);
	}

	/* $ROOTDIR/tmp/kernel does exist */

	r = testPath(TEST_EXISTS|TEST_IS_DIRECTORY,
		"%s/%s", rootPath, "/tmp/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_INIM_PATH_ISNT_DIRECTORY,
			rootPath, "/tmp/kernel");
		return (R_FAILURE);
	}

	/* $ROOTDIR/.tmp_proto/kernel is a symbolic link */

	r = testPath(TEST_IS_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/.tmp_proto/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_INIM_PATH_ISNT_SYMLINK,
			rootPath, "/.tmp_proto/kernel");
		return (R_FAILURE);
	}

	/* must not be initial installation to the install root */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		/* initial install: install root cannot be netinstall image */
		log_msg(LOG_MSG_DEBUG, DBG_INIM_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial zone install: no path can be netinstall image */
		log_msg(LOG_MSG_DEBUG, DBG_INIM_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* target is a netinstall image */

	log_msg(LOG_MSG_DEBUG, DBG_INIM_PATH_IS_NETINSTALL_IMAGE, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_mounted_miniroot
 * Description:	determine if target is a mounted miniroot image
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must not be initial installation to the install root
 *  - must not be installation of a zone
 *  - zone name must be "global"
 *  - $ROOTDIR/tmp/kernel must exist and must be a symbolic link
 *  - $ROOTDIR/tmp/root/kernel must exist and must be a directory
 */

static int
cmd_is_mounted_miniroot(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_mounted_miniroot";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {
		recursion--;
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* current zone name must be "global" */

	if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IMRT_BAD_CURRENT_ZONE,
			rootPath, GLOBAL_ZONENAME);
		return (R_FAILURE);
	}

	/* $ROOTDIR/tmp/kernel is a symbolic link */

	r = testPath(TEST_IS_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/tmp/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_IMRT_PATH_ISNT_SYMLINK,
			rootPath, "/tmp/kernel");
		return (R_FAILURE);
	}

	/* $ROOTDIR/tmp/root/kernel is a directory */

	r = testPath(TEST_EXISTS|TEST_IS_DIRECTORY,
		"%s/%s", rootPath, "/tmp/root/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_IMRT_PATH_ISNT_DIRECTORY,
			rootPath, "/tmp/root/kernel");
		return (R_FAILURE);
	}

	/* must not be initial installation to the install root */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		/* initial install: install root cannot be mounted miniroot */
		log_msg(LOG_MSG_DEBUG, DBG_IMRT_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial zone install: no path can be mounted miniroot */
		log_msg(LOG_MSG_DEBUG, DBG_IMRT_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* target is a mounted miniroot */

	log_msg(LOG_MSG_DEBUG, DBG_IMRT_PATH_IS_MOUNTED_MINIROOT, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_nonglobal_zone
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 *  - must not be initial installation to the install root
 *  - must not be installation of a global zone
 *  - success if installation of a non-global zone
 */

static int
cmd_is_nonglobal_zone(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_nonglobal_zone";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {
		recursion--;
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* handle if non-global zone installation to the install root */

	if ((a_gdt->gd_nonglobalZoneInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_INSTALL_ZONENAME_IS_NGZ,
			rootPath, a_gdt->gd_zoneName);
		return (R_SUCCESS);
	}

	/* must not be initial installation to the install root */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		/* initial install: install root cannot be non-global zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a global zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial global zone install: no path can be nonglobal zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_GLOBAL_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/*
	 * *********************************************************************
	 * if root directory is "/" then the only thing that needs to be done is
	 * to test the zone name directly - if the zone name is "global" then
	 * the target is not a non-global zone; otherwise if the zone name is
	 * not "global" then the target IS a non-global zone.
	 * *********************************************************************
	 */

	if (strcmp(rootPath, "/") == 0) {
		/* target is current running root */
		if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) == 0) {
			/* in the global zone */
			log_msg(LOG_MSG_DEBUG, DBG_NGZN_ZONENAME_ISNT_NGZ,
				rootPath, a_gdt->gd_zoneName);
			return (R_FAILURE);
		}
		/* in a non-global zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_ZONENAME_IS_NGZ,
			rootPath, a_gdt->gd_zoneName);
		return (R_SUCCESS);
	}

	/*
	 * $ROOTDIR/etc/zones/index must exist in a global zone. It also
	 * exists in a non-global zone after s10u4 but we can't check that
	 * since it is undeterministic for all releases so we only check
	 * for the global zone here.
	 */

	r = testPath(TEST_EXISTS, "%s/%s", rootPath, "/etc/zones/index");
	if (r == R_SUCCESS) {

		/* See if "global" exists in .../etc/zones/index */

		if (testPath(TEST_GLOBAL_TOKEN_IN_FILE, "%s/%s", rootPath,
		    "/etc/zones/index") != R_SUCCESS) {
			log_msg(LOG_MSG_DEBUG, DBG_NGZN_ZONENAME_ISNT_NGZ,
			    rootPath, GLOBAL_ZONENAME);
			return (R_FAILURE);
		}
	}

	/*
	 * *********************************************************************
	 * If the root directory is "/" then you can use only the zone
	 * name to determine if the zone is non-global or not since the
	 * package is being installed or removed to the current "zone".
	 *
	 * Since the root directory being tested is not "/" then you have to
	 * look into the target to try and infer zone type using means other
	 * than the zone name only.
	 * *********************************************************************
	 */

	/* reject if any items found that cannot be in a non-global zone */

	/* .tmp_proto must not exist */

	r = testPath(TEST_NOT_EXISTS, "%s/%s", rootPath, ".tmp_proto");
	if (r != R_SUCCESS) {
		/* $R/.tmp_proto cannot exist in a non-global zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_PATH_EXISTS,
			rootPath, "/.tmp_proto");
		return (R_FAILURE);
	}

	/* /var must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/var");
	if (r != R_SUCCESS) {
		/* $R/var cannot be a symbolic link in a non-global zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_PATH_DOES_NOT_EXIST,
			rootPath, "/var");
		return (R_FAILURE);
	}

	/* $ROOTDIR/tmp/root/kernel must not exist */

	r = testPath(TEST_NOT_EXISTS,
		"%s/%s", rootPath, "/tmp/root/kernel");
	if (r != R_SUCCESS) {
		/* $R/tmp/root/kernel cannot exist in a non-global zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_PATH_EXISTS,
			rootPath, "/tmp/root/kernel");
		return (R_FAILURE);
	}

	/*
	 * *********************************************************************
	 * no items exist in $ROOTDIR that identify something other than
	 * a non-global zone.
	 *
	 * if in global zone no more tests possible: is a non-global zone
	 * *********************************************************************
	 */

	if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) == 0) {
		/* in the global zone */
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_IN_GZ_IS_NONGLOBAL_ZONE,
			rootPath);
		return (R_SUCCESS);
	}

	/*
	 * *********************************************************************
	 * In non-global zone: interrogate zone name and type.
	 *
	 * The parent zone is the zone that the "pkgadd" or "pkgrm" command was
	 * run in. The child zone is the zone that the "pkginstall" or
	 * "pkgremove" command was run in.
	 * *********************************************************************
	 */

	/*
	 * If parent zone name and current zone name defined, and
	 * both zone names are the same, since pkgcond is running
	 * inside of a non-global zone, this is how the scratch
	 * zone is implemented, so target is a non-global zone
	 */

	if ((a_gdt->gd_parentZoneName != NULL) &&
		(a_gdt->gd_currentZoneName != NULL) &&
		(strcmp(a_gdt->gd_parentZoneName,
					a_gdt->gd_currentZoneName) == 0)) {
			/* parent and current zone name identical: non-gz */
			log_msg(LOG_MSG_DEBUG, DBG_NGZN_PARENT_CHILD_SAMEZONE,
				rootPath, a_gdt->gd_parentZoneName);
			return (R_SUCCESS);
	}

	/*
	 * In non-global zone if inherited FS's exits
	 * or zone specific read only FS's exist
	 * or it is in a mounted state.
	 */

	if (a_gdt->gd_inheritedFileSystems != NULL ||
		a_gdt->gd_srFsMountedRO || a_gdt->inMountedState) {
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_IS_NONGLOBAL_ZONE, rootPath);
		return (R_SUCCESS);
	}

	/*
	 * the parent and current zone name are not the same;
	 * interrogate the zone types: the parent must be global
	 * and the current must be non-global, which would be set
	 * when a package command is run in the global zone that in
	 * turn runs a package command within the non-global zone.
	 */

	/* if defined, parent zone type must be "global" */

	if ((a_gdt->gd_parentZoneType != NULL) &&
		(strcmp(a_gdt->gd_parentZoneType, "nonglobal") == 0)) {
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_BAD_PARENT_ZONETYPE,
			rootPath, "nonglobal");
		return (R_FAILURE);
	}

	/* if defined, current zone type must be "nonglobal" */

	if ((a_gdt->gd_currentZoneType != NULL) &&
		(strcmp(a_gdt->gd_currentZoneType, GLOBAL_ZONENAME) == 0)) {
		log_msg(LOG_MSG_DEBUG, DBG_NGZN_BAD_CURRENT_ZONETYPE,
			rootPath, GLOBAL_ZONENAME);
		return (R_FAILURE);
	}

	/*
	 * *********************************************************************
	 * no other tests possible: target is a non-global zone
	 * *********************************************************************
	 */

	log_msg(LOG_MSG_DEBUG, DBG_NGZN_IS_NONGLOBAL_ZONE, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_running_system
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must not be initial installation to the install root
 *  - must not be installation of a zone
 *  - must not be a diskless client
 *  - $ROOTDIR must be "/"
 *  - zone name must be "global"
 */

static int
cmd_is_running_system(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_running_system";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* a running system cannot be a diskless client */

		r = cmd_is_diskless_client(argc, argv, a_gdt);

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				return (R_FAILURE);
			case R_FAILURE:
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* if root path is "/" then check zone name */

	if (strcmp(rootPath, "/") != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IRST_ROOTPATH_BAD, rootPath, "/");
		return (R_FAILURE);
	}

	/* zone name must be global */

	if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IRST_ZONE_BAD, rootPath,
			GLOBAL_ZONENAME);
		return (R_FAILURE);
	}

	/* must not be initial installation to the install root */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		/* initial install: install root cannot be the running system */
		log_msg(LOG_MSG_DEBUG, DBG_IRST_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial zone install: no path can be running system */
		log_msg(LOG_MSG_DEBUG, DBG_IRST_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* target is a running system */

	log_msg(LOG_MSG_DEBUG, DBG_IRST_PATH_IS_RUNNING_SYSTEM, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_can_add_driver
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * Implementation:
 * A driver can be added to the system if the components of a Solaris
 * instance capable of loading drivers is present and it is not the
 * currently running system.
 */

static int
cmd_can_add_driver(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "can_add_driver";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* see if this is the current running system */

		r = cmd_is_running_system(argc, argv, a_gdt);

		/* cannot be a diskless client */

		if (r != R_SUCCESS) {
			r = cmd_is_diskless_client(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				/* is a running system */
				return (R_FAILURE);
			case R_FAILURE:
				/* not a running syste */
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				/* cannot determine if is a running system */
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* /etc must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/etc");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_ADDV_PATH_IS_SYMLINK,
			rootPath, "/etc");
		return (R_FAILURE);
	}

	/* /platform must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/platform");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_ADDV_PATH_IS_SYMLINK,
			rootPath, "/platform");
		return (R_FAILURE);
	}

	/* /kernel must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_ADDV_PATH_IS_SYMLINK,
			rootPath, "/kernel");
		return (R_FAILURE);
	}

	/* can add a driver */

	log_msg(LOG_MSG_DEBUG, DBG_ADDV_YES, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_can_update_driver
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * Implementation:
 * A driver can be added to the system if the components of a Solaris
 * instance capable of loading drivers is present and it is not the
 * currently running system.
 */

static int
cmd_can_update_driver(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "can_update_driver";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* see if this is the current running system */

		r = cmd_is_running_system(argc, argv, a_gdt);

		/* cannot be a diskless client */

		if (r != R_SUCCESS) {
			r = cmd_is_diskless_client(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				/* is a running system */
				return (R_FAILURE);
			case R_FAILURE:
				/* not a running syste */
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				/* cannot determine if is a running system */
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* /etc must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/etc");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_UPDV_PATH_IS_SYMLINK,
			rootPath, "/etc");
		return (R_FAILURE);
	}

	/* /platform must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/platform");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_UPDV_PATH_IS_SYMLINK,
			rootPath, "/platform");
		return (R_FAILURE);
	}

	/* /kernel must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_UPDV_PATH_IS_SYMLINK,
			rootPath, "/kernel");
		return (R_FAILURE);
	}

	/* can update driver */

	log_msg(LOG_MSG_DEBUG, DBG_UPDV_YES, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_can_remove_driver
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * Implementation:
 * A driver can be added to the system if the components of a Solaris
 * instance capable of loading drivers is present and it is not the
 * currently running system.
 */

static int
cmd_can_remove_driver(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "can_remove_driver";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* see if this is the current running system */

		r = cmd_is_running_system(argc, argv, a_gdt);

		/* cannot be a diskless client */

		if (r != R_SUCCESS) {
			r = cmd_is_diskless_client(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				/* is a running system */
				return (R_FAILURE);
			case R_FAILURE:
				/* not a running syste */
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				/* cannot determine if is a running system */
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* /etc must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/etc");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_RMDV_PATH_IS_SYMLINK,
			rootPath, "/etc");
		return (R_FAILURE);
	}

	/* /platform must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/platform");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_RMDV_PATH_IS_SYMLINK,
			rootPath, "/platform");
		return (R_FAILURE);
	}

	/* /kernel must exist and must not be a symbolic link */

	r = testPath(TEST_EXISTS|TEST_NOT_SYMBOLIC_LINK,
		"%s/%s", rootPath, "/kernel");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_RMDV_PATH_IS_SYMLINK,
			rootPath, "/kernel");
		return (R_FAILURE);
	}

	/* can remove driver */

	log_msg(LOG_MSG_DEBUG, DBG_RMDV_YES, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_path_writable
 * Description:	determine if target path is writable (not inherited)
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 * - path must be found in the file systems configured
 * - file system type must not be "inherited"
 * - mount options must not include "read only"
 */

static int
cmd_is_path_writable(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	FSI_T	*list;
	char	*rootPath = NULL;
	int	c;
	int	n;
	int	nn;
	int	r;
	long	listSize;
	long	rootPathLen;
static	char	*cmdName = "is_path_writable";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {
		recursion--;
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc != 1) {
		(void) usage(ERR_REQUIRED_ROOTPATH_MISSING, cmdName);
		return (R_USAGE);
	}

	if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
		return (R_ERROR);
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* search file system conf for this path */

	rootPathLen = strlen(rootPath);
	list = a_gdt->gd_fileSystemConfig;
	listSize = a_gdt->gd_fileSystemConfigLen;
	for (nn = 0, n = 0; n < listSize; n++) {
		long	mplen = strlen(list[n].fsi_mntPoint);
		if (rootPathLen < mplen) {
			/* root path is longer than target, ignore */
			continue;
		}
		if (strncmp(rootPath, list[n].fsi_mntPoint, mplen) == 0) {
			/* remember last partial match */
			nn = n;
		}
	}

	log_msg(LOG_MSG_DEBUG, DBG_PWRT_INFO,
		rootPath, list[nn].fsi_mntPoint, list[nn].fsi_fsType,
		list[nn].fsi_mntOptions);

	/*
	 * need to determine if the mount point is writeable:
	 * If parent mount point is "inherited" then it is not writeable
	 */

	if (strcmp(list[nn].fsi_fsType, FSTYPE_INHERITED) == 0) {
		log_msg(LOG_MSG_DEBUG, DBG_PWRT_INHERITED, rootPath,
			list[nn].fsi_mntOptions);
		return (R_FAILURE);
	}

	/* see if the file system is mounted with the "read only" option */

	r = mountOptionPresent(list[nn].fsi_mntOptions, MNTOPT_RO);
	if (r == R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_PWRT_READONLY,
			rootPath, list[nn].fsi_mntOptions);
		return (R_FAILURE);
	}

	/* target path is writable */

	log_msg(LOG_MSG_DEBUG, DBG_PWRT_IS, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_alternative_root
 * Description:	determine if target is an alternative root
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * Implementation:
 *  - success if an initial installation to the install root
 *	(an initial install to $PKG_INSTALL_ROOT means that $PKG_INSTALL_ROOT
 *	points to an alternative root that is under construction)
 *  - must not be installation of a zone
 *  - must not be a boot environment
 *  - must not be a diskless client
 *  - must not be a mounted miniroot
 *  - must not be a netinstall image
 *  - must not be a nonglobal zone
 *  - must not be a running system
 *  - $ROOTDIR must not be "/"
 *  - $ROOTDIR/var must exist
 */

static int
cmd_is_alternative_root(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_alternative_root";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/*
		 * an alternative root cannot be any of the following
		 */

		/* cannot be a boot_environment */

		r = cmd_is_boot_environment(argc, argv, a_gdt);

		/* cannot be a diskless_client */

		if (r != R_SUCCESS) {
			r = cmd_is_diskless_client(argc, argv, a_gdt);
		}

		/* cannot be a mounted_miniroot */

		if (r != R_SUCCESS) {
			r = cmd_is_mounted_miniroot(argc, argv, a_gdt);
		}

		/* cannot be a netinstall_image */

		if (r != R_SUCCESS) {
			r = cmd_is_netinstall_image(argc, argv, a_gdt);
		}

		/* cannot be a nonglobal_zone */

		if (r != R_SUCCESS) {
			r = cmd_is_nonglobal_zone(argc, argv, a_gdt);
		}

		/* cannot be a running_system */

		if (r != R_SUCCESS) {
			r = cmd_is_running_system(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		/* return failure if any of the preceeding are true */

		switch (r) {
			case R_SUCCESS:
				return (R_FAILURE);
			case R_FAILURE:
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* return success if initial installation */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		log_msg(LOG_MSG_DEBUG, DBG_IALR_INITIAL_INSTALL, rootPath);
		return (R_SUCCESS);
	}

	/* root path must not be "/" */

	if (strcmp(rootPath, "/") == 0) {
		log_msg(LOG_MSG_DEBUG, DBG_IALR_BAD_ROOTPATH, rootPath, "/");
		return (R_FAILURE);
	}

	/* /var must exist */

	r = testPath(TEST_EXISTS,
		"%s/%s", rootPath, "/var");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_IALR_PATH_DOES_NOT_EXIST,
			rootPath, "/var");
		return (R_FAILURE);
	}

	/* must not be installation of a zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial zone install: no path can be alternative root */
		log_msg(LOG_MSG_DEBUG, DBG_IALR_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* target is an alternative root */

	log_msg(LOG_MSG_DEBUG, DBG_IALR_IS, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_boot_environment
 * Description:	determine if target is an alternative, inactive boot environment
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must not be initial installation to the install root
 *  - must not be installation of a zone
 *  - must not be a diskless client
 *  - must not be a netinstall image
 *  - must not be a mounted miniroot
 *  - $ROOTDIR must not be "/"
 *  - $ROOTDIR/etc/lutab must exist
 *  - $ROOTDIR/etc/lu must exist and must be a directory
 */

static int
cmd_is_boot_environment(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_boot_environment";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {
		/*
		 * a boot environment cannot be any of the following
		 */

		/* cannot be a diskless client */

		r = cmd_is_diskless_client(argc, argv, a_gdt);

		/* cannot be a netinstall_image */

		if (r != R_SUCCESS) {
			r = cmd_is_netinstall_image(argc, argv, a_gdt);
		}

		/* cannot be a mounted_miniroot */

		if (r != R_SUCCESS) {
			r = cmd_is_mounted_miniroot(argc, argv, a_gdt);
		}

		/* no need to guard against recursion any more */

		recursion--;

		/* return failure if any of the preceeding are true */

		switch (r) {
			case R_SUCCESS:
				return (R_FAILURE);
			case R_FAILURE:
				break;
			case R_USAGE:
			case R_ERROR:
			default:
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* root path must not be "/" */

	if (strcmp(rootPath, "/") == 0) {
		log_msg(LOG_MSG_DEBUG, DBG_BENV_BAD_ROOTPATH, rootPath, "/");
		return (R_FAILURE);
	}

	/* zone name must be global */

	if (strcmp(a_gdt->gd_zoneName, GLOBAL_ZONENAME) != 0) {
		log_msg(LOG_MSG_DEBUG, DBG_BENV_BAD_ZONE, rootPath,
			GLOBAL_ZONENAME);
		return (R_FAILURE);
	}

	/* $ROOTDIR/etc/lutab must exist */

	r = testPath(TEST_EXISTS, "%s/%s", rootPath, "/etc/lutab");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_BENV_NO_ETCLUTAB, rootPath,
			"/etc/lutab");
		return (R_FAILURE);
	}

	/* $ROOTDIR/etc/lu must exist */

	r = testPath(TEST_EXISTS|TEST_IS_DIRECTORY,
		"%s/%s", rootPath, "/etc/lu");
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_DEBUG, DBG_BENV_NO_ETCLU, rootPath, "/etc/lu");
		return (R_FAILURE);
	}

	/* must not be initial installation */

	if ((a_gdt->gd_initialInstall == B_TRUE) &&
	    (strcmp(a_gdt->gd_installRoot, rootPath) == 0)) {
		log_msg(LOG_MSG_DEBUG, DBG_BENV_INITIAL_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* must not be installation of a zone */

	if ((a_gdt->gd_globalZoneInstall == B_TRUE) ||
	    (a_gdt->gd_nonglobalZoneInstall == B_TRUE)) {
		/* initial zone install: no path can be boot environment */
		log_msg(LOG_MSG_DEBUG, DBG_BENV_ZONE_INSTALL, rootPath);
		return (R_FAILURE);
	}

	/* target is a boot environment */

	log_msg(LOG_MSG_DEBUG, DBG_BENV_IS, rootPath);

	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_sparse_root_ng_zone
 * Description:	determine if target is a sparse non-global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENATION:
 *  - must be a non-global zone
 *  - inherited file systems must be present, and/or
 *  - read-only lofs file systems must be present
 */

static int
cmd_is_sparse_root_ng_zone(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_sparse_root_nonglobal_zone";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* see if this is a non-global zone */

		r = cmd_is_nonglobal_zone(argc, argv, a_gdt);

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				/* is a non-global zone */
				break;
			case R_FAILURE:
				/* not a non-global zone */
				return (R_FAILURE);
			case R_USAGE:
			case R_ERROR:
			default:
				/* cannot determine if non-global zone */
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/*
	 * in a non-global zone:
	 * if any file systems are inherited, or if /usr is read only,
	 * then the target is a sparse root non-global zone.
	 */

	if ((a_gdt->gd_inheritedFileSystems != (char **)NULL) ||
		(a_gdt->gd_srFsMountedRO == B_TRUE)) {
		/* no inherited file systems */
		log_msg(LOG_MSG_DEBUG, DBG_SRNG_IS, rootPath);
		return (R_SUCCESS);
	}

	/* target is not a sparse root non-global zone */

	log_msg(LOG_MSG_DEBUG, DBG_SRNG_IS_NOT, rootPath);

	return (R_FAILURE);

}

/*
 * Name:	cmd_is_what
 * Description:	determine what the target is
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 */

static int
cmd_is_what(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	cur_cmd;
	int	r;
static	char	*cmdName = "is_what";

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/*
	 * construct the command line for all of the packages
	 */

	argc = 0;
	argv[argc++] = strdup(get_prog_name());
	argv[argc++] = strdup(rootPath);

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/* search for specified subcommand and execute if found */

	for (cur_cmd = 0; cmds[cur_cmd].c_name != NULL; cur_cmd++) {
		int	result;

		/* do not recursively call this function */

		if (cmds[cur_cmd].c_func == cmd_is_what) {
			continue;
		}

		/* call subcommand with its own argc/argv */

		result = cmds[cur_cmd].c_func(argc, argv, a_gdt);

		/* process result code and exit */

		result = adjustResults(result);
		log_msg(LOG_MSG_INFO, MSG_IS_WHAT_RESULT,
			cmds[cur_cmd].c_name, result);
	}
	return (R_SUCCESS);
}

/*
 * Name:	cmd_is_whole_root_ng_zone
 * Description:	determine if target is a global zone
 * Scope:	public
 * Arguments:	argc,argv:
 *		  - optional path to target to test
 * Returns:	int
 *			== 0 - success
 *			!= 0 - failure
 * IMPLEMENTATION:
 *  - must be a non-global zone
 *  - no inherited file systems may be present
 *  - no read-only lofs file systems may be present
 */

static int
cmd_is_whole_root_ng_zone(int argc, char **argv, GLOBALDATA_T *a_gdt)
{
	char	*rootPath = NULL;
	int	c;
	int	r;
static	char	*cmdName = "is_whole_root_nonglobal_zone";
static	int	recursion = 0;

	/* process any command line options */

	while ((c = getopt(argc, argv, ":")) != EOF) {
		switch (c) {
		case '\0':	/* prevent end-of-loop not reached warning */
			break;
		case '?':
		default:
			(void) usage(MSG_IS_INVALID_OPTION, optopt, cmdName);
			return (R_USAGE);
		}
	}

	/* prevent recursion */

	if (recursionCheck(&recursion, cmdName) == B_FALSE) {

		/* see if this is a non-global zone */

		r = cmd_is_nonglobal_zone(argc, argv, a_gdt);

		/* no need to guard against recursion any more */

		recursion--;

		switch (r) {
			case R_SUCCESS:
				/* is a non-global zone */
				break;
			case R_FAILURE:
				/* not a non-global zone */
				return (R_FAILURE);
			case R_USAGE:
			case R_ERROR:
			default:
				/* cannot determine if non-global zone */
				return (r);
		}
	}

	/* normalize argc/argv */

	argc -= optind;
	argv += optind;

	/* error if more than one argument */

	if (argc > 1) {
		log_msg(LOG_MSG_ERR, ERR_UNRECOGNIZED_OPTION, argv[1]);
		(void) usage(MSG_IS_INVALID_OPTION, argv[1]);
		return (R_USAGE);
	}

	/* process root path if first argument present */

	if (argc == 1) {
		if (setRootPath(argv[0], "argv[0]", B_TRUE) != R_SUCCESS) {
			return (R_ERROR);
		}
	}

	/* get current root path */

	r = getRootPath(&rootPath);
	if (r != R_SUCCESS) {
		return (r);
	}

	/* start of command debugging information */

	echoDebug(DBG_ROOTPATH_IS, rootPath);

	/*
	 * in a non-global zone:
	 * if no file systems are inherited, and if /usr is not
	 * read only, then the target is a whole root non-global zone.
	 */

	if ((a_gdt->gd_inheritedFileSystems == (char **)NULL) &&
		(a_gdt->gd_srFsMountedRO == B_FALSE)) {
		/* no inherited file systems */
		log_msg(LOG_MSG_DEBUG, DBG_WRNG_IS, rootPath);
		return (R_SUCCESS);
	}

	/* target is not a whole-root non-global zone */

	log_msg(LOG_MSG_DEBUG, DBG_WRNG_IS_NOT, rootPath);

	return (R_FAILURE);
}

/*
 * *****************************************************************************
 * utility support functions
 * *****************************************************************************
 */

/*
 * Name:	getMountOption
 * Description:	return next mount option in a string
 * Arguments:	p - pointer to string containing mount options
 * Output:	none
 * Returns:	char * - pointer to next option in string "p"
 * Side Effects: advances input "p" and inserts \0 in place of the
 *		option separator found.
 */

static char *
getMountOption(char **p)
{
	char *cp = *p;
	char *retstr;

	/* advance past all white space */

	while (*cp && isspace(*cp))
		cp++;

	/* remember start of next option */

	retstr = cp;

	/* advance to end of string or option separator */

	while (*cp && *cp != ',')
		cp++;

	/* replace separator with '\0' if not at end of string */
	if (*cp) {
		*cp = '\0';
		cp++;
	}

	/* reset caller's pointer and return pointer to option */

	*p = cp;
	return (retstr);
}

/*
 * Name:	mountOptionPresent
 * Description:	determine if specified mount option is present in list
 *		of mount point options
 * Arguments:	a_mntOptions - pointer to string containing list of mount
 *			point options to search
 *		a_opt - pointer to string containing option to search for
 * Output:	none
 * Returns:	R_SUCCESS - option is present in list of mount point options
 *		R_FAILURE - options is not present
 *		R_ERROR - unable to determine if option is present or not
 */

static int
mountOptionPresent(char *a_mntOptions, char *a_opt)
{
	char tmpopts[MNT_LINE_MAX];
	char *f, *opts = tmpopts;

	/* return false if no mount options present */

	if ((a_opt == NULL) || (*a_opt == '\0')) {
		return (R_FAILURE);
	}

	/* return not present if no list of options to search */

	if (a_mntOptions == NULL) {
		return (R_FAILURE);
	}

	/* return not present if list of options to search is empty */

	if (*a_mntOptions == '\0') {
		return (R_FAILURE);
	}

	/* make local copy of option list to search */

	(void) strcpy(opts, a_mntOptions);

	/* scan each option looking for the specified option */

	f = getMountOption(&opts);
	for (; *f; f = getMountOption(&opts)) {
		/* return success if option matches target */
		if (strncmp(a_opt, f, strlen(a_opt)) == 0) {
			return (R_SUCCESS);
		}
	}

	/* option not found */

	return (R_FAILURE);
}

/*
 * Name:	sortedInsert
 * Description:	perform an alphabetical sorted insert into a list
 * Arguments:	r_list - pointer to list to insert next entry into
 *		a_listSize - pointer to current list size
 *		a_mntPoint - mount point to insert (is sort key)
 *		a_fsType - file system type for mount point
 *		a_mntOptions - file syste mount options for mount point
 * Output:	None
 * Returns:	None
 */

static void
sortedInsert(FSI_T **r_list, long *a_listSize, char *a_mntPoint,
	char *a_fsType, char *a_mntOptions)
{
	int	listSize;
	FSI_T	*list;
	int	n;

	/* entry assertions */

	assert(a_listSize != (long *)NULL);
	assert(a_mntPoint != NULL);
	assert(a_fsType != NULL);
	assert(a_mntOptions != NULL);

	/* entry debugging info */

	echoDebug(DBG_SINS_ENTRY, a_mntPoint, a_fsType, a_mntOptions);

	/* localize references to the list and list size */

	listSize = *a_listSize;
	list = *r_list;

	/*
	 * if list empty insert this entry as the first one in the list
	 */

	if (listSize == 0) {
		/* allocate new entry for list */
		listSize++;
		list = (FSI_T *)realloc(list, sizeof (FSI_T)*(listSize+1));

		/* first entry is data passed to this function */
		list[0].fsi_mntPoint = strdup(a_mntPoint);
		list[0].fsi_fsType = strdup(a_fsType);
		list[0].fsi_mntOptions = strdup(a_mntOptions);

		/* second entry is all NULL - end of entry marker */
		list[1].fsi_mntPoint = NULL;
		list[1].fsi_fsType = NULL;
		list[1].fsi_mntOptions = NULL;

		/* restore list and list size references to caller */
		*a_listSize = listSize;
		*r_list = list;

		return;
	}

	/*
	 * list not empty - scan looking for largest match
	 */

	for (n = 0; n < listSize; n++) {
		int	c;

		/* compare target with current list entry */

		c = strcmp(list[n].fsi_mntPoint, a_mntPoint);

		if (c == 0) {
			char	*me;
			long	len;

			/* entry already in list -- merge entries */

			len = strlen(list[n].fsi_mntOptions) +
				strlen(a_mntOptions) + 2;
			me = (char *)calloc(1, len);

			/* merge two mount options lists into one */

			(void) strlcat(me, list[n].fsi_mntOptions, len);
			(void) strlcat(me, ",", len);
			(void) strlcat(me, a_mntOptions, len);

			/* free old list, replace with merged one */

			free(list[n].fsi_mntOptions);
			list[n].fsi_mntOptions = me;

			echoDebug(DBG_SORTEDINS_SKIPPED,
				n, list[n].fsi_mntPoint, a_fsType,
				list[n].fsi_fsType, a_mntOptions,
				list[n].fsi_mntOptions);

			continue;
		} else if (c < 0) {
			/* entry before this one - skip */
			continue;
		}

		/*
		 * entry after this one - insert new entry
		 */

		/* allocate one more entry and make space for new entry */
		listSize++;
		list = (FSI_T *)realloc(list,
			sizeof (FSI_T)*(listSize+1));
		(void) memmove(&(list[n+1]), &(list[n]),
			sizeof (FSI_T)*(listSize-n));

		/* insert this entry into list */
		list[n].fsi_mntPoint = strdup(a_mntPoint);
		list[n].fsi_fsType = strdup(a_fsType);
		list[n].fsi_mntOptions = strdup(a_mntOptions);

		/* restore list and list size references to caller */
		*a_listSize = listSize;
		*r_list = list;

		return;
	}

	/*
	 * all entries are before this one - append to end of list
	 */

	/* allocate new entry at end of list */
	listSize++;
	list = (FSI_T *)realloc(list, sizeof (FSI_T)*(listSize+1));

	/* append this entry to the end of the list */
	list[listSize-1].fsi_mntPoint = strdup(a_mntPoint);
	list[listSize-1].fsi_fsType = strdup(a_fsType);
	list[listSize-1].fsi_mntOptions = strdup(a_mntOptions);

	/* restore list and list size references to caller */
	*a_listSize = listSize;
	*r_list = list;
}

/*
 * Name:	calculateFileSystemConfig
 * Description:	generate sorted list of all mounted file systems
 * Arguments:	a_gdt - global data structure to place sorted entries into
 * Output:	None
 * Returns:	R_SUCCESS - successfully generated mounted file systems list
 *		R_FAILURE - options is not present
 *		R_ERROR - unable to determine if option is present or not
 */

static int
calculateFileSystemConfig(GLOBALDATA_T *a_gdt)
{
	FILE		*fp;
	struct mnttab	mntbuf;
	FSI_T		*list;
	long		listSize;
	boolean_t	readOnlyMountFound = B_FALSE;

	/* entry assetions */

	assert(a_gdt != (GLOBALDATA_T *)NULL);

	/* entry debugging info */

	echoDebug(DBG_CALCSCFG_ENTRY);

	/* allocate a list that has one termination entry */

	list = (FSI_T *)calloc(1, sizeof (FSI_T));
	list[0].fsi_mntPoint = NULL;
	list[0].fsi_fsType = NULL;
	list[0].fsi_mntOptions = NULL;
	listSize = 0;

	/* insert entries for all inherited file systems */

	if (a_gdt->gd_inheritedFileSystems) {
		int n;
		char **ifs = a_gdt->gd_inheritedFileSystems;

		/* debugging info */

		echoDebug(DBG_CALCSCFG_INHERITED);

		/* insert all inherited file systems */

		for (n = 0; ifs[n]; n++) {
			sortedInsert(&list, &listSize, ifs[n],
				FSTYPE_INHERITED, MNTOPT_RO);
		}
	}

	/* open the mount table for reading */

	fp = fopen(MNTTAB, "r");
	if (fp == (FILE *)NULL) {
		return (R_ERROR);
	}

	/* debugging info */

	echoDebug(DBG_CALCSCFG_MOUNTED);

	/* go through all the specials looking for the device */

	while (getmntent(fp, &mntbuf) == 0) {
		if (mntbuf.mnt_mountp[0] == '/') {
			sortedInsert(&list, &listSize,
			strdup(mntbuf.mnt_mountp),
			strdup(mntbuf.mnt_fstype),
			strdup(mntbuf.mnt_mntopts ? mntbuf.mnt_mntopts : ""));
		}

		/*
		 * Set flag if we are in a non-global zone and it is in
		 * the mounted state.
		 */

		if (strcmp(mntbuf.mnt_mountp, "/a") == 0 &&
			strcmp(mntbuf.mnt_special, "/a") == 0 &&
			strcmp(mntbuf.mnt_fstype, "lofs") == 0) {
			a_gdt->inMountedState = B_TRUE;
		}

		if (!readOnlyMountFound) {
			readOnlyMountFound = checkForReadOnlyMount(a_gdt,
			    mntbuf.mnt_mountp, mntbuf.mnt_fstype,
			    mntbuf.mnt_mntopts);
		}
	}

	/* close mount table file */

	(void) fclose(fp);

	/* store list pointers in global data structure */

	a_gdt->gd_fileSystemConfig = list;
	a_gdt->gd_fileSystemConfigLen = listSize;

	return (R_SUCCESS);
}

/*
 * Name:	checkForReadOnlyMount
 * Description:	given a mount point, type and options, determine if the
 *              mounted file system is part of a "sparse root" configuration
 *              by checking if the known Zone directories a ro LOFS mounted.
 * Arguments:	a_gdt - global data structure to place sorted entries into
 *		a_mntPoint - pointer to string representing mount point
 *		a_fsType - pointer to string representing file system type
 *		a_mntOptions - pointer to string representing the options
 *			used to mount the file system
 * Returns:	B_TRUE - if sparse root mount is found
 * 		B_FLASE - if no sparse root mount's are found
 * Side Effects: set:
 *			a_gdt->gd_srFsMountedRO = B_TRUE
 *		if the mounted file system is part of a 'sparse root' config
 */

static boolean_t
checkForReadOnlyMount(GLOBALDATA_T *a_gdt, char *a_mntPoint,
	char *a_fsType, char *a_mntOptions)
{
	/* entry assertions */
	int	i;
	char mntPoint[MAXPATHLEN];
	char *zDirs[] = { "/usr", "/lib", "/platform", "/sbin", NULL };
	char *aZDirs[] = { "/a/usr", "/a/lib", "/a/platform", "/a/sbin", NULL };

	assert(a_gdt != (GLOBALDATA_T *)NULL);
	assert(a_mntPoint != NULL);
	assert(a_fsType != NULL);

	/* return if no read-only mount option */

	if (mountOptionPresent(a_mntOptions, MNTOPT_RO) != R_SUCCESS) {
		return (B_FALSE);
	}

	/* return if file system is not read-only mounted */

	if (strcmp(a_fsType, MNTTYPE_LOFS) != 0) {
		return (B_FALSE);
	}

	/* file system is a read-only lofs mounted.  */

	/* Check read-only lofs mount's appended to the command line path */

	if (a_gdt->gd_cmdline_path != NULL) {
		if (strncmp(a_mntPoint, a_gdt->gd_cmdline_path,
			strlen(a_gdt->gd_cmdline_path)) == 0) {
			for (i = 0; zDirs[i] != NULL; i++) {
				(void) snprintf(mntPoint, sizeof (mntPoint),
				    "%s%s", a_gdt->gd_cmdline_path,
				    zDirs[i]);
				if (strcmp(a_mntPoint, mntPoint) == 0) {
					echoDebug(DBG_CKSR_FSREADONLY,
					    a_mntPoint, a_fsType);
					a_gdt->gd_srFsMountedRO = B_TRUE;
					return (B_TRUE);
				}
			}
		}

	/* Check read-only lofs mount's in the mounted state */

	} else if (a_gdt->inMountedState) {
		for (i = 0; aZDirs[i] != NULL; i++) {
			if (strncmp(a_mntPoint, aZDirs[i],
			    sizeof (aZDirs[i])) == 0) {
				echoDebug(DBG_CKSR_FSREADONLY, a_mntPoint,
				    a_fsType);
				a_gdt->gd_srFsMountedRO = B_TRUE;
				return (B_TRUE);
			}
		}

	/* Check read-only lofs mount's for live system */

	} else {
		for (i = 0; zDirs[i] != NULL; i++) {
			if (strncmp(a_mntPoint, zDirs[i],
			    sizeof (zDirs[i])) == 0) {
				echoDebug(DBG_CKSR_FSREADONLY, a_mntPoint,
				    a_fsType);
				a_gdt->gd_srFsMountedRO = B_TRUE;
				return (B_TRUE);
			}
		}
	}

	return (B_FALSE);
}

/*
 * Name: 	adjustResults
 * Description:	adjust output result code before existing
 * Arguments:	a_result - result code to adjust
 * Returns:	int - adjusted result code
 */

static int
adjustResults(int a_result)
{
	boolean_t	negate = getNegateResults();
	int		realResult;

	/* adjust code as appropriate */

	switch (a_result) {
	case R_SUCCESS:		/* condition satisfied */
		realResult = ((negate == B_TRUE) ? 1 : 0);
		break;
	case R_FAILURE:		/* condition not satisfied */
		realResult = ((negate == B_TRUE) ? 0 : 1);
		break;
	case R_USAGE:		/* usage errors */
		realResult = 2;
		break;
	case R_ERROR:		/* condition could not be determined */
	default:
		realResult = 3;
		break;
	}

	/* debugging output */

	log_msg(LOG_MSG_DEBUG, DBG_ADJUST_RESULTS, a_result, negate,
		realResult);

	/* return results */

	return (realResult);
}

/*
 * Name:        setCmdLinePath
 * Description:	set global command line path
 * Arguments:   path - path to set from the command line
 *              args - command line args
 *              num_args - number of command line args
 * Returns:     R_SUCCESS - root path successfully set
 *              R_FAILURE - root path could not be set
 *              R_ERROR - fatal error attempting to set root path
 */

static void
setCmdLinePath(char **path, char **args, int num_args)
{
	char   rp[PATH_MAX] = { '\0' };
	struct stat statbuf;

	if (*path != NULL) {
		return;
	}

	/*
	 * If a path "pkgcond is_global_zone [path]" is provided on the
	 * command line it must be the last argument.
	 */

	if (realpath(args[num_args - 1], rp) != NULL) {
		if (stat(rp, &statbuf) == 0) {
			/* make sure the target is a directory */
			if ((statbuf.st_mode & S_IFDIR)) {
				*path = strdup(rp);
			} else {
				*path = NULL;
			}
		}
	}
}

/*
 * Name:	setRootPath
 * Description:	set global root path returned by getRootPath
 * Arguments:	a_path - root path to set
 *		a_mustExist - B_TRUE if path must exist (else error)
 *			- B_FALSE if path may not exist
 * Returns:	R_SUCCESS - root path successfully set
 *		R_FAILURE - root path could not be set
 *		R_ERROR - fatal error attempting to set root path
 */

static int
setRootPath(char *a_path, char *a_envVar, boolean_t a_mustExist)
{
	char		rp[PATH_MAX] = { '\0' };
	struct stat	statbuf;

	/* if no data then issue warning and return success */

	if ((a_path == NULL) || (*a_path == '\0')) {
		echoDebug(DBG_NO_DEFAULT_ROOT_PATH_SET);
		return (R_SUCCESS);
	}

	/* path present - resolve to absolute path */

	if (realpath(a_path, rp) == NULL) {
		if (a_mustExist == B_TRUE) {
			/* must exist ... error */
			log_msg(LOG_MSG_ERR, ERR_DEFAULT_ROOT_INVALID,
				a_path, strerror(errno));
			return (R_ERROR);
		} else {
			/* may not exist - use path as specified */
			(void) strcpy(rp, a_path);
		}
	}

	/* debugging output */

	echoDebug(DBG_DEFAULT_ROOT_PATH_SET, rp, a_envVar ? a_envVar : "");

	/* validate path existence if it must exist */

	if (a_mustExist == B_TRUE) {

		/* get node status */

		if (stat(rp, &statbuf) != 0) {
			log_msg(LOG_MSG_ERR, ERR_DEFAULT_ROOT_INVALID,
				rp, strerror(errno));
			return (R_ERROR);
		}

		/* make sure the target is a directory */

		if (!(statbuf.st_mode & S_IFDIR)) {
			log_msg(LOG_MSG_ERR, ERR_DEFAULT_ROOT_NOT_DIR, rp);
			return (R_ERROR);
		}
	}

	/* target exists and is a directory - set */

	echoDebug(DBG_SET_ROOT_PATH_TO, rp);

	/* store copy of resolved root path */

	_rootPath = strdup(rp);

	/* success! */

	return (R_SUCCESS);
}

/*
 * Name:	testPath
 * Description:	determine if a path meets the specified conditions
 * Arguments:	a_tt - conditions to test path against
 * 		a_format - format to use to generate path
 *		arguments following a_format - as needed for a_format
 * Returns:	R_SUCCESS - the path meets all of the specified conditions
 *		R_FAILURE - the path does not meet all of the conditions
 *		R_ERROR - error attempting to test path
 */

/*PRINTFLIKE2*/
static int
testPath(TEST_TYPES a_tt, char *a_format, ...)
{
	char		*mbPath;	/* copy for the path to be returned */
	char		bfr[1];
	int		r;
	size_t		vres = 0;
	struct stat	statbuf;
	va_list		ap;
	int		fd;

	/* entry assertions */

	assert(a_format != NULL);
	assert(*a_format != '\0');

	/* determine size of the message in bytes */

	va_start(ap, a_format);
	vres = vsnprintf(bfr, 1, a_format, ap);
	va_end(ap);

	assert(vres > 0);

	/* allocate storage to hold the message */

	mbPath = (char *)calloc(1, vres+2);
	assert(mbPath != NULL);

	/* generate the results of the printf conversion */

	va_start(ap, a_format);
	vres = vsnprintf(mbPath, vres+1, a_format, ap);
	va_end(ap);

	assert(vres > 0);

	echoDebug(DBG_TEST_PATH, mbPath, (unsigned long)a_tt);

	/*
	 * When a path given to open(2) contains symbolic links, the
	 * open system call first resolves all symbolic links and then
	 * opens that final "resolved" path. As a result, it is not
	 * possible to check the result of an fstat(2) against the
	 * file descriptor returned by open(2) for S_IFLNK (a symbolic
	 * link) since all symbolic links are resolved before the
	 * target is opened.
	 *
	 * When testing the target as being (or not being) a symbolic
	 * link, first use lstat(2) against the target to determine
	 * whether or not the specified target itself is (or is not) a
	 * symbolic link.
	 */

	if (a_tt & (TEST_IS_SYMBOLIC_LINK|TEST_NOT_SYMBOLIC_LINK)) {
		/*
		 * testing target is/is not a symbolic link; use lstat
		 * to determine the status of the target itself rather
		 * than what the target might finally address.
		 */

		if (lstat(mbPath, &statbuf) != 0) {
			echoDebug(DBG_CANNOT_LSTAT_PATH, mbPath,
				strerror(errno));
			free(mbPath);
			return (R_FAILURE);
		}

		/* Is the target required to be a symbolic link? */

		if (a_tt & TEST_IS_SYMBOLIC_LINK) {
			/* target must be a symbolic link */
			if (!(statbuf.st_mode & S_IFLNK)) {
				/* failure: target is not a symbolic link */
				echoDebug(DBG_IS_NOT_A_SYMLINK, mbPath);
				free(mbPath);
				return (R_FAILURE);
			}
			/* success: target is a symbolic link */
			echoDebug(DBG_SYMLINK_IS, mbPath);
		}

		/* Is the target required to not be a symbolic link? */

		if (a_tt & TEST_NOT_SYMBOLIC_LINK) {
			/* target must not be a symbolic link */
			if (statbuf.st_mode & S_IFLNK) {
				/* failure: target is a symbolic link */
				echoDebug(DBG_IS_A_SYMLINK, mbPath);
				free(mbPath);
				return (R_FAILURE);
			}
			/* success: target is not a symbolic link */
			echoDebug(DBG_SYMLINK_NOT, mbPath);
		}

		/*
		 * if only testing is/is not a symbolic link, then
		 * no need to open the target: return success.
		 */

		if (!(a_tt &
		    (~(TEST_IS_SYMBOLIC_LINK|TEST_NOT_SYMBOLIC_LINK)))) {
			free(mbPath);
			return (R_SUCCESS);
		}
	}

	/* resolve path and remove any whitespace */

	r = resolvePath(&mbPath);
	if (r != R_SUCCESS) {
		echoDebug(DBG_TEST_PATH_NO_RESOLVE, mbPath);
		free(mbPath);
		if (a_tt & TEST_NOT_EXISTS) {
			return (R_SUCCESS);
		}
		return (r);
	}

	echoDebug(DBG_TEST_PATH_RESOLVE, mbPath);

	/* open the file - this is the basic existence test */

	fd = open(mbPath, O_RDONLY|O_LARGEFILE, 0);

	/* existence test failed if file cannot be opened */

	if (fd < 0) {
		/*
		 * target could not be opened - if testing for non-existence,
		 * return success, otherwise return failure
		 */
		if (a_tt & TEST_NOT_EXISTS) {
			echoDebug(DBG_CANNOT_ACCESS_PATH_OK, mbPath);
			free(mbPath);
			return (R_SUCCESS);
		}

		echoDebug(DBG_CANNOT_ACCESS_PATH_BUT_SHOULD,
		    mbPath, strerror(errno));
		free(mbPath);

		return (R_FAILURE);
	}

	/*
	 * target successfully opened - if testing for non-existence,
	 * return failure, otherwise continue with specified tests
	 */

	if (a_tt & TEST_NOT_EXISTS) {
		/* testing for non-existence: return failure */
		echoDebug(DBG_TEST_EXISTS_SHOULD_NOT, mbPath);
		free(mbPath);
		(void) close(fd);
		return (R_FAILURE);
	}

	/* get the file status */

	r = fstat(fd, &statbuf);
	if (r != 0) {
		echoDebug(DBG_PATH_DOES_NOT_EXIST, mbPath, strerror(errno));
		(void) close(fd);
		free(mbPath);
		return (R_FAILURE);
	}

	/* required to be a directory? */

	if (a_tt & TEST_IS_DIRECTORY) {
		if (!(statbuf.st_mode & S_IFDIR)) {
			/* is not a directory */
			echoDebug(DBG_IS_NOT_A_DIRECTORY, mbPath);
			free(mbPath);
			return (R_FAILURE);
		}
		/* a directory */
		echoDebug(DBG_DIRECTORY_IS, mbPath);
	}

	/* required to not be a directory? */

	if (a_tt & TEST_NOT_DIRECTORY) {
		if (statbuf.st_mode & S_IFDIR) {
			/* is a directory */
			echoDebug(DBG_IS_A_DIRECTORY, mbPath);
			free(mbPath);
			return (R_FAILURE);
		}
		/* not a directory */
		echoDebug(DBG_DIRECTORY_NOT, mbPath);
	}

	/* required to be a file? */

	if (a_tt & TEST_IS_FILE) {
		if (!(statbuf.st_mode & S_IFREG)) {
			/* is not a regular file */
			echoDebug(DBG_IS_NOT_A_FILE, mbPath);
			free(mbPath);
			return (R_FAILURE);
		}
		/* a regular file */
		echoDebug(DBG_FILE_IS, mbPath);
	}

	/* required to not be a file? */

	if (a_tt & TEST_NOT_FILE) {
		if (statbuf.st_mode & S_IFREG) {
			/* is a regular file */
			echoDebug(DBG_IS_A_FILE, mbPath);
			free(mbPath);
			return (R_FAILURE);
		}
		/* not a regular file */
		echoDebug(DBG_FILE_NOT, mbPath);
	}

	/*
	 * Find token (global) in file pointed to by mbPath.
	 * token is only compared to first word in mbPath.
	 */

	if (a_tt & TEST_GLOBAL_TOKEN_IN_FILE) {
		if (!(statbuf.st_mode & S_IFREG)) {
			/* is not a regular file */
			echoDebug(DBG_IS_NOT_A_FILE, mbPath);
			free(mbPath);
			return (R_FAILURE);
		}
		/* If global exists then we're not in a non-global zone */
		if (findToken(mbPath, GLOBAL_ZONENAME) == R_SUCCESS) {
			echoDebug(DBG_TOKEN__EXISTS, GLOBAL_ZONENAME, mbPath);
			free(mbPath);
			return (R_FAILURE);
		}
	}

	(void) close(fd);

	/* success! */

	echoDebug(DBG_TESTPATH_OK, mbPath);

	/* free up temp storage used to hold path to test */

	free(mbPath);

	return (R_SUCCESS);
}

/*
 * Name:        findToken
 * Description:	Find first token in file.
 * Arguments:
 *              path - file to search for token
 *              token - string to search for
 * Returns:
 *              R_SUCCESS - the token exists
 *              R_FAILURE - the token does not exist
 *              R_ERROR - fatal error attempting to find token
 */

static int
findToken(char *path, char *token)
{
	FILE	*fp;
	char	*cp;
	char	line[MAXPATHLEN];

	if (path == NULL || token == NULL) {
		return (R_ERROR);
	}
	if ((fp = fopen(path, "r")) == NULL) {
		return (R_ERROR);
	}

	while (fgets(line, sizeof (line), fp) != NULL) {
		for (cp = line; *cp && isspace(*cp); cp++);
		/* skip comments */
		if (*cp == '#') {
			continue;
		}
		if (pkgstrContainsToken(cp, token, ":")) {
			(void) fclose(fp);
			return (R_SUCCESS);
		}
	}
	(void) fclose(fp);
	return (R_FAILURE);
}


/*
 * Name:	resolvePath
 * Description:	fully resolve a path to an absolute real path
 * Arguments:	r_path - pointer to pointer to malloc()ed storage containing
 *			the path to resolve - this path may be reallocated
 *			as necessary to hold the fully resolved path
 * Output:	r_path - is realloc()ed as necessary
 * Returns:	R_SUCCESS - the path is fully resolved
 *		R_FAILURE - the path could not be resolved
 *		R_ERROR - fatal error attempting to resolve path
 */

static int
resolvePath(char **r_path)
{
	int		i;
	char		resolvedPath[MAXPATHLEN+1] = {'\0'};
	size_t		mbPathlen;	/* length of multi-byte path */
	size_t		wcPathlen;	/* length of wide-character path */
	wchar_t		*wcPath;	/* wide-character version of the path */
	wchar_t		*wptr;		/* scratch pointer */

	/* entry assertions */

	assert(r_path != (char **)NULL);

	/* return error if the path is completely empty */

	if (*r_path == '\0') {
		return (R_FAILURE);
	}

	/* remove all leading whitespace */

	removeLeadingWhitespace(r_path);

	/*
	 * convert to real path: an absolute pathname that names the same file,
	 * whose resolution does not involve ".", "..",  or  symbolic links.
	 */

	if (realpath(*r_path, resolvedPath) != NULL) {
		free(*r_path);
		*r_path = strdup(resolvedPath);
	}

	/*
	 *  convert the multi-byte version of the path to a
	 *  wide-character rendering, for doing our figuring.
	 */

	mbPathlen = strlen(*r_path);

	if ((wcPath = (wchar_t *)
		calloc(1, sizeof (wchar_t)*(mbPathlen+1))) == NULL) {
		return (R_FAILURE);
	}

	/*LINTED*/
	if ((wcPathlen = mbstowcs(wcPath, *r_path, mbPathlen)) == -1) {
		free(wcPath);
		return (R_FAILURE);
	}

	/*
	 *  remove duplicate slashes first ("//../" -> "/")
	 */

	for (wptr = wcPath, i = 0; i < wcPathlen; i++) {
		*wptr++ = wcPath[i];

		if (wcPath[i] == '/') {
			i++;

			while (wcPath[i] == '/') {
				i++;
			}

			i--;
		}
	}

	*wptr = '\0';

	/*
	 *  now convert back to the multi-byte format.
	 */

	/*LINTED*/
	if (wcstombs(*r_path, wcPath, mbPathlen) == -1) {
		free(wcPath);
		return (R_FAILURE);
	}

	/* at this point have a path */

	/* free up temporary storage */

	free(wcPath);

	return (R_SUCCESS);
}

/*
 * Name:	removeLeadingWhitespace
 * Synopsis:	Remove leading whitespace from string
 * Description:	Remove all leading whitespace characters from a string
 * Arguments:	a_str - [RO, *RW] - (char **)
 *			Pointer to handle to string (in allocated storage) to
 *			remove all leading whitespace from
 * Returns:	void
 *			The input string is modified as follows:
 *			== NULL:
 *				- input string was NULL
 *				- input string is all whitespace
 *			!= NULL:
 *				- copy of input string with leading
 *				  whitespace removed
 * CAUTION:	The input string must be allocated space (via malloc() or
 *		strdup()) - it must not be a static or inline character string
 * NOTE:	The input string a_str will be freed with 'free'
 *		if it is all whitespace, or if it contains any leading
 *		whitespace characters
 * NOTE:    	Any string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the string is no longer needed.
 * Errors:	If the string cannot be created, the process exits
 */

static void
removeLeadingWhitespace(char **a_str)
{
	char	*o_str;

	/* entry assertions */

	assert(a_str != (char **)NULL);

	/* if string is null, just return */

	if (*a_str == NULL) {
		return;
	}
	o_str = *a_str;

	/* if string is empty, deallocate and return NULL */

	if (*o_str == '\0') {
		/* free string */
		free(*a_str);
		*a_str = NULL;
		return;
	}

	/* if first character is not a space, just return */

	if (!isspace(*o_str)) {
		return;
	}

	/* advance past all space characters */

	while ((*o_str != '\0') && (isspace(*o_str))) {
		o_str++;
	}

	/* if string was all space characters, deallocate and return NULL */

	if (*o_str == '\0') {
		/* free string */
		free(*a_str);
		*a_str = NULL;
		return;
	}

	/* have non-space/null byte, return dup, deallocate original */

	o_str = strdup(o_str);
	free(*a_str);
	*a_str = o_str;
}

/*
 * Name:	getZoneName
 * Description:	get the name of the zone this process is running in
 * Arguments:	r_zoneName - pointer to pointer to receive zone name
 * Output:	r_zoneName - a pointer to malloc()ed storage containing
 *			the zone name this process is running in is stored
 *			in the location pointed to by r_zoneName
 * Returns:	R_SUCCESS - the zone name is successfully returned
 *		R_FAILURE - the zone name is not successfully returned
 *		R_ERROR - error attempting to get the zone name
 */

static int
getZoneName(char **r_zoneName)
{
static char zoneName[ZONENAME_MAX] = { '\0' };

	/* if zone name not already present, retrieve and cache name */

	if (zoneName[0] == '\0') {
		if (getzonenamebyid(getzoneid(), zoneName,
			sizeof (zoneName)) < 0) {
			log_msg(LOG_MSG_ERR, ERR_CANNOT_GET_ZONENAME);
			return (R_ERROR);
		}
	}

	/* return cached zone name */

	*r_zoneName = zoneName;
	return (R_SUCCESS);
}

/*
 * Name:	getRootPath
 * Description:	get the root path being tested by this process
 * Arguments:	r_rootPath - pointer to pointer to receive root path
 * Output:	r_rootPath - a pointer to malloc()ed storage containing
 *			the root path name this process is testing
 * Returns:	R_SUCCESS - the root path is successfully returned
 *		R_FAILURE - the root path is not successfully returned
 *		R_ERROR - error attempting to get the root path
 */

static int
getRootPath(char **r_rootPath)
{
	*r_rootPath = _rootPath;
	return (R_SUCCESS);
}

/*
 * Name:	setVerbose
 * Description:	Turns on verbose output
 * Scope:	public
 * Arguments:	verbose = B_TRUE indicates verbose mode
 * Returns:	none
 */

static void
setVerbose(boolean_t setting)
{
	/* set log verbose messages */

	log_set_verbose(setting);

	/* set interactive messages */

	echoSetFlag(setting);
}

/*
 * Name:	negate_results
 * Description:	control negation of results
 * Scope:	public
 * Arguments:	setting
 *		== B_TRUE indicates negated results mode
 *		== B_FALSE indicates non-negated results mode
 * Returns:	none
 */

static void
setNegateResults(boolean_t setting)
{
	log_msg(LOG_MSG_DEBUG, DBG_SET_NEGATE_RESULTS,
		_negateResults, setting);

	_negateResults = setting;
}

/*
 * Name:	getNegateResults
 * Description:	Returns whether or not to results are negated
 * Scope:	public
 * Arguments:	none
 * Returns:	B_TRUE - results are negated
 *		B_FALSE - results are not negated
 */

static boolean_t
getNegateResults(void)
{
	return (_negateResults);
}

/*
 * Name:	usage
 * Description:	output usage string
 * Arguments:	a_format - format to use to generate message
 *		arguments following a_format - as needed for a_format
 * Output:	Outputs the usage string to stderr.
 * Returns:	R_ERROR
 */

static int
usage(char *a_format, ...)
{
	int		cur_cmd;
	char		cmdlst[LINE_MAX+1] = { '\0' };
	char		*message;
	char		bfr[1];
	char		*p = get_prog_name();
	size_t		vres = 0;
	va_list		ap;

	/* entry assertions */

	assert(a_format != NULL);
	assert(*a_format != '\0');

	/* determine size of the message in bytes */

	va_start(ap, a_format);
	/* LINTED warning: variable format specifier to vsnprintf(); */
	vres = vsnprintf(bfr, 1, a_format, ap);
	va_end(ap);

	assert(vres > 0);

	/* allocate storage to hold the message */

	message = (char *)calloc(1, vres+2);
	assert(message != NULL);

	/* generate the results of the printf conversion */

	va_start(ap, a_format);
	/* LINTED warning: variable format specifier to vsnprintf(); */
	vres = vsnprintf(message, vres+1, a_format, ap);
	va_end(ap);

	assert(vres > 0);

	/* generate list of all defined conditions */

	for (cur_cmd = 0; cmds[cur_cmd].c_name != NULL; cur_cmd++) {
		(void) strlcat(cmdlst, "\t", sizeof (cmdlst));
		(void) strlcat(cmdlst, cmds[cur_cmd].c_name, sizeof (cmdlst));
		if (cmds[cur_cmd].c_args != NULL) {
			(void) strlcat(cmdlst, cmds[cur_cmd].c_args,
						sizeof (cmdlst));
		}
		(void) strlcat(cmdlst, "\n", sizeof (cmdlst));
	}

	/* output usage with conditions */

	log_msg(LOG_MSG_INFO, MSG_USAGE, message, p ? p : "pkgcond", cmdlst);

	return (R_ERROR);
}

/*
 * Name:	parseGlobalData
 * Description:	parse environment global data and store in global data structure
 * Arguments:	a_envVar - pointer to string representing the name of the
 *			environment variable to get and parse
 *		r_gdt - pointer to pointer to global data structure to fill in
 *			using the parsed data from a_envVar
 * Output:	none
 * Returns:	R_SUCCESS - the global data is successfully parsed
 *		R_FAILURE - problem parsing global data
 *		R_ERROR - fatal error attempting to parse global data
 */

static int
parseGlobalData(char *a_envVar, GLOBALDATA_T **r_gdt)
{
	int		r;
	int		n;
	char		*a;
	SML_TAG		*tag;
	SML_TAG		*ntag;

	assert(r_gdt != (GLOBALDATA_T **)NULL);

	/*
	 * allocate space for global data structure if needed
	 */

	if (*r_gdt == (GLOBALDATA_T *)NULL) {
		*r_gdt = (GLOBALDATA_T *)calloc(1, sizeof (GLOBALDATA_T));
	}

	/*
	 * get initial installation indication:
	 * If the initial install variable is set to "true", then an initial
	 * installation of Solaris is underway. When this condition is true:
	 * - if the path being checked is the package install root, then
	 *   the path is considered to be an 'alternative root' which is
	 *   currently being installed.
	 * - if the path being checked is not the package install root, then
	 *   the path needs to be further analyzed to determine what it may
	 *   be referring to.
	 */

	a = getenv(ENV_VAR_INITIAL_INSTALL);
	if ((a != NULL) && (strcasecmp(a, "true") == 0)) {
		(*r_gdt)->gd_initialInstall = B_TRUE;
	}

	/* get current zone name */

	r = getZoneName(&(*r_gdt)->gd_zoneName);
	if (r != R_SUCCESS) {
		(*r_gdt)->gd_zoneName = "";
	}

	/*
	 * get zone installation status:
	 * - If the package install zone name is not set, then an installation
	 *   of a global zone, or of a non-global zone, is not underway.
	 * - If the package install zone name is set to "global", then an
	 *   installation of a global zone is underway. In this case, no path
	 *   can be a netinstall image, diskless client, mounted miniroot,
	 *   non-global zone, the current running system, alternative root,
	 *   or alternative boot environment.
	 * - If the package install zone name is set to a value other than
	 *   "global", then an installation of a non-global zone with that name
	 *   is underway.  In this case, no path can be a netinstall image,
	 *   diskless client, mounted miniroot, global zone, the current
	 *   running system, alternative root, or alternative boot environment.
	 */

	a = getenv(ENV_VAR_PKGZONENAME);
	if ((a == NULL) || (*a == '\0')) {
		/* not installing a zone */
		(*r_gdt)->gd_globalZoneInstall = B_FALSE;
		(*r_gdt)->gd_nonglobalZoneInstall = B_FALSE;
	} else if (strcmp(a, GLOBAL_ZONENAME) == 0) {
		/* installing a global zone */
		(*r_gdt)->gd_globalZoneInstall = B_TRUE;
		(*r_gdt)->gd_nonglobalZoneInstall = B_FALSE;
		(*r_gdt)->gd_zoneName = a;
	} else {
		/* installing a non-global zone by that name */
		(*r_gdt)->gd_globalZoneInstall = B_FALSE;
		(*r_gdt)->gd_nonglobalZoneInstall = B_TRUE;
		(*r_gdt)->gd_zoneName = a;
	}

	/*
	 * get package install root. If it doesn't exist check for
	 * patch install root (ROOTDIR)
	 */

	a = getenv(ENV_VAR_PKGROOT);
	if ((a != NULL) && (*a != '\0')) {
		(*r_gdt)->gd_installRoot = a;
	} else {
		a = getenv(ENV_VAR_PATCHROOT);
		if ((a != NULL) && (*a != '\0')) {
			(*r_gdt)->gd_installRoot = a;
		} else {
			(*r_gdt)->gd_installRoot = "/";
		}
	}

	/*
	 * get patch client version: always set if $ROOTDIR != / and
	 * the $ROOTDIR/var/sadm/softinfo/INST_RELEASE file exists.
	 */

	a = getenv(ENV_VAR_PATCH_CLIENTVER);
	(*r_gdt)->gd_patchClientVersion = (a ? a : "");

	/* get the global data environment variable */

	a = getenv(a_envVar);

	/* if no data then issue warning and return success */

	if ((a == NULL) || (*a_envVar == '\0')) {
		log_msg(LOG_MSG_DEBUG, DBG_NO_GLOBAL_DATA_AVAILABLE, a_envVar);
		return (R_SUCCESS);
	}

	/* data present - parse into SML structure */

	log_msg(LOG_MSG_DEBUG, DBG_PARSE_GLOBAL, a);

	r = smlConvertStringToTag(&tag, a);
	if (r != R_SUCCESS) {
		log_msg(LOG_MSG_ERR, ERR_CANNOT_PARSE_GLOBAL_DATA, a);
		return (R_FAILURE);
	}

	smlDbgPrintTag(tag, DBG_PARSED_ENVIRONMENT, a_envVar);

	/* fill in global data structure */

	/* find the environment condition information structure */

	ntag = smlGetTagByName(tag, 0, TAG_COND_TOPLEVEL);
	if (ntag == SML_TAG__NULL) {
		log_msg(LOG_MSG_WRN, WRN_PARSED_DATA_MISSING,
			TAG_COND_TOPLEVEL);
		return (R_FAILURE);
	}

	/*
	 * data found - extract what we know about
	 */

	/* parent zone name */

	a = smlGetParamByTag(ntag, 0, TAG_COND_PARENT_ZONE, TAG_COND_ZONE_NAME);
	(*r_gdt)->gd_parentZoneName = a;

	/* parent zone type */

	a = smlGetParamByTag(ntag, 0, TAG_COND_PARENT_ZONE, TAG_COND_ZONE_TYPE);
	(*r_gdt)->gd_parentZoneType = a;

	/* current zone name */

	a = smlGetParamByTag(ntag, 0, TAG_COND_CURRENT_ZONE,
		TAG_COND_ZONE_NAME);
	(*r_gdt)->gd_currentZoneName = a;

	/* current zone type */

	a = smlGetParamByTag(ntag, 0, TAG_COND_CURRENT_ZONE,
		TAG_COND_ZONE_TYPE);
	(*r_gdt)->gd_currentZoneType = a;

	/* extract any inherited file systems */

	for (n = 0; ; n++) {
		char	**ifs;

		a = smlGetParamByTag(ntag, n, TAG_COND_INHERITED_FS,
			TAG_COND_FS_NAME);

		if (a == NULL) {
			if (n > 0) {
				/* LINTED warning: variable may be used */
				(*r_gdt)->gd_inheritedFileSystems = ifs;
			}
			break;
		}

		if (n == 0) {
			ifs = (char **)calloc(1, sizeof (char **)*(n+2));
			ifs[n] = a;
			ifs[n+1] = NULL;
		} else {
			ifs = (char **)realloc(ifs, sizeof (char **)*(n+2));
			ifs[n] = a;
			ifs[n+1] = NULL;
		}
	}

	return (R_SUCCESS);
}

/*
 * Name:	dumpGlobalData
 * Description:	dump global data structure using echoDebug
 * Arguments:	a_gdt - pointer to global data structure to dump
 * Outputs:	echoDebug is called to output global data strucutre information
 * Returns:	void
 */

static void
dumpGlobalData(GLOBALDATA_T *a_gdt)
{
	/* entry assertions */

	assert(a_gdt != (GLOBALDATA_T *)NULL);

	/* debugging enabled, dump the global data structure */

	echoDebug(DBG_DUMP_GLOBAL_ENTRY);
	echoDebug(DBG_DUMP_GLOBAL_PARENT_ZONE,
		a_gdt->gd_parentZoneName ? a_gdt->gd_parentZoneName : "",
		a_gdt->gd_parentZoneType ? a_gdt->gd_parentZoneType : "");
	echoDebug(DBG_DUMP_GLOBAL_CURRENT_ZONE,
		a_gdt->gd_currentZoneName ? a_gdt->gd_currentZoneName : "",
		a_gdt->gd_currentZoneType ? a_gdt->gd_currentZoneType : "");

	if (a_gdt->gd_inheritedFileSystems) {
		int n;
		char **ifs = a_gdt->gd_inheritedFileSystems;
		for (n = 0; ifs[n]; n++) {
			echoDebug(DBG_DUMP_GLOBAL_LINE, n, ifs[n]);
		}
	}
}

/*
 * Name:	recursionCheck
 * Description:	prevent recursive calling of functions
 * Arguments:	r_recursion - pointer to int recursion counter
 *		a_function - pointer to name of function
 * Returns:	B_TRUE - function is recursively called
 *		B_FALSE - function not recursively called
 */

static boolean_t
recursionCheck(int *r_recursion, char *a_function)
{
	/* prevent recursion */

	(*r_recursion)++;
	if (*r_recursion > 1) {
		echoDebug(DBG_RECURSION, a_function, *r_recursion);
		(*r_recursion)--;
		return (B_TRUE);
	}

	echoDebug(DBG_NO_RECURSION, a_function);
	return (B_FALSE);
}

/*
 * Name:	quit
 * Description:	cleanup and exit
 * Arguments:	a_retcode - the code to use to determine final exit status;
 *			if this is NOT "99" and if a "ckreturnFunc" is
 *			set, then that function is called with a_retcode
 *			to set the final exit status.
 *		Valid values are:
 *		0 - success
 *		1 - package operation failed (fatal error)
 *		2 - non-fatal error (warning)
 *		3 - user selected quit (operation interrupted)
 *		4 - admin settings prevented operation
 *		5 - interaction required and -n (non-interactive) specified
 *		"10" is added to indicate "immediate reboot required"
 *		"20" is be added to indicate "reboot after install required"
 *		99 - do not interpret the code - just exit "99"
 * Returns:	<<this function does not return - calls exit()>>
 * NOTE:	This is needed because libinst functions can call "quit(99)"
 *		to force an error exit.
 */

void
quit(int a_retcode)
{
	/* process return code if not quit(99) */

	if (a_retcode == 99) {
		exit(0x7f);	/* processing error (127) */
	}

	exit(R_FAILURE);
}