/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"


#include <stdio.h>
#include <strings.h>
#include <limits.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <libintl.h>
#include <libvscan.h>


/* Property Names */
#define	VS_ADM_MAXSIZE		"max-size"
#define	VS_ADM_MAXSIZE_ACTION	"max-size-action"
#define	VS_ADM_TYPES		"types"

/* Scan Engine Property Names */
#define	VS_ADM_SE_ENABLE	"enable"
#define	VS_ADM_SE_HOST		"host"
#define	VS_ADM_SE_PORT		"port"
#define	VS_ADM_SE_MAXCONN	"max-connection"

/* Property Values */
#define	VS_ADM_ON		"on"
#define	VS_ADM_OFF		"off"
#define	VS_ADM_ALLOW		"allow"
#define	VS_ADM_DENY		"deny"


/*
 * Print buffer length: used for sizing buffers that are filled with
 * user-readable strings for property values. Define a number that
 * accounts for some pre-value information, and won't (likely)
 * wrap an 80-column display
 */
#define	VS_ADM_PRINT_BUF_LEN	4096

/* Program exit codes */
#define	VS_ADM_EXIT_SUCCESS	0
#define	VS_ADM_EXIT_ERROR	1
#define	VS_ADM_EXIT_USAGE	2


/*
 * vscanadm property definition. Maps the property ids to a
 * property name, and includes functions to convert to and from
 * input strings and native data.
 */
typedef struct vs_adm_property {
	const char *vap_name;
	uint64_t vap_id;
	int (*vap_parse)(const char *, void *);
	int (*vap_unparse)(const void *, char *, size_t);
} vs_adm_property_t;


/* usage/help information for subcommnds */
#define	VS_ADM_HELP_GET		("[-p property]...\n" \
	"\tdisplay vscan properties")
#define	VS_ADM_HELP_SET		("-p property=value [-p property=value]...\n" \
	"\tset values of vscan properties")
#define	VS_ADM_HELP_GET_ENG	("[-p property] [engine_id]\n" \
	"\tdisplay values of scan engine properties")
#define	VS_ADM_HELP_ADD_ENG	("[-p property=value]... engine_id\n" \
	"\tadd scan engine")
#define	VS_ADM_HELP_SET_ENG	("-p property=value [-p property=value]" \
	"... engine_id\n\tset values of scan engine properties")
#define	VS_ADM_HELP_REM_ENG	("engine_id\n" \
	"\tremove scan engine")
#define	VS_ADM_HELP_SHOW	("\n\tdisplay the values of all vscan " \
	"service and scan engine properties")
#define	VS_ADM_HELP_STATS	("[-z]\n\tdisplay vscan service statistics")
#define	VS_ADM_HELP_IMPORT	("-p property filename\n" \
	"\timport property from file")
#define	VS_ADM_HELP_EXPORT	("-p property filename\n" \
	"\texport property to file")
#define	VS_ADM_HELP_VALIDATE	("-p property filename\n" \
	"\tvalidate property in file")


/*
 * vscanadm command structure. Encapsulates the vscanadm
 * subcommand name, pointer to the subcommand implementation
 * function, and a help id to get usage/help information.
 */
typedef struct vs_adm_cmd {
	int (*vac_func)(int, char *[]);
	const char *vac_name;
	char *vac_helpid;
}
vs_adm_cmd_t;


/* Subcommand implementation functions */
static int vs_adm_set(int, char **);
static int vs_adm_get(int, char **);
static int vs_adm_set_engine(int, char **);
static int vs_adm_get_engine(int, char **);
static int vs_adm_rem_engine(int, char **);
static int vs_adm_show(int, char **);
static int vs_adm_stats(int, char **);
static int vs_adm_import(int, char **);
static int vs_adm_export(int, char **);
static int vs_adm_validate(int, char **);


/*
 * Parse routines to transform libvscan API data into user-readable strings
 */
static int vs_adm_parse_maxsize(const char *, void *);
static int vs_adm_parse_maxsize_action(const char *, void *);
static int vs_adm_parse_types(const char *, void *);
static int vs_adm_parse_enable(const char *, void *);
static int vs_adm_parse_host(const char *, void *);
static int vs_adm_parse_port(const char *, void *);
static int vs_adm_parse_maxconn(const char *, void *);


/*
 * Unparse routines to transform strings from the user input into
 * API native data.
 *
 * While some value validation is performed in the course of unparsing
 * string data, complete value validation is left to libvscan.
 * Values that are in unacceptable form, out of range, or otherwise
 * violate rules for a given property will be rejected
 */
static int vs_adm_unparse_maxsize(const void *, char *, size_t);
static int vs_adm_unparse_maxsize_action(const void *, char *, size_t);
static int vs_adm_unparse_types(const void *, char *, size_t);
static int vs_adm_unparse_enable(const void *, char *, size_t);
static int vs_adm_unparse_host(const void *, char *, size_t);
static int vs_adm_unparse_port(const void *, char *, size_t);
static int vs_adm_unparse_maxconn(const void *, char *, size_t);


/*
 * The properties table includes a vscanadm property entry, specifying
 * the property nane, property id, parse amd inparse methods,
 * for each vscanadm property.
 */
static const vs_adm_property_t vs_adm_props_all[] = {
	{ VS_ADM_MAXSIZE, VS_PROPID_MAXSIZE,
		vs_adm_parse_maxsize, vs_adm_unparse_maxsize },
	{ VS_ADM_MAXSIZE_ACTION, VS_PROPID_MAXSIZE_ACTION,
		vs_adm_parse_maxsize_action, vs_adm_unparse_maxsize_action },
	{ VS_ADM_TYPES, VS_PROPID_TYPES,
		vs_adm_parse_types, vs_adm_unparse_types },
	{ VS_ADM_SE_ENABLE, VS_PROPID_SE_ENABLE,
		vs_adm_parse_enable, vs_adm_unparse_enable },
	{ VS_ADM_SE_HOST, VS_PROPID_SE_HOST,
		vs_adm_parse_host, vs_adm_unparse_host },
	{ VS_ADM_SE_PORT, VS_PROPID_SE_PORT,
		vs_adm_parse_port, vs_adm_unparse_port },
	{ VS_ADM_SE_MAXCONN, VS_PROPID_SE_MAXCONN,
		vs_adm_parse_maxconn, vs_adm_unparse_maxconn },
	{ NULL, 0, NULL, NULL }
};


/*
 * The subcommand table.  Used to find the subcommand specified
 * by the user and dispatch the processing for the subcommand.
 * Also used to display usage information for each subcommand.
 */
static const vs_adm_cmd_t vs_adm_cmds[] =
{
	{ vs_adm_get, "get", VS_ADM_HELP_GET },
	{ vs_adm_set, "set", VS_ADM_HELP_SET },
	{ vs_adm_get_engine, "get-engine", VS_ADM_HELP_GET_ENG },
	{ vs_adm_set_engine, "set-engine", VS_ADM_HELP_SET_ENG },
	{ vs_adm_set_engine, "add-engine", VS_ADM_HELP_ADD_ENG },
	{ vs_adm_rem_engine, "remove-engine", VS_ADM_HELP_REM_ENG },
	{ vs_adm_import, "import", VS_ADM_HELP_IMPORT },
	{ vs_adm_export, "export", VS_ADM_HELP_EXPORT },
	{ vs_adm_validate, "validate", VS_ADM_HELP_VALIDATE },
	{ vs_adm_show, "show", VS_ADM_HELP_SHOW },
	{ vs_adm_stats, "stats", VS_ADM_HELP_STATS },
	{ NULL, NULL, NULL }
};


static const char *vs_adm_cmd;
static const char *vs_adm_subcmd;

static int vs_adm_usage(FILE *);
static int vs_adm_props_from_input(int, char **, vs_props_t *, uint64_t *);
static void vs_adm_output_getcmd(uint64_t, const void *);
static void vs_adm_output_stats(vs_stats_t *);
static const vs_adm_property_t *vs_adm_prop_by_name(const char *);
static const vs_adm_property_t *vs_adm_prop_by_id(const uint64_t);
static int vs_adm_parse(const vs_adm_property_t *, const char *, void *);
static void vs_adm_unparse(const vs_adm_property_t *, const void *,
    char *, size_t);

static int vs_adm_file_read(char *, char *, int);
static int vs_adm_file_write(char *, char *);
static int vs_adm_file_usage(int argc, char **argv);

/*
 * main
 */
int
main(int argc, char **argv)
{
	const vs_adm_cmd_t *cp;
	const char *p;
	int i, err;

	/* executable and subcommand names */
	if ((p = strrchr(argv[0], '/')) == NULL)
		vs_adm_cmd = argv[0];
	else
		vs_adm_cmd = p + 1;

	vs_adm_subcmd = argv[1];

	/* require at least command and sub-command */
	if (argc < 2)
		return (vs_adm_usage(stdout));

	/* Check for the "-?" help switch */
	for (i = 1; i < argc; i++) {
		if (strcmp(argv[i], "-?") == 0)
			return (vs_adm_usage(stdout));
	}

	/* Locate the specified subcommand */
	for (cp = vs_adm_cmds; cp->vac_name != NULL; cp++) {
		if (strcmp(cp->vac_name, vs_adm_subcmd) == 0)
			break;
	}

	if (cp->vac_name == NULL) {
		(void) fprintf(stderr, "%s: %s -- %s\n",
		    gettext("invalid subcommand"),
		    vs_adm_cmd, vs_adm_subcmd);
		return (vs_adm_usage(stderr));
	}

	/* invoke sub-command handler */
	err = cp->vac_func(argc, argv);

	return (err == VS_ADM_EXIT_USAGE ? vs_adm_usage(stderr) : err);
}


/*
 * vs_adm_usage
 */
static int
vs_adm_usage(FILE *fp)
{
	const vs_adm_cmd_t *cp;

	for (cp = vs_adm_cmds; cp->vac_name != NULL; cp++) {
		(void) fprintf(fp, "%s %s", vs_adm_cmd, cp->vac_name);
		if (cp->vac_helpid != NULL)
			(void) fprintf(fp, " %s\n", cp->vac_helpid);
	}

	return (VS_ADM_EXIT_USAGE);
}


/*
 * vs_adm_get
 *
 * Gets and displays general vscan service configuration properties.
 */
static int
vs_adm_get(int argc, char **argv)
{
	uint64_t propids;
	int i, rc;
	vs_props_t vp;
	const vs_adm_property_t *vap;

	(void) memset(&vp, 0, sizeof (vp));

	if (argc <= 2) {
		propids = VS_PROPID_GEN_ALL;
	} else {
		propids = 0LL;
		for (i = 2; i < argc; i++) {
			/* the "-p" specifier is optional */
			if (strcmp(argv[i], "-p") == 0) {
				if (++i >= argc)
					return (VS_ADM_EXIT_USAGE);
			}

			if ((vap = vs_adm_prop_by_name(argv[i])) == NULL) {
				(void) fprintf(stderr, "%s '%s'\n",
				    gettext("invalid property"), argv[i]);
				return (VS_ADM_EXIT_ERROR);
			}

			propids |= vap->vap_id;
		}
	}

	rc = vs_props_get(&vp, propids);
	if (rc != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s\n", vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	vs_adm_output_getcmd(propids, &vp);

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_set
 *
 * Sets values for general vscan service configuration properties
 *
 * Calls a common function used by the set, add, and remove
 * subcommands to modify general property values.
 */
static int
vs_adm_set(int argc, char **argv)
{
	vs_props_t vp;
	uint64_t propids;
	int rc;

	if (argc < 3)
		return (VS_ADM_EXIT_USAGE);

	rc = vs_adm_props_from_input(argc, argv, &vp, &propids);
	if (rc != VS_ADM_EXIT_SUCCESS)
		return (rc);

	rc = vs_props_set(&vp, propids);
	if (rc != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s\n", vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_get_engine
 *
 * Gets and displays scan engine configuration properties for
 * one or more scan engines.
 */
static int
vs_adm_get_engine(int argc, char **argv)
{
	int i, rc;
	uint64_t propids;
	char *engid = NULL;
	const vs_adm_property_t *vap;
	vs_props_all_t va;

	propids = 0LL;
	for (i = 2; i < argc; i++) {
		/* if not preceded by -p, must be engine id and must be last */
		if (strcmp(argv[i], "-p") != 0) {
			if (i != (argc - 1))
				return (VS_ADM_EXIT_USAGE);

			engid = argv[i];
			if (strlen(engid) > VS_SE_NAME_LEN) {
				(void) fprintf(stderr, "%s\n",
				    gettext("invalid scan engine"));
				return (VS_ADM_EXIT_ERROR);
			}
		} else {
			/* property should follow the -p */
			if (++i >= argc)
				return (VS_ADM_EXIT_USAGE);

			if ((vap = vs_adm_prop_by_name(argv[i])) == NULL) {
				(void) fprintf(stderr, "%s '%s'\n",
				    gettext("invalid property"), argv[i]);
				return (VS_ADM_EXIT_ERROR);
			}

			propids |= vap->vap_id;
		}
	}

	if (propids == 0LL)
		propids = VS_PROPID_SE_ALL;

	/* get properties for specified engine */
	if (engid) {
		rc = vs_props_se_get(engid, &va.va_se[0], propids);
		if (rc != VS_ERR_NONE) {
			(void) fprintf(stderr, "%s\n", vs_strerror(rc));
			return (VS_ADM_EXIT_ERROR);
		}
		vs_adm_output_getcmd(propids, &va.va_se[0]);
		return (VS_ADM_EXIT_SUCCESS);
	}

	/* get properties for all engines */
	if ((rc = vs_props_get_all(&va)) != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s\n", vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	for (i = 0; i < VS_SE_MAX; i++) {
		if (*(va.va_se[i].vep_engid) == 0)
			break;
		vs_adm_output_getcmd(propids, &va.va_se[i]);
	}
	if (i == 0) {
		(void) fprintf(stdout, "%s\n",
		    gettext("no scan engines configured"));
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_set_engine
 *
 * Sets one or more scan engine configuration properties for a
 * single scan engine.
 */
static int
vs_adm_set_engine(int argc, char **argv)
{
	const vs_adm_property_t *vap;
	vs_props_se_t sep;
	char *val;
	uint64_t propids;
	int i, rc;
	char *engid;
	int add = (strcmp(vs_adm_subcmd, "add-engine") == 0) ? 1 : 0;


	if ((argc < 3) || ((!add) && (argc < 4)))
		return (VS_ADM_EXIT_USAGE);

	/* Get the engine id */
	engid = argv[argc - 1];
	if (strchr(engid, '=') || strcmp(argv[argc - 2], "-p") == 0) {
		return (VS_ADM_EXIT_USAGE);
	}

	if (strlen(engid) > VS_SE_NAME_LEN) {
		(void) fprintf(stderr, "%s\n",
		    gettext("invalid scan engine"));
		return (VS_ADM_EXIT_ERROR);
	}

	propids = 0LL;

	for (i = 2; i < (argc - 1); i++) {
		/* The "-p" is optional */
		if (strcmp(argv[i], "-p") == 0) {
			if (++i >= argc)
				return (VS_ADM_EXIT_USAGE);
		}

		if ((val = strchr(argv[i], '=')) == NULL)
			return (VS_ADM_EXIT_USAGE);

		*val = 0;
		val++;

		/* Find the SE property pointer from the SE property name */
		if ((vap = vs_adm_prop_by_name(argv[i])) == NULL) {
			(void) fprintf(stderr, "%s '%s'\n",
			    gettext("invalid property"), argv[i]);
			return (VS_ADM_EXIT_ERROR);
		}

		propids |= vap->vap_id;

		if ((vs_adm_parse(vap, val, &sep)) != 0) {
			(void) fprintf(stderr, "%s '%s'\n",
			    gettext("invalid property value"), val);
			return (VS_ADM_EXIT_ERROR);
		}
	}

	if (add)
		rc = vs_props_se_create(engid, &sep, propids);
	else
		rc = vs_props_se_set(engid, &sep, propids);

	if (rc != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s\n", vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_rem_engine
 */
/* ARGSUSED */
static int
vs_adm_rem_engine(int argc, char **argv)
{
	int rc;
	char *engid;

	if (argc != 3)
		return (VS_ADM_EXIT_USAGE);

	engid = argv[2];

	if (strlen(engid) > VS_SE_NAME_LEN) {
		(void) fprintf(stderr, "%s\n",
		    gettext("invalid scan engine"));
		return (VS_ADM_EXIT_ERROR);
	}

	if ((rc = vs_props_se_delete(engid)) != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s\n", vs_strerror(rc));
		return (rc);
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_import
 */
static int
vs_adm_import(int argc, char **argv)
{
	int rc;
	vs_props_t vp;
	uint64_t propids;
	char *filename;

	if ((rc = vs_adm_file_usage(argc, argv)) != VS_ADM_EXIT_SUCCESS)
		return (rc);

	filename = argv[argc - 1];
	rc = vs_adm_file_read(filename, vp.vp_types, sizeof (vp.vp_types));
	if (rc != VS_ADM_EXIT_SUCCESS)
		return (rc);

	propids = VS_PROPID_TYPES;
	rc = vs_props_set(&vp, propids);
	if (rc != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s\n", vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_validate
 */
static int
vs_adm_validate(int argc, char **argv)
{
	int rc;
	vs_props_t vp;
	char *filename;

	if ((rc = vs_adm_file_usage(argc, argv)) != VS_ADM_EXIT_SUCCESS)
		return (rc);

	filename = argv[argc - 1];
	rc = vs_adm_file_read(filename, vp.vp_types, sizeof (vp.vp_types));
	if (rc != VS_ADM_EXIT_SUCCESS)
		return (rc);

	if (vs_props_validate(&vp, VS_PROPID_TYPES) != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s: %s\n", filename, vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	(void) fprintf(stdout, "%s: valid\n", filename);
	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_export
 */
static int
vs_adm_export(int argc, char **argv)
{
	int rc;
	vs_props_t vp;
	uint64_t propids;
	char *filename;

	if ((rc = vs_adm_file_usage(argc, argv)) != VS_ADM_EXIT_SUCCESS)
		return (rc);

	filename = argv[argc - 1];
	(void) memset(&vp, 0, sizeof (vs_props_t));
	propids = VS_PROPID_TYPES;
	if ((rc = vs_props_get(&vp, propids)) != VS_ERR_NONE) {
		(void) fprintf(stderr, "%s: %s\n", filename, vs_strerror(rc));
		return (VS_ADM_EXIT_ERROR);
	}

	rc = vs_adm_file_write(filename, vp.vp_types);
	if (rc != VS_ADM_EXIT_SUCCESS)
		return (rc);

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_file_usage
 *
 * import, export and validate - VS_PROPID_TYPES only
 */
static int
vs_adm_file_usage(int argc, char **argv)
{
	const vs_adm_property_t *vap;
	char *prop;

	if (argc < 4)
		return (VS_ADM_EXIT_USAGE);

	/* -p optional */
	if (strcmp(argv[2], "-p") == 0) {
		if (argc != 5)
			return (VS_ADM_EXIT_USAGE);
	} else if (argc != 4)
		return (VS_ADM_EXIT_USAGE);

	/* only VS_PROPID_TYPES supported */
	prop = argv[argc - 2];
	vap = vs_adm_prop_by_name(prop);
	if ((vap == NULL) || (vap->vap_id != VS_PROPID_TYPES)) {
		(void) fprintf(stderr, "%s '%s'\n",
		    gettext("invalid property"), prop);
		return (VS_ADM_EXIT_USAGE);
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_file_read
 */
static int
vs_adm_file_read(char *filename, char *buf, int len)
{
	FILE *fp;

	if ((fp = fopen(filename, "r")) == NULL) {
		(void) fprintf(stderr, "%s: %s\n", filename,
		    vs_strerror(VS_ERR_SYS));
		return (VS_ADM_EXIT_ERROR);
	}

	(void) memset(buf, 0, len);
	if (fgets(buf, len, fp) == NULL) {
		(void) fprintf(stderr, "%s: %s\n", filename,
		    gettext("invalid property value"));
		(void) fclose(fp);
		return (VS_ADM_EXIT_ERROR);
	}

	(void) fclose(fp);

	/* remove newline */
	if (buf[strlen(buf) - 1] == '\n')
		buf[strlen(buf) - 1] = '\0';

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_file_write
 */
static int
vs_adm_file_write(char *filename, char *buf)
{
	FILE *fp;
	int bytes;

	if ((fp = fopen(filename, "w")) == NULL) {
		(void) fprintf(stderr, "%s: %s\n", filename,
		    vs_strerror(VS_ERR_SYS));
		return (VS_ADM_EXIT_ERROR);
	}

	bytes = fprintf(fp, "%s\n", buf);
	if ((bytes < 0) || (bytes != strlen(buf) + 1)) {
		(void) fprintf(stderr, "%s: %s\n", filename,
		    vs_strerror(VS_ERR_SYS));
		(void) fclose(fp);
		return (VS_ADM_EXIT_ERROR);
	}

	(void) fclose(fp);
	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_show
 *
 * Gets and displays all general properties and all scan engine
 * properties.
 */
/* ARGSUSED */
static int
vs_adm_show(int argc, char **argv)
{
	if (argc > 2)
		return (VS_ADM_EXIT_USAGE);

	(void) vs_adm_get(argc, argv);
	(void) vs_adm_get_engine(argc, argv);

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_stats
 *
 * Gets and displays vscan service statistics.
 */
/* ARGSUSED */
static int
vs_adm_stats(int argc, char **argv)
{
	int rc;
	vs_stats_t stats;

	/* get statistics */
	if (argc == 2) {
		if ((rc = vs_statistics(&stats)) == VS_ERR_NONE) {
			vs_adm_output_stats(&stats);
			return (VS_ADM_EXIT_SUCCESS);
		} else {
			(void) fprintf(stdout, "%s\n", vs_strerror(rc));
			return (VS_ADM_EXIT_ERROR);
		}
	}

	/* reset statistics */
	if (argc == 3 && strcmp(argv[2], "-z") == 0) {
		if ((rc = vs_statistics_reset()) == VS_ERR_NONE) {
			return (VS_ADM_EXIT_SUCCESS);
		} else {
			(void) fprintf(stdout, "%s\n", vs_strerror(rc));
			return (VS_ADM_EXIT_ERROR);
		}
	}

	/* usage error */
	return (vs_adm_usage(stdout));
}


/*
 * vs_adm_output_stats
 */
static void
vs_adm_output_stats(vs_stats_t *stats)
{
	int i;
	char *engid;

	if (stats == NULL)
		return;

	(void) fprintf(stdout, "scanned=%lld\n", stats->vss_scanned);
	(void) fprintf(stdout, "infected=%lld\n", stats->vss_infected);
	if (stats->vss_cleaned > 0)
		(void) printf("cleaned=%lld\n", stats->vss_cleaned);
	(void) fprintf(stdout, "failed=%lld\n", stats->vss_failed);

	for (i = 0; i < VS_SE_MAX; i++) {
		engid = stats->vss_eng[i].vss_engid;
		if (*engid == 0)
			break;
		(void) fprintf(stdout, "%s:errors=%lld\n", engid,
		    stats->vss_eng[i].vss_errors);
	}
}


/*
 * vs_adm_props_from_input
 */
static int
vs_adm_props_from_input(int argc, char **argv, vs_props_t *vsprops,
    uint64_t *propids)
{
	const vs_adm_property_t *vap;
	char *val;
	int i;

	(void) memset(vsprops, 0, sizeof (vs_props_t));

	*propids = 0LL;
	for (i = 2; i < argc; i++) {
		/* The "-p" is optional */
		if (strcmp(argv[i], "-p") == 0) {
			if (++i >= argc)
				return (VS_ADM_EXIT_USAGE);
		}

		if ((val = strchr(argv[i], '=')) == NULL)
			return (VS_ADM_EXIT_USAGE);

		/* Find the vscanadm property pointer from the property name */
		*val = '\0';
		val++;
		if ((vap = vs_adm_prop_by_name(argv[i])) == NULL) {
			(void) fprintf(stderr, "%s '%s'\n",
			    gettext("invalid property"), argv[i]);
			return (VS_ADM_EXIT_ERROR);
		}

		/* Add in the property id and parse the property value */
		*propids |= vap->vap_id;
		if ((vs_adm_parse(vap, val, vsprops)) != 0) {
			(void) fprintf(stderr, "%s '%s'\n",
			    gettext("invalid property value"), val);
			return (VS_ADM_EXIT_ERROR);
		}
	}

	return (VS_ADM_EXIT_SUCCESS);
}


/*
 * vs_adm_output_getcmd
 *
 * Prints the results of a get command; both the get for general
 * configuration properties as well as the get for an engine
 * properties.
 *
 */
static void
vs_adm_output_getcmd(uint64_t propids, const void *props)
{
	char value[VS_ADM_PRINT_BUF_LEN];
	uint64_t propid;
	const vs_adm_property_t *vap;
	char *label = NULL;

	if (VS_PROPID_IS_SE(propids))
		label = ((vs_props_se_t *)props)->vep_engid;

	/*
	 * Unparse values from the property structure into readable strings
	 * and print them.
	 */
	for (propid = 1LL; propid <= VS_PROPID_MAX; propid <<= 1) {
		if ((propids & propid) == 0)
			continue;

		if ((vap = vs_adm_prop_by_id(propid)) == NULL)
			continue;

		*value = '\0';
		vs_adm_unparse(vap, props, value, sizeof (value));

		if (label)
			(void) fprintf(stdout, "%s:", label);
		(void) fprintf(stdout, "%s=%s\n", vap->vap_name, value);
	}

	(void) fprintf(stdout, "\n");
}


/*
 * vs_adm_prop_by_name
 *
 * Finds and returns a pointer to a vscan property structure from the
 * property table by property name.
 */
static const vs_adm_property_t *
vs_adm_prop_by_name(const char *propname)
{
	const vs_adm_property_t *p;

	for (p = vs_adm_props_all; p->vap_name != NULL; p++) {
		if (strcmp(propname, p->vap_name) == 0)
			return (p);
	}

	return (NULL);
}


/*
 * vs_adm_prop_by_id
 *
 * Finds and returns a pointer to a vscan property structure from the
 * property table by property name.
 */
static const vs_adm_property_t *
vs_adm_prop_by_id(const uint64_t propid)
{
	const vs_adm_property_t *p;

	for (p = vs_adm_props_all; p->vap_id != 0; p++) {
		if (propid == p->vap_id)
			return (p);
	}

	return (NULL);
}


/*
 * vs_adm_parse
 *
 * Entry point for parsing the user input strings into a data structure
 * used for setting values. Dispatches the actual parsing to the parse
 * routine for the specified vscanadm property.
 *
 * This function is used to dispatch parsing for values supplied by the
 * user for all subcommands; both the general configuration as well as
 * scan engine configuration. The structure pointer is therefore typed
 * as a void pointer, and cast appropriately in the parse routine for
 * the vscanadm property.
 */
static int
vs_adm_parse(const vs_adm_property_t *vap, const char *valvap_name,
	void *vp)
{
	return ((vap->vap_parse)(valvap_name, vp));
}


/*
 * vs_adm_parse_maxsize
 *
 * Parses a user-supplied string into a maxsize (decimal) value for
 * the general vscan configuration properties.
 */
static int
vs_adm_parse_maxsize(const char *valstr, void *vp)
{
	vs_props_t *svcp = vp;

	uint64_t maxsize;
	char *end;

	errno = 0;
	maxsize = strtoll(valstr, &end, 10);
	if (errno != 0)
		return (-1);
	(void) snprintf(svcp->vp_maxsize, sizeof (svcp->vp_maxsize),
	    "%llu%s", maxsize, end);

	return (0);
}


/*
 * vs_adm_parse_maxsize_action
 *
 * Parses a user-supplied string into a maxsize action value for the
 * general vscan configuration properties.
 *
 * Returns: 0 success
 *         -1 failure
 */
static int
vs_adm_parse_maxsize_action(const char *valstr, void *vp)
{
	vs_props_t *svcp = vp;

	if (strcmp(valstr, VS_ADM_ALLOW) == 0) {
		svcp->vp_maxsize_action = B_TRUE;
		return (0);
	}

	if (strcmp(valstr, VS_ADM_DENY) == 0) {
		svcp->vp_maxsize_action = B_FALSE;
		return (0);
	}

	return (-1);
}


/*
 * vs_adm_parse_types
 *
 * Returns: 0 success
 *         -1 on failure.
 */
static int
vs_adm_parse_types(const char *valstr, void *vp)
{
	vs_props_t *svcp = vp;

	if (strlen(valstr) >= sizeof (svcp->vp_types))
		return (-1);

	if (strlcpy(svcp->vp_types, valstr, sizeof (svcp->vp_types))
	    >= sizeof (svcp->vp_types))
		return (-1);

	return (0);
}


/*
 * vs_adm_parse_enable
 *
 * Parses a user-supplied string into an enable value for the
 * properties of a scan engine.
 *
 * Returns: 0 success
 *         -1 on failure.
 */
static int
vs_adm_parse_enable(const char *valstr, void *vp)
{
	vs_props_se_t *sep = vp;

	if (strcmp(valstr, VS_ADM_ON) == 0) {
		sep->vep_enable = B_TRUE;
		return (0);
	}

	if (strcmp(valstr, VS_ADM_OFF) == 0) {
		sep->vep_enable = B_FALSE;
		return (0);
	}

	return (-1);
}


/*
 * vs_adm_parse_host
 *
 * Parses a user-supplied string into an ip address value for the
 * properties of a scan engine.
 */
static int
vs_adm_parse_host(const char *valstr, void *vp)
{
	vs_props_se_t *sep = vp;

	if (strlen(valstr) >= sizeof (sep->vep_host))
		return (-1);

	if (strlcpy(sep->vep_host, valstr, sizeof (sep->vep_host)) >=
	    sizeof (sep->vep_host))
		return (-1);

	return (0);
}


/*
 * vs_adm_parse_port
 *
 * Parses a user-supplied string into a port value for the properties of
 * a scan engine. The port is an unsigned short int, but the conversion
 * must be done on a word-sized int. Casting the converted int into the
 * port member of the property structure can result in a valid but
 * unintended value, so the range is checked first for validity.
 *
 * Returns: 0 success
 *         -1 on failure.
 */
static int
vs_adm_parse_port(const char *valstr, void *vp)
{
	vs_props_se_t *sep = vp;
	unsigned long port;
	char *end;

	end = 0;
	port = strtoul(valstr, &end, 0);
	if (port > UINT16_MAX || (end < (valstr + strlen(valstr))))
		return (-1);

	sep->vep_port = port;

	return (0);
}


/*
 * vs_adm_parse_maxconn
 *
 * Parses a user-supplied string into a max connections (decimal) value
 * for the properties of a scan engine.
 *
 * Returns: 0 success
 *         -1 on failure.
 */
static int
vs_adm_parse_maxconn(const char *valstr, void *vp)
{
	vs_props_se_t *sep = vp;
	char *end;

	sep->vep_maxconn = strtoll(valstr, &end, 10);
	if (end < valstr + strlen(valstr))
		return (-1);

	return (0);
}


/*
 * vs_adm_unparse
 *
 * Entry point for unparsing native data into a readable string
 * used for display to the user. Dispatches the actual unparsing to
 * the unparse routine for the specified vscanadm property.
 *
 * This function is used to dispatch unparsing for all subcommands.
 * The structure pointer is therefore typed as a void pointer, and
 * cast appropriately in the unparse routine for the vscanadm property.
 */
static void
vs_adm_unparse(const vs_adm_property_t *vap, const void *vp,
	char *buf, size_t len)
{
	if ((vap->vap_unparse)(vp, buf, len) != 0)
		(void) snprintf(buf, len, gettext(" (error) "));
}


/*
 *  vs_adm_unparse_maxsize
 *
 * Unparses a max fsize value in native data form into a
 * user-readable string.
 */
/* ARGSUSED */
static int
vs_adm_unparse_maxsize(const void *vp, char *buf, size_t len)
{
	const vs_props_t *svcp = vp;

	(void) snprintf(buf, len, "%s", svcp->vp_maxsize);

	return (0);
}


/*
 * vs_adm_unparse_maxsize_action
 *
 * Unparses a max fsize action value in native data form into a
 * user-readable string.
 */
/* ARGSUSED */
static int
vs_adm_unparse_maxsize_action(const void *vp, char *buf, size_t len)
{
	const vs_props_t *svcp = vp;

	(void) snprintf(buf, len, "%s",
	    svcp->vp_maxsize_action ?  VS_ADM_ALLOW : VS_ADM_DENY);

	return (0);
}


/*
 * vs_adm_unparse_types
 *
 * Returns: 0 success
 *         -1 on failure.
 */
static int
vs_adm_unparse_types(const void *vp, char *buf, size_t len)
{
	const vs_props_t *svcp = vp;

	(void) strlcpy(buf, svcp->vp_types, len);

	return (0);
}


/*
 * vs_adm_unparse_enable
 *
 * Unparses the enable value for a scan engine in native data
 * form into a user-readable string.
 */
/* ARGSUSED */
static int
vs_adm_unparse_enable(const void *vp, char *buf, size_t len)
{
	const vs_props_se_t *sep = vp;

	(void) snprintf(buf, len, "%s",
	    sep->vep_enable ?  VS_ADM_ON : VS_ADM_OFF);

	return (0);
}


/*
 * vs_adm_unparse_host
 *
 * Unparses an ip address for a scan engine in native data
 * form into a user-readable string.
 *
 * Returns: 0 success
 *         -1 on failure.
 */
/* ARGSUSED */
static int
vs_adm_unparse_host(const void *vp, char *buf, size_t len)
{
	const vs_props_se_t *sep = vp;

	(void) strlcpy(buf, sep->vep_host, len);

	return (0);
}


/*
 * vs_adm_unparse_port
 *
 * Unparses a port value for a scan engine in native data
 * form into a user-readable string.
 */
/* ARGSUSED */
static int
vs_adm_unparse_port(const void *vp, char *buf, size_t len)
{
	const vs_props_se_t *sep = vp;

	(void) snprintf(buf, len, "%hu", sep->vep_port);

	return (0);
}


/*
 * vs_adm_unparse_maxconn
 *
 * Unparses a max connecctions for a scan engine in native data
 * form into a user-readable string.
 *
 */
/* ARGSUSED */
static int
vs_adm_unparse_maxconn(const void *vp, char *buf, size_t len)
{
	const vs_props_se_t *sep = vp;

	(void) snprintf(buf, len, "%lld", sep->vep_maxconn);

	return (0);
}