mgmt/common/mgmt_acsls.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.
 */


#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <netdb.h>
#include <procfs.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <ctype.h>
#include <dlfcn.h>

#include "mgmt_acsls.h"
#include "mgmt_library.h"
#include "mgmt_media.h"
#include "mms_cfg.h"

static char *_SrcFile = __FILE__; /* Using __FILE__ makes duplicate strings */

/*
 * This code represents a ACS client application and communicates with the ACS
 * library via the ACSAPI interface. ACSAPI procedures communicate via IPC
 * with the SSI process running on this same client machine. Each client app
 * can send multiple requests to the ACS Library Manager via this SSI. The SSI
 * receives requests from one or more clients, places them on a queue, and sends
 * the requests to the CSI to relay them to the ACS Library Manager. Multiple
 * heterogeneous clients can communicate and manage the ACSLS Library via the
 * same SSI. The SSI also relays the responses back to the appropriate client
 * application. The CSI and SSI talk to each other via RPC. The same RPC program
 * number is used for all instances of SSI and CSI connections. So there is a
 * limitation that a client cannot connect to multiple ACSLS.
 *
 * The ACSAPI resides on the client machine as a set of three C language library
 * object modules to be linked with a client application. These modules are  the
 * formal interface, and the functions that carry out the IPC for requests and
 * responses.
 *
 */

static int acs_dlsym(void);

pthread_mutex_t	acs_mutex = PTHREAD_MUTEX_INITIALIZER;
static boolean_t acs_init = B_FALSE;
static STATUS (*dl_acs_display)(SEQ_NO, TYPE, DISPLAY_XML_DATA) = NULL;
static STATUS (*dl_acs_response)(int, SEQ_NO *, REQ_ID *, ACS_RESPONSE_TYPE *,
    ALIGNED_BYTES) = NULL;

/* Display configuration and status */
static int acs_display_info(int query_type, char *cmdarg, mms_list_t *lst);
static int parse_drv_resp(void *buf, mms_list_t *lst);
static int parse_lsm_resp(void *buf, mms_list_t *lst);
static int parse_vol_resp(void *buf, mms_list_t *vol_list);
static int parse_f(char *f, char *s, size_t len);
static int parse_f_int(char *f, uint32_t *s);
static int parse_f_date(char *f, time_t *t);

static acs_query_cmdresp_t acs_query_cmdresp_tbl[] = {
	{ACS_DISPLAY_CAP,		ACS_XMLREQ_CAP,		NULL},
	{ACS_DISPLAY_CELL,		ACS_XMLREQ_CELL,	NULL},
	{ACS_DISPLAY_DRIVE,		ACS_XMLREQ_DRIVE,	parse_drv_resp},
	{ACS_DISPLAY_LOCK,		ACS_XMLREQ_LOCK,	NULL},
	{ACS_DISPLAY_LSM,		ACS_XMLREQ_LSM,		parse_lsm_resp},
	{ACS_DISPLAY_PANEL,		ACS_XMLREQ_PANEL,	NULL},
	{ACS_DISPLAY_POOL,		ACS_XMLREQ_POOL,	NULL},
	{ACS_DISPLAY_VOL,		ACS_XMLREQ_VOL,		parse_vol_resp},
	{ACS_DISPLAY_VOL_BY_MEDIA,	ACS_XMLREQ_VOL_BY_MEDIA, NULL},
	{ACS_DISPLAY_VOL_CLEANING,	ACS_XMLREQ_VOL_CLEANING, NULL},
	{ACS_DISPLAY_VOL_ACCESSED,	ACS_XMLREQ_VOL_ACCESSED, NULL},
	{ACS_DISPLAY_VOL_ENTERED,	ACS_XMLREQ_VOL_ENTERED,	NULL},
	{ACS_DISPLAY_UNSUPPORTED,	"",			NULL}
};


/*
 *  As ACSLS is a separate product, all functions must be retrieved
 *  using dlopen/dlsym().  Do it once for the duration of the exe.
 */
static int
acs_dlsym(void)
{
	int		st = 0;
	void		*hdl = NULL;
	char		buf[2048];
	char		acspath[2048];

	st = mms_cfg_getvar(MMS_CFG_LIBAPI_PATH, acspath);
	if (st != 0) {
		return (st);
	}

	(void) pthread_mutex_lock(&acs_mutex);
	if (!acs_init) {
		(void) snprintf(buf, sizeof (buf), "%s/%s",
		    acspath, "libapi.so");
		hdl = dlopen(buf, RTLD_LAZY);
		if (hdl == NULL) {
			/* not there, try the normal locations */
			hdl = dlopen("libapi.so", RTLD_LAZY);
			if (hdl == NULL) {  /* still no luck */
				(void) pthread_mutex_unlock(&acs_mutex);
				return (MMS_MGMT_ACSLS_NOT_FOUND);
			}
		}
		dl_acs_display = (STATUS (*)(SEQ_NO, TYPE, DISPLAY_XML_DATA))
		    dlsym(hdl, "acs_display");

		dl_acs_response = (STATUS (*)(int, SEQ_NO *, REQ_ID *,
		    ACS_RESPONSE_TYPE *, ALIGNED_BYTES))dlsym(hdl,
		    "acs_response");

		if ((!dl_acs_display) || (!dl_acs_response)) {
			st = MMS_MGMT_ACSLS_NOT_FOUND;
		} else {
			acs_init = B_TRUE;
		}
	}
	(void) pthread_mutex_unlock(&acs_mutex);

	return (st);
}

/*
 * Interface to control the lifecycle of the SSI process and its children
 *
 * Any priviledged client of ACSLS can start the SSI process. The same process
 * is to be used by all ACS clients on this machine to communicate within the
 * ACSLS library. Do not start multiple SSI process.
 *
 * The envva ACSAPI_SSI_SOCKET is the local port number of the SSI
 */
int
acs_start_ssi(char *acshost, char *ssiport)
{
	int	st;
	mms_list_t	proclist;
	pid_t   pid;
	char    env_acshost[NI_MAXHOST + 13]; /* CSI_HOSTNAME=<hostname> */
	char    env_acsport[128];
	int	status;
	char	acspath[2048];
	char	ssibuf[1024];
	char	sockbuf[1024];
	char	*cmd[3];
	char	*hostport;

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

	st = mms_cfg_getvar(MMS_CFG_SSI_PATH, acspath);
	if (st != 0) {
		return (st);
	}

	(void) snprintf(ssibuf, sizeof (ssibuf), "%s/%s", acspath, "ssi");
	if (find_process(ssibuf, &proclist) == 0) {
		if (!mms_list_empty(&proclist)) {
			mms_list_free_and_destroy(&proclist, free);
			return (0);
		}
	}

	(void) snprintf(env_acshost, sizeof (env_acshost), "CSI_HOSTNAME=%s",
	    acshost);
	hostport = strrchr(env_acshost, ':');
	if (hostport != NULL) {
		*hostport = '\0';
		hostport++;
		/* don't set if we're using the default port */
		if (strcmp(hostport, "50004") == 0) {
			hostport = NULL;
		}
	}

	if (hostport != NULL) {
		(void) snprintf(env_acsport, sizeof (env_acsport),
		    "CSI_HOSTPORT=%s", hostport);
	}

	(void) snprintf(ssibuf, sizeof (ssibuf), "MMS_SSI_PATH=%s", acspath);

	if (ssiport != NULL) {
		(void) snprintf(sockbuf, sizeof (sockbuf),
		    "ACSAPI_SSI_SOCKET=%s", ssiport);
	} else {
		(void) snprintf(sockbuf, sizeof (sockbuf),
		    "ACSAPI_SSI_SOCKET=%s", "50004");
	}

	/* set required envvars */
	(void) putenv(env_acshost);
	if (hostport != NULL) {
		(void) putenv(env_acsport);
	}
	(void) putenv(sockbuf);
	(void) putenv(ssibuf);

	cmd[0] = "/usr/bin/mmsssi.sh";
	cmd[1] = "1";
	cmd[2] = NULL;

	pid = exec_mgmt_cmd(NULL, NULL, 0, 0, B_TRUE, cmd);
	mms_trace(MMS_DEBUG, "exec_mgmt_cmd: %s %s", cmd[0], cmd[1]);

	status = check_exit(pid, NULL);

	if (status != 0) {
		mms_trace(MMS_ERR,
		    "Could not start ACSLS client daemon, exec status = %d",
		    status);
	}

	return (status);
}


/*
 * get the configuration of the acs library, given the name of the acsls
 * hostname and port.
 *
 * If get_drives is TRUE, get information about drives as well as libraries
 */
int
get_acs_library_cfg(
	char *acshost,
	boolean_t get_drives,
	mms_list_t *lsm_list
)
{
	int		st;
	char		location[128];
	mms_acslib_t	*lsm = NULL;

	if ((acshost == NULL) || (lsm_list == NULL)) {
		return (MMS_MGMT_NOARG);
	}

	mms_list_create(lsm_list, sizeof (mms_acslib_t),
	    offsetof(mms_acslib_t, lib_link));

	/* check if the acsls host is accessible and start if it not */
	if (acs_start_ssi(acshost, NULL) != 0) {
		return (MMS_MGMT_ERR_EXEC_SSI);
	}

	/* get all the acs-lsm */
	st = acs_display_info(ACS_DISPLAY_LSM, NULL, lsm_list);
	if (st != 0) {
		return (st);
	}

	if (get_drives) {
		mms_list_foreach(lsm_list, lsm) {
			/* get the drives in each library */
			(void) snprintf(location, sizeof (location),
			    "%d,%d,*,*", lsm->acs, lsm->lsm);

			st = acs_display_info(ACS_DISPLAY_DRIVE, location,
			    &lsm->drive_list);
			if (st != 0) {
				break;
			}
		}
	}

	return (st);
}

static int
wait_for_response(
	int	seq,
	int	(*parse_acs_resp)(void *, mms_list_t *),
	mms_list_t *lst)
{

	STATUS			st;
	SEQ_NO			rseq;
	REQ_ID			reqid;
	int			ret;
	ALIGNED_BYTES		rbuf[MAX_MESSAGE_SIZE / sizeof (ALIGNED_BYTES)];
	ACS_RESPONSE_TYPE	type;

	if ((parse_acs_resp == NULL) || (lst == NULL)) {
		return (MMS_MGMT_NOARG);
	}

	/*
	 * call acs_response() repeatedly until the FINAL packet for this
	 * request has been received
	 */
	do {
		(void) memset(rbuf, 0, sizeof (rbuf));

		st = dl_acs_response(
		    10, /* Block for 10 seconds */
		    &rseq,
		    &reqid,
		    &type,
		    rbuf);

		if (st == STATUS_IPC_FAILURE) {
			return (MMS_MGMT_ERR_ACSLS_RSP);
		}

		if (rseq != seq) {
			mms_trace(MMS_ERR, "Invalid ACS Sequence number, %d",
			    rseq);
			return (MMS_MGMT_ERR_ACSLS_RSP);
		}

		if ((type == RT_INTERMEDIATE) || (type == RT_FINAL)) {
			ret = parse_acs_resp(rbuf, lst);
			if (ret != 0) {
				ret = MMS_MGMT_ERR_ACSLS_PARSE;
				break;
			}
		}
	} while (type != RT_FINAL);

	return (ret);
}


/*
 * To get the configuration of the components in an ACSLS library, or their
 * status, use the 'display' command to create complex or detailed queries
 * using XML as the Query language. The XML request is then sent to the SSI
 * using the acs_display() ACSAPI and the responses are awaited and parsed.
 *
 * The SSI process must be running before this API can be used.
 */
int
acs_display_info(
	int	query_type,	/* type of query */
	char	*cmdarg,	/* arguments for the XML request */
	mms_list_t	*lst)		/* response parsed as a list */
{

	int			st = 0;
	SEQ_NO			seq;
	DISPLAY_XML_DATA	cmd;
	char			*s = "*";
	size_t			len;

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

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

	if (cmdarg && (strlen(cmdarg) > 0)) {
		s = cmdarg;
	}

	/* LINTED [E_SEC_PRINTF_VAR_FMT] */
	len = snprintf(cmd.xml_data, sizeof (cmd.xml_data),
	    acs_query_cmdresp_tbl[query_type].xmlreq, s);
	mms_trace(MMS_INFO, "DISPLAY cmd:\n%s", cmd.xml_data);
	cmd.length = strlen(cmd.xml_data);

	if (len > MAX_XML_DATA_SIZE) {
		return (ENAMETOOLONG);
	}

	/*
	 * generate a sequence number, this uniquely identifies the response
	 * with the request.  SEQ_NO is defined as a short int.
	 */
	seq = (SEQ_NO)(time(NULL));

	if ((dl_acs_display(seq, TYPE_DISPLAY, cmd)) != STATUS_SUCCESS) {
		return (MMS_MGMT_ERR_ACSLS_PARSE);
	}

	st = wait_for_response(seq, (int (*)(void *, mms_list_t *))
	    acs_query_cmdresp_tbl[query_type].parse_resp, lst);

	if (st != 0) {
		mms_trace(MMS_INFO, "get acs display info failed %d", st);
		return (st);
	} else {
		mms_trace(MMS_INFO, "get acs display info success");
	}

	return (st);
}


/*
 * parse_drive_resp() assumes the format of the data response, the
 * following information is expected in the drive data:
 * acs, lsm, panel, drive, type, status, state and serial number
 */
static int
parse_drv_resp(
	void	*buf,
	mms_list_t	*drive_list)
{

	ACS_DISPLAY_RESPONSE	*res;
	size_t			l;
	char			*ptr1, *ptr2;
	mms_drive_t		*drive;
	char			junkbuf[1024];
	char			xml_buf[MAX_MESSAGE_SIZE + 1];
	int			len;

	if ((buf == NULL) || (drive_list == NULL)) {
		return (MMS_MGMT_NOARG);
	}

	res = (ACS_DISPLAY_RESPONSE *)buf;
	if (res->display_status != STATUS_SUCCESS) {
		return (MMS_MGMT_ERR_ACSLS_RSP);
	}

	len = res->display_xml_data.length;
	(void) strncpy(xml_buf, res->display_xml_data.xml_data,
	    len);
	xml_buf[len] = '\0';
	mms_trace(MMS_INFO, "Display DRV response len = %d :\n%s",
	    len, xml_buf);
	ptr1 = xml_buf;

	ptr2 = strstr(ptr1, "</data></display></response>");
	if (ptr2 != NULL) {
		*ptr2 = NULL;
	};

	/*
	 * <r> marks the start of a drive entry, <f> marks the start of a field
	 *
	 * <r>
	 * <f maxlen="3">acs</f>
	 * <f maxlen="3">lsm</f>
	 * <f maxlen="5">panel</f>
	 * <f maxlen="5">drive</f>
	 * <f maxlen="9">status</f>
	 * <f maxlen="10">state</f>
	 * <f maxlen="6">volume</f>
	 * <f maxlen="9">type</f>
	 * <f maxlen="5">lock</f>
	 * <f maxlen="32">serial_num</f>
	 * <f maxlen="14">condition</f>
	 * </r>
	 */

	if ((ptr2 = strstr(ptr1, "<data>")) != NULL) {

		if (drive_list->list_size == 0) {
			mms_list_create(drive_list, sizeof (mms_drive_t),
			    offsetof(mms_drive_t, drive_link));
		}

		while ((ptr2 = strstr(ptr1, "<r>")) != NULL) {

			drive = calloc(1, sizeof (mms_drive_t));
			if (drive == NULL) {
				return (ENOMEM);
			}

			/* extract string from <f ....>..</f> */
			ptr2 += 3; /* skip past <r> */
			l = parse_f_int(ptr2, &drive->acs);
			ptr2 += l;
			l = parse_f_int(ptr2, &drive->lsm);
			ptr2 += l;
			l = parse_f_int(ptr2, &drive->panel);
			ptr2 += l;
			l = parse_f_int(ptr2, &drive->drive);
			ptr2 += l;
			/* properly convert flags and provide for volume */
			/* status */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;
			/* state */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;
			/* volume */
			l = parse_f(ptr2, drive->volid, sizeof (drive->volid));
			ptr2 += l;
			l = parse_f(ptr2, drive->type, sizeof (drive->type));
			ptr2 += l;
			/* lock */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;
			l = parse_f(ptr2, drive->serialnum,
			    sizeof (drive->serialnum));
			ptr2 += l;
			/* condition */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;

			mms_list_insert_tail(drive_list, drive);

			ptr2 += 4; /* advance to the start of the next drive */
			ptr1 = ptr2;
		}
	}
	return (0);
}


/*
 * parse_vol_resp() assumes the format of the data response, the
 * following information is expected in the volume data:
 * vol_id, acs, lsm, panel, row, column, pool, status, media, and type
 */
static int
parse_vol_resp(void *buf, mms_list_t *vol_list)
{

	ACS_DISPLAY_RESPONSE	*res;
	size_t			l;
	char			*ptr1, *ptr2;
	mms_acscart_t		*vol;
	char			junkbuf[1024];
	char			xml_buf[MAX_MESSAGE_SIZE + 1];
	int			len;

	if ((buf == NULL) || (vol_list == NULL)) {
		return (MMS_MGMT_NOARG);
	}

	res = (ACS_DISPLAY_RESPONSE *)buf;
	if (res->display_status != STATUS_SUCCESS) {
		return (MMS_MGMT_ERR_ACSLS_RSP);
	}

	len = res->display_xml_data.length;
	(void) strncpy(xml_buf, res->display_xml_data.xml_data,
	    len);
	xml_buf[len] = '\0';
	mms_trace(MMS_INFO, "Display VOL response len = %d :\n%s",
	    len, xml_buf);
	ptr1 = xml_buf;

	ptr2 = strstr(ptr1, "</data></display></response>");
	if (ptr2 != NULL) {
		*ptr2 = NULL;
	};
	if ((ptr2 = strstr(ptr1, "<data>")) != NULL) {

		/* only create the list if it's the first time through */
		if (vol_list->list_size == 0) {
			mms_list_create(vol_list, sizeof (mms_acscart_t),
			    offsetof(mms_acscart_t, next));
		}

		while ((ptr2 = strstr(ptr1, "<r>")) != NULL) {
			vol = calloc(1, sizeof (mms_acscart_t));
			if (vol == NULL) {
				return (ENOMEM);
			}
			/* extract string from <f ....>..</f> */
			ptr2 += 3; /* skip past <r> */

			l = parse_f(ptr2, vol->label, sizeof (vol->label));
			ptr2 += l;
			l = parse_f_int(ptr2, (uint32_t *)&vol->libacs);
			ptr2 += l;
			l = parse_f_int(ptr2, (uint32_t *)&vol->liblsm);
			ptr2 += l;
			/* drive */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;
			/* type - cleaning|data */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;
			l = parse_f(ptr2, vol->mtype, sizeof (vol->mtype));
			ptr2 += l;
			/* status */
			l = parse_f(ptr2, junkbuf, sizeof (junkbuf));
			ptr2 += l;
			l = parse_f_date(ptr2, &vol->access);
			ptr2 += l;

			mms_list_insert_tail(vol_list, vol);

			/* advance to the start of the next volume */
			ptr2 = strstr(ptr2, "</r>");
			if (ptr2 == NULL) {
				/* malformed response */
				break;
			}
			ptr1 = ptr2 + 4;
		}
	}
	return (0);
}


/*
 * parse_lsm_resp() parses the response data assuming a particular
 * format for the data. The following information is expected in the
 * response:- acs, lsm, status, state and serial number
 *
 */
static int
parse_lsm_resp(
	void	*buf,
	mms_list_t	*lsm_list)
{
	ACS_DISPLAY_RESPONSE	*res;
	size_t			l;
	char			*ptr1, *ptr2;
	mms_acslib_t		*lsm;
	char			status[1024];
	char			state[1024];
	char			xml_buf[MAX_MESSAGE_SIZE + 1];
	int			len;

	if ((buf == NULL) || (lsm_list == NULL)) {
		return (MMS_MGMT_NOARG);
	}

	res = (ACS_DISPLAY_RESPONSE *)buf;
	if (res->display_status != STATUS_SUCCESS) {
		return (MMS_MGMT_ERR_ACSLS_RSP);
	}

	len = res->display_xml_data.length;
	(void) strncpy(xml_buf, res->display_xml_data.xml_data,
	    len);
	xml_buf[len] = '\0';
	mms_trace(MMS_INFO, "Display LSM response len = %d :\n%s",
	    len, xml_buf);
	ptr1 = xml_buf;

	ptr2 = strstr(ptr1, "</data></display></response>");
	if (ptr2 != NULL) {
		*ptr2 = NULL;
	};

	if ((ptr2 = strstr(ptr1, "<data>")) != NULL) {
		if (lsm_list->list_size == 0) {
			mms_list_create(lsm_list, sizeof (mms_acslib_t),
			    offsetof(mms_acslib_t, lib_link));
		}

		while ((ptr2 = strstr(ptr1, "<r>")) != NULL) {

			lsm = calloc(1, sizeof (mms_acslib_t));
			if (lsm == NULL) {
				return (ENOMEM);
			}

			ptr2 += 3; /* skip past <r> */
			l = parse_f_int(ptr2, &lsm->acs);
			ptr2 += l;
			l = parse_f_int(ptr2, &lsm->lsm);
			ptr2 += l;
			/* parse status and state to flags */
			l = parse_f(ptr2, status, sizeof (status));
			ptr2 += l;
			l = parse_f(ptr2, state, sizeof (state));
			ptr2 += l;
			l = parse_f(ptr2, lsm->serialnum,
			    sizeof (lsm->serialnum));
			ptr2 += l;
			l = parse_f(ptr2, lsm->type, sizeof (lsm->type));
			ptr2 += l;

			mms_list_insert_tail(lsm_list, lsm);

			/* advance to the start of the next drive */
			ptr2 = strstr(ptr2, "</r>");
			if (ptr2 == NULL) {
				/* malformed response */
				break;
			}
			ptr1 = ptr2 + 4;
		}
	}
	return (0);
}

static int /* return number of characters parsed */
parse_f(char *f, char *s, size_t len) {

	size_t n;
	char *ptr;

	if (f == NULL || strlen(f) == 0) {
		return (0);
	}

	ptr = strstr(f, "</f>");
	if (ptr != NULL) {
		*ptr = '\0';
	}
	n = strlen(f);

	ptr = strchr(f, '>');
	if (ptr == NULL) {
		return (0);
	}

	ptr++;

	(void) strlcpy(s, ptr, len);

	return (n + 4);
}

/* parse just a single char */
static int
parse_f_int(char *f, uint32_t *i)
{
	char	*ptr;
	char	*ptr2;
	size_t	n;
	char	buf[4];
	int	j;

	if (!f || !i) {
		return (0);
	}

	ptr = strchr(f, '>');
	if (ptr == NULL) {
		return (0);
	}

	ptr++;

	for (j = 0; j < 4; j++, ptr++) {
		if (!isdigit(*ptr)) {
			break;
		}
		buf[j] = *ptr;
	}
	buf[j] = '\0';
	ptr2 = strchr(ptr, '>');
	if (ptr2 == NULL) {
		return (0);
	}
	n = (++ptr2 - f);

	*i = atoi(buf);

	return (n);
}

static int
parse_f_date(char *f, time_t *t)
{
	struct tm	tm;
	char		*ptr;
	size_t		n;

	if (!f || !t) {
		return (0);
	}

	ptr = strchr(f, '>');
	if (ptr == NULL) {
		return (0);
	}

	ptr++;

	ptr = strptime(ptr, "%Y-%m-%d %T", &tm);

	ptr = strstr(ptr, "</f>");
	if (ptr == NULL) {
		return (0);
	}
	ptr += 4;

	n = ptr - f;

	*t = mktime(&tm);
return (n);
}

/*
 * get volumes from an acs library, given the name of the acsls
 * hostname and port.
 *
 * in_vols is optional, allows the requester to ask for only
 * those volumes he/she is interested in.
 *
 */
int
get_acs_volumes(
	char *acshost,
	char *in_vols,
	mms_list_t *vol_list
)
{
	int		st;

	if ((acshost == NULL) || (vol_list == NULL)) {
		return (MMS_MGMT_NOARG);
	}

	/* check if the acsls host is accessible and start if it not */
	if (acs_start_ssi(acshost, NULL) != 0) {
		return (MMS_MGMT_ERR_EXEC_SSI);
	}

	st = acs_display_info(ACS_DISPLAY_VOL, in_vols, vol_list);
	if (st != 0) {
		return (st);
	}

	return (st);
}