#include <stdlib.h>

#include <stdio.h>

#include <strings.h>

#include <sys/types.h>

#include <unistd.h>

#include <wchar.h>

#include <libintl.h>

#include <errno.h>

#include <time.h>

#include <string.h>

#include <assert.h>

#include <getopt.h>

#include <cmdparse.h>

#include <stmfadm.h>

#include <libstmf.h>

#include <signal.h>

#include <pthread.h>

#include <locale.h>

static int addHostGroupMemberFunc(int, char **, cmdOptions_t *, void *);

static int addTargetGroupMemberFunc(int, char **, cmdOptions_t *, void *);

static int addViewFunc(int, char **, cmdOptions_t *, void *);

static int createHostGroupFunc(int, char **, cmdOptions_t *, void *);

static int createLuFunc(int, char **, cmdOptions_t *, void *);

static int modifyLuFunc(int, char **, cmdOptions_t *, void *);

static int importLuFunc(int, char **, cmdOptions_t *, void *);

static int deleteLuFunc(int, char **, cmdOptions_t *, void *);

static int createTargetGroupFunc(int, char **, cmdOptions_t *, void *);

static int deleteHostGroupFunc(int, char **, cmdOptions_t *, void *);

static int deleteTargetGroupFunc(int, char **, cmdOptions_t *, void *);

static int listLuFunc(int, char **, cmdOptions_t *, void *);

static int listTargetFunc(int, char **, cmdOptions_t *, void *);

static int listViewFunc(int, char **, cmdOptions_t *, void *);

static int listHostGroupFunc(int, char **, cmdOptions_t *, void *);

static int listStateFunc(int, char **, cmdOptions_t *, void *);

static int listTargetGroupFunc(int, char **, cmdOptions_t *, void *);

static int offlineTargetFunc(int, char **, cmdOptions_t *, void *);

static int offlineLuFunc(int, char **, cmdOptions_t *, void *);

static int onlineTargetFunc(int, char **, cmdOptions_t *, void *);

static int onlineLuFunc(int, char **, cmdOptions_t *, void *);

static int onlineOfflineTarget(char *, int);

static int onlineOfflineLu(char *, int);

static int removeHostGroupMemberFunc(int, char **, cmdOptions_t *, void *);

static int removeTargetGroupMemberFunc(int, char **, cmdOptions_t *, void *);

static int callModify(char *, stmfGuid *, uint32_t, const char *, const char *);

static int removeViewFunc(int, char **, cmdOptions_t *, void *);

static char *getExecBasename(char *);

static int parseDevid(char *input, stmfDevid *devid);

static void printGroupProps(stmfGroupProperties *groupProps);

static int checkScsiNameString(wchar_t *, stmfDevid *);

static int checkHexUpper(char *);

static int checkIscsiName(wchar_t *);

static void printLuProps(stmfLogicalUnitProperties *luProps);

static int printExtLuProps(stmfGuid *guid);

static void printGuid(stmfGuid *guid, FILE *printWhere);

static void printTargetProps(stmfTargetProperties *);

static void printSessionProps(stmfSessionList *);

static int setLuPropFromInput(luResource, char *);

static int convertCharToPropId(char *, uint32_t *);

#define VERSION_STRING_MAJOR "1"

#define VERSION_STRING_MINOR "0"

#define MAX_DEVID_INPUT 256

#define GUID_INPUT 32

#define MAX_LU_NBR 16383

#define ONLINE_LU 0

#define OFFLINE_LU 1

#define ONLINE_TARGET 2

#define OFFLINE_TARGET 3

#define PROPS_FORMAT " %-18s: "

#define VIEW_FORMAT " %-13s: "

#define LVL3_FORMAT " %s"

#define LVL4_FORMAT " %s"

#define SNS_EUI_16 16

#define SNS_EUI_24 24

#define SNS_EUI_32 32

#define SNS_NAA_16 16

#define SNS_NAA_32 32

#define SNS_WWN_16 16

#define SNS_IQN_223 223

#define GUID "GUID"

#define ALIAS "ALIAS"

#define VID "VID"

#define PID "PID"

#define META_FILE "META"

#define WRITE_PROTECT "WP"

#define WRITEBACK_CACHE_DISABLE "WCD"

#define COMPANY_ID "OUI"

#define BLOCK_SIZE "BLK"

#define SERIAL_NUMBER "SERIAL"

#define MGMT_URL "MGMT-URL"

#define MODIFY_HELP "\n"\

"Description: Modify properties of a logical unit. \n" \

"Valid properties for -p, --lu-prop are: \n" \

" alias - alias for logical unit (up to 255 chars)\n" \

" mgmt-url - Management URL address\n" \

" wcd - write cache disabled (true, false)\n" \

" wp - write protect (true, false)\n\n" \

"-f alters the meaning of the operand to be a file name\n" \

"rather than a LU name. This allows for modification\n" \

#define CREATE_HELP "\n"\

"Description: Create a logical unit. \n" \

"Valid properties for -p, --lu-prop are: \n" \

" alias - alias for logical unit (up to 255 chars)\n" \

" blk - block size in bytes in 2^n\n" \

" guid - 32 ascii hex characters in NAA format \n" \

" meta - separate meta data file name\n" \

" mgmt-url - Management URL address\n" \

" oui - organizational unique identifier\n" \

" 6 ascii hex characters of valid format\n" \

" pid - product identifier (up to 16 chars)\n" \

" serial - serial number (up to 252 chars)\n" \

" vid - vendor identifier (up to 8 chars)\n" \

" wcd - write cache disabled (true, false)\n" \

#define ADD_VIEW_HELP "\n"\

"Description: Add a view entry to a logical unit. \n" \

"A view entry is comprised of three elements; the \n" \

"logical unit number, the target group name and the\n" \

"host group name. These three elements combine together\n" \

"to form a view for a given COMSTAR logical unit.\n" \

"This view is realized by a client, a SCSI initiator,\n" \

optionTbl_t longOptions[] = {

{"all", no_arg, 'a', NULL},

{"group-name", required_arg, 'g', "group-name"},

{"keep-views", no_arg, 'k', NULL},

{"lu-name", required_arg, 'l', "LU-Name"},

{"lun", required_arg, 'n', "logical-unit-number"},

{"lu-prop", required_arg, 'p', "logical-unit-property=value"},

{"file", no_arg, 'f', "filename"},

{"size", required_arg, 's', "size K/M/G/T/P"},

{"target-group", required_arg, 't', "group-name"},

{"host-group", required_arg, 'h', "group-name"},

{"verbose", no_arg, 'v', NULL},

{NULL, 0, 0, 0}

};

subCommandProps_t subcommands[] = {

{"add-hg-member", addHostGroupMemberFunc, "g", "g", NULL,

OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},

{"add-tg-member", addTargetGroupMemberFunc, "g", "g", NULL,

OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},

{"add-view", addViewFunc, "nth", NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_LU, ADD_VIEW_HELP},

{"create-hg", createHostGroupFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},

{"create-tg", createTargetGroupFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},

{"create-lu", createLuFunc, "ps", NULL, NULL, OPERAND_MANDATORY_SINGLE,

"lu file", CREATE_HELP},

{"delete-hg", deleteHostGroupFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},

{"modify-lu", modifyLuFunc, "psf", NULL, NULL, OPERAND_MANDATORY_SINGLE,

OPERANDSTRING_LU, MODIFY_HELP},

{"delete-lu", deleteLuFunc, "k", NULL, NULL,

OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_LU, NULL},

{"delete-tg", deleteTargetGroupFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_GROUP_NAME, NULL},

{"import-lu", importLuFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, "file name", NULL},

{"list-hg", listHostGroupFunc, "v", NULL, NULL,

OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_GROUP_NAME, NULL},

{"list-lu", listLuFunc, "v", NULL, NULL, OPERAND_OPTIONAL_MULTIPLE,

OPERANDSTRING_LU, NULL},

{"list-state", listStateFunc, NULL, NULL, NULL, OPERAND_NONE, NULL},

{"list-target", listTargetFunc, "v", NULL, NULL,

OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_TARGET, NULL},

{"list-tg", listTargetGroupFunc, "v", NULL, NULL,

OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_GROUP_NAME, NULL},

{"list-view", listViewFunc, "l", "l", NULL,

OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_VIEW_ENTRY, NULL},

{"online-lu", onlineLuFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_LU, NULL},

{"offline-lu", offlineLuFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_LU, NULL},

{"online-target", onlineTargetFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_TARGET, NULL},

{"offline-target", offlineTargetFunc, NULL, NULL, NULL,

OPERAND_MANDATORY_SINGLE, OPERANDSTRING_TARGET, NULL},

{"remove-hg-member", removeHostGroupMemberFunc, "g", "g", NULL,

OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},

{"remove-tg-member", removeTargetGroupMemberFunc, "g", "g", NULL,

OPERAND_MANDATORY_MULTIPLE, OPERANDSTRING_GROUP_MEMBER, NULL},

{"remove-view", removeViewFunc, "la", "l", NULL,

OPERAND_OPTIONAL_MULTIPLE, OPERANDSTRING_VIEW_ENTRY, NULL},

{NULL, 0, NULL, NULL, 0, NULL, 0, NULL, NULL}

};

char *cmdName;

static int

addHostGroupMemberFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int i;

int ret = 0;

int stmfRet;

stmfGroupName groupName = {0};

wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};

stmfDevid devid;

for (; options->optval; options++) {

switch (options->optval) {

/* host group name */

case 'g':

(void) mbstowcs(groupNamePrint, options->optarg,

sizeof (stmfGroupName) - 1);

bcopy(options->optarg, groupName,

strlen(options->optarg));

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

for (i = 0; i < operandLen; i++) {

if (parseDevid(operands[i], &devid) != 0) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName, operands[i],

gettext("unrecognized device id"));

ret++;

continue;

}

stmfRet = stmfAddToHostGroup(&groupName, &devid);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_EXISTS:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("already exists"));

ret++;

break;

case STMF_ERROR_GROUP_NOT_FOUND:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("not found"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("resource busy"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("unknown error"));

ret++;

break;

}

}

return (ret);

}

static int

addTargetGroupMemberFunc(int operandLen, char *operands[],

cmdOptions_t *options, void *args)

{

int i;

int ret = 0;

int stmfRet;

stmfGroupName groupName = {0};

wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};

stmfDevid devid;

for (; options->optval; options++) {

switch (options->optval) {

/* target group name */

case 'g':

(void) mbstowcs(groupNamePrint, options->optarg,

sizeof (stmfGroupName) - 1);

bcopy(options->optarg, groupName,

strlen(options->optarg));

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

for (i = 0; i < operandLen; i++) {

if (parseDevid(operands[i], &devid) != 0) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName, operands[i],

gettext("unrecognized device id"));

ret++;

continue;

}

stmfRet = stmfAddToTargetGroup(&groupName, &devid);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_EXISTS:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("already exists"));

ret++;

break;

case STMF_ERROR_GROUP_NOT_FOUND:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("not found"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("resource busy"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_SERVICE_ONLINE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service must be offline"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("unknown error"));

ret++;

break;

}

}

return (ret);

}

static int

parseDevid(char *input, stmfDevid *devid)

{

wchar_t inputWc[MAX_DEVID_INPUT + 1] = {0};

/* convert to wcs */

(void) mbstowcs(inputWc, input, MAX_DEVID_INPUT);

/*

if (checkScsiNameString(inputWc, devid) == 0) {

return (0);

}

return (-1);

}

static int

checkScsiNameString(wchar_t *input, stmfDevid *devid)

{

char *mbString = NULL;

int mbStringLen;

int len;

int i;

/*

mbString = calloc(1, (mbStringLen = wcstombs(mbString, input, 0)) + 1);

if (mbString == NULL) {

(void) fprintf(stderr, "%s: %s\n",

cmdName, "Insufficient memory\n");

return (-1);

}

if (wcstombs(mbString, input, mbStringLen) == (size_t)-1) {

return (-1);

}

/*

if (strncmp(mbString, "iqn.", 4) == 0) {

if ((len = strlen(mbString)) > (SNS_IQN_223)) {

return (-1);

}

for (i = 0; i < len; i++) {

mbString[i] = tolower(mbString[i]);

}

if (checkIscsiName(input + 4) != 0) {

return (-1);

}

} else if (strncmp(mbString, "wwn.", 4) == 0) {

if ((len = strlen(mbString + 4)) != SNS_WWN_16) {

return (-1);

} else if (checkHexUpper(mbString + 4) != 0) {

return (-1);

}

} else if (strncmp(mbString, "eui.", 4) == 0) {

if ((len = strlen(mbString + 4)) != SNS_EUI_16) {

return (-1);

} else if (checkHexUpper(mbString + 4) != 0) {

return (-1);

}

} else {

return (-1);

}

/*

devid->identLength = strlen(mbString);

bzero(devid->ident, STMF_IDENT_LENGTH);

bcopy(mbString, devid->ident, devid->identLength);

return (0);

}

static int

checkHexUpper(char *input)

{

int i;

for (i = 0; i < strlen(input); i++) {

if (isxdigit(input[i])) {

input[i] = toupper(input[i]);

continue;

}

return (-1);

}

return (0);

}

static int

checkIscsiName(wchar_t *input)

{

int i;

for (i = 0; input[i] != 0; i++) {

if (!iswalnum(input[i]) && input[i] != '-' &&

input[i] != '.' && input[i] != ':') {

return (-1);

}

}

return (0);

}

static int

addViewFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

stmfViewEntry viewEntry;

stmfGuid inGuid;

unsigned int guid[sizeof (stmfGuid)];

uint16_t inputLuNbr;

int ret = 0;

int stmfRet;

int i;

char sGuid[GUID_INPUT + 1];

bzero(&viewEntry, sizeof (viewEntry));

/* init view entry structure */

viewEntry.allHosts = B_TRUE;

viewEntry.allTargets = B_TRUE;

viewEntry.luNbrValid = B_FALSE;

/* check input length */

if (strlen(operands[0]) != GUID_INPUT) {

(void) fprintf(stderr, "%s: %s: %s%d%s\n", cmdName, operands[0],

gettext("must be "), GUID_INPUT,

gettext(" hexadecimal digits"));

return (1);

}

for (; options->optval; options++) {

switch (options->optval) {

/* logical unit number */

case 'n':

viewEntry.luNbrValid = B_TRUE;

inputLuNbr = atoi(options->optarg);

if (inputLuNbr > MAX_LU_NBR) {

(void) fprintf(stderr, "%s: %d: %s\n",

cmdName, inputLuNbr,

gettext("Logical unit number"

" must be less than 16384"));

return (1);

}

viewEntry.luNbr[0] = inputLuNbr >> 8;

viewEntry.luNbr[1] = inputLuNbr & 0xff;

break;

/* host group */

case 'h':

viewEntry.allHosts = B_FALSE;

bcopy(options->optarg, viewEntry.hostGroup,

strlen(options->optarg));

break;

/* target group */

case 't':

viewEntry.allTargets = B_FALSE;

bcopy(options->optarg, viewEntry.targetGroup,

strlen(options->optarg));

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

/* convert to lower case for scan */

for (i = 0; i < 32; i++)

sGuid[i] = tolower(operands[0][i]);

sGuid[i] = 0;

(void) sscanf(sGuid, "%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",

&guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],

&guid[6], &guid[7], &guid[8], &guid[9], &guid[10], &guid[11],

&guid[12], &guid[13], &guid[14], &guid[15]);

for (i = 0; i < sizeof (stmfGuid); i++) {

inGuid.guid[i] = guid[i];

}

/* add the view entry */

stmfRet = stmfAddViewEntry(&inGuid, &viewEntry);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_EXISTS:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[0], gettext("already exists"));

ret++;

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[0], gettext("resource busy"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_LUN_IN_USE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("LUN already in use"));

ret++;

break;

case STMF_ERROR_VE_CONFLICT:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("view entry exists"));

ret++;

break;

case STMF_ERROR_CONFIG_NONE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service is not initialized"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

case STMF_ERROR_INVALID_HG:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid host group"));

ret++;

break;

case STMF_ERROR_INVALID_TG:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid target group"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[0], gettext("unknown error"));

ret++;

break;

}

return (ret);

}

static int

createHostGroupFunc(int operandLen, char *operands[],

cmdOptions_t *options, void *args)

{

int ret = 0;

int stmfRet;

wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};

stmfGroupName groupName = {0};

(void) strlcpy(groupName, operands[0], sizeof (groupName));

(void) mbstowcs(groupNamePrint, (char *)groupName,

sizeof (stmfGroupName) - 1);

/* call create group */

stmfRet = stmfCreateHostGroup(&groupName);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_EXISTS:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[0], gettext("already exists"));

ret++;

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

operands[0], gettext("resource busy"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[0], gettext("unknown error"));

ret++;

break;

}

return (ret);

}

static int

createLuFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

luResource hdl = NULL;

int ret = 0;

int stmfRet = 0;

char guidAsciiBuf[33];

stmfGuid createdGuid;

stmfRet = stmfCreateLuResource(STMF_DISK, &hdl);

if (stmfRet != STMF_STATUS_SUCCESS) {

(void) fprintf(stderr, "%s: %s\n",

cmdName, gettext("Failure to create lu resource\n"));

return (1);

}

for (; options->optval; options++) {

switch (options->optval) {

case 'p':

ret = setLuPropFromInput(hdl, options->optarg);

if (ret != 0) {

(void) stmfFreeLuResource(hdl);

return (1);

}

break;

case 's':

stmfRet = stmfSetLuProp(hdl, STMF_LU_PROP_SIZE,

options->optarg);

if (stmfRet != STMF_STATUS_SUCCESS) {

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("size param invalid"));

(void) stmfFreeLuResource(hdl);

return (1);

}

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

stmfRet = stmfSetLuProp(hdl, STMF_LU_PROP_FILENAME, operands[0]);

if (stmfRet != STMF_STATUS_SUCCESS) {

(void) fprintf(stderr, "%s: %s\n",

cmdName, gettext("could not set filename"));

return (1);

}

stmfRet = stmfCreateLu(hdl, &createdGuid);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_BUSY:

case STMF_ERROR_LU_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_FILE_IN_USE:

(void) fprintf(stderr, "%s: filename %s: %s\n", cmdName,

operands[0], gettext("in use"));

ret++;

break;

case STMF_ERROR_INVALID_BLKSIZE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid block size"));

ret++;

break;

case STMF_ERROR_GUID_IN_USE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("guid in use"));

ret++;

break;

case STMF_ERROR_META_FILE_NAME:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("meta file error"));

ret++;

break;

case STMF_ERROR_DATA_FILE_NAME:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("data file error"));

ret++;

break;

case STMF_ERROR_FILE_SIZE_INVALID:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("file size invalid"));

ret++;

break;

case STMF_ERROR_SIZE_OUT_OF_RANGE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid size"));

ret++;

break;

case STMF_ERROR_META_CREATION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("could not create meta file"));

ret++;

break;

case STMF_ERROR_WRITE_CACHE_SET:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("could not set write cache"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("unknown error"));

ret++;

break;

}

if (ret != 0) {

goto done;

}

(void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf),

"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"

"%02X%02X%02X%02X%02X%02X",

createdGuid.guid[0], createdGuid.guid[1], createdGuid.guid[2],

createdGuid.guid[3], createdGuid.guid[4], createdGuid.guid[5],

createdGuid.guid[6], createdGuid.guid[7], createdGuid.guid[8],

createdGuid.guid[9], createdGuid.guid[10], createdGuid.guid[11],

createdGuid.guid[12], createdGuid.guid[13], createdGuid.guid[14],

createdGuid.guid[15]);

(void) printf("Logical unit created: %s\n", guidAsciiBuf);

done:

(void) stmfFreeLuResource(hdl);

return (ret);

}

static int

modifyLuFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

stmfGuid inGuid;

unsigned int guid[sizeof (stmfGuid)];

int ret = 0;

int i;

char *fname = NULL;

char *lasts = NULL;

char sGuid[GUID_INPUT + 1];

char *prop = NULL;

char *propVal = NULL;

boolean_t fnameUsed = B_FALSE;

uint32_t propId;

cmdOptions_t *optionStart = options;

for (; options->optval; options++) {

switch (options->optval) {

case 'f':

fnameUsed = B_TRUE;

fname = operands[0];

break;

}

}

options = optionStart;

/* check input length */

if (!fnameUsed && strlen(operands[0]) != GUID_INPUT) {

(void) fprintf(stderr, "%s: %s: %s%d%s\n", cmdName, operands[0],

gettext("must be "), GUID_INPUT,

gettext(" hexadecimal digits"));

return (1);

}

if (!fnameUsed) {

/* convert to lower case for scan */

for (i = 0; i < 32; i++)

sGuid[i] = tolower(operands[0][i]);

sGuid[i] = 0;

(void) sscanf(sGuid,

"%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",

&guid[0], &guid[1], &guid[2], &guid[3], &guid[4], &guid[5],

&guid[6], &guid[7], &guid[8], &guid[9], &guid[10],

&guid[11], &guid[12], &guid[13], &guid[14], &guid[15]);

for (i = 0; i < sizeof (stmfGuid); i++) {

inGuid.guid[i] = guid[i];

}

}

for (; options->optval; options++) {

switch (options->optval) {

case 'p':

prop = strtok_r(options->optarg, "=", &lasts);

propVal = strtok_r(NULL, "=", &lasts);

ret = convertCharToPropId(prop, &propId);

if (ret != 0) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName,

gettext("invalid property specified"),

prop);

return (1);

}

if (propVal == NULL &&

propId != STMF_LU_PROP_MGMT_URL) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName, options->optarg,

gettext("invalid property specifier"

"- prop=val\n"));

return (1);

}

if (propVal == NULL) {

ret = callModify(fname, &inGuid, propId,

"", prop);

} else {

ret = callModify(fname, &inGuid, propId,

propVal, prop);

}

if (ret != 0) {

return (1);

}

break;

case 's':

if (callModify(fname, &inGuid,

STMF_LU_PROP_SIZE, options->optarg,

"size") != 0) {

return (1);

}

break;

case 'f':

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

return (ret);

}

static int

callModify(char *fname, stmfGuid *luGuid, uint32_t prop, const char *propVal,

const char *propString)

{

int ret = 0;

int stmfRet = 0;

if (!fname) {

stmfRet = stmfModifyLu(luGuid, prop, propVal);

} else {

stmfRet = stmfModifyLuByFname(STMF_DISK, fname, prop,

propVal);

}

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_BUSY:

case STMF_ERROR_LU_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_INVALID_BLKSIZE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid block size"));

ret++;

break;

case STMF_ERROR_GUID_IN_USE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("guid in use"));

ret++;

break;

case STMF_ERROR_META_FILE_NAME:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("meta file error"));

ret++;

break;

case STMF_ERROR_DATA_FILE_NAME:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("data file error"));

ret++;

break;

case STMF_ERROR_FILE_SIZE_INVALID:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("file size invalid"));

ret++;

break;

case STMF_ERROR_SIZE_OUT_OF_RANGE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid size"));

ret++;

break;

case STMF_ERROR_META_CREATION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("could not create meta file"));

ret++;

break;

case STMF_ERROR_INVALID_PROP:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("invalid property for modify"));

ret++;

break;

case STMF_ERROR_WRITE_CACHE_SET:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("could not set write cache"));

ret++;

break;

case STMF_ERROR_ACCESS_STATE_SET:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("cannot modify while in standby mode"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s: %s: %d\n", cmdName,

gettext("could not set property"), propString,

stmfRet);

ret++;

break;

}

return (ret);

}

static int

importLuFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int stmfRet = 0;

int ret = 0;

char guidAsciiBuf[33];

stmfGuid createdGuid;

stmfRet = stmfImportLu(STMF_DISK, operands[0], &createdGuid);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_BUSY:

case STMF_ERROR_LU_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_FILE_IN_USE:

(void) fprintf(stderr, "%s: filename %s: %s\n", cmdName,

operands[0], gettext("in use"));

ret++;

break;

case STMF_ERROR_GUID_IN_USE:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("guid in use"));

ret++;

break;

case STMF_ERROR_META_FILE_NAME:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("meta file error"));

ret++;

break;

case STMF_ERROR_DATA_FILE_NAME:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("data file error"));

ret++;

break;

case STMF_ERROR_META_CREATION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("could not create meta file"));

ret++;

break;

case STMF_ERROR_WRITE_CACHE_SET:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("could not set write cache"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("unknown error"));

ret++;

break;

}

if (ret != STMF_STATUS_SUCCESS) {

goto done;

}

(void) snprintf(guidAsciiBuf, sizeof (guidAsciiBuf),

"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X"

"%02X%02X%02X%02X%02X%02X",

createdGuid.guid[0], createdGuid.guid[1], createdGuid.guid[2],

createdGuid.guid[3], createdGuid.guid[4], createdGuid.guid[5],

createdGuid.guid[6], createdGuid.guid[7], createdGuid.guid[8],

createdGuid.guid[9], createdGuid.guid[10], createdGuid.guid[11],

createdGuid.guid[12], createdGuid.guid[13], createdGuid.guid[14],

createdGuid.guid[15]);

(void) printf("Logical unit imported: %s\n", guidAsciiBuf);

done:

return (ret);

}

static int

setLuPropFromInput(luResource hdl, char *optarg)

{

char *prop = NULL;

char *propVal = NULL;

char *lasts = NULL;

uint32_t propId;

int ret = 0;

prop = strtok_r(optarg, "=", &lasts);

if ((propVal = strtok_r(NULL, "=", &lasts)) == NULL) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName, optarg,

gettext("invalid property specifier - prop=val\n"));

return (1);

}

ret = convertCharToPropId(prop, &propId);

if (ret != 0) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName, gettext("invalid property specified"), prop);

return (1);

}

ret = stmfSetLuProp(hdl, propId, propVal);

if (ret != STMF_STATUS_SUCCESS) {

(void) fprintf(stderr, "%s: %s %s: ",

cmdName, gettext("unable to set"), prop);

switch (ret) {

case STMF_ERROR_INVALID_PROPSIZE:

(void) fprintf(stderr, "invalid length\n");

break;

case STMF_ERROR_INVALID_ARG:

(void) fprintf(stderr, "bad format\n");

break;

default:

(void) fprintf(stderr, "\n");

break;

}

return (1);

}

return (0);

}

static int

convertCharToPropId(char *prop, uint32_t *propId)

{

if (strcasecmp(prop, GUID) == 0) {

*propId = STMF_LU_PROP_GUID;

} else if (strcasecmp(prop, ALIAS) == 0) {

*propId = STMF_LU_PROP_ALIAS;

} else if (strcasecmp(prop, VID) == 0) {

*propId = STMF_LU_PROP_VID;

} else if (strcasecmp(prop, PID) == 0) {

*propId = STMF_LU_PROP_PID;

} else if (strcasecmp(prop, WRITE_PROTECT) == 0) {

*propId = STMF_LU_PROP_WRITE_PROTECT;

} else if (strcasecmp(prop, WRITEBACK_CACHE_DISABLE) == 0) {

*propId = STMF_LU_PROP_WRITE_CACHE_DISABLE;

} else if (strcasecmp(prop, BLOCK_SIZE) == 0) {

*propId = STMF_LU_PROP_BLOCK_SIZE;

} else if (strcasecmp(prop, SERIAL_NUMBER) == 0) {

*propId = STMF_LU_PROP_SERIAL_NUM;

} else if (strcasecmp(prop, COMPANY_ID) == 0) {

*propId = STMF_LU_PROP_COMPANY_ID;

} else if (strcasecmp(prop, META_FILE) == 0) {

*propId = STMF_LU_PROP_META_FILENAME;

} else if (strcasecmp(prop, MGMT_URL) == 0) {

*propId = STMF_LU_PROP_MGMT_URL;

} else {

return (1);

}

return (0);

}

static int

deleteLuFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int i, j;

int ret = 0;

int stmfRet;

unsigned int inGuid[sizeof (stmfGuid)];

stmfGuid delGuid;

boolean_t keepViews = B_FALSE;

boolean_t viewEntriesRemoved = B_FALSE;

boolean_t noLunFound = B_FALSE;

boolean_t views = B_FALSE;

char sGuid[GUID_INPUT + 1];

stmfViewEntryList *viewEntryList = NULL;

for (; options->optval; options++) {

switch (options->optval) {

/* Keep views for logical unit */

case 'k':

keepViews = B_TRUE;

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

for (i = 0; i < operandLen; i++) {

for (j = 0; j < GUID_INPUT; j++) {

if (!isxdigit(operands[i][j])) {

break;

}

sGuid[j] = tolower(operands[i][j]);

}

if (j != GUID_INPUT) {

(void) fprintf(stderr, "%s: %s: %s%d%s\n",

cmdName, operands[i], gettext("must be "),

GUID_INPUT,

gettext(" hexadecimal digits long"));

continue;

}

sGuid[j] = 0;

(void) sscanf(sGuid,

"%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",

&inGuid[0], &inGuid[1], &inGuid[2], &inGuid[3],

&inGuid[4], &inGuid[5], &inGuid[6], &inGuid[7],

&inGuid[8], &inGuid[9], &inGuid[10], &inGuid[11],

&inGuid[12], &inGuid[13], &inGuid[14], &inGuid[15]);

for (j = 0; j < sizeof (stmfGuid); j++) {

delGuid.guid[j] = inGuid[j];

}

stmfRet = stmfDeleteLu(&delGuid);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_NOT_FOUND:

noLunFound = B_TRUE;

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("unknown error"));

ret++;

break;

}

if (!keepViews) {

stmfRet = stmfGetViewEntryList(&delGuid,

&viewEntryList);

if (stmfRet == STMF_STATUS_SUCCESS) {

for (j = 0; j < viewEntryList->cnt; j++) {

(void) stmfRemoveViewEntry(&delGuid,

viewEntryList->ve[j].veIndex);

}

viewEntriesRemoved = B_TRUE;

stmfFreeMemory(viewEntryList);

} else if (stmfRet != STMF_ERROR_NOT_FOUND) {

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("unable to remove view entries\n"));

ret++;

} /* No view entries to remove */

}

if (keepViews) {

stmfRet = stmfGetViewEntryList(&delGuid,

&viewEntryList);

if (stmfRet == STMF_STATUS_SUCCESS) {

views = B_TRUE;

stmfFreeMemory(viewEntryList);

}

}

if ((!viewEntriesRemoved && noLunFound && !views) ||

(!views && keepViews && noLunFound)) {

(void) fprintf(stderr, "%s: %s: %s\n",

cmdName, sGuid,

gettext("not found"));

ret++;

}

noLunFound = viewEntriesRemoved = views = B_FALSE;

}

return (ret);

}

static int

createTargetGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int ret = 0;

int stmfRet;

wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};

stmfGroupName groupName = {0};

(void) strlcpy(groupName, operands[0], sizeof (groupName));

(void) mbstowcs(groupNamePrint, (char *)groupName,

sizeof (stmfGroupName) - 1);

/* call create group */

stmfRet = stmfCreateTargetGroup(&groupName);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_EXISTS:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("already exists"));

ret++;

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("resource busy"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("unknown error"));

ret++;

break;

}

return (ret);

}

static int

deleteHostGroupFunc(int operandLen, char *operands[],

cmdOptions_t *options, void *args)

{

int ret = 0;

int stmfRet;

wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};

stmfGroupName groupName = {0};

(void) strlcpy(groupName, operands[0], sizeof (groupName));

(void) mbstowcs(groupNamePrint, (char *)groupName,

sizeof (stmfGroupName) - 1);

/* call delete group */

stmfRet = stmfDeleteHostGroup(&groupName);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_NOT_FOUND:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("not found"));

ret++;

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("resource busy"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_GROUP_IN_USE:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint,

gettext("group is in use by existing view entry"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("unknown error"));

ret++;

break;

}

return (ret);

}

static int

deleteTargetGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int ret = 0;

int stmfRet;

wchar_t groupNamePrint[sizeof (stmfGroupName)] = {0};

stmfGroupName groupName = {0};

(void) strlcpy(groupName, operands[0], sizeof (groupName));

(void) mbstowcs(groupNamePrint, (char *)groupName,

sizeof (stmfGroupName) - 1);

/* call delete group */

stmfRet = stmfDeleteTargetGroup(&groupName);

switch (stmfRet) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_NOT_FOUND:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("not found"));

ret++;

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("resource busy"));

ret++;

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

ret++;

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

ret++;

break;

case STMF_ERROR_GROUP_IN_USE:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint,

gettext("group is in use by existing view entry"));

ret++;

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

ret++;

break;

default:

(void) fprintf(stderr, "%s: %ws: %s\n", cmdName,

groupNamePrint, gettext("unknown error"));

ret++;

break;

}

return (ret);

}

static int

listHostGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int ret = 0;

int stmfRet;

int i, j, outerLoop;

boolean_t verbose = B_FALSE;

boolean_t found = B_TRUE;

boolean_t operandEntered;

stmfGroupList *groupList;

stmfGroupProperties *groupProps;

wchar_t operandName[sizeof (stmfGroupName)];

wchar_t groupNamePrint[sizeof (stmfGroupName)];

for (; options->optval; options++) {

switch (options->optval) {

case 'v':

verbose = B_TRUE;

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

if (operandLen > 0) {

outerLoop = operandLen;

operandEntered = B_TRUE;

} else {

outerLoop = 1;

operandEntered = B_FALSE;

}

stmfRet = stmfGetHostGroupList(&groupList);

if (stmfRet != STMF_STATUS_SUCCESS) {

switch (stmfRet) {

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("unknown error"));

break;

}

return (1);

}

for (i = 0; i < outerLoop; i++) {

for (found = B_FALSE, j = 0; j < groupList->cnt; j++) {

(void) mbstowcs(groupNamePrint,

(char *)groupList->name[j],

sizeof (stmfGroupName) - 1);

groupNamePrint[sizeof (stmfGroupName) - 1] = 0;

if (operandEntered) {

(void) mbstowcs(operandName, operands[i],

sizeof (stmfGroupName) - 1);

operandName[sizeof (stmfGroupName) - 1] = 0;

if (wcscmp(operandName, groupNamePrint)

== 0) {

found = B_TRUE;

}

}

if ((found && operandEntered) || !operandEntered) {

(void) printf("Host Group: %ws\n",

groupNamePrint);

if (verbose) {

stmfRet = stmfGetHostGroupMembers(

&(groupList->name[j]), &groupProps);

if (stmfRet != STMF_STATUS_SUCCESS) {

return (1);

}

printGroupProps(groupProps);

}

if (found && operandEntered) {

break;

}

}

}

if (operandEntered && !found) {

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("not found"));

ret = 1;

}

}

return (ret);

}

static void

printGroupProps(stmfGroupProperties *groupProps)

{

int i;

wchar_t memberIdent[sizeof (groupProps->name[0].ident) + 1] = {0};

for (i = 0; i < groupProps->cnt; i++) {

(void) mbstowcs(memberIdent, (char *)groupProps->name[i].ident,

sizeof (groupProps->name[0].ident));

(void) printf("\tMember: %ws\n", memberIdent);

}

}

static int

listTargetGroupFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int ret = 0;

int stmfRet;

int i, j, outerLoop;

boolean_t verbose = B_FALSE;

boolean_t found = B_TRUE;

boolean_t operandEntered;

stmfGroupList *groupList;

stmfGroupProperties *groupProps;

wchar_t operandName[sizeof (stmfGroupName)];

wchar_t groupNamePrint[sizeof (stmfGroupName)];

for (; options->optval; options++) {

switch (options->optval) {

case 'v':

verbose = B_TRUE;

break;

default:

(void) fprintf(stderr, "%s: %c: %s\n",

cmdName, options->optval,

gettext("unknown option"));

return (1);

}

}

if (operandLen > 0) {

outerLoop = operandLen;

operandEntered = B_TRUE;

} else {

outerLoop = 1;

operandEntered = B_FALSE;

}

stmfRet = stmfGetTargetGroupList(&groupList);

if (stmfRet != STMF_STATUS_SUCCESS) {

switch (stmfRet) {

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("unknown error"));

break;

}

return (1);

}

for (i = 0; i < outerLoop; i++) {

for (found = B_FALSE, j = 0; j < groupList->cnt; j++) {

(void) mbstowcs(groupNamePrint,

(char *)groupList->name[j],

sizeof (stmfGroupName) - 1);

groupNamePrint[sizeof (stmfGroupName) - 1] = 0;

if (operandEntered) {

(void) mbstowcs(operandName, operands[i],

sizeof (stmfGroupName) - 1);

operandName[sizeof (stmfGroupName) - 1] = 0;

if (wcscmp(operandName, groupNamePrint)

== 0) {

found = B_TRUE;

}

}

if ((found && operandEntered) || !operandEntered) {

(void) printf("Target Group: %ws\n",

groupNamePrint);

if (verbose) {

stmfRet = stmfGetTargetGroupMembers(

&(groupList->name[j]), &groupProps);

if (stmfRet != STMF_STATUS_SUCCESS) {

return (1);

}

printGroupProps(groupProps);

}

if (found && operandEntered) {

break;

}

}

}

if (operandEntered && !found) {

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("not found"));

ret = 1;

}

}

return (ret);

}

static int

listLuFunc(int operandLen, char *operands[], cmdOptions_t *options, void *args)

{

cmdOptions_t *optionList = options;

boolean_t operandEntered;

int i, j;

int ret = 0;

int stmfRet;

int outerLoop;

unsigned int inGuid[sizeof (stmfGuid)];

stmfGuid cmpGuid;

boolean_t verbose = B_FALSE;

boolean_t found;

char sGuid[GUID_INPUT + 1];

stmfGuidList *luList;

stmfLogicalUnitProperties luProps;

boolean_t invalidInput = B_FALSE;

stmfViewEntryList *viewEntryList;

for (; optionList->optval; optionList++) {

switch (optionList->optval) {

case 'v':

verbose = B_TRUE;

break;

}

}

if ((stmfRet = stmfGetLogicalUnitList(&luList))

!= STMF_STATUS_SUCCESS) {

switch (stmfRet) {

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("list failed"));

break;

}

return (1);

}

if (operandLen > 0) {

operandEntered = B_TRUE;

outerLoop = operandLen;

} else {

operandEntered = B_FALSE;

outerLoop = 1;

}

for (invalidInput = B_FALSE, i = 0; i < outerLoop; i++) {

if (operandEntered) {

if (strlen(operands[i]) != GUID_INPUT) {

invalidInput = B_TRUE;

} else {

for (j = 0; j < GUID_INPUT; j++) {

if (!isxdigit(operands[i][j])) {

invalidInput = B_TRUE;

break;

}

}

}

if (invalidInput) {

(void) fprintf(stderr, "%s: %s: %s%d%s\n",

cmdName, operands[i], gettext("must be "),

GUID_INPUT,

gettext(" hexadecimal digits long"));

invalidInput = B_FALSE;

continue;

}

for (j = 0; j < GUID_INPUT; j++) {

sGuid[j] = tolower(operands[i][j]);

}

sGuid[j] = 0;

(void) sscanf(sGuid,

"%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x%2x",

&inGuid[0], &inGuid[1], &inGuid[2], &inGuid[3],

&inGuid[4], &inGuid[5], &inGuid[6], &inGuid[7],

&inGuid[8], &inGuid[9], &inGuid[10], &inGuid[11],

&inGuid[12], &inGuid[13], &inGuid[14], &inGuid[15]);

for (j = 0; j < sizeof (stmfGuid); j++) {

cmpGuid.guid[j] = inGuid[j];

}

}

for (found = B_FALSE, j = 0; j < luList->cnt; j++) {

if (operandEntered) {

if (bcmp(luList->guid[j].guid, cmpGuid.guid,

sizeof (stmfGuid)) == 0) {

found = B_TRUE;

}

}

if ((found && operandEntered) || !operandEntered) {

(void) printf("LU Name: ");

printGuid(&luList->guid[j], stdout);

(void) printf("\n");

if (verbose) {

stmfRet = stmfGetLogicalUnitProperties(

&(luList->guid[j]), &luProps);

if (stmfRet == STMF_STATUS_SUCCESS) {

printLuProps(&luProps);

} else {

(void) fprintf(stderr, "%s:",

cmdName);

printGuid(&luList->guid[j],

stderr);

(void) fprintf(stderr, "%s\n",

gettext(" get properties "

"failed"));

}

stmfRet = stmfGetViewEntryList(

&(luList->guid[j]),

&viewEntryList);

(void) printf(PROPS_FORMAT,

"View Entry Count");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%d",

viewEntryList->cnt);

} else if (stmfRet ==

STMF_ERROR_NOT_FOUND) {

(void) printf("0");

} else {

(void) printf("unknown");

}

(void) printf("\n");

ret = printExtLuProps(

&(luList->guid[j]));

}

if (found && operandEntered) {

break;

}

}

}

if (operandEntered && !found) {

(void) fprintf(stderr, "%s: %s: %s\n", cmdName,

operands[i], gettext("not found"));

ret = 1;

}

}

return (ret);

}

static void

printGuid(stmfGuid *guid, FILE *stream)

{

int i;

for (i = 0; i < 16; i++) {

(void) fprintf(stream, "%02X", guid->guid[i]);

}

}

static int

printExtLuProps(stmfGuid *guid)

{

int stmfRet;

luResource hdl = NULL;

int ret = 0;

char propVal[MAXNAMELEN];

size_t propValSize = sizeof (propVal);

if ((stmfRet = stmfGetLuResource(guid, &hdl))

!= STMF_STATUS_SUCCESS) {

switch (stmfRet) {

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_NOT_FOUND:

/* No error here */

return (0);

break;

default:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("get extended properties failed"));

break;

}

return (1);

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_FILENAME, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Data File");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_META_FILENAME, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Meta File");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_SIZE, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Size");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_BLOCK_SIZE, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Block Size");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_MGMT_URL, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Management URL");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_VID, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Vendor ID");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_PID, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Product ID");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_SERIAL_NUM, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Serial Num");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n", propVal);

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_WRITE_PROTECT, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Write Protect");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n",

strcasecmp(propVal, "true") ? "Disabled" : "Enabled");

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_WRITE_CACHE_DISABLE, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Writeback Cache");

if (stmfRet == STMF_STATUS_SUCCESS) {

(void) printf("%s\n",

strcasecmp(propVal, "true") ? "Enabled" : "Disabled");

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else if (stmfRet == STMF_ERROR_NO_PROP_STANDBY) {

(void) printf("prop unavailable in standby\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

stmfRet = stmfGetLuProp(hdl, STMF_LU_PROP_ACCESS_STATE, propVal,

&propValSize);

(void) printf(PROPS_FORMAT, "Access State");

if (stmfRet == STMF_STATUS_SUCCESS) {

if (strcmp(propVal, STMF_ACCESS_ACTIVE) == 0) {

(void) printf("%s\n", "Active");

} else if (strcmp(propVal,

STMF_ACCESS_ACTIVE_TO_STANDBY) == 0) {

(void) printf("%s\n", "Active->Standby");

} else if (strcmp(propVal, STMF_ACCESS_STANDBY) == 0) {

(void) printf("%s\n", "Standby");

} else if (strcmp(propVal,

STMF_ACCESS_STANDBY_TO_ACTIVE) == 0) {

(void) printf("%s\n", "Standby->Active");

} else {

(void) printf("%s\n", "Unknown");

}

} else if (stmfRet == STMF_ERROR_NO_PROP) {

(void) printf("not set\n");

} else {

(void) printf("<error retrieving property>\n");

ret++;

}

done:

(void) stmfFreeLuResource(hdl);

return (ret);

}

static void

printLuProps(stmfLogicalUnitProperties *luProps)

{

(void) printf(PROPS_FORMAT, "Operational Status");

switch (luProps->status) {

case STMF_LOGICAL_UNIT_ONLINE:

(void) printf("Online");

break;

case STMF_LOGICAL_UNIT_OFFLINE:

(void) printf("Offline");

break;

case STMF_LOGICAL_UNIT_ONLINING:

(void) printf("Onlining");

break;

case STMF_LOGICAL_UNIT_OFFLINING:

(void) printf("Offlining");

break;

case STMF_LOGICAL_UNIT_UNREGISTERED:

(void) printf("unregistered");

(void) strncpy(luProps->providerName, "unregistered",

sizeof (luProps->providerName));

break;

default:

(void) printf("unknown");

break;

}

(void) printf("\n");

(void) printf(PROPS_FORMAT, "Provider Name");

if (luProps->providerName[0] != 0) {

(void) printf("%s", luProps->providerName);

} else {

(void) printf("unknown");

}

(void) printf("\n");

(void) printf(PROPS_FORMAT, "Alias");

if (luProps->alias[0] != 0) {

(void) printf("%s", luProps->alias);

} else {

(void) printf("-");

}

(void) printf("\n");

}

static void

printTargetProps(stmfTargetProperties *targetProps)

{

(void) printf(PROPS_FORMAT, "Operational Status");

switch (targetProps->status) {

case STMF_TARGET_PORT_ONLINE:

(void) printf("Online");

break;

case STMF_TARGET_PORT_OFFLINE:

(void) printf("Offline");

break;

case STMF_TARGET_PORT_ONLINING:

(void) printf("Onlining");

break;

case STMF_TARGET_PORT_OFFLINING:

(void) printf("Offlining");

break;

default:

(void) printf("unknown");

break;

}

(void) printf("\n");

(void) printf(PROPS_FORMAT, "Provider Name");

if (targetProps->providerName[0] != 0) {

(void) printf("%s", targetProps->providerName);

}

(void) printf("\n");

(void) printf(PROPS_FORMAT, "Alias");

if (targetProps->alias[0] != 0) {

(void) printf("%s", targetProps->alias);

} else {

(void) printf("-");

}

(void) printf("\n");

(void) printf(PROPS_FORMAT, "Protocol");

switch (targetProps->protocol) {

case STMF_PROTOCOL_FIBRE_CHANNEL:

(void) printf("%s", "Fibre Channel");

break;

case STMF_PROTOCOL_ISCSI:

(void) printf("%s", "iSCSI");

break;

case STMF_PROTOCOL_SRP:

(void) printf("%s", "SRP");

break;

case STMF_PROTOCOL_SAS:

(void) printf("%s", "SAS");

break;

default:

(void) printf("%s", "unknown");

break;

}

(void) printf("\n");

}

static void

printSessionProps(stmfSessionList *sessionList)

{

int i;

char *cTime;

wchar_t initiator[STMF_IDENT_LENGTH + 1];

(void) printf(PROPS_FORMAT, "Sessions");

(void) printf("%d\n", sessionList->cnt);

for (i = 0; i < sessionList->cnt; i++) {

(void) mbstowcs(initiator,

(char *)sessionList->session[i].initiator.ident,

STMF_IDENT_LENGTH);

initiator[STMF_IDENT_LENGTH] = 0;

(void) printf(LVL3_FORMAT, "Initiator: ");

(void) printf("%ws\n", initiator);

(void) printf(LVL4_FORMAT, "Alias: ");

if (sessionList->session[i].alias[0] != 0) {

(void) printf("%s", sessionList->session[i].alias);

} else {

(void) printf("-");

}

(void) printf("\n");

(void) printf(LVL4_FORMAT, "Logged in since: ");

cTime = ctime(&(sessionList->session[i].creationTime));

if (cTime != NULL) {

(void) printf("%s", cTime);

} else {

(void) printf("unknown\n");

}

}

}

static int

getStmfState(stmfState *state)

{

int ret;

ret = stmfGetState(state);

switch (ret) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_SERVICE_NOT_FOUND:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service not found"));

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

break;

case STMF_ERROR_SERVICE_DATA_VERSION:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("STMF service version incorrect"));

break;

default:

(void) fprintf(stderr, "%s: %s: %d\n", cmdName,

gettext("unknown error"), ret);

break;

}

return (ret);

}

static int

listStateFunc(int operandLen, char *operands[], cmdOptions_t *options,

void *args)

{

int ret;

stmfState state;

boolean_t aluaEnabled;

uint32_t node;

if ((ret = getStmfState(&state)) != STMF_STATUS_SUCCESS)

return (ret);

(void) printf("%-18s: ", "Operational Status");

switch (state.operationalState) {

case STMF_SERVICE_STATE_ONLINE:

(void) printf("online");

break;

case STMF_SERVICE_STATE_OFFLINE:

(void) printf("offline");

break;

case STMF_SERVICE_STATE_ONLINING:

(void) printf("onlining");

break;

case STMF_SERVICE_STATE_OFFLINING:

(void) printf("offlining");

break;

default:

(void) printf("unknown");

break;

}

(void) printf("\n");

(void) printf("%-18s: ", "Config Status");

switch (state.configState) {

case STMF_CONFIG_STATE_NONE:

(void) printf("uninitialized");

break;

case STMF_CONFIG_STATE_INIT:

(void) printf("initializing");

break;

case STMF_CONFIG_STATE_INIT_DONE:

(void) printf("initialized");

break;

default:

(void) printf("unknown");

break;

}

(void) printf("\n");

ret = stmfGetAluaState(&aluaEnabled, &node);

switch (ret) {

case STMF_STATUS_SUCCESS:

break;

case STMF_ERROR_PERM:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("permission denied"));

break;

case STMF_ERROR_BUSY:

(void) fprintf(stderr, "%s: %s\n", cmdName,

gettext("resource busy"));

break;

default:

(void) fprintf(stderr, "%s: %s: %d\n", cmdName,

gettext("unknown error"), ret);

break;

}

(void) printf("%-18s: ", "ALUA Status");

if (ret == STMF_STATUS_SUCCESS) {

if (aluaEnabled == B_TRUE) {

(void) printf("enabled");

} else {

(void) printf("disabled");

}

} else {

(void) printf("unknown");