path: root/usr/src/cmd/srptadm/srptadm.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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <strings.h>
#include <ctype.h>
#include <libnvpair.h>
#include <libintl.h>
#include <libgen.h>
#include <pwd.h>
#include <auth_attr.h>
#include <secdb.h>
#include <libscf.h>
#include <limits.h>
#include <locale.h>
#include <dirent.h>

#include <libstmf.h>
#include <libsrpt.h>

/* SMF service info */
#define	STMF_SVC	"svc:/system/stmf:default"

#define	STMF_STALE(ret) {\
	if (ret == STMF_ERROR_PROV_DATA_STALE) {\
		(void) fprintf(stderr, "%s\n",\
		    gettext("Configuration changed during processing.  "\
		    "Check the configuration, then retry this command "\
		    "if appropriate."));\
	}\
}

#define	SRPTADM_CHKAUTH(sec) {\
	if (!chkauthattr(sec, srptadm_uname)) {\
		(void) fprintf(stderr,\
		    gettext("Error, operation requires authorization %s"),\
		    sec);\
		(void) fprintf(stderr, "\n");\
		return (1);\
	}\
}

#define	PROPS_FORMAT	"    %-20s: "

static struct option srptadm_long[] = {
	{"enable",		no_argument,		NULL, 'e'},
	{"disable",		no_argument,		NULL, 'd'},
	{"reset",		no_argument,		NULL, 'r'},
	{"help",		no_argument,		NULL, '?'},
	{"help",		no_argument,		NULL, 'h'},
	{NULL, 0, NULL, 0}
};

static char m_def[] = "srptadm modify-defaults [-e] [-d]";
static char l_def[] = "srptadm list-defaults";
static char s_tgt[] = "srptadm modify-target [-e] [-d] [-r] <hca>";
static char l_tgt[] = "srptadm list-target [<hca>]";

/* keep the order of this enum in the same order as the 'subcmds' struct */
typedef enum {
	MODIFY_DEFAULT,
	LIST_DEFAULT,
	MODIFY_TARGET,
	LIST_TARGET,
	NULL_SUBCMD	/* must always be last! */
} srptadm_sub_t;

typedef struct {
	char		*name;
	char		*shortopts;
	char		*usemsg;
} srptadm_subcmds_t;

static srptadm_subcmds_t	subcmds[] = {
	{"modify-defaults", "edh?", m_def},
	{"list-defaults", "h?", l_def},
	{"modify-target", "edrh?", s_tgt},
	{"list-target", "h?", l_tgt},
	{NULL, ":h?", NULL},
};

/* used for checking if user is authorized */
static char *srptadm_uname = NULL;

/* prototypes */
static int get_local_hcas(char **hcaArray, int count);
static int print_target_props(char *hca);
static int list_target(char *hca);
static int disable_target(char *hca);
static int reset_target(char *hca);
static int list_defaults(void);
static int enable_target(char *hca);
static int set_default_state(boolean_t enabled);

int
main(int argc, char *argv[])
{
	int		ret = 0;
	int		idx = NULL_SUBCMD;
	char		c;
	int		newargc = argc;
	char		**newargv = NULL;
	char		*objp;
	int		srptind = 0;
	struct passwd	*pwd = NULL;
	char		*smfstate = NULL;
	boolean_t	reset = B_FALSE;
	int		dflag = 0;
	int		eflag = 0;

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

	if (argc < 2) {
		ret = 1;
		goto usage_error;
	}

	for (idx = 0; subcmds[idx].name != NULL; idx++) {
		if (strcmp(argv[1], subcmds[idx].name) == 0) {
			break;
		}
	}

	/* get the caller's user name for subsequent chkauthattr() calls */
	pwd = getpwuid(getuid());
	if (pwd == NULL) {
		(void) fprintf(stderr, "%s\n",
		    gettext("Could not determine callers user name."));
		return (1);
	}

	srptadm_uname = strdup(pwd->pw_name);

	/* increment past command & subcommand */
	newargc--;
	newargv = &(argv[1]);

	while ((ret == 0) && (newargv)) {
		c = getopt_long(newargc, newargv, subcmds[idx].shortopts,
		    srptadm_long, &srptind);
		if (c == -1) {
			break;
		}

		switch (c) {
			case 0:
				/* flag set by getopt */
				break;
			case 'd':
				dflag++;
				break;
			case 'e':
				eflag++;
				break;
			case 'r':
				reset = B_TRUE;
				break;
			case '?':
				/*
				 * '?' is returned for both unrecognized
				 * options and if explicitly provided on
				 * the command line.  The latter should
				 * be handled the same as -h.
				 */
				if (strcmp(newargv[optind-1], "-?") != 0) {
					(void) fprintf(stderr,
					    gettext("Unrecognized option %s"),
					    newargv[optind-1]);
					(void) fprintf(stderr, "\n");
					ret = 1;
				}
				goto usage_error;
			case 'h':
				goto usage_error;
			case ':':
				(void) fprintf(stderr,
				    gettext("Option %s requires an operand."),
				    newargv[optind-1]);
				(void) fprintf(stderr, "\n");

				/* FALLTHROUGH */
			default:
				ret = 1;
				break;
		}
	}

	if (ret != 0) {
		goto usage_error;
	}

	/* after getopt() to allow handling of -h option */
	if ((srptadm_sub_t)idx == NULL_SUBCMD) {
		(void) fprintf(stderr, "%s\n",
		    gettext("Error, no subcommand specified"));
		ret = 1;
		goto usage_error;
	}

	newargc -= optind;
	if (newargc == 0) {
		newargv = NULL;
		objp = NULL;
	} else {
		newargv = &(newargv[optind]);
		objp = newargv[0];
	}

	if (objp == NULL) {
		switch ((srptadm_sub_t)idx) {
		case MODIFY_TARGET:
			/* These subcommands need operands */
			ret = 1;
			goto usage_error;
		default:
			break;
		}
	}

	if (newargc > 1) {
		switch ((srptadm_sub_t)idx) {
		case MODIFY_TARGET:
		case LIST_TARGET:
			/* These subcommands should have at most one operand */
			ret = 1;
			goto usage_error;

		default:
			break;
		}
	}


	/*
	 * Make sure STMF service is enabled before proceeding.
	 */
	smfstate = smf_get_state(STMF_SVC);
	if (!smfstate ||
	    (strcmp(smfstate, SCF_STATE_STRING_ONLINE) != 0)) {
		(void) fprintf(stderr, "%s\n",
		    gettext("The STMF service must be online "
		    "before running this command."));
		(void) fprintf(stderr,
		    gettext("Use 'svcadm enable -r %s'"), STMF_SVC);
		(void) fprintf(stderr, "\n");
		(void) fprintf(stderr, "%s\n",
		    gettext("to enable the service and its prerequisite "
		    "services and/or"));
		(void) fprintf(stderr,
		    gettext("'svcs -x %s' to determine why it is not online."),
		    STMF_SVC);
		(void) fprintf(stderr, "\n");

		return (1);
	}

	switch ((srptadm_sub_t)idx) {
		case MODIFY_DEFAULT:
			if (eflag) {
				ret = set_default_state(B_TRUE);
			} else if (dflag) {
				ret = set_default_state(B_FALSE);
			} else {
				ret = 1;
				goto usage_error;
			}
			break;
		case LIST_DEFAULT:
			ret = list_defaults();
			break;
		case MODIFY_TARGET:
			if (reset) {
				ret = reset_target(objp);
			} else if (eflag) {
				ret = enable_target(objp);
			} else if (dflag) {
				ret = disable_target(objp);
			} else {
				ret = 1;
				goto usage_error;
			}
			break;
		case LIST_TARGET:
			ret = list_target(objp);
			break;
		default:
			ret = 1;
			goto usage_error;
	}

	if (ret != 0) {
		(void) fprintf(stderr,
		    gettext("srptadm %s failed with error %d"),
		    subcmds[idx].name, ret);
		(void) fprintf(stderr, "\n");
	}
	return (ret);

usage_error:
	if (subcmds[idx].name) {
		(void) printf("%s\n", gettext(subcmds[idx].usemsg));
	} else {
		/* overall usage */
		(void) printf("%s\n\n", gettext("srptadm usage:"));
		for (idx = 0; subcmds[idx].name != NULL; idx++) {
			if (!subcmds[idx].usemsg) {
				continue;
			}
			(void) printf("\t%s\n", gettext(subcmds[idx].usemsg));
		}
	}

	return (ret);
}

static int
set_default_state(boolean_t enabled)
{
	int		ret;
	char		*sec = "solaris.smf.modify.stmf";

	SRPTADM_CHKAUTH(sec);

	ret = srpt_SetDefaultState(enabled);

	return (ret);
}

static int
enable_target(char *hca)
{
	int		ret;
	char		*sec = "solaris.smf.modify.stmf";

	SRPTADM_CHKAUTH(sec);

	ret = srpt_SetTargetState(hca, B_TRUE);

	return (ret);
}

static int
disable_target(char *hca)
{
	int		ret;
	char		*sec = "solaris.smf.modify.stmf";

	SRPTADM_CHKAUTH(sec);

	ret = srpt_SetTargetState(hca, B_FALSE);

	return (ret);
}

static int
reset_target(char *hca)
{
	int		ret;
	char		*sec = "solaris.smf.modify.stmf";

	SRPTADM_CHKAUTH(sec);

	ret = srpt_ResetTarget(hca);

	return (ret);
}

static int
list_defaults(void)
{
	int		ret;
	char		*sec = "solaris.smf.read.stmf";
	boolean_t	enabled;

	SRPTADM_CHKAUTH(sec);

	/* only state set as default for now */
	ret = srpt_GetDefaultState(&enabled);

	if (ret == 0) {
		(void) printf("%s:\n\n",
		    gettext("SRP Target Service Default Properties"));

		(void) printf("    %s:\t",
		    gettext("Target creation enabled by default"));

		if (enabled) {
			(void) printf("%s\n", gettext("true"));
		} else {
			(void) printf("%s\n", gettext("false"));
		}
	}

	return (ret);
}

static int
list_target(char *hca)
{
	int		ret;
	char		*sec = "solaris.smf.read.stmf";
	char		*hcaArr[1024];	/* way bigger than we'll ever see */
	int		i;

	SRPTADM_CHKAUTH(sec);

	if (hca != NULL) {
		ret = print_target_props(hca);
		return (ret);
	}

	/* get list of HCAs configured on this system, from /dev/cfg */
	(void) memset(&hcaArr, 0, 1024 * sizeof (char *));

	ret = get_local_hcas(hcaArr, sizeof (hcaArr));
	if (ret == ETOOMANYREFS) {
		(void) fprintf(stderr, "Internal error:  too many HCAs\n");
		goto done;
	} else if (ret != 0) {
		(void) fprintf(stderr, "Error getting list of HCAs: %d\n", ret);
		goto done;
	}

	for (i = 0; i < 1024; i++) {
		if (hcaArr[i] == NULL) {
			break;
		}
		ret = print_target_props(hcaArr[i]);
	}

done:
	for (i = 0; i < 1024; i++) {
		if (hcaArr[i] == NULL) {
			break;
		}
		free(hcaArr[i]);
	}

	return (ret);
}

static int
print_target_props(char *hca)
{
	int		ret;
	boolean_t	enabled;
	char		buf[32];
	char		euibuf[64];
	uint64_t	hcaguid;
	stmfDevid	devid;
	stmfTargetProperties	props;
	char		*state;

	ret = srpt_NormalizeGuid(hca, buf, sizeof (buf), &hcaguid);
	if (ret != 0) {
		(void) fprintf(stderr, "Invalid target HCA: %s\n",
		    hca);
		return (ret);
	}

	/* only property set is enabled */
	ret = srpt_GetTargetState(buf, &enabled);
	if (ret != 0) {
		(void) fprintf(stderr,
		    "Could not get enabled state for %s: %d\n",
		    buf, ret);
		return (ret);
	}

	(void) printf("Target HCA %s:\n", buf);

	(void) printf(PROPS_FORMAT, gettext("Enabled"));

	if (enabled) {
		(void) printf("%s\n", gettext("true"));
	} else {
		(void) printf("%s\n", gettext("false"));
	}

	state = "-";

	(void) snprintf(euibuf, sizeof (euibuf), "eui.%016llX", hcaguid);

	ret = stmfDevidFromIscsiName(euibuf, &devid);
	if (ret == STMF_STATUS_SUCCESS) {
		ret = stmfGetTargetProperties(&devid, &props);
		if (ret == STMF_STATUS_SUCCESS) {
			if (props.status == STMF_TARGET_PORT_ONLINE) {
				state = "online";
			} else {
				state = "offline";
			}
		}
	}

	(void) printf(PROPS_FORMAT, gettext("SRP Target Name"));
	(void) printf("%s\n", euibuf);
	(void) printf(PROPS_FORMAT, gettext("Operational Status"));
	(void) printf("%s\n", state);

	(void) printf("\n");

	return (0);
}


static int
get_local_hcas(char **hcaArray, int count)
{
	int		ret = 0;
	char		*cfgdir = "/dev/cfg";
	DIR		*dirp = NULL;
	struct dirent	*entry;
	int		idx = 0;
	char		*bufp;

	if ((hcaArray == NULL) || (count == 0)) {
		return (EINVAL);
	}

	dirp = opendir(cfgdir);

	if (dirp == NULL) {
		ret = errno;
		(void) fprintf(stderr, "Could not open %s: errno %d\n",
		    cfgdir, ret);
		return (ret);
	}

	while ((entry = readdir(dirp)) != NULL) {
		bufp = &entry->d_name[0];

		if (strncmp(bufp, "hca:", 4) != 0) {
			continue;
		}

		bufp += 4;

		hcaArray[idx] = strdup(bufp);
		if (hcaArray[idx] == NULL) {
			ret = ENOMEM;
			break;
		}
		idx++;

		if (idx >= count) {
			ret = ETOOMANYREFS;
			break;
		}
	}

	return (ret);
}