/*
 * 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.
 */

#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/nvpair.h>
#include <door.h>
#include <fcntl.h>

#include "mms_mgmt.h"
#include "mgmt_acsls.h"
#include "mmp_defs.h"
#include "mgmt_media.h"
#include "mgmt_sym.h"
#include "mgmt_util.h"

static char *_SrcFile = __FILE__;
#define	HERE _SrcFile, __LINE__

static char *mmsmntdoor = "/var/run/mmsmnt_door";

static int voltype_in_use(void *session, char *voltype);
static int
mgmt_show_mmvols(void *session, char *pcl, char *library, nvlist_t **vols);
static int
mgmt_show_partition(void *session, char *pcl, char *library, nvlist_t **parts);
static int call_mmsmnt(door_arg_t *arg);

static char *label_fname = "                 ";
static mms_mgmt_setopt_t cartridgegrpopts[] = {
	{O_NAME, "CartridgeGroupName", NULL, B_TRUE, NULL},
	{NULL, NULL, NULL, B_FALSE, NULL}
};
#define	CGOPT_COUNT	sizeof (cartridgegrpopts) / sizeof (mms_mgmt_setopt_t)

/*
 * Note that O_APPS (string array) is required for CartridgeGroupApplication.
 * Add a CGA for each application specified in the array.
 */
static mms_mgmt_setopt_t cgappopts[] = {
	{O_NAME, "CartridgeGroupName", NULL, B_TRUE, NULL},
	{O_APPS, "ApplicationName", NULL, B_TRUE, NULL},
	{NULL, NULL, NULL, B_FALSE, NULL}
};
#define	CGAOPT_COUNT	sizeof (cgappopts) / sizeof (mms_mgmt_setopt_t)

/*
 * mms_mgmt_discover_media()
 *
 *  Finds ACSLS media, optionally filtered by library acs & lsm.
 *  Those already configured for use with MMS are filtered out unless
 *  'showall' is TRUE.
 *
 *  Required opts are:
 *    acshost
 *    acsport (if not the default)
 *      -- or --
 *    library
 *  If library specified, get ACS information from LIBRARY object.
 */
int
mms_mgmt_discover_media(
    void *session, boolean_t showall, nvlist_t *opts, mms_list_t *vol_list,
    nvlist_t *errs)
{
	int		st;
	mms_acslib_t	*lsm = NULL;
	mms_acslib_t	*nlsm = NULL;
	mms_acscart_t	*vol = NULL;
	mms_acscart_t	*nvol = NULL;
	mms_list_t	lib_list;
	char		*acshost = NULL;
	char		*val = NULL;
	char		**in_libs = NULL;
	int		count = 0;
	void		*sess = NULL;
	void		*sessp = session;
	boolean_t	found;
	int		i;
	char		tid[64];
	char		cmd[8192];
	void		*response;
	nvlist_t	*volattrs = NULL;
	nvlist_t	*avl = NULL;
	int		ost;

	if (!opts || !vol_list) {
		return (MMS_MGMT_NOARG);
	}

	(void) memset(vol_list, 0, sizeof (mms_list_t));

	/*
	 * we need either the ACSLS host or one or more libraries to
	 * proceed.
	 */
	(void) nvlist_lookup_string(opts, O_ACSHOST, &acshost);
	in_libs = mgmt_var_to_array(opts, O_MMSLIB, &count);

	if (!acshost && !in_libs) {
		st = ENOENT;
		MGMT_ADD_OPTERR(errs, O_ACSHOST, st);
		MGMT_ADD_OPTERR(errs, O_MMSLIB, st);

		return (st);
	}

	if (session == NULL) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st == 0) {
			sessp = sess;
		} else {
			return (st);
		}
	}

	/* get list of libs MMS knows about */
	st = mms_get_library(sessp, B_FALSE, &lib_list);
	if (st != 0) {
		goto done;
	}

	if (!acshost) {
		/* only supporting a single ACSLS server for V1 */
		lsm = mms_list_head(&lib_list);
		if (lsm == NULL) {
			st = ENOENT;
			MGMT_ADD_OPTERR(errs, O_ACSHOST, st);
			goto done;
		}
		acshost = lsm->acshost;
	}

	if (count > 0) {
		/* remove libraries not in our list */
		lsm = mms_list_head(&lib_list);
		while (lsm != NULL) {
			nlsm = mms_list_next(&lib_list, lsm);
			found = B_FALSE;

			for (i = 0; i < count; i++) {
				if (strcmp(in_libs[i], lsm->name) == 0) {
					found = B_TRUE;
					break;
				}
			}
			if (!found) {
				/* remove */
				mms_list_remove(&lib_list, lsm);
				free(lsm);
			}
			lsm = nlsm;
		}
	}

	/* all of the volumes from the ACSLS server */
	st = get_acs_volumes(acshost, NULL, vol_list);
	if (st != 0) {
		goto done;
	}

	/* weed out volumes for libraries we're not interested in */
	vol = mms_list_head(vol_list);
	while (vol != NULL) {
		nvol = mms_list_next(vol_list, vol);
		found = B_FALSE;

		mms_list_foreach(&lib_list, lsm) {
			if (strcmp(lsm->type, "DISK") == 0) {
				continue;
			}
			if ((lsm->acs == vol->libacs) &&
			    (lsm->lsm == vol->liblsm)) {
				found = B_TRUE;
				break;
			}
		}
		if (!found) {
			mms_list_remove(vol_list, vol);
			free(vol);
		} else {
			if (lsm->name[0] != '\0') {
				(void) strlcpy(vol->libname, lsm->name,
				    sizeof (vol->libname));
			}
		}
		vol = nvol;
	}

	/* fetch the list of cartridges MMS knows about */
	(void) mms_gen_taskid(tid);

	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue] "
	    "report[CARTRIDGE.'CartridgePCL' CARTRIDGE.'CartridgeTypeName' "
	    "CARTRIDGE.'LibraryName' CARTRIDGE.'CartridgeGroupName'] ", tid);

	if (count > 0) {
		(void) strlcat(cmd, "match [or ", sizeof (cmd));
		for (i = 0; i < count; i++) {
			if (in_libs[i] == NULL) {
				continue;
			}
			(void) strlcat(cmd, "streq(LIBRARY.'LibraryName' ",
			    sizeof (cmd));
			(void) strlcat(cmd, "'", sizeof (cmd));
			(void) strlcat(cmd, in_libs[i], sizeof (cmd));
			(void) strlcat(cmd, "') ", sizeof (cmd));
		}
		(void) strlcat(cmd, "]", sizeof (cmd));
	}
	(void) strlcat(cmd, ";", sizeof (cmd));

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "list volumes", &response);
	if (st == 0) {
		st = mmp_get_nvattrs("volid", B_TRUE, response, &volattrs);
		mms_free_rsp(response);
	}

	if (st != 0) {
		goto done;
	}

	/*
	 * TODO:  this will break horribly if barcodes are not unique for
	 * all libs.  Fix this to be more library-aware.
	 */
	vol = mms_list_head(vol_list);
	while (vol != NULL) {
		nvol = mms_list_next(vol_list, vol);

		ost = nvlist_lookup_nvlist(volattrs, vol->label, &avl);
		if (ost == 0) {
			if (!showall) {
				mms_list_remove(vol_list, vol);
			} else {
				ost = nvlist_lookup_string(avl,
				    O_MPOOL, &val);
				if (ost == 0) {
					(void) strlcpy(vol->groupname, val,
					    sizeof (vol->groupname));
				}
			}
		}
		vol = nvol;
	}

done:
	mgmt_free_str_arr(in_libs, count);

	if (volattrs) {
		nvlist_free(volattrs);
	}

	free_acslib_list(&lib_list);

	if (st != 0) {
		mms_list_free_and_destroy(vol_list, free);
		vol_list = NULL;
	}

	return (st);
}

int
mms_mgmt_add_mpool(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	char		**varray = NULL;
	int		count = 0;
	int		i;

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.create")) {
		return (EACCES);
	}

	st = mms_add_object(session, "CARTRIDGEGROUP", cartridgegrpopts,
	    nvl, errs);

	if (st == 0) {
		/* save original values */
		varray = mgmt_var_to_array(nvl, O_APPS, &count);

		for (i = 0; i < count; i++) {
			if (!varray[i] || (strlen(varray[i]) == 0) ||
			    (strcasecmp(varray[i], "none") == 0) ||
			    (strcasecmp(varray[i], "all") == 0)) {
				continue;
			}

			/* put back a single value */
			(void) nvlist_add_string(nvl, O_APPS, varray[i]);
			st = mms_add_object(session,
			    "CARTRIDGEGROUPAPPLICATION", cgappopts, nvl, errs);
			if (st != 0) {
				break;
			}
		}

		/* put back original values */
		if (varray) {
			(void) nvlist_add_string_array(nvl, O_APPS, varray,
			    count);
			mgmt_free_str_arr(varray, count);
		}
	}

	return (st);
}

int
mms_mgmt_modify_mpool(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	char		**varray = NULL;
	int		count = 0;
	int		i;
	char		cmd[8192];
	char		tid[64];
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		*mpool;
	nvlist_t	*cgattrs = NULL;
	nvlist_t	*new = NULL;
	nvpair_t	*nvp;
	char		*val;
	boolean_t	found;

	/* get list of apps, if new list != old list, update */

	if (!mgmt_chk_auth("solaris.mms.modify")) {
		return (EACCES);
	}

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &mpool);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	varray = mgmt_var_to_array(nvl, O_APPS, &count);
	if (varray == NULL) {
		/* error or nothing to do? */
		return (0);
	}

	/* get list of already-established apps */
	(void) mms_gen_taskid(tid);

	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue] "
	    "match[streq(CARTRIDGEGROUPAPPLICATION.'CartridgeGroupName' '%s')] "
	    "report[CARTRIDGEGROUPAPPLICATION.'ApplicationName'];",
	    tid, mpool);

	if (session == NULL) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			goto done;
		}
		sessp = sess;
	}

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "modify cartridgegroup",
	    &response);
	if (st == 0) {
		st = mmp_get_nvattrs("ApplicationName", B_FALSE, response,
		    &cgattrs);
		mms_free_rsp(response);
	}
	if (st != 0) {
		goto done;
	}

	/* see if we need to add any apps */
	for (i = 0; i < count; i++) {
		if (!varray[i] || (strlen(varray[i]) == 0) ||
		    (strcasecmp(varray[i], "none") == 0) ||
		    (strcasecmp(varray[i], "all") == 0)) {
			continue;
		}

		if (!nvlist_exists(cgattrs, varray[i])) {
			if (!new) {
				(void) nvlist_alloc(&new, NV_UNIQUE_NAME, 0);
				(void) nvlist_add_string(new, O_NAME, mpool);
			}

			(void) nvlist_add_string(new, O_APPS, varray[i]);
			st = mms_add_object(sessp, "CARTRIDGEGROUPAPPLICATION",
			    cgappopts, new, errs);
			if (st != 0) {
				break;
			}
		}
	}

	/* and if we need to remove any */
	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(cgattrs, nvp)) != NULL) {
		val = nvpair_name(nvp);
		if (!val) {
			/* can't happen? */
			continue;
		}

		found = B_FALSE;

		for (i = 0; i < count; i++) {
			if (strcmp(val, varray[i]) == 0) {
				found = B_TRUE;
				break;
			}
		}

		if (found) {
			continue;
		}

		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "delete task['%s'] type[CARTRIDGEGROUPAPPLICATION] "
		    "match[and "
		    "(streq(CARTRIDGEGROUPAPPLICATION.'CartridgeGroupName' "
		    "'%s') "
		    "streq(CARTRIDGEGROUPAPPLICATION.'ApplicationName' "
		    "'%s'))];",
		    tid, mpool, val);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "modify cartridgegroup",
		    &response);
		if (st != 0) {
			break;
		}
	}

done:

	if (new) {
		nvlist_free(new);
	}

	if (cgattrs) {
		nvlist_free(cgattrs);
	}

	mgmt_free_str_arr(varray, count);

	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	return (st);
}

/*
 * verify no cartridges 'allocated'
 *   force?  remove cart anyway
 * remove all carts
 * remove cartridgegroupapplications
 * remove cartridgegroup
 */
int
mms_mgmt_remove_mpool(void *session, char *mpool, boolean_t force,
    nvlist_t *errs)
{
	int		st;
	nvlist_t	*nvl = NULL;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];

	if (!mpool) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.delete")) {
		return (EACCES);
	}

	st = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0);
	if (st != 0) {
		return (st);
	}

	(void) nvlist_add_string(nvl, O_NAME, mpool);
	(void) nvlist_add_boolean_value(nvl, O_FORCE, force);
	(void) nvlist_add_string(nvl, O_VOLUMES, "*");

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			nvlist_free(nvl);
			return (st);
		}
		sessp = sess;
	}

	st = mms_mgmt_remove_cartridges(sessp, nvl, errs);

	if (st != 0) {
		goto done;
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "delete task['%s'] type[CARTRIDGEGROUPAPPLICATION] "
	    "match[streq"
	    "(CARTRIDGEGROUPAPPLICATION.'CartridgeGroupName' '%s')];",
	    tid, mpool);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "remove cartridgegroup",
	    &response);
	if (st != 0) {
		goto done;
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "delete task['%s'] type[CARTRIDGEGROUP] "
	    "match[streq(CARTRIDGEGROUP.'CartridgeGroupName' '%s')];",
	    tid, mpool);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "remove cartridgegroup",
	    &response);
	if (st != 0) {
		goto done;
	}

done:
	if (nvl) {
		nvlist_free(nvl);
	}

	return (st);
}

/* ARGSUSED */
int
mms_mgmt_remove_dpool(void *session, char *dpool, boolean_t force,
    nvlist_t *errs)
{
	int		st;
	nvlist_t	*nvl = NULL;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];

	if (!dpool) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.delete")) {
		return (EACCES);
	}

	st = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0);
	if (st != 0) {
		return (st);
	}

	(void) nvlist_add_string(nvl, O_NAME, dpool);
	(void) nvlist_add_boolean_value(nvl, O_FORCE, force);

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			nvlist_free(nvl);
			return (st);
		}
		sessp = sess;
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "delete task['%s'] type[DRIVEGROUPAPPLICATION] "
	    "match[streq"
	    "(DRIVEGROUPAPPLICATION.'DriveGroupName' '%s')];",
	    tid, dpool);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "remove drivegroup",
	    &response);
	if (st != 0) {
		goto done;
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "delete task['%s'] type[DRIVEGROUP] "
	    "match[streq(DRIVEGROUP.'DriveGroupName' '%s')];",
	    tid, dpool);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "remove drivegroup",
	    &response);
	if (st != 0) {
		goto done;
	}

done:
	if (nvl) {
		nvlist_free(nvl);
	}

	return (st);
}

int
mms_mgmt_add_cartridges(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	char		*mpool;
	char		**volarr = NULL;
	char		*libname;
	char		*mtype = NULL;
	int		count;
	int		i;
	char		tid[64];
	char		cmd[8192];
	void		*sess = NULL;
	void		*sessp = session;
	mms_list_t	lib_list;
	mms_acslib_t	*lsm;
	char		*volstr;
	mms_list_t	vol_list;
	mms_acscart_t	*vol;
	size_t		len = 0;
	void		*response;
	nvlist_t	*cart = NULL;
	char		*volxml = "</token><token>volume</token><token>";
	int		st_save = 0;
	char		*rwmode = "readwrite";

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	(void) memset(&vol_list, 0, sizeof (mms_list_t));

	st = nvlist_lookup_string(nvl, O_NAME, &mpool);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_MMSLIB, &libname);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_MMSLIB, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_VOLTYPE, &mtype);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_MTYPE, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, "readonly", &rwmode);
	if (st == 0) {
		if (strcmp(rwmode, "true") == 0) {
			rwmode = "readonly";
		} else if (strcmp(rwmode, "false") == 0) {
			rwmode = "readwrite";
		} else {
			st = MMS_MGMT_INVALID_READONLY;
			MGMT_ADD_OPTERR(errs, "readonly", st);
			return (st);
		}
	}

	volarr = mgmt_var_to_array(nvl, O_VOLUMES, &count);
	if (volarr == NULL) {
		st = ENOENT;
		MGMT_ADD_OPTERR(errs, O_VOLUMES, st);
		return (st);
	}

	if (session == NULL) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			mgmt_free_str_arr(volarr, count);
			return (st);
		}
		sessp = sess;
	}

	/* get the library information */
	st = mms_get_library(sessp, B_FALSE, &lib_list);
	if (st != 0) {
		goto done;
	}

	mms_list_foreach(&lib_list, lsm) {
		if (strcmp(lsm->name, libname) == 0) {
			break;
		}
	}
	if (lsm == NULL) {
		st = EINVAL;
		MGMT_ADD_ERR(errs, O_MMSLIB, st);
		goto done;
	}

	/* get the volume info from the ACSLS server */
	for (i = 0; i < count; i++) {
		len += strlen(volarr[i]) + strlen(volxml);

	}
	len++;	/* include trailing nul */
	volstr = malloc(len);
	if (volstr == NULL) {
		st = ENOMEM;
		goto done;
	}
	volstr[0] = '\0';
	for (i = 0; i < count; i++) {
		if (i > 0) {
			(void) strlcat(volstr, volxml, len);
		}
		(void) strlcat(volstr, volarr[i], len);
	}

	st = get_acs_volumes(lsm->acshost, volstr, &vol_list);
	free(volstr);

	if (st != 0) {
		goto done;
	}

	/* requested volumes don't appear in the returned list */
	if (vol_list.list_size == 0) {
		st = ENOENT;
		for (i = 0; i < count; i++) {
			if (volarr[i]) {
				MGMT_ADD_ERR(errs, volarr[i], st);
			}
		}
		goto done;
	}

	/* list to be used when creating PARTITIONs */
	st = nvlist_alloc(&cart, NV_UNIQUE_NAME, 0);
	if (st != 0) {
		goto done;
	}
	/* pre-populate with constant values */
	(void) nvlist_add_string(cart, O_MMSLIB, libname);

	for (i = 0; i < count; i++) {
		mms_list_foreach(&vol_list, vol) {
			if (strcmp(vol->label, volarr[i]) == 0) {
				break;
			}
		}
		if (vol == NULL) {
			/* should never happen */
			continue;
		}

		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "create task['%s'] type[CARTRIDGE] "
		    "set[CARTRIDGE.'CartridgePCL' '%s'] "
		    "set[CARTRIDGE.'CartridgeTypeName' '%s'] "
		    "set[CARTRIDGE.'CartridgeGroupName' '%s'] "
		    "set[CARTRIDGE.'LibraryName' '%s']; ",
		    tid, vol->label, mtype, mpool, libname);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "add volume",
		    &response);
		if (st != 0) {
			MGMT_ADD_ERR(errs, vol->label, st);
			st_save = MMS_MGMT_CREATE_CART_ERR;
			continue;
		}
		/* create the PARTITION */
		(void) nvlist_add_string(cart, O_NAME, vol->label);
		st = mms_mgmt_create_partition(sessp,
		    vol->label, -1, libname, rwmode, errs);
		if (st != 0) {
			MGMT_ADD_ERR(errs, vol->label, st);
			st_save = MMS_MGMT_CREATE_PART_ERR;
			mms_mgmt_add_vol_cleanup(sessp, vol->label, libname);
			break;
		}
	}

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	free_acslib_list(&lib_list);
	mms_list_free_and_destroy(&vol_list, free);
	mgmt_free_str_arr(volarr, count);

	if (cart) {
		nvlist_free(cart);
	}

	return (st_save == 0 ? st : st_save);
}

int
mms_mgmt_add_voltype(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	void		*sessp = session;
	void		*sess = NULL;
	void		*response = NULL;
	char		tid[64];
	char		cmd[8192];
	nvlist_t	*stypes = NULL;
	nvlist_t	*ctypes = NULL;
	nvlist_t	*mnvl = NULL;
	char		*in_ty = NULL;
	char		*in_sz = NULL;
	char		*in_media = NULL;
	char		*val;

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &in_ty);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_SIZE, &in_sz);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_SIZE, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_MTYPE, &in_media);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_MTYPE, st);
		return (st);
	}

	if (!sessp) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/* see if we've already got this type */
	st = mms_mgmt_show_cartridge_type(sessp, in_ty, &stypes);
	if (st != 0) {
		goto done;
	}

	/* we'll get an empty list if it isn't already defined */
	st = nvlist_lookup_nvlist(stypes, in_ty, &mnvl);
	if (st == 0) {
		/* make sure all attributes match */
		val = NULL;
		(void) nvlist_lookup_string(mnvl, "CartridgeTypeMediaLength",
		    &val);
		if ((!val) || (strcmp(val, in_sz) != 0)) {
			st = EINVAL;
			MGMT_ADD_OPTERR(errs, O_SIZE, st);
			goto done;
		}

		val = NULL;
		(void) nvlist_lookup_string(mnvl, "CartridgeShapeName", &val);
		if ((!val) || (strcmp(val, in_media) != 0)) {
			st = EINVAL;
			MGMT_ADD_OPTERR(errs, O_MTYPE, st);
			goto done;
		}

		/* all matched, nothing to do */
		goto done;
	}

	nvlist_free(stypes);
	stypes = NULL;

	st = mms_mgmt_list_supported_types(sessp, &stypes);
	if (st != 0) {
		MGMT_ADD_ERR(errs, "internal error", st);
		goto done;
	}

	st = nvlist_lookup_nvlist(stypes, "CARTRIDGE", &ctypes);
	if (st != 0) {
		MGMT_ADD_ERR(errs, "internal error", st);
		goto done;
	}

	/* make sure requested media type is supported */
	st = nvlist_lookup_nvlist(ctypes, in_media, &mnvl);
	if (st != 0) {
		if (st == ENOENT) {
			st = EOPNOTSUPP;
		}
		MGMT_ADD_ERR(errs, in_media, st);
		goto done;
	}

	/* DISK type may be any size, so set in_sz = 0 */
	if (strcmp(in_media, "DISK") == 0) {
		in_sz = "0";
	}

	/* create the new type */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "create task['%s'] type[CARTRIDGETYPE] "
	    "set[CARTRIDGETYPE.'CartridgeTypeName' '%s'] "
	    "set[CARTRIDGETYPE.'CartridgeTypeNumberSides' '1'] "
	    "set[CARTRIDGETYPE.'CartridgeTypeMediaType' 'data'] "
	    "set[CARTRIDGETYPE.'CartridgeTypeMediaLength' '%s'] "
	    "set[CARTRIDGETYPE.'CartridgeShapeName' '%s'];",
	    tid, in_ty, in_sz, in_media);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "create cartridge type",
	    &response);

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (stypes) {
		nvlist_free(stypes);
	}

	return (st);
}

static int
voltype_in_use(void *session, char *voltype)
{
	int		st;
	void		*sessp = session;
	void		*sess = NULL;
	void		*response = NULL;
	char		tid[64];
	char		cmd[8192];
	nvlist_t	*clist = NULL;

	if (!voltype) {
		return (MMS_MGMT_NOARG);
	}

	/* first, check to see if any cartridges are using this type */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue unique] "
	    "report[CARTRIDGE.'CartridgeTypeName'] "
	    "match[streq(CARTRIDGETYPE.'CartridgeTypeName' '%s')];",
	    tid, voltype);

	if (!sessp) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "check voltype", &response);
	if (st == 0) {
		st = mmp_get_nvattrs("CartridgeTypeName", B_FALSE,
		    response, &clist);
		mms_free_rsp(response);
	}

	if (st == 0) {
		if (nvlist_exists(clist, voltype)) {
			st = EBUSY;
		}
	}

	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (clist) {
		nvlist_free(clist);
	}

	return (st);
}

int
mms_mgmt_remove_voltype(void *session, char *voltype)
{
	int		st;
	void		*sessp = session;
	void		*sess = NULL;
	void		*response = NULL;
	char		tid[64];
	char		cmd[8192];

	if (!voltype) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	if (!sessp) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/* first, check to see if any cartridges are using this type */
	st = voltype_in_use(sessp, voltype);

	if (st == 0) {
		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "delete task['%s'] type[CARTRIDGETYPE] "
		    "match[streq(CARTRIDGETYPE.'CartridgeTypeName' '%s')];",
		    tid, voltype);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "delete voltype",
		    &response);
	}

	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	return (st);
}

int
mms_mgmt_modify_voltype(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	void		*sessp = session;
	void		*sess = NULL;
	void		*response = NULL;
	char		tid[64];
	char		cmd[8192];
	char		buf[1024];
	char		*vtype = NULL;
	char		*sz = NULL;
	char		*mtype = NULL;

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &vtype);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	if (!sessp) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/* first, check to see if any cartridges are using this type */
	st = voltype_in_use(sessp, vtype);
	if (st != 0) {
		goto done;
	}

	(void) nvlist_lookup_string(nvl, O_MTYPE, &mtype);
	(void) nvlist_lookup_string(nvl, O_SIZE, &sz);

	if (!sz && !mtype) {
		goto done;
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "attribute task['%s'] type[CARTRIDGETYPE] "
	    "match[streq(CARTRIDGETYPE.'CartridgeTypeName' '%s')]",
	    tid);

	if (sz) {
		(void) snprintf(buf, sizeof (buf),
		    " set[CARTRIDGETYPE.'CartridgeTypeMediaLength' '%s']",
		    sz);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}

	if (mtype) {
		(void) snprintf(buf, sizeof (buf),
		    "set[CARTRIDGETYPE.'CartridgeShapeName' '%s'];",
		    mtype);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}

	(void) strlcat(cmd, ";", sizeof (cmd));

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "delete voltype", &response);

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	return (st);
}

int
mms_mgmt_show_cartridge_type(void *session, char *voltype, nvlist_t **nvl)
{
	int		st;
	void		*sessp = session;
	void		*sess = NULL;
	void		*response = NULL;
	char		tid[64];
	char		cmd[8192];
	char		buf[1024];

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	/* if voltype is NULL, return a list of all found */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue] "
	    "report[CARTRIDGETYPE]", tid);

	if (voltype != NULL) {
		(void) snprintf(buf, sizeof (buf),
		    " match[streq (CARTRIDGETYPE.'CartridgeTypeName' '%s')]",
		    voltype);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}

	(void) strlcat(cmd, ";", sizeof (cmd));

	if (!sessp) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "list cartridgetype",
	    &response);
	if (st == 0) {
		st = mmp_get_nvattrs("voltype", B_TRUE, response, nvl);
		mms_free_rsp(response);
	}

	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	return (st);
}


int
mms_mgmt_remove_cartridges(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	char		*mpool;
	boolean_t	force = B_FALSE;
	nvlist_t	*vols = NULL;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	nvpair_t	*nvp;
	nvlist_t	*vlist;
	char		*val;
	char		*vname;
	boolean_t	skip = B_FALSE;
	char		tid[64];
	char		cmd[8192];
	int		skipped = 0;
	nvlist_t	*pclnv = NULL;
	char		*lib = NULL;

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &mpool);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	if (!nvlist_exists(nvl, O_VOLUMES)) {
		/* nothing to remove */
		return (0);
	}

	(void) nvlist_lookup_string(nvl, O_MMSLIB, &lib);

	(void) nvlist_lookup_boolean_value(nvl, O_FORCE, &force);

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/* tell the list function not to translate the var names */
	(void) nvlist_add_boolean_value(nvl, "cvt_mmp", B_FALSE);

	st = mms_mgmt_list_vols(sessp, nvl, &vols);
	if (st != 0) {
		goto done;
	}

	/* Create a temporary nvlist to store PCL & Library */
	st = nvlist_alloc(&pclnv, NV_UNIQUE_NAME, 0);
	if (st != 0) {
		goto done;
	}
	(void) nvlist_add_string(pclnv, O_MMSLIB, lib);

	/* vols is now a list of the volumes we're supposed to remove */
	nvp = NULL;

	while ((nvp = nvlist_next_nvpair(vols, nvp)) != NULL) {
		st = nvpair_value_nvlist(nvp, &vlist);
		if (st != 0) {
			continue;
		}
		st = nvlist_lookup_string(vlist, "CartridgePCL", &vname);
		if (st != 0) {
			continue;
		}

		skip = B_FALSE;

		if (!force) {
			st = nvlist_lookup_string(vlist, "CartridgeState",
			    &val);
			if (st != 0) {
				/* don't remove it if we can't tell state */
				continue;
			}
			if (strcmp(val, "allocated") == 0) {
				/* fail */
				MGMT_ADD_ERR(errs, vname, EBUSY);
				skipped++;
				skip = B_TRUE;
			}
		}

		if (skip) {
			continue;
		}

		(void) nvlist_add_string(pclnv, O_NAME, vname);

		/* remove partitions and vols if necessary */
		st = mms_mgmt_remove_partition(sessp, pclnv, errs);
		if (st != 0) {
			MGMT_ADD_ERR(errs, vname, st);
			continue;
		}

		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "delete task['%s'] type[CARTRIDGE] "
		    "match[and (streq(CARTRIDGE.'CartridgeGroupName' '%s') "
		    "streq(CARTRIDGE.'CartridgePCL' '%s'))];",
		    tid, mpool, vname);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "delete cartridge",
		    &response);
		if (st != 0) {
			MGMT_ADD_ERR(errs, vname, st);
			continue;
		}

		/* check for disk cartridges, remove the on-disk files if yes */
		st = nvlist_lookup_string(vlist, "CartridgeTypeName", &val);
		if (st == 0) {
			if (strcmp(val, "DISK") == 0) {
				char	*mntp = NULL;
				char	*rpath = NULL;

				(void) nvlist_lookup_string(vlist,
				    "CartridgeMountPoint", &mntp);
				(void) nvlist_lookup_string(vlist,
				    "CartridgePath", &rpath);
				if (!mntp || !rpath) {
					MGMT_ADD_ERR(errs, "bad cartridge path",
					    ENOENT);
					continue;
				}
				(void) snprintf(cmd, sizeof (cmd), "%s/%s",
				    mntp, rpath);
				st = mgmt_delete_dkvol(cmd, errs);
				if (st != 0) {
					MGMT_ADD_ERR(errs, cmd, st);
				}
			}
		}
	}

	if (pclnv) {
		nvlist_free(pclnv);
	}


done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (vols) {
		nvlist_free(vols);
	}

	if ((st == 0) && skipped) {
		st = MMS_MGMT_CARTRIDGE_INUSE;
	}

	return (st);
}

/*
 *  list by mpool, by mpool&cartridge id or all
 */
int
mms_mgmt_list_vols(void *session, nvlist_t *nvl, nvlist_t **vol_list)
{
	int		st;
	char		*mpool = NULL;
	char		**volarr = NULL;
	int		count;
	char		tid[64];
	char		cmd[8192];
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	boolean_t	all = B_TRUE;
	int		i;
	boolean_t	cvt_mmp = B_TRUE;
	char		*key = "volid";

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	(void) nvlist_lookup_string(nvl, O_NAME, &mpool);

	st = nvlist_lookup_boolean_value(nvl, "cvt_mmp", &cvt_mmp);
	if (st == ENOENT) {
		cvt_mmp = B_TRUE;
	} else if (cvt_mmp == B_FALSE) {
		key = "CartridgePCL";
	}
	st = 0;

	volarr = mgmt_var_to_array(nvl, O_VOLUMES, &count);
	if (volarr != NULL) {
		/* special case for all volumes */
		if (strcmp(volarr[0], "*") != 0) {
			all = B_FALSE;
		}
	}

	if (*vol_list == NULL) {
		st = nvlist_alloc(vol_list, NV_UNIQUE_NAME, 0);
		if (st != 0) {
			goto done;
		}

	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/*
	 * get the cartridges from MMS.
	 */
	if (all) {
		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "show task['%s'] reportmode[namevalue] "
		    "report[CARTRIDGE] ", tid);

		if (!mpool) {
			(void) strlcat(cmd, ";", sizeof (cmd));
		} else {
			(void) strlcat(cmd,
			    "match[streq(CARTRIDGE.'CartridgeGroupName' '",
			    sizeof (cmd));
			(void) strlcat(cmd, mpool, sizeof (cmd));
			(void) strlcat(cmd, "')];", sizeof (cmd));
		}
		st = mms_mgmt_send_cmd(sessp, tid, cmd, "show cartridges",
		    &response);
		if (st == 0) {
			st = mmp_get_nvattrs(key, cvt_mmp, response,
			    vol_list);
			mms_free_rsp(response);
		}
	} else {
		for (i = 0; i < count; i++) {
			(void) mms_gen_taskid(tid);
			(void) snprintf(cmd, sizeof (cmd),
			    "show task['%s'] reportmode[namevalue] "
			    "report[CARTRIDGE] ", tid);

			if (mpool) {
				(void) strlcat(cmd, "match[and (streq(",
				    sizeof (cmd));
				(void) strlcat(cmd,
				    "CARTRIDGE.'CartridgeGroupName' '",
				    sizeof (cmd));
				(void) strlcat(cmd, mpool, sizeof (cmd));
				(void) strlcat(cmd, "') ", sizeof (cmd));
			}
			(void) strlcat(cmd, "streq(CARTRIDGE.'CartridgePCL' '",
			    sizeof (cmd));
			(void) strlcat(cmd, volarr[i], sizeof (cmd));
			(void) strlcat(cmd, "')", sizeof (cmd));
			if (mpool) {
				(void) strlcat(cmd, ")", sizeof (cmd));
			}
			(void) strlcat(cmd, "];", sizeof (cmd));

			st = mms_mgmt_send_cmd(sessp, tid, cmd,
			    "show cartridges", &response);
			if (st == 0) {
				st = mmp_get_nvattrs(key, cvt_mmp,
				    response, vol_list);
				mms_free_rsp(response);
			} else {
				break;
			}
		}
	}

	if (st == 0) {
		mgmt_filter_results(nvl, *vol_list);
	}

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	mgmt_free_str_arr(volarr, count);

	return (st);
}

int
mms_mgmt_show_dpool(void *session, nvlist_t *nvl, nvlist_t **pools)
{
	int		st;
	char		**names = NULL;
	int		count;
	char		tid[64];
	char		cmd[8192];
	char		buf[1024];
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	int		i;
	char		*key = O_DPOOL;
	nvlist_t	*nva = NULL;
	nvpair_t	*nvp = NULL;
	char		*dpname = NULL;

	if (!nvl || !pools) {
		return (MMS_MGMT_NOARG);
	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	names = mgmt_var_to_array(nvl, O_NAME, &count);

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue] "
	    "report[DRIVEGROUP]",
	    tid);

	if (count > 1) {
		(void) strlcat(cmd, "match[or(", sizeof (cmd));
	} else if (count == 1) {
		(void) strlcat(cmd, "match[", sizeof (cmd));
	}
	for (i = 0; i < count; i++) {
		(void) snprintf(buf, sizeof (buf),
		    " streq (DRIVEGROUP.'DriveGroupName' '%s')",
		    names[i]);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}
	if (count > 1) {
		(void) strlcat(cmd, ")];", sizeof (cmd));
	} else if (count == 1) {
		(void) strlcat(cmd, "];", sizeof (cmd));
	} else {
		(void) strlcat(cmd, ";", sizeof (cmd));
	}

	*pools = NULL;
	st = mms_mgmt_send_cmd(sessp, tid, cmd, "show dpool", &response);
	if (st == 0) {
		st = mmp_get_nvattrs(key, B_TRUE, response, pools);
		mms_free_rsp(response);
	}

	if (st != 0) {
		goto done;
	}

	while ((nvp = nvlist_next_nvpair(*pools, nvp)) != NULL) {
		st = nvpair_value_nvlist(nvp, &nva);
		if (st != 0) {
			continue;
		}
		dpname = nvpair_name(nvp);

		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "show task['%s'] reportmode[namevalue] "
		    "report[DRIVEGROUPAPPLICATION.'ApplicationName' ] "
		    "match[streq(DRIVEGROUP.'DriveGroupName' '%s')];",
		    tid, dpname);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "dpool apps",
		    &response);
		if (st == 0) {
			st = mmp_get_nvattrs_array("application", B_TRUE,
			    response, nva);
			mms_free_rsp(response);
		}
		if (st != 0) {
			continue;
		}

		/*
		 * Get drives in this dpool
		 */
		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "show task['%s'] reportmode[namevalue] "
		    "report[DRIVE.'DriveName' ] "
		    "match[streq(DRIVEGROUP.'DriveGroupName' '%s')];",
		    tid, dpname);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "dpool apps",
		    &response);
		if (st == 0) {
			st = mmp_get_nvattrs_array("drive", B_TRUE,
			    response, nva);
			mms_free_rsp(response);
		}
		if (st != 0) {
			continue;
		}
	}

	mgmt_filter_results(nvl, *pools);

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (names) {
		mgmt_free_str_arr(names, count);
	}

	return (st);
}

int
mms_mgmt_show_mpool(void *session, nvlist_t *nvl, nvlist_t **pools)
{
	int		st;
	char		**names = NULL;
	int		count;
	char		tid[64];
	char		cmd[8192];
	char		buf[1024];
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	int		i;
	char		*key = O_MPOOL;
	int		vcount = 0;
	uint64_t	poolsz = 0;
	uint64_t	vsz = 0;
	nvlist_t	*vols = NULL;
	nvlist_t	*nva = NULL;
	nvpair_t	*nvp = NULL;
	nvlist_t	*nvav = NULL;
	nvpair_t	*nvpv = NULL;
	char		*val;

	if (!nvl || !pools) {
		return (MMS_MGMT_NOARG);
	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	names = mgmt_var_to_array(nvl, O_NAME, &count);

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue] "
	    "report[CARTRIDGEGROUP]",
	    tid);

	if (count > 1) {
		(void) strlcat(cmd, "match[or(", sizeof (cmd));
	} else if (count == 1) {
		(void) strlcat(cmd, "match[", sizeof (cmd));
	}
	for (i = 0; i < count; i++) {
		(void) snprintf(buf, sizeof (buf),
		    " streq (CARTRIDGEGROUP.'CartridgeGroupName' '%s')",
		    names[i]);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}
	if (count > 1) {
		(void) strlcat(cmd, ")];", sizeof (cmd));
	} else if (count == 1) {
		(void) strlcat(cmd, "];", sizeof (cmd));
	} else {
		(void) strlcat(cmd, ";", sizeof (cmd));
	}

	*pools = NULL;
	st = mms_mgmt_send_cmd(sessp, tid, cmd, "show mpool", &response);
	if (st == 0) {
		st = mmp_get_nvattrs(key, B_TRUE, response, pools);
		mms_free_rsp(response);
	}

	if (st != 0) {
		goto done;
	}

	while ((nvp = nvlist_next_nvpair(*pools, nvp)) != NULL) {
		st = nvpair_value_nvlist(nvp, &nva);
		if (st != 0) {
			continue;
		}
		val = nvpair_name(nvp);

		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "show task['%s'] reportmode[namevalue] "
		    "report[CARTRIDGE.'CartridgePCL' "
		    "CARTRIDGETYPE.'CartridgeShapeName' "
		    "CARTRIDGETYPE.'CartridgeTypeMediaLength' "
		    "PARTITION.'PartitionSize'] "
		    "match[streq(CARTRIDGEGROUP.'CartridgeGroupName' '%s')];",
		    tid, val);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "mpool vols",
		    &response);
		if (st == 0) {
			st = mmp_get_nvattrs("CartridgePCL", B_FALSE,
			    response, &vols);
			mms_free_rsp(response);
		}
		if (st != 0) {
			continue;
		}

		nvpv = NULL;
		cmd[0] = '\0';
		poolsz = 0;
		vcount = 0;

		while ((nvpv = nvlist_next_nvpair(vols, nvpv)) != NULL) {
			st = nvpair_value_nvlist(nvpv, &nvav);
			if (st != 0) {
				continue;
			}
			vcount++;

			st = nvlist_lookup_string(nvav, "CartridgeShapeName",
			    &val);
			if (st == 0) {
				(void) snprintf(buf, sizeof (buf), "%s,", val);
				if (strstr(cmd, buf) == NULL) {
					(void) strlcat(cmd, buf, sizeof (cmd));
				}
			}
			st = nvlist_lookup_string(nvav, "PartitionSize",
			    &val);
			if (st == 0) {
				(void) do_val_mms_size(val, &vsz);
				poolsz += vsz;
			} else {
				st = nvlist_lookup_string(nvav,
				    "CartridgeTypeMediaLength", &val);
				if (st == 0) {
					(void) do_val_mms_size(val, &vsz);
					poolsz += vsz;
				}
			}

		}
		nvlist_free(vols);
		vols = NULL;
		(void) snprintf(buf, sizeof (buf), "%lu", poolsz);
		(void) nvlist_add_string(nva, "total size", buf);
		(void) snprintf(buf, sizeof (buf), "%d", vcount);
		(void) nvlist_add_string(nva, "total volumes", buf);
		val = strrchr(cmd, ',');
		if (val != NULL) {
			*val = NULL;
		}
		(void) nvlist_add_string(nva, "voltype", cmd);
	}

	mgmt_filter_results(nvl, *pools);

	/* TODO:  list of cartridges + sum space used/free/avail */

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (names) {
		mgmt_free_str_arr(names, count);
	}

	return (st);
}

/* ARGSUSED */
int
mms_mgmt_create_partition(void *session, char *pcl, int64_t size, char *lib,
    char *rwmode, nvlist_t *errs)
{
	int		st;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];
	nvlist_t	*carts = NULL;

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	if (size > 0) {
		size /= (1024 * 1024);		/* convert to mega bytes */
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "create task['%s'] type[PARTITION] "
	    "set[PARTITION.'PartitionName' 'part1'] "
	    "set[PARTITION.'SideName' 'side 1'] "
	    "set[PARTITION.'CartridgePCL' '%s'] "
	    "set[PARTITION.'PartitionAvailable' '%lld'] "
	    "set[PARTITION.'PartitionSize' '%lld'] "
	    "set[PARTITION.'PartitionPercentAvailable' '%d'] "
	    "set[PARTITION.'PartitionRWMode' '%s'] "
	    "set[PARTITION.'LibraryName' '%s'];",
	    tid, pcl, size, size, size == -1 ? -1 : 100, rwmode, lib);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "create partition", &response);

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (carts) {
		nvlist_free(carts);
	}

	return (st);
}

int
mms_mgmt_remove_partition(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];
	char		*pcl = NULL;
	char		*lib = NULL;
	nvlist_t	*carts = NULL;
	nvlist_t	*vols = NULL;

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &pcl);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_MMSLIB, &lib);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_MMSLIB, st);
	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/* check for existing volumes */
	st = mgmt_show_mmvols(sessp, pcl, lib, &vols);
	if (st != 0) {
		goto done;
	}

	if (vols) {
		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "delete task['%s'] type[VOLUME] "
		    "match[and (streq(PARTITION.'CartridgePCL' '%s') "
		    "streq(PARTITION.'LibraryName' '%s'))];",
		    tid, pcl, lib);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "delete volume",
		    &response);
		if (st != 0) {
			goto done;
		}
	}

	/* now the partitions */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "delete task['%s'] type[PARTITION] "
	    "match[and (streq (PARTITION.'LibraryName' '%s') "
	    "streq(PARTITION.'CartridgePCL' '%s'))];",
	    tid, lib, pcl);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "delete partition",
	    &response);

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (carts) {
		nvlist_free(carts);
	}

	if (vols) {
		nvlist_free(vols);
	}

	return (st);
}

int
mms_mgmt_label_multi(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	int		rst = 0;
	void		*sess = NULL;
	void		*sessp = session;
	char		*pass = NULL;
	char		*app = NULL;
	char		*inst = NULL;
	char		**varr = NULL;
	int		count = 0;
	int		i;

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	varr = mgmt_var_to_array(nvl, O_NAME, &count);
	if (!varr) {
		st = ENOENT;
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	if (!session) {
		(void) nvlist_lookup_string(nvl, O_APPS, &app);
		(void) nvlist_lookup_string(nvl, "instance", &inst);
		(void) nvlist_lookup_string(nvl, O_MMPASS, &pass);

		st = create_mm_clnt(app, inst, pass, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	for (i = 0; i < count; i++) {
		(void) nvlist_add_string(nvl, O_NAME, varr[i]);

		st = mms_mgmt_label_vol(sessp, nvl, errs);
		if (st != 0) {
			/* save return status */
			if (rst == 0) {
				rst = st;
			}
		}
	}

	/* set 'name' back to the way it started */
	(void) nvlist_add_string_array(nvl, O_NAME, varr, count);

	mgmt_free_str_arr(varr, count);

	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	return (rst);
}

int
mms_mgmt_label_vol(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];
	char		buf[1024];
	char		*pcl;
	char		*lib;
	char		*app;
	char		*inst = NULL;
	char		*pass = NULL;
	nvlist_t	*attrs = NULL;
	nvlist_t	*carts = NULL;
	nvpair_t	*nva;
	boolean_t	force = B_FALSE;
	boolean_t	nomount = B_FALSE;

	if (!mgmt_chk_auth("solaris.mms.media")) {
		return (EACCES);
	}

	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &pcl);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_MMSLIB, &lib);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_MMSLIB, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_APPS, &app);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_APPS, st);
		return (st);
	}

	(void) nvlist_lookup_boolean_value(nvl, O_FORCE, &force);

	if (!session) {
		(void) nvlist_lookup_string(nvl, "instance", &inst);
		(void) nvlist_lookup_string(nvl, O_MMPASS, &pass);

		st = create_mm_clnt(app, inst, pass, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/*
	 * Check if cartridge exists.
	 */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] reportmode[namevalue] report[CARTRIDGE] "
	    "match[and (streq(CARTRIDGE.'LibraryName' '%s') "
	    "streq(CARTRIDGE.'CartridgePCL' '%s'))];",
	    tid, lib, pcl);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "show cartridge", &response);
	if (st == 0) {
		st = mmp_get_nvattrs("CartridgePCL", B_FALSE, response, &carts);
		mms_free_rsp(response);
	}

	if (!nvlist_exists(carts, pcl)) {
		MGMT_ADD_OPTERR(errs, pcl, st);
		goto done;
	}

	/* check if partition for cartridge exists.  if no, create */
	st = mgmt_show_partition(sessp, pcl, lib, &attrs);

	if (st != 0) {
		goto done;
	}

	if (attrs == NULL) {
		st = mms_mgmt_create_partition(sessp, pcl, -1, lib,
		    "readwrite", errs);
	} else {
		nva = nvlist_next_nvpair(attrs, NULL);
		if (nva) {
			if (nvlist_next_nvpair(attrs, nva)) {
				/* got more than 1, not supported */
				st = MMS_MGMT_ERR_PARTITION_NOT_UNIQUE;
				MGMT_ADD_ERR(errs, pcl, st);
				goto done;
			}
		}
	}

	nvlist_free(attrs);
	attrs = NULL;

	/* check for existing volumes */
	st = mgmt_show_mmvols(sessp, pcl, lib, &attrs);
	if (st != 0) {
		goto done;
	}

	if (!attrs) {
		/* create a volume */
		(void) snprintf(buf, sizeof (buf), "%s_%s", lib, pcl);
		(void) mms_gen_taskid(tid);
		(void) snprintf(cmd, sizeof (cmd),
		    "allocate task['%s'] newvolname['%s'] "
		    "who['%s'] "
		    "match[and (streq(CARTRIDGE.'CartridgePCL' '%s') "
		    "streq(CARTRIDGE.'LibraryName' '%s'))];",
		    tid, buf, app, pcl, lib);

		st = mms_mgmt_send_cmd(sessp, tid, cmd, "create volume",
		    &response);
		if (st != 0) {
			MGMT_ADD_ERR(errs, pcl, st);
			goto done;
		}
	} else if (!force) {
		st = MMS_MGMT_CARTRIDGE_INUSE;
		MGMT_ADD_ERR(errs, pcl, st);
		goto done;
	}

	/* filename is 17 spaces - tells MM to re-init volume */
	(void) nvlist_add_string(nvl, "filename", label_fname);

	/*
	 * If '-n' is not specified, them mount and label the cartridge
	 */
	st = nvlist_lookup_boolean_value(nvl, O_NOMOUNT, &nomount);
	if (st != 0 || nomount != B_TRUE) {
		/* ok, mount with appropriate options */
		st = mms_mgmt_mount_vol(sessp, nvl, errs);

		if (st == 0) {
			/* label is a quick mount/unmount */
			st = mms_mgmt_unmount_vol(nvl, errs);
		}
	}

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (attrs) {
		nvlist_free(attrs);
	}
	if (carts) {
		nvlist_free(carts);
	}

	return (st);
}

static int
mgmt_show_partition(void *session, char *pcl, char *library, nvlist_t **parts)
{
	int		st;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];
	nvlist_t	*plist = NULL;
	nvpair_t	*nvp = NULL;

	if (!pcl || !library || !parts) {
		return (MMS_MGMT_NOARG);
	}

	st = nvlist_alloc(&plist, NV_UNIQUE_NAME, 0);
	if (st != 0) {
		return (st);
	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	*parts = NULL;

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] report[PARTITION] reportmode[namevalue] "
	    "match[and (streq(PARTITION.'CartridgePCL' '%s') "
	    "streq(PARTITION.'LibraryName' '%s'))];",
	    tid, pcl, library);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "show partition", &response);
	if (st == 0) {
		st = mmp_get_nvattrs("PartitionName", B_FALSE, response,
		    &plist);
		mms_free_rsp(response);
	}

	if (st == 0) {
		nvp = nvlist_next_nvpair(plist, NULL);
		if (nvp) {
			*parts = plist;
		} else {
			nvlist_free(plist);
		}
	}

	return (st);
}

static int
mgmt_show_mmvols(void *session, char *pcl, char *library, nvlist_t **vols)
{
	int		st;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response;
	char		tid[64];
	char		cmd[8192];
	nvlist_t	*vlist = NULL;
	nvpair_t	*nvp = NULL;

	if (!pcl || !library || !vols) {
		return (MMS_MGMT_NOARG);
	}

	st = nvlist_alloc(&vlist, NV_UNIQUE_NAME, 0);
	if (st != 0) {
		return (st);
	}

	if (!session) {
		st = create_mm_clnt(NULL, NULL, NULL, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] report[VOLUME] reportmode[namevalue] "
	    "match[and (streq(PARTITION.'CartridgePCL' '%s') "
	    "streq(PARTITION.'LibraryName' '%s'))];",
	    tid, pcl, library);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "show volume", &response);
	if (st == 0) {
		st = mmp_get_nvattrs("VolumeName", B_FALSE, response, &vlist);
		mms_free_rsp(response);
	}

	if (st == 0) {
		nvp = nvlist_next_nvpair(vlist, NULL);
		if (!nvp) {
			/* nothing there */
			nvlist_free(vlist);
			*vols = NULL;
		} else {
			*vols = vlist;
		}
	}

	return (st);
}

static int
call_mmsmnt(door_arg_t *arg)
{
	int		st;
	int		doorfd = -1;
	int		count;
	/* LINTED [warning: pointer cast may result in improper alignment] */
	mmsmnt_arg_t	*mntarg = (mmsmnt_arg_t *)arg->rbuf;
	int		saverr;
	timespec_t	sleepfor = {5, 0};	/* 5 seconds */
	char		*cmd[2];

	if (arg == NULL) {
		return (MMS_MGMT_NOARG);
	}

	cmd[0] = MMSSBINDIR"/mmsmnt";
	cmd[1] = NULL;

	/* will get overwritten with correct status as appropriate */
	st = ENOTCONN;

	/* try 5 times to get connected, then give up */
	for (count = 0; count < 5; count++) {
		doorfd = open(mmsmntdoor, O_RDWR);
		if (doorfd == -1) {
			if (errno == ENOENT) {
			/* server is not running.  Try to start it */
				(void) exec_mgmt_cmd(NULL, NULL, 0, 0, B_TRUE,
				    cmd);
				mms_trace(MMS_DEBUG,
				    "exec_mgmt_cmd: %s", cmd[0]);
			} else {
				st = errno;
				return (st);
			}
		}

		/*
		 * try to contact the server - if door_call successful,
		 * status will be set by the server
		 */
		st = door_call(doorfd, arg);
		saverr = errno;

		if (st == 0) {
			/* connected ok, return error from daemon */
			st = mntarg->st;
			break;
		}

		(void) close(doorfd);
		doorfd = -1;

		if (saverr == EBADF) {
			/*
			 * server was not running when we opened
			 * the door file
			 */
			(void) exec_mgmt_cmd(NULL, NULL, 0, 0, B_TRUE, cmd);
			mms_trace(MMS_DEBUG, "exec_mgmt_cmd: %s", cmd[0]);
			/* give the server a chance to start */
			(void) nanosleep(&sleepfor, NULL);
		} else if ((saverr != EAGAIN) && (saverr != EINTR)) {
			/* A non-recoverable error occurred */
			st = saverr;
			mms_trace(MMS_ERR,
			    "Could not contact the mmsmnt process, %d", st);
			return (st);
		}
	}

	if (doorfd != -1) {
		(void) close(doorfd);
	}

	return (st);
}

int
mms_mgmt_mount_vol(void *session, nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	void		*sess = NULL;
	void		*sessp = session;
	void		*response = NULL;
	char		tid[64];
	char		cmd[8192];
	char		mbuf[7168];
	char		buf[1024];
	char		*pcl;
	char		*lib;
	char		*mfile = NULL;
	char		*val;
	char		*app = NULL;
	char		*vname;
	nvlist_t	*attrs = NULL;
	nvpair_t	*nvp;
	nvlist_t	*nva;
	nvlist_t	*mntattrs = NULL;
	mmsmnt_arg_t	arg;
	door_arg_t	d_arg;
	int		others = 0;
	struct passwd	*pwd = NULL;
	char		*usernm = NULL;
	nvlist_t	*cattrs = NULL;
	boolean_t	isdsk = B_FALSE;
	char		**varray = NULL;
	int		count = 0;
	boolean_t	vbool = B_FALSE;
	int		i;
	char		*inst = NULL;
	char		*pass = NULL;

	if (!mgmt_chk_auth("solaris.mms.io.read")) {
		return (EACCES);
	}

	/* this function is unique, in that it returns the session */
	if (!nvl) {
		return (MMS_MGMT_NOARG);
	}

	st = nvlist_lookup_string(nvl, O_NAME, &pcl);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_MMSLIB, &lib);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_MMSLIB, st);
		return (st);
	}

	st = nvlist_lookup_string(nvl, O_APPS, &app);
	if (st != 0) {
		/* if not specified, see if we can mount as admin */
		if (st == ENOENT) {
			st = 0;
			app = "MMS";
			(void) nvlist_add_string(nvl, O_APPS, app);
		} else {
			MGMT_ADD_OPTERR(errs, O_APPS, st);
			return (st);
		}
	}

	(void) nvlist_lookup_string(nvl, "filename", &mfile);
	(void) nvlist_lookup_string(nvl, "instance", &inst);
	(void) nvlist_lookup_string(nvl, O_MMPASS, &pass);

	if (!sessp) {
		st = create_mm_clnt(app, inst, pass, NULL, &sess);
		if (st != 0) {
			return (st);
		}
		sessp = sess;
	}

	/* check for volumes.  If one doesn't exist, fail */
	st = mgmt_show_mmvols(sessp, pcl, lib, &attrs);
	if (st == 0) {
		if (!attrs) {
			st = MMS_MGMT_VOL_NOT_INIT;
		}
	}
	if (st != 0) {
		MGMT_ADD_ERR(errs, pcl, st);
		goto done;
	}

	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(attrs, nvp)) != NULL) {
		st = nvpair_value_nvlist(nvp, &nva);
		if (st != 0) {
			goto done;
		}
		st = nvlist_lookup_string(nva, "ApplicationName", &val);
		if (st != 0) {
			continue;
		}

		if (strcasecmp(val, app) != 0) {
			continue;
		}

		/* found a valid volume */
		break;
	}

	if ((st != 0) || (nvp == NULL)) {
		st = MMS_MGMT_NO_USABLE_VOL;
		MGMT_ADD_ERR(errs, pcl, st);
		goto done;
	}

	st = nvlist_lookup_string(nva, "VolumeName", &vname);
	if (st != 0) {
		goto done;
	}

	/* see what type of cartridge this is */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "show task['%s'] report[CARTRIDGETYPE.'CartridgeShapeName'] "
	    "reportmode[namevalue] "
	    "match[and (streq(CARTRIDGE.'CartridgePCL' '%s') "
	    "streq(LIBRARY.'LibraryName' '%s'))];",
	    tid, pcl, lib);

	st = mms_mgmt_send_cmd(sessp, tid, cmd, "get cartridge type",
	    &response);
	if (st == 0) {
		st = mmp_get_nvattrs("CartridgeShapeName", B_FALSE, response,
		    &cattrs);
		mms_free_rsp(response);
	}
	if (st == 0) {
		if (nvlist_exists(cattrs, "DISK")) {
			isdsk = B_TRUE;
		}
	}
	/* reset */
	if (cattrs) {
		nvlist_free(cattrs);
	}
	st = 0;

	st = nvlist_lookup_string(nvl, "user", &usernm);
	if ((st != 0) || (usernm == NULL)) {
		pwd = getpwuid(getuid());
		if (pwd != NULL) {
			usernm = pwd->pw_name;
		}
		if (usernm == NULL) {
			usernm = "root";
		}
	}

	/* at last, create the mount command */
	(void) mms_gen_taskid(tid);
	(void) snprintf(cmd, sizeof (cmd),
	    "mount task['%s'] user['%s'] type[VOLUME] "
	    "match[and (streq(LIBRARY.'LibraryName' '%s') "
	    "streq(CARTRIDGE.'CartridgePCL' '%s'))] "
	    "report[MOUNTLOGICAL] reportmode[namevalue] ",
	    tid, usernm, lib, pcl);

	if (mfile) {
		(void) snprintf(buf, sizeof (buf), "filename['%s'] ",
		    mfile);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}

	st = nvlist_lookup_string(nvl, "blocksize", &val);
	if (st == 0) {
		(void) snprintf(buf, sizeof (buf), "blocksize['%s'] ", val);
		(void) strlcat(cmd, buf, sizeof (cmd));
	}

	st = nvlist_lookup_boolean_value(nvl, O_NOWAIT, &vbool);
	if ((st == 0) && (vbool)) {
		(void) strlcat(cmd, "when[immediate] ", sizeof (cmd));
	} else {
		(void) strlcat(cmd, "when[blocking] ", sizeof (cmd));
	}
	st = 0;

	/* get the firstmount and accessmodes */
	mbuf[0] = '\0';

	if (mfile && (strcmp(mfile, label_fname) == 0)) {
		/* The 17-space filename indicates we're labeling */
		(void) strlcat(cmd, "accessmode['creat'] ", sizeof (cmd));
		(void) strlcat(mbuf, "firstmount[", sizeof (mbuf));
	} else {
		/* all options go into accessmode otherwise */
		(void) strlcat(mbuf, "accessmode[", sizeof (mbuf));
	}

	/* get the rest of the options */
	if (isdsk) {
		others++;
		(void) strlcat(mbuf, "'st_bsd' ", sizeof (mbuf));
	}

	st = nvlist_lookup_string(nvl, O_MMSDRV, &val);
	if (st == 0) {
		others++;
		(void) snprintf(buf, sizeof (buf), "'%s' ", val);
		(void) strlcat(mbuf, buf, sizeof (mbuf));
	}

	st = nvlist_lookup_boolean_value(nvl, O_NOREWIND, &vbool);
	if ((st == 0) && (vbool)) {
		others++;
		(void) strlcat(mbuf, "'norewind' ", sizeof (mbuf));
	}

	st = nvlist_lookup_string(nvl, O_DENSITY, &val);
	if (st == 0) {
		others++;
		(void) snprintf(buf, sizeof (buf), "'%s' ", val);
		(void) strlcat(mbuf, buf, sizeof (mbuf));
	}

	varray = mgmt_var_to_array(nvl, "mode", &count);
	for (i = 0; i < count; i++) {
		if (!varray[i]) {
			continue;
		}
		others++;
		(void) snprintf(buf, sizeof (buf), "'%s' ", varray[i]);
		(void) strlcat(mbuf, buf, sizeof (mbuf));
	}
	mgmt_free_str_arr(varray, count);
	varray = NULL;
	count = 0;

	st = nvlist_lookup_string(nvl, "readonly", &val);
	if (st == 0) {
		if (strcasecmp(val, "true") == 0) {
			(void) snprintf(buf, sizeof (buf), "'readonly' ");
		} else {
			(void) snprintf(buf, sizeof (buf), "'readwrite' ");
		}
		others++;
		(void) strlcat(mbuf, buf, sizeof (mbuf));
	}

	if (others > 0) {
		(void) strlcat(mbuf, "]", sizeof (mbuf));
		(void) strlcat(cmd, mbuf, sizeof (cmd));
	}

	(void) strlcat(cmd, ";", sizeof (cmd));

	/*
	 *  Call the mount daemon.  If successful, the handle will be
	 *  returned.
	 */

	(void) memset(&arg, 0, sizeof (mmsmnt_arg_t));
	(void) memset(&d_arg, 0, sizeof (door_arg_t));

	arg.op = 1;
	(void) strlcpy(arg.cartridge, pcl, sizeof (arg.cartridge));
	(void) strlcpy(arg.library, lib, sizeof (arg.library));
	(void) strlcpy(arg.volname, vname, sizeof (arg.volname));
	(void) strlcpy(arg.cmd, cmd, sizeof (arg.cmd));
	if (pass) {
		(void) strlcpy(arg.pass, pass, sizeof (arg.pass));
	}
	if (inst) {
		(void) strlcpy(arg.inst, inst, sizeof (arg.inst));
	}
	if (app) {
		(void) strlcpy(arg.app, app, sizeof (arg.app));
	}
	d_arg.data_ptr = (char *)&arg;
	d_arg.data_size = sizeof (mmsmnt_arg_t);
	d_arg.desc_ptr = NULL;
	d_arg.desc_num = 0;
	d_arg.rbuf = (char *)&arg;
	d_arg.rsize = d_arg.data_size;

	st = call_mmsmnt(&d_arg);

	if (st == 0) {
		(void) nvlist_add_string(nvl, "mountdev", arg.devname);
	}

done:
	if (sess) {
		(void) mms_goodbye(sess, 0);
	}

	if (attrs) {
		nvlist_free(attrs);
	}

	if (mntattrs) {
		nvlist_free(mntattrs);
	}

	return (st);
}

int
mms_mgmt_unmount_vol(nvlist_t *nvl, nvlist_t *errs)
{
	int		st;
	char		*lib = NULL;
	char		*pcl = NULL;
	char		*dev = NULL;
	char		*app = NULL;
	char		*inst = NULL;
	char		*pass = NULL;
	void		*sess = NULL;
	void		*resp = NULL;
	char		tid[64];
	char		cmd[8192];
	nvlist_t	*attrs = NULL;
	boolean_t	phys = B_FALSE;
	mmsmnt_arg_t	arg;
	door_arg_t	d_arg;

	if (!mgmt_chk_auth("solaris.mms.io.read")) {
		return (EACCES);
	}

	(void) memset(&arg, 0, sizeof (mmsmnt_arg_t));
	(void) memset(&d_arg, 0, sizeof (d_arg));

	/* requires either the pseudodevice name, *or* library/volume */
	st = nvlist_lookup_string(nvl, O_NAME, &pcl);
	if (st != 0) {
		MGMT_ADD_OPTERR(errs, O_NAME, st);
		return (st);
	}

	if (pcl[0] == '/') {
		(void) strlcpy(arg.devname, pcl, sizeof (arg.devname));
	} else {
		(void) strlcpy(arg.cartridge, pcl, sizeof (arg.cartridge));
	}

	st = nvlist_lookup_string(nvl, O_MMSLIB, &lib);
	if ((st != 0) && (arg.cartridge[0] != '\0')) {
		MGMT_ADD_OPTERR(errs, O_MMSLIB, st);
		return (st);
	}

	if (lib) {
		(void) strlcpy(arg.library, lib, sizeof (arg.library));
	}

	/* could specify all the options, but unlikely */
	st = nvlist_lookup_string(nvl, "mountdev", &dev);
	if (st == 0) {
		(void) strlcpy(arg.devname, dev, sizeof (arg.devname));
	}

	(void) nvlist_lookup_string(nvl, O_APPS, &app);
	if (!app) {
		app = "MMS";
	}
	(void) nvlist_lookup_string(nvl, "instance", &inst);
	(void) nvlist_lookup_string(nvl, O_MMPASS, &pass);

	/* make sure user is permitted to unmount this volume */
	if (strcasecmp(app, "MMS") != 0) {
		st = create_mm_clnt(app, inst, pass, NULL, &sess);
		if (st != 0) {
			return (st);
		}

		(void) mms_gen_taskid(tid);

		if (pcl[0] == '/') {
			(void) snprintf(cmd, sizeof (cmd),
			    "show task['%s'] report[MOUNTPHYSICAL] "
			    "reportmode[namevalue] "
			    "match[and "
			    "(streq(MOUNTPHYSICAL.'ApplicationName' '%s') "
			    "streq(MOUNTLOGICAL.'MountLogicalHandle' '%s'))];",
			    tid, app, pcl);
		} else {
			(void) snprintf(cmd, sizeof (cmd),
			    "show task['%s'] report[MOUNTPHYSICAL] "
			    "reportmode[namevalue] "
			    "match[and "
			    "(streq(MOUNTPHYSICAL.'ApplicationName' '%s') "
			    "streq(MOUNTPHYSICAL.'CartridgePCL' '%s'))];",
			    tid, app, pcl);
		}

		st = mms_mgmt_send_cmd(sess, tid, cmd, "check mounted vol",
		    &resp);
		if (st == 0) {
			st = mmp_get_nvattrs("ApplicationName", B_FALSE,
			    resp, &attrs);
			mms_free_rsp(resp);
		}
		if (st == 0) {
			if (!nvlist_exists(attrs, app)) {
				st = MMS_MGMT_VOL_NOT_MOUNTED;
			}
			nvlist_free(attrs);
		}

		(void) mms_goodbye(sess, 0);

		if (st != 0) {
			return (st);
		}
	}

	arg.op = 2;

	/* see if they want the cartridge physically unloaded */
	st = nvlist_lookup_boolean_value(nvl, "unload", &phys);
	if (phys) {
		(void) strlcpy(arg.cmd, "physicalunmount", sizeof (arg.cmd));
	}

	d_arg.data_ptr = (char *)&arg;
	d_arg.data_size = sizeof (mmsmnt_arg_t);
	d_arg.desc_ptr = NULL;
	d_arg.desc_num = 0;
	d_arg.rbuf = (char *)&arg;
	d_arg.rsize = d_arg.data_size;

	st = call_mmsmnt(&d_arg);

	return (st);
}