xref: /onnv-gate/usr/src/lib/libsun_ima/common/ima.c (revision 11271:d0c8b5d253aa)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <syslog.h>
#include <errno.h>
#include <wchar.h>
#include <widec.h>
#include <libsysevent.h>
#include <sys/nvpair.h>
#include <fcntl.h>
#include <stdio.h>
#include <time.h>
#include <libdevinfo.h>
#include <sys/scsi/generic/commands.h>
#include <sys/scsi/generic/status.h>
#include <sys/scsi/adapters/iscsi_if.h>
#include <sys/iscsi_protocol.h>
#include <ima.h>
#include <libsun_ima.h>

#define	LIBRARY_PROPERTY_IMPLEMENTATION_VERSION	L"1.0.0"
#define	LIBRARY_PROPERTY_VENDOR			L"Sun Microsystems, Inc."
#define	OS_DEVICE_NAME 				"/devices/iscsi"
#define	LIBRARY_FILE_NAME			L"libsun_ima.so"

#define	OS_DEVICE_NAME_LEN		256
#define	USCSI_TIMEOUT_IN_SEC		10
#define	MAX_AUTHMETHODS			10
#define	NUM_SUPPORTED_AUTH_METHODS	2
#define	SUN_IMA_MAX_DIGEST_ALGORITHMS	2	/* NONE and CRC 32 */
#define	SUN_IMA_IP_ADDRESS_LEN		256
#define	SUN_IMA_IP_PORT_LEN		64
#define	SUN_IMA_MAX_RADIUS_SECRET_LEN	128
#define	MAX_LONG_LONG_STRING_LEN	10
#define	MAX_INQUIRY_BUFFER_LEN		0xffff
#define	MAX_REPORT_LUNS_BUFFER_LEN	0xffffffff
#define	MAX_READ_CAPACITY16_BUFFER_LEN	0xffffffff

/* Forward declaration */
#define	BOOL_PARAM			1
#define	MIN_MAX_PARAM			2

/* OK */
#define	DISC_ADDR_OK			0
/* Incorrect IP address */
#define	DISC_ADDR_INTEGRITY_ERROR   	1
/* Error converting text IP address to numeric binary form */
#define	DISC_ADDR_IP_CONV_ERROR		2

/* Currently not defined in  IMA_TARGET_DISCOVERY_METHOD enum */
#define	IMA_TARGET_DISCOVERY_METHOD_UNKNOWN  0

static IMA_OID		lhbaObjectId;
static IMA_UINT32	pluginOwnerId;
static sysevent_handle_t *shp;



/*
 * Custom struct to allow tgpt to be specified.
 */
typedef struct _SUN_IMA_DISC_ADDRESS_KEY
{
	IMA_NODE_NAME name;
	IMA_ADDRESS_KEY	address;
	IMA_UINT16 tpgt;
} SUN_IMA_DISC_ADDRESS_KEY;

/*
 * Custom struct to allow tgpt to be specified.
 */
typedef struct _SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES
{
	IMA_UINT keyCount;
	SUN_IMA_DISC_ADDRESS_KEY keys[1];
} SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES;

/*
 * Custom struct to allow tgpt to be specified.
 */
typedef struct _SUN_IMA_DISC_ADDR_PROP_LIST
{
	IMA_UINT discAddrCount;
	IMA_DISCOVERY_ADDRESS_PROPERTIES props[1];
} SUN_IMA_DISC_ADDR_PROP_LIST;


static IMA_OBJECT_VISIBILITY_FN pObjectVisibilityCallback = NULL;
static IMA_OBJECT_PROPERTY_FN pObjectPropertyCallback = NULL;

static IMA_STATUS getISCSINodeParameter(int paramType, IMA_OID *oid,
    void *pProps, uint32_t paramIndex);
static IMA_STATUS setISCSINodeParameter(int paramType, IMA_OID *oid,
    void *pProps, uint32_t paramIndex);
static IMA_STATUS setAuthMethods(IMA_OID oid, IMA_UINT *pMethodCount,
    const IMA_AUTHMETHOD *pMethodList);
static IMA_STATUS getAuthMethods(IMA_OID oid, IMA_UINT *pMethodCount,
    IMA_AUTHMETHOD *pMethodList);

static int prepare_discovery_entry(IMA_TARGET_ADDRESS discoveryAddress,
    entry_t *entry);
static IMA_STATUS configure_discovery_method(IMA_BOOL enable,
    iSCSIDiscoveryMethod_t method);
static IMA_STATUS get_target_oid_list(uint32_t targetListType,
    IMA_OID_LIST **ppList);
static IMA_STATUS get_target_lun_oid_list(IMA_OID * targetOid,
		iscsi_lun_list_t  **ppLunList);
static int get_lun_devlink(di_devlink_t link, void *osDeviceName);
static IMA_STATUS getDiscoveryAddressPropertiesList(
	SUN_IMA_DISC_ADDR_PROP_LIST **ppList
);
static IMA_STATUS sendTargets(IMA_TARGET_ADDRESS address,
    SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES **ppList
);

static IMA_STATUS getSupportedAuthMethods(IMA_OID lhbaOid,
    IMA_BOOL getSettableMethods, IMA_UINT *pMethodCount,
    IMA_AUTHMETHOD *pMethodList);
static IMA_STATUS getLuProperties(IMA_OID luId, IMA_LU_PROPERTIES *pProps);
static IMA_STATUS getTargetProperties(IMA_OID targetId,
    IMA_TARGET_PROPERTIES *pProps);

void InitLibrary();

static void libSwprintf(wchar_t *wcs, const wchar_t *lpszFormat, ...)
{
	va_list args;
	va_start(args, lpszFormat);
	(void) vswprintf(wcs, OS_DEVICE_NAME_LEN - 1, lpszFormat, args);
	va_end(args);
}

static void
sysevent_handler(sysevent_t *ev)
{
	IMA_OID tmpOid;
	IMA_BOOL becomingVisible = IMA_FALSE;
	IMA_UINT i;

	const char *visibility_subclasses[] = {
		ESC_ISCSI_STATIC_START,
		ESC_ISCSI_STATIC_END,
		ESC_ISCSI_SEND_TARGETS_START,
		ESC_ISCSI_SEND_TARGETS_END,
		ESC_ISCSI_SLP_START,
		ESC_ISCSI_SLP_END,
		ESC_ISCSI_ISNS_START,
		ESC_ISCSI_ISNS_END,
		NULL
	};

	tmpOid.ownerId = pluginOwnerId;
	tmpOid.objectType = IMA_OBJECT_TYPE_TARGET;
	tmpOid.objectSequenceNumber = 0;

	/* Make sure our event class matches what we are looking for */
	if (strncmp(EC_ISCSI, sysevent_get_class_name(ev),
	    strlen(EC_ISCSI)) != 0) {
		return;
	}


	/* Check for object property changes */
	if ((strncmp(ESC_ISCSI_PROP_CHANGE,
	    sysevent_get_subclass_name(ev),
	    strlen(ESC_ISCSI_PROP_CHANGE)) == 0)) {
		if (pObjectPropertyCallback != NULL)
			pObjectPropertyCallback(tmpOid);
	} else {
		i = 0;
		while (visibility_subclasses[i] != NULL) {
			if ((strncmp(visibility_subclasses[i],
			    sysevent_get_subclass_name(ev),
			    strlen(visibility_subclasses[i])) == 0) &&
			    pObjectVisibilityCallback != NULL) {
				becomingVisible = IMA_TRUE;
				pObjectVisibilityCallback(becomingVisible,
				    tmpOid);
			}
			i++;
		}
	}
}

IMA_STATUS init_sysevents() {
	const char *subclass_list[] = {
		ESC_ISCSI_STATIC_START,
		ESC_ISCSI_STATIC_END,
		ESC_ISCSI_SEND_TARGETS_START,
		ESC_ISCSI_SEND_TARGETS_END,
		ESC_ISCSI_SLP_START,
		ESC_ISCSI_SLP_END,
		ESC_ISCSI_ISNS_START,
		ESC_ISCSI_ISNS_END,
		ESC_ISCSI_PROP_CHANGE,
	};

	/* Bind event handler and create subscriber handle */
	shp = sysevent_bind_handle(sysevent_handler);
	if (shp == NULL) {
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (sysevent_subscribe_event(shp, EC_ISCSI, subclass_list, 9) != 0) {
		sysevent_unbind_handle(shp);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}
	return (IMA_STATUS_SUCCESS);
}

IMA_STATUS Initialize(IMA_UINT32 pluginOid) {
	pluginOwnerId = pluginOid;
	return (init_sysevents());
}

void Terminate() {
	if (shp != NULL) {
		sysevent_unsubscribe_event(shp, EC_ISCSI);
	}

}

void InitLibrary() {
}

static void GetBuildTime(IMA_DATETIME* pdatetime)
{
	(void) memset(pdatetime, 0, sizeof (IMA_DATETIME));
}

/*ARGSUSED*/
IMA_API IMA_STATUS IMA_GetNodeProperties(
	IMA_OID nodeOid,
	IMA_NODE_PROPERTIES *pProps
)
{
	int fd;
	iscsi_param_get_t pg;

	pProps->runningInInitiatorMode = IMA_TRUE;
	pProps->runningInTargetMode = IMA_FALSE;
	pProps->nameAndAliasSettable = IMA_FALSE;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&pg, 0, sizeof (iscsi_param_get_t));
	pg.g_vers = ISCSI_INTERFACE_VERSION;
	pg.g_param = ISCSI_LOGIN_PARAM_INITIATOR_NAME;

	if (ioctl(fd, ISCSI_PARAM_GET, &pg) == -1) {
		pProps->nameValid = IMA_FALSE;
	} else {
		if (strlen((char *)pg.g_value.v_name) > 0) {
			(void) mbstowcs(pProps->name,
			    (char *)pg.g_value.v_name,
			    IMA_NODE_NAME_LEN);
			pProps->nameValid = IMA_TRUE;
		} else {
			pProps->nameValid = IMA_FALSE;
		}
	}

	(void) memset(&pg, 0, sizeof (iscsi_param_get_t));
	pg.g_vers = ISCSI_INTERFACE_VERSION;
	pg.g_param = ISCSI_LOGIN_PARAM_INITIATOR_ALIAS;
	(void) memset(pProps->alias, 0,
	    sizeof (IMA_WCHAR) * IMA_NODE_ALIAS_LEN);
	if (ioctl(fd, ISCSI_PARAM_GET, &pg) == -1) {
		pProps->aliasValid = IMA_FALSE;
	} else {
		if (strlen((char *)pg.g_value.v_name) > 0) {
			(void) mbstowcs(pProps->alias,
			    (char *)pg.g_value.v_name,
			    IMA_NODE_ALIAS_LEN);
			pProps->aliasValid = IMA_TRUE;
		}
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_SetNodeName(
	IMA_OID nodeOid,
	const IMA_NODE_NAME newName
)
{
	int fd;
	iscsi_param_set_t ps;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&ps, 0, sizeof (iscsi_param_set_t));
	ps.s_oid = nodeOid.objectSequenceNumber;
	ps.s_vers = ISCSI_INTERFACE_VERSION;
	ps.s_param = ISCSI_LOGIN_PARAM_INITIATOR_NAME;
	(void) wcstombs((char *)ps.s_value.v_name, newName, ISCSI_MAX_NAME_LEN);
	if (ioctl(fd, ISCSI_INIT_NODE_NAME_SET, &ps)) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_PARAM_SET ioctl failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_SetNodeAlias(
	IMA_OID nodeOid,
	const IMA_NODE_ALIAS newAlias
)
{
	int fd;
	iscsi_param_set_t ps;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&ps, 0, sizeof (iscsi_param_set_t));
	ps.s_oid = nodeOid.objectSequenceNumber;
	ps.s_vers = ISCSI_INTERFACE_VERSION;
	ps.s_param = ISCSI_LOGIN_PARAM_INITIATOR_ALIAS;

	/* newAlias = NULL specifies that the alias should be deleted. */
	if (newAlias != NULL)
		(void) wcstombs((char *)ps.s_value.v_name, newAlias,
		    ISCSI_MAX_NAME_LEN);
	else
		(void) wcstombs((char *)ps.s_value.v_name,
		    L"", ISCSI_MAX_NAME_LEN);

	if (ioctl(fd, ISCSI_PARAM_SET, &ps)) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_PARAM_SET ioctl failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}


IMA_API IMA_STATUS IMA_GetLhbaOidList(
	IMA_OID_LIST **ppList
)
{
	/* Always return the same object ID for the lhba */
	lhbaObjectId.objectType = IMA_OBJECT_TYPE_LHBA;
	lhbaObjectId.ownerId = pluginOwnerId;
	lhbaObjectId.objectSequenceNumber = ISCSI_INITIATOR_OID;

	*ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST));
	if (*ppList == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	(*ppList)->oidCount = 1;
	(void) memcpy(&(*ppList)->oids[0],
	    &lhbaObjectId, sizeof (lhbaObjectId));
	return (IMA_STATUS_SUCCESS);
}


/*
 * Get the discovery properties of the LHBA
 */
/*ARGSUSED*/
IMA_API IMA_STATUS IMA_GetDiscoveryProperties(
	IMA_OID oid,
	IMA_DISCOVERY_PROPERTIES *pProps
)
{
	int fd;
	iSCSIDiscoveryProperties_t discoveryProps;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&discoveryProps, 0, sizeof (discoveryProps));
	discoveryProps.vers = ISCSI_INTERFACE_VERSION;

	if (ioctl(fd, ISCSI_DISCOVERY_PROPS, &discoveryProps) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_PROPS ioctl failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	pProps->iSnsDiscoverySettable = discoveryProps.iSNSDiscoverySettable;
	pProps->iSnsDiscoveryEnabled = discoveryProps.iSNSDiscoveryEnabled;
	/*
	 * Set the iSNS discovery method - The IMA specification indicates
	 * this field is valid only if iSNS discovery is enabled.
	 */
	if (pProps->iSnsDiscoveryEnabled == IMA_TRUE) {
		switch (discoveryProps.iSNSDiscoveryMethod) {
			case iSNSDiscoveryMethodStatic:
				pProps->iSnsDiscoveryMethod =
				    IMA_ISNS_DISCOVERY_METHOD_STATIC;
				break;
			case iSNSDiscoveryMethodDHCP:
				pProps->iSnsDiscoveryMethod =
				    IMA_ISNS_DISCOVERY_METHOD_DHCP;
				break;
			case iSNSDiscoveryMethodSLP:
				pProps->iSnsDiscoveryMethod =
				    IMA_ISNS_DISCOVERY_METHOD_SLP;
				break;
			default:
				(void) close(fd);
				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}
	(void) memcpy(pProps->iSnsHost.id.hostname,
	    discoveryProps.iSNSDomainName,
	    sizeof (pProps->iSnsHost.id.hostname));
	pProps->slpDiscoverySettable = discoveryProps.SLPDiscoverySettable;
	pProps->slpDiscoveryEnabled = discoveryProps.SLPDiscoveryEnabled;
	pProps->staticDiscoverySettable =
	    discoveryProps.StaticDiscoverySettable;
	pProps->staticDiscoveryEnabled = discoveryProps.StaticDiscoveryEnabled;
	pProps->sendTargetsDiscoverySettable =
	    discoveryProps.SendTargetsDiscoverySettable;
	pProps->sendTargetsDiscoveryEnabled =
	    discoveryProps.SendTargetsDiscoveryEnabled;

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_FreeMemory(
	void *pMemory
)
{
	if (pMemory != NULL)
		free(pMemory);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_GetNonSharedNodeOidList(
		IMA_OID_LIST **ppList
)
{
	if (ppList == NULL)
		return (IMA_ERROR_INVALID_PARAMETER);

	*ppList = (IMA_OID_LIST*) calloc(1, sizeof (IMA_OID_LIST));
	if (*ppList == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->oidCount = 0;

	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_GetFirstBurstLengthProperties(
		IMA_OID Oid,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH));
}

IMA_API IMA_STATUS IMA_GetMaxBurstLengthProperties(
		IMA_OID Oid,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH));
}

IMA_API IMA_STATUS IMA_GetMaxRecvDataSegmentLengthProperties(
		IMA_OID Oid,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH));
}

/*ARGSUSED*/
IMA_API IMA_STATUS IMA_PluginIOCtl(
		IMA_OID pluginOid,
		IMA_UINT command,
		const void *pInputBuffer,
		IMA_UINT inputBufferLength,
		void *pOutputBuffer,
		IMA_UINT *pOutputBufferLength
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

IMA_API	IMA_STATUS IMA_SetFirstBurstLength(
		IMA_OID lhbaId,
		IMA_UINT firstBurstLength
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = firstBurstLength;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH));
}

IMA_API	IMA_STATUS IMA_SetMaxBurstLength(
		IMA_OID lhbaId,
		IMA_UINT maxBurstLength
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = maxBurstLength;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH));
}

IMA_API	IMA_STATUS IMA_SetMaxRecvDataSegmentLength(
		IMA_OID lhbaId,
		IMA_UINT maxRecvDataSegmentLength
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = maxRecvDataSegmentLength;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH));
}

IMA_API	IMA_STATUS IMA_GetMaxConnectionsProperties(
		IMA_OID Oid,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_MAX_CONNECTIONS));
}

IMA_API	IMA_STATUS IMA_SetMaxConnections(
		IMA_OID lhbaId,
		IMA_UINT maxConnections
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = maxConnections;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_MAX_CONNECTIONS));
}

IMA_API	IMA_STATUS IMA_GetDefaultTime2RetainProperties(
		IMA_OID lhbaId,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, pProps,
	    ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN));
}

IMA_API	IMA_STATUS IMA_SetDefaultTime2Retain(
		IMA_OID lhbaId,
		IMA_UINT defaultTime2Retain
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = defaultTime2Retain;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN));
}

IMA_API	IMA_STATUS IMA_GetDefaultTime2WaitProperties(
		IMA_OID lhbaId,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, pProps,
	    ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT));
}

IMA_API	IMA_STATUS IMA_SetDefaultTime2Wait(
		IMA_OID lhbaId,
		IMA_UINT defaultTime2Wait
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = defaultTime2Wait;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT));
}

IMA_API	IMA_STATUS IMA_GetMaxOutstandingR2TProperties(
		IMA_OID Oid,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_OUTSTANDING_R2T));
}

IMA_API	IMA_STATUS IMA_SetMaxOutstandingR2T(
		IMA_OID lhbaId,
		IMA_UINT maxOutstandingR2T
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = maxOutstandingR2T;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &lhbaId, &mv,
	    ISCSI_LOGIN_PARAM_OUTSTANDING_R2T));
}


IMA_API	IMA_STATUS IMA_GetErrorRecoveryLevelProperties(
		IMA_OID Oid,
		IMA_MIN_MAX_VALUE *pProps
)
{
	return (getISCSINodeParameter(MIN_MAX_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL));
}

IMA_API	IMA_STATUS IMA_SetErrorRecoveryLevel(
		IMA_OID Oid,
		IMA_UINT errorRecoveryLevel
)
{
	IMA_MIN_MAX_VALUE mv;

	mv.currentValue = errorRecoveryLevel;
	return (setISCSINodeParameter(MIN_MAX_PARAM, &Oid, &mv,
	    ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL));
}

IMA_API	IMA_STATUS IMA_GetInitialR2TProperties(
		IMA_OID Oid,
		IMA_BOOL_VALUE *pProps
)
{
	return (getISCSINodeParameter(BOOL_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_INITIAL_R2T));
}

IMA_API	IMA_STATUS IMA_SetInitialR2T(
		IMA_OID Oid,
		IMA_BOOL initialR2T
)
{
	IMA_BOOL_VALUE bv;

	bv.currentValue = initialR2T;
	return (setISCSINodeParameter(BOOL_PARAM, &Oid, &bv,
	    ISCSI_LOGIN_PARAM_INITIAL_R2T));
}


IMA_API	IMA_STATUS IMA_GetImmediateDataProperties(
		IMA_OID Oid,
		IMA_BOOL_VALUE *pProps
)
{
	return (getISCSINodeParameter(BOOL_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_IMMEDIATE_DATA));
}

IMA_API	IMA_STATUS IMA_SetImmediateData(
		IMA_OID Oid,
		IMA_BOOL immediateData
)
{
	IMA_BOOL_VALUE bv;

	bv.currentValue = immediateData;
	return (setISCSINodeParameter(BOOL_PARAM, &Oid, &bv,
	    ISCSI_LOGIN_PARAM_IMMEDIATE_DATA));
}

IMA_API	IMA_STATUS IMA_GetDataPduInOrderProperties(
		IMA_OID Oid,
		IMA_BOOL_VALUE *pProps
)
{
	return (getISCSINodeParameter(BOOL_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER));
}

IMA_API	IMA_STATUS IMA_SetDataPduInOrder(
		IMA_OID Oid,
		IMA_BOOL dataPduInOrder
)
{
	IMA_BOOL_VALUE bv;

	bv.currentValue = dataPduInOrder;
	return (setISCSINodeParameter(BOOL_PARAM, &Oid, &bv,
	    ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER));
}

IMA_API	IMA_STATUS IMA_GetDataSequenceInOrderProperties(
		IMA_OID Oid,
		IMA_BOOL_VALUE *pProps
)
{
	return (getISCSINodeParameter(BOOL_PARAM, &Oid, pProps,
	    ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER));
}

IMA_API	IMA_STATUS IMA_SetDataSequenceInOrder(
		IMA_OID Oid,
		IMA_BOOL dataSequenceInOrder
)
{
	IMA_BOOL_VALUE bv;

	bv.currentValue = dataSequenceInOrder;
	return (setISCSINodeParameter(BOOL_PARAM, &Oid, &bv,
	    ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER));
}


/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_SetStatisticsCollection(
		IMA_OID Oid,
		IMA_BOOL enableStatisticsCollection
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}


/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_GetDiscoveryAddressOidList(
		IMA_OID Oid,
		IMA_OID_LIST **ppList
)
{
	int fd, i, addr_list_size;
	iscsi_addr_list_t *idlp, al_info;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&al_info, 0, sizeof (al_info));
	al_info.al_vers = ISCSI_INTERFACE_VERSION;
	al_info.al_in_cnt = 0;

	/*
	 * Issue ioctl to obtain the number of targets.
	 */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, &al_info) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl %d failed, errno: %d",
		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	addr_list_size = sizeof (iscsi_addr_list_t);
	if (al_info.al_out_cnt > 1) {
		addr_list_size += (sizeof (iscsi_addr_list_t) *
		    al_info.al_out_cnt - 1);
	}

	idlp = (iscsi_addr_list_t *)calloc(1, addr_list_size);
	if (idlp == NULL) {
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	idlp->al_vers = ISCSI_INTERFACE_VERSION;
	idlp->al_in_cnt = al_info.al_out_cnt;
	/* Issue the same ioctl again to obtain the OIDs. */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, idlp) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_OID_LIST_GET ioctl %d failed, errno: %d",
		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
		free(idlp);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	*ppList = (IMA_OID_LIST *)calloc(1, sizeof (IMA_OID_LIST) +
	    idlp->al_out_cnt * sizeof (IMA_OID));
	if (*ppList == NULL) {
		free(idlp);
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->oidCount = idlp->al_out_cnt;

	for (i = 0; i < idlp->al_out_cnt; i++) {
		(*ppList)->oids[i].objectType =
		    IMA_OBJECT_TYPE_DISCOVERY_ADDRESS;
		(*ppList)->oids[i].ownerId = pluginOwnerId;
		(*ppList)->oids[i].objectSequenceNumber =
		    idlp->al_addrs[i].a_oid;
	}

	free(idlp);
	(void) close(fd);

	return (IMA_STATUS_SUCCESS);
}


/* ARGSUSED */
IMA_API	IMA_STATUS IMA_GetStaticDiscoveryTargetOidList(
		IMA_OID Oid,
		IMA_OID_LIST **ppList
)
{
	if (Oid.objectType == IMA_OBJECT_TYPE_PNP) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}

	return (get_target_oid_list(ISCSI_STATIC_TGT_OID_LIST, ppList));
}

/* ARGSUSED */
IMA_API	IMA_STATUS IMA_GetTargetOidList(
		IMA_OID Oid,
		IMA_OID_LIST **ppList
)
{
	return (get_target_oid_list(ISCSI_TGT_PARAM_OID_LIST, ppList));
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_SetIsnsDiscovery(
		IMA_OID phbaId,
		IMA_BOOL enableIsnsDiscovery,
		IMA_ISNS_DISCOVERY_METHOD discoveryMethod,
		const IMA_HOST_ID *iSnsHost
)
{
	/* XXX need to set discovery Method and domaineName */
	return (configure_discovery_method(enableIsnsDiscovery,
	    iSCSIDiscoveryMethodISNS));
}


/* ARGSUSED */
IMA_API	IMA_STATUS IMA_SetSlpDiscovery(
		IMA_OID phbaId,
		IMA_BOOL enableSlpDiscovery
)
{
	return (configure_discovery_method(enableSlpDiscovery,
	    iSCSIDiscoveryMethodSLP));
}


/* ARGSUSED */
IMA_API	IMA_STATUS IMA_SetStaticDiscovery(
		IMA_OID phbaId,
		IMA_BOOL enableStaticDiscovery
)
{
	return (configure_discovery_method(enableStaticDiscovery,
	    iSCSIDiscoveryMethodStatic));
}

/* ARGSUSED */
IMA_API	IMA_STATUS IMA_SetSendTargetsDiscovery(
		IMA_OID phbaId,
		IMA_BOOL enableSendTargetsDiscovery
)
{
	return (configure_discovery_method(enableSendTargetsDiscovery,
	    iSCSIDiscoveryMethodSendTargets));
}

/*ARGSUSED*/
IMA_API IMA_STATUS IMA_RemoveDiscoveryAddress(
		IMA_OID	discoveryAddressOid
)
{
	int status, fd, i, addr_list_size;
	iscsi_addr_list_t *idlp, al_info;
	iscsi_addr_t *matched_addr = NULL;
	entry_t	entry;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&al_info, 0, sizeof (al_info));
	al_info.al_vers = ISCSI_INTERFACE_VERSION;
	al_info.al_in_cnt = 0;

	/*
	 * Issue ioctl to obtain the number of discovery address.
	 */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, &al_info) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl %d failed, errno: %d",
		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (al_info.al_out_cnt == 0) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}

	addr_list_size = sizeof (iscsi_addr_list_t);
	if (al_info.al_out_cnt > 1) {
		addr_list_size += (sizeof (iscsi_addr_list_t) *
		    al_info.al_out_cnt - 1);
	}

	idlp = (iscsi_addr_list_t *)calloc(1, addr_list_size);
	if (idlp == NULL) {
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	idlp->al_vers = ISCSI_INTERFACE_VERSION;
	idlp->al_in_cnt = al_info.al_out_cnt;

	/* Issue the same ioctl again to obtain the OIDs. */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, idlp) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_OID_LIST_GET ioctl %d failed, errno: %d",
		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
		free(idlp);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	for (i = 0; i < idlp->al_out_cnt; i++) {
		if (discoveryAddressOid.objectSequenceNumber !=
		    idlp->al_addrs[i].a_oid)
			continue;
		matched_addr = &(idlp->al_addrs[i]);
	}

	if (matched_addr == NULL) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}


	(void) memset(&entry, 0, sizeof (entry_t));
	entry.e_vers = ISCSI_INTERFACE_VERSION;
	entry.e_oid  = discoveryAddressOid.objectSequenceNumber;
	if (matched_addr->a_addr.i_insize == sizeof (struct in_addr)) {
		bcopy(&matched_addr->a_addr.i_addr.in4,
		    &entry.e_u.u_in4, sizeof (entry.e_u.u_in4));
		entry.e_insize = sizeof (struct in_addr);
	} else if (matched_addr->a_addr.i_insize == sizeof (struct in6_addr)) {
		bcopy(&matched_addr->a_addr.i_addr.in6,
		    &entry.e_u.u_in6, sizeof (entry.e_u.u_in6));
		entry.e_insize = sizeof (struct in6_addr);
	} else {
		/* Should not happen */
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_GET returned bad address");
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	entry.e_port = matched_addr->a_port;
	entry.e_tpgt = 0;
	entry.e_oid = discoveryAddressOid.objectSequenceNumber;

	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_CLEAR, &entry)) {
		status = errno;
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_CLEAR ioctl failed, errno: %d",
		    errno);
		if (status == EBUSY) {
			return (IMA_ERROR_LU_IN_USE);
		} else {
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}

	free(idlp);
	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}


/*ARGSUSED*/
IMA_API IMA_STATUS IMA_AddDiscoveryAddress(
		IMA_OID	oid,
		const IMA_TARGET_ADDRESS discoveryAddress,
		IMA_OID	*pDiscoveryAddressOid
)
{
	entry_t	    entry;
	int	    fd;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (prepare_discovery_entry(discoveryAddress, &entry) !=
	    DISC_ADDR_OK) {
		(void) close(fd);
		return (IMA_ERROR_INVALID_PARAMETER);
	}

	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_SET, &entry)) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_SET ioctl failed, errno: %d",
		    errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	pDiscoveryAddressOid->ownerId = pluginOwnerId;
	pDiscoveryAddressOid->objectType = IMA_OBJECT_TYPE_DISCOVERY_ADDRESS;
	pDiscoveryAddressOid->objectSequenceNumber = entry.e_oid;

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_GetStaticDiscoveryTargetProperties(
		IMA_OID	staticTargetOid,
		IMA_STATIC_DISCOVERY_TARGET_PROPERTIES *pProps
)
{
	char static_target_addr_str[SUN_IMA_IP_ADDRESS_LEN];
	char static_target_addr_port_str[SUN_IMA_IP_ADDRESS_LEN];
	int af, fd, status;
	iscsi_static_property_t prop;
	/* LINTED */
	IMA_HOST_ID *host;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&prop, 0, sizeof (iscsi_static_property_t));
	prop.p_vers = ISCSI_INTERFACE_VERSION;
	prop.p_oid = (uint32_t)staticTargetOid.objectSequenceNumber;
	if (ioctl(fd, ISCSI_STATIC_GET, &prop) != 0) {
		status = errno;
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_GET ioctl failed, errno: %d", status);
		if (status == ENOENT) {
			return (IMA_ERROR_OBJECT_NOT_FOUND);

		} else {
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}
	(void) close(fd);

	(void) mbstowcs(pProps->staticTarget.targetName, (char *)prop.p_name,
	    sizeof (pProps->staticTarget.targetName)/sizeof (IMA_WCHAR));

	if (prop.p_addr_list.al_addrs[0].a_addr.i_insize ==
	    sizeof (struct in_addr)) {
		/* IPv4 */
		af = AF_INET;
	} else if (prop.p_addr_list.al_addrs[0].a_addr.i_insize ==
	    sizeof (struct in6_addr)) {
		/* IPv6 */
		af = AF_INET6;
	} else {
		/* Should not happen */
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_GET returned bad address");
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (inet_ntop(af, &prop.p_addr_list.al_addrs[0].a_addr.i_addr,
	    static_target_addr_str, sizeof (static_target_addr_str)) == NULL) {
		/* Should not happen */
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_GET returned address that cannot "
		    "be inet_ntop");
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	} else {
		if (af == AF_INET) {
			(void) snprintf(static_target_addr_port_str,
			    SUN_IMA_IP_ADDRESS_LEN,
			    "%s:%ld",
			    static_target_addr_str,
			    prop.p_addr_list.al_addrs[0].a_port);
		} else {
			(void) snprintf(static_target_addr_port_str,
			    SUN_IMA_IP_ADDRESS_LEN,
			    "[%s]:%ld",
			    static_target_addr_str,
			    prop.p_addr_list.al_addrs[0].a_port);
		}
		host = &pProps->staticTarget.targetAddress.hostnameIpAddress;
		(void) mbstowcs(pProps->staticTarget.
		    targetAddress.hostnameIpAddress.
		    id.hostname, static_target_addr_port_str,
		    sizeof (host->id.hostname) / sizeof (IMA_WCHAR));
	}

	return (IMA_STATUS_SUCCESS);
}

/*ARGSUSED*/
IMA_API IMA_STATUS IMA_GetDiscoveryAddressProperties(
		IMA_OID	discoveryAddressOid,
		IMA_DISCOVERY_ADDRESS_PROPERTIES *pProps
)
{
	int fd;
	int i;
	int addr_list_size;
	iscsi_addr_list_t *idlp, al_info;
	iscsi_addr_t *matched_addr = NULL;
	/* LINTED */
	IMA_TARGET_ADDRESS *addr;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&al_info, 0, sizeof (al_info));
	al_info.al_vers = ISCSI_INTERFACE_VERSION;
	al_info.al_in_cnt = 0;

	/*
	 * Issue ioctl to obtain the number of discovery addresses.
	 */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, &al_info) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl %d failed, errno: %d",
		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (al_info.al_out_cnt == 0) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}

	addr_list_size = sizeof (iscsi_addr_list_t);
	if (al_info.al_out_cnt > 1) {
		addr_list_size += (sizeof (iscsi_addr_list_t) *
		    al_info.al_out_cnt - 1);
	}

	idlp = (iscsi_addr_list_t *)calloc(1, addr_list_size);
	if (idlp == NULL) {
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	idlp->al_vers = ISCSI_INTERFACE_VERSION;
	idlp->al_in_cnt = al_info.al_out_cnt;

	/* Issue the same ioctl again to obtain the OIDs. */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, idlp) != 0) {
		free(idlp);
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_OID_LIST_GET ioctl %d failed, errno: %d",
		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	for (i = 0; i < idlp->al_out_cnt; i++) {
		if (discoveryAddressOid.objectSequenceNumber !=
		    idlp->al_addrs[i].a_oid)
			continue;
		matched_addr = &(idlp->al_addrs[i]);
	}

	if (matched_addr == NULL) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}

	if (matched_addr->a_addr.i_insize == sizeof (struct in_addr)) {
		pProps->discoveryAddress.hostnameIpAddress.id.
		    ipAddress.ipv4Address = IMA_TRUE;
	} else if (matched_addr->a_addr.i_insize == sizeof (struct in6_addr)) {
		pProps->discoveryAddress.hostnameIpAddress.id.
		    ipAddress.ipv4Address = IMA_FALSE;
	} else {
		/* Should not happen */
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_GET returned bad address");
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	addr = &pProps->discoveryAddress;
	bcopy(&(matched_addr->a_addr.i_addr), pProps->discoveryAddress.
	    hostnameIpAddress.id.ipAddress.ipAddress,
	    sizeof (addr->hostnameIpAddress.id.ipAddress.ipAddress));

	pProps->discoveryAddress.portNumber = matched_addr->a_port;

	pProps->associatedLhbaOid.objectType = IMA_OBJECT_TYPE_LHBA;
	pProps->associatedLhbaOid.ownerId = pluginOwnerId;
	pProps->associatedLhbaOid.objectSequenceNumber = ISCSI_INITIATOR_OID;

	free(idlp);
	(void) close(fd);

	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_RemoveStaticDiscoveryTarget(
		IMA_OID staticTargetOid
)
{
	entry_t	entry;
	int	status, fd;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&entry, 0, sizeof (entry_t));
	entry.e_vers = ISCSI_INTERFACE_VERSION;
	entry.e_oid = (uint32_t)staticTargetOid.objectSequenceNumber;

	if (ioctl(fd, ISCSI_STATIC_CLEAR, &entry)) {
		status = errno;
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_CLEAR ioctl failed, errno: %d", errno);
		if (status == EBUSY) {
			return (IMA_ERROR_LU_IN_USE);
		} else {
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

/*ARGSUSED*/
IMA_API IMA_STATUS IMA_AddStaticDiscoveryTarget(
		IMA_OID lhbaOid,
		const IMA_STATIC_DISCOVERY_TARGET staticConfig,
		IMA_OID *pTargetOid
)
{
	char			tmp_target_str[SUN_IMA_IP_ADDRESS_LEN];
	char			target_addr_str[SUN_IMA_IP_ADDRESS_LEN];
	char			target_port_str[SUN_IMA_IP_PORT_LEN];
	iscsi_target_entry_t	target;
	int			fd;
	int			target_in_addr_size;
	int			target_port;
	union {
		struct in_addr	u_in4;
		struct in6_addr	u_in6;
	}			target_in;

	/*
	 * staticConfig.address may come in with port number at its trailer.
	 * Parse it to separate the IP address and port number.
	 * Also translate the hostname to IP address if needed.
	 */
	(void) wcstombs(tmp_target_str,
	    staticConfig.targetAddress.hostnameIpAddress.
	    id.hostname, sizeof (tmp_target_str));

	if (tmp_target_str[0] == '[') {
		/* IPv6 address */
		char *closeBracketPos;
		closeBracketPos = strchr(tmp_target_str, ']');
		if (!closeBracketPos) {
			return (IMA_ERROR_INVALID_PARAMETER);
		}

		*closeBracketPos = NULL;
		(void) strlcpy(target_addr_str, &tmp_target_str[1],
		    sizeof (target_addr_str));

		if (inet_pton(AF_INET6, target_addr_str,
		    &target_in.u_in6) != 1) {
			return (IMA_ERROR_INVALID_PARAMETER);
		}
		target_in_addr_size = sizeof (struct in6_addr);

		/* Extract the port number */
		closeBracketPos++;
		if (*closeBracketPos == ':') {
			closeBracketPos++;

			if (*closeBracketPos != NULL) {
				(void) strlcpy(target_port_str, closeBracketPos,
				    sizeof (target_port_str));
				target_port = atoi(target_port_str);
			} else {
				target_port = ISCSI_LISTEN_PORT;
			}
		} else {
			/* No port number specified; use default port */
			target_port = ISCSI_LISTEN_PORT;
		}
	} else {
		/* IPv4 address */
		char *colonPos;
		colonPos = strchr(tmp_target_str, ':');
		if (!colonPos) {
			/* No port number specified; use default port */
			target_port = ISCSI_LISTEN_PORT;
			(void) strlcpy(target_addr_str, tmp_target_str,
			    sizeof (target_addr_str));
		} else {
			*colonPos = NULL;
			(void) strlcpy(target_addr_str, tmp_target_str,
			    sizeof (target_addr_str));
			/* Extract the port number */
			colonPos++;
			if (*colonPos != NULL) {
				(void) strlcpy(target_port_str, colonPos,
				    sizeof (target_port_str));
				target_port = atoi(target_port_str);
			} else {
				target_port = ISCSI_LISTEN_PORT;
			}
		}

		if (inet_pton(AF_INET, target_addr_str,
		    &target_in.u_in4) != 1) {
			return (IMA_ERROR_INVALID_PARAMETER);
		}

		target_in_addr_size = sizeof (struct in_addr);
	}


	(void) memset(&target, 0, sizeof (iscsi_target_entry_t));
	target.te_entry.e_vers = ISCSI_INTERFACE_VERSION;
	target.te_entry.e_oid = ISCSI_OID_NOTSET;
	target.te_entry.e_tpgt = ISCSI_DEFAULT_TPGT;

	(void) wcstombs((char *)target.te_name, staticConfig.targetName,
	    ISCSI_MAX_NAME_LEN);

	target.te_entry.e_insize = target_in_addr_size;
	if (target.te_entry.e_insize == sizeof (struct in_addr)) {
		target.te_entry.e_u.u_in4.s_addr = target_in.u_in4.s_addr;
	} else if (target.te_entry.e_insize == sizeof (struct in6_addr)) {
		bcopy(target_in.u_in6.s6_addr,
		    target.te_entry.e_u.u_in6.s6_addr,
		    sizeof (struct in6_addr));
	} else {
		/* Should not happen */
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_GET returned bad address");
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	target.te_entry.e_port = target_port;

	/* No target portal group specified. Default to -1. */
	target.te_entry.e_tpgt = ISCSI_DEFAULT_TPGT;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (ioctl(fd, ISCSI_STATIC_SET, &target)) {
		/*
		 * Encountered problem setting the IP address and port for
		 * the target just added.
		 */
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_STATIC_SET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	pTargetOid->objectType = IMA_OBJECT_TYPE_TARGET;
	pTargetOid->ownerId = pluginOwnerId;
	pTargetOid->objectSequenceNumber = target.te_entry.e_oid;

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API	IMA_STATUS IMA_GetTargetProperties(
		IMA_OID targetId,
		IMA_TARGET_PROPERTIES *pProps
)
{
	return (getTargetProperties(targetId, pProps));
}

static IMA_STATUS getTargetProperties(
		IMA_OID targetId,
		IMA_TARGET_PROPERTIES *pProps
)
{
	int		    fd;
	iscsi_property_t    prop;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&prop, 0, sizeof (iscsi_property_t));
	prop.p_vers = ISCSI_INTERFACE_VERSION;
	prop.p_oid = (uint32_t)targetId.objectSequenceNumber;

	if (ioctl(fd, ISCSI_TARGET_PROPS_GET, &prop) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_PROPS_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) mbstowcs(pProps->name, (char *)prop.p_name, IMA_NODE_NAME_LEN);
	(void) memset(pProps->alias, 0,
	    sizeof (IMA_WCHAR) * IMA_NODE_ALIAS_LEN);
	if (prop.p_alias_len > 0) {
		(void) mbstowcs(pProps->alias, (char *)prop.p_alias,
		    IMA_NODE_ALIAS_LEN);
	}

	/* Initialize the discovery method to unknown method. */
	pProps->discoveryMethodFlags = IMA_TARGET_DISCOVERY_METHOD_UNKNOWN;
	if (!((prop.p_discovery & iSCSIDiscoveryMethodStatic) ^
	    iSCSIDiscoveryMethodStatic)) {
		pProps->discoveryMethodFlags |=
		    IMA_TARGET_DISCOVERY_METHOD_STATIC;
	}

	if (!((prop.p_discovery & iSCSIDiscoveryMethodSLP) ^
	    iSCSIDiscoveryMethodSLP)) {
		pProps->discoveryMethodFlags |=	IMA_TARGET_DISCOVERY_METHOD_SLP;
	}

	if (!((prop.p_discovery & iSCSIDiscoveryMethodISNS) ^
	    iSCSIDiscoveryMethodISNS)) {
		pProps->discoveryMethodFlags |=	iSCSIDiscoveryMethodISNS;
	}

	if (!((prop.p_discovery & iSCSIDiscoveryMethodSendTargets) ^
	    iSCSIDiscoveryMethodSendTargets)) {
		pProps->discoveryMethodFlags |= iSCSIDiscoveryMethodSendTargets;
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_GetTargetErrorStatistics(
		IMA_OID targetId,
		IMA_TARGET_ERROR_STATISTICS *pStats
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

IMA_API	IMA_STATUS IMA_GetLuOidList(
		IMA_OID oid,
		IMA_OID_LIST **ppList
)
{
	IMA_STATUS		status;
	int			i;
	iscsi_lun_list_t	*pLunList;

	if (oid.objectType == IMA_OBJECT_TYPE_LHBA) {
		status = get_target_lun_oid_list(NULL, &pLunList);
	} else {
		status = get_target_lun_oid_list(&oid, &pLunList);
	}

	if (!IMA_SUCCESS(status)) {
		return (status);
	}

	*ppList = (IMA_OID_LIST *) calloc(1, (sizeof (IMA_OID_LIST) +
	    (pLunList->ll_out_cnt * sizeof (IMA_OID))));
	if (*ppList == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->oidCount = pLunList->ll_out_cnt;
	for (i = 0; i < pLunList->ll_out_cnt; i++) {
		(*ppList)->oids[i].objectType = IMA_OBJECT_TYPE_LU;
		(*ppList)->oids[i].ownerId = pluginOwnerId;
		(*ppList)->oids[i].objectSequenceNumber =
		    pLunList->ll_luns[i].l_oid;
	}

	free(pLunList);
	return (IMA_STATUS_SUCCESS);
}

IMA_API	IMA_STATUS IMA_GetLuOid(
		IMA_OID targetId,
		IMA_UINT64 lun,
		IMA_OID *pluId
)
{
	IMA_STATUS		status;
	int			i;
	iscsi_lun_list_t	*pLunList;

	status = get_target_lun_oid_list(&targetId, &pLunList);
	if (!IMA_SUCCESS(status)) {
		return (status);
	}

	for (i = 0; i < pLunList->ll_out_cnt; i++) {
		if (pLunList->ll_luns[i].l_num == lun) {
			pluId->objectType = IMA_OBJECT_TYPE_LU;
			pluId->ownerId = pluginOwnerId;
			pluId->objectSequenceNumber =
			    pLunList->ll_luns[i].l_oid;
			free(pLunList);
			return (IMA_STATUS_SUCCESS);
		}
	}

	free(pLunList);
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

IMA_API	IMA_STATUS IMA_GetLuProperties(
		IMA_OID luId,
		IMA_LU_PROPERTIES *pProps
)
{
	return (getLuProperties(luId, pProps));
}

static IMA_STATUS getLuProperties(
		IMA_OID luId,
		IMA_LU_PROPERTIES *pProps
)
{
	IMA_STATUS		status;
	iscsi_lun_list_t	*pLunList;
	int			j;
	IMA_BOOL		lunMatch = IMA_FALSE;
	int			fd;
	iscsi_lun_props_t	lun;
	di_devlink_handle_t	hdl;

	if (luId.objectType != IMA_OBJECT_TYPE_LU) {
		return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
	}

	/*
	 * get list of lun oids for all targets
	 */
	status = get_target_lun_oid_list(NULL, &pLunList);
	if (!IMA_SUCCESS(status)) {
		return (status);
	}
	for (j = 0; j < pLunList->ll_out_cnt; j++) {
		/*
		 * for each lun, check if match is found
		 */
		if (pLunList->ll_luns[j].l_oid == luId.objectSequenceNumber) {
			/*
			 * match found, break out of lun loop
			 */
			lunMatch = IMA_TRUE;
			break;
		}
	}

	if (lunMatch == IMA_TRUE) {
		(void) memset(&lun, 0, sizeof (iscsi_lun_props_t));
		lun.lp_vers = ISCSI_INTERFACE_VERSION;
		lun.lp_tgt_oid = pLunList->ll_luns[j].l_tgt_oid;
		lun.lp_oid = pLunList->ll_luns[j].l_oid;
	}

	free(pLunList);

	if (lunMatch == IMA_FALSE) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}

	/*
	 * get lun properties
	 */
	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (ioctl(fd, ISCSI_LUN_PROPS_GET, &lun)) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_LUN_PROPS_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}
	(void) close(fd);

	/*
	 * set property values
	 */
	pProps->associatedTargetOid.objectType = IMA_OBJECT_TYPE_TARGET;
	pProps->associatedTargetOid.ownerId = pluginOwnerId;
	pProps->associatedTargetOid.objectSequenceNumber = lun.lp_tgt_oid;
	pProps->targetLun = (IMA_UINT64)lun.lp_num;
	pProps->exposedToOs = IMA_TRUE;
	(void) memset(&pProps->timeExposedToOs, 0,
	    sizeof (pProps->timeExposedToOs));

	if (lun.lp_status == LunValid) {

		/* add minor device delimiter */
		(void) strcat(lun.lp_pathname, ":");

		if ((strstr(lun.lp_pathname, "sd@") != NULL) ||
		    (strstr(lun.lp_pathname, "ssd@") != NULL) ||
		    (strstr(lun.lp_pathname, "disk@") != NULL)) {
			/*
			 * modify returned pathname to obtain the 2nd slice
			 * of the raw disk
			 */
			(void) strcat(lun.lp_pathname, "c,raw");
		}

		/*
		 * Pathname returned by driver is the physical device path.
		 * This name needs to be converted to the OS device name.
		 */
		if (hdl = di_devlink_init(lun.lp_pathname, DI_MAKE_LINK)) {
			pProps->osDeviceName[0] = L'\0';
			(void) di_devlink_walk(hdl, NULL, lun.lp_pathname,
			    DI_PRIMARY_LINK, (void *)pProps->osDeviceName,
			    get_lun_devlink);
			if (pProps->osDeviceName[0] != L'\0') {
				/* OS device name synchronously made */
				pProps->osDeviceNameValid = IMA_TRUE;
			} else {
				pProps->osDeviceNameValid = IMA_FALSE;
			}

			(void) di_devlink_fini(&hdl);
		} else {
			pProps->osDeviceNameValid = IMA_FALSE;
		}

	} else {
		pProps->osDeviceNameValid = IMA_FALSE;
	}

	pProps->osParallelIdsValid = IMA_FALSE;

	return (IMA_STATUS_SUCCESS);
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_GetStatisticsProperties(
		IMA_OID oid,
		IMA_STATISTICS_PROPERTIES *pProps
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_GetDeviceStatistics(
		IMA_OID luId,
		IMA_DEVICE_STATISTICS *pStats
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

IMA_API	IMA_STATUS IMA_LuInquiry(
	IMA_OID deviceId,
	IMA_BOOL evpd,
	IMA_BOOL cmddt,
	IMA_BYTE pageCode,
	IMA_BYTE *pOutputBuffer,
	IMA_UINT *pOutputBufferLength,
	IMA_BYTE *pSenseBuffer,
	IMA_UINT *pSenseBufferLength
)
{
	IMA_LU_PROPERTIES luProps;
	IMA_STATUS status;
	unsigned char cmdblk[CDB_GROUP0];
	IMA_UINT buflen;
	int fd;
	iscsi_uscsi_t uscsi;

	(void) memset(&cmdblk[0], 0, CDB_GROUP0);
	cmdblk[0] = SCMD_INQUIRY;

	if (evpd == IMA_TRUE)
		cmdblk[1] |= 0x01;
	if (cmddt == IMA_TRUE)
		cmdblk[1] |= 0x02;

	cmdblk[2] = pageCode;

	if (*pOutputBufferLength > MAX_INQUIRY_BUFFER_LEN) {
		buflen = MAX_INQUIRY_BUFFER_LEN;
	} else {
		buflen = *pOutputBufferLength;
	}
	cmdblk[3] = (buflen & 0xff00) >> 8;
	cmdblk[4] = (buflen & 0x00ff);

	(void) memset(&uscsi, 0, sizeof (iscsi_uscsi_t));
	uscsi.iu_vers 	= ISCSI_INTERFACE_VERSION;

	/* iu_oid is a session oid in the driver */
	if (deviceId.objectType == IMA_OBJECT_TYPE_TARGET) {
		uscsi.iu_oid	= deviceId.objectSequenceNumber;
		uscsi.iu_lun	= 0;
	} else {
		/*
		 * Get LU properties and associated session oid
		 * for this lun(deviceId) and put in uscsi.iu_oid
		 */
		status = getLuProperties(deviceId, &luProps);
		if (status != IMA_STATUS_SUCCESS) {
			return (status);
		}
		uscsi.iu_oid = (uint32_t)luProps.associatedTargetOid.
		    objectSequenceNumber;
		uscsi.iu_lun = luProps.targetLun;
	}

	uscsi.iu_ucmd.uscsi_flags = USCSI_READ;
	uscsi.iu_ucmd.uscsi_timeout = USCSI_TIMEOUT_IN_SEC;
	uscsi.iu_ucmd.uscsi_bufaddr = (char *)pOutputBuffer;
	uscsi.iu_ucmd.uscsi_buflen = buflen;
	uscsi.iu_ucmd.uscsi_rqbuf = (char *)pSenseBuffer;
	uscsi.iu_ucmd.uscsi_rqlen = (pSenseBufferLength != NULL) ?
	    *pSenseBufferLength : 0;
	uscsi.iu_ucmd.uscsi_cdb = (char *)&cmdblk[0];
	uscsi.iu_ucmd.uscsi_cdblen = CDB_GROUP0;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (ioctl(fd, ISCSI_USCSI, &uscsi) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_PROPS_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (uscsi.iu_ucmd.uscsi_status == STATUS_CHECK) {
		if (pSenseBufferLength != NULL) {
			*pSenseBufferLength -= uscsi.iu_ucmd.uscsi_rqresid;
		}
		return (IMA_ERROR_SCSI_STATUS_CHECK_CONDITION);
	}

	*pOutputBufferLength = buflen - uscsi.iu_ucmd.uscsi_resid;
	return (IMA_STATUS_SUCCESS);
}

IMA_API	IMA_STATUS IMA_LuReadCapacity(
		IMA_OID deviceId,
		IMA_UINT cdbLength,
		IMA_BYTE *pOutputBuffer,
		IMA_UINT *pOutputBufferLength,

		IMA_BYTE *pSenseBuffer,
		IMA_UINT *pSenseBufferLength
)
{
	IMA_LU_PROPERTIES luProps;
	IMA_STATUS status;
	/* CDB_GROUP4 size is safe for both 10 and 16 byte CDBs */
	unsigned char cmdblk[CDB_GROUP4];
	IMA_UINT buflen;
	int fd;
	iscsi_uscsi_t uscsi;

	(void) memset(&cmdblk[0], 0, CDB_GROUP4);

	if (cdbLength == CDB_GROUP1) {
		/* Read Capacity (10) command. */
		cmdblk[0] = SCMD_READ_CAPACITY;
		buflen = *pOutputBufferLength;
	} else if (cdbLength == CDB_GROUP4) {
		/*
		 * Read Capacity (16) is a Service Action In command. One
		 * command byte (0x9E) is overloaded for multiple operations,
		 * with the second CDB byte specifying the desired operation.
		 */
		cmdblk[0] = SCMD_SVC_ACTION_IN_G4;
		cmdblk[1] = SSVC_ACTION_READ_CAPACITY_G4;

		if (*pOutputBufferLength > MAX_READ_CAPACITY16_BUFFER_LEN) {
			buflen = MAX_READ_CAPACITY16_BUFFER_LEN;
		} else {
			buflen = *pOutputBufferLength;
		}
		cmdblk[10] = (buflen & 0xff000000) >> 24;
		cmdblk[11] = (buflen & 0x00ff0000) >> 16;
		cmdblk[12] = (buflen & 0x0000ff00) >> 8;
		cmdblk[13] = (buflen & 0x000000ff);
	} else {
		/* only 10 and 16 byte CDB are supported */
		return (IMA_ERROR_NOT_SUPPORTED);
	}

	(void) memset(&uscsi, 0, sizeof (iscsi_uscsi_t));
	uscsi.iu_vers 	= ISCSI_INTERFACE_VERSION;

	/* iu_oid is a session oid in the driver */
	if (deviceId.objectType == IMA_OBJECT_TYPE_TARGET) {
		uscsi.iu_oid	= deviceId.objectSequenceNumber;
		uscsi.iu_lun	= 0;
	} else {
		/*
		 * Get LU properties and associated session oid
		 * for this lun(deviceId) and put in uscsi.iu_oid
		 */
		status = getLuProperties(deviceId, &luProps);
		if (status != IMA_STATUS_SUCCESS) {
			return (status);
		}
		uscsi.iu_oid = (uint32_t)luProps.associatedTargetOid.
		    objectSequenceNumber;
		uscsi.iu_lun = luProps.targetLun;
	}

	uscsi.iu_ucmd.uscsi_flags = USCSI_READ;
	uscsi.iu_ucmd.uscsi_timeout = USCSI_TIMEOUT_IN_SEC;
	uscsi.iu_ucmd.uscsi_bufaddr = (char *)pOutputBuffer;
	uscsi.iu_ucmd.uscsi_buflen = buflen;
	uscsi.iu_ucmd.uscsi_rqbuf = (char *)pSenseBuffer;
	uscsi.iu_ucmd.uscsi_rqlen = (pSenseBufferLength != NULL) ?
	    *pSenseBufferLength : 0;
	uscsi.iu_ucmd.uscsi_cdb = (char *)&cmdblk[0];
	uscsi.iu_ucmd.uscsi_cdblen = cdbLength;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (ioctl(fd, ISCSI_USCSI, &uscsi) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_PROPS_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (uscsi.iu_ucmd.uscsi_status == STATUS_CHECK) {
		if (pSenseBufferLength != NULL) {
			*pSenseBufferLength -= uscsi.iu_ucmd.uscsi_rqresid;
		}
		return (IMA_ERROR_SCSI_STATUS_CHECK_CONDITION);
	}

	*pOutputBufferLength = buflen - uscsi.iu_ucmd.uscsi_resid;
	return (IMA_STATUS_SUCCESS);
}

IMA_API	IMA_STATUS IMA_LuReportLuns(
		IMA_OID deviceId,
		IMA_BOOL sendToWellKnownLun,
		IMA_BYTE selectReport,

		IMA_BYTE *pOutputBuffer,
		IMA_UINT *pOutputBufferLength,

		IMA_BYTE *pSenseBuffer,
		IMA_UINT *pSenseBufferLength
)
{
	IMA_LU_PROPERTIES luProps;
	IMA_STATUS status;
	unsigned char cmdblk[CDB_GROUP5];
	IMA_UINT buflen;
	int fd;
	iscsi_uscsi_t uscsi;

	(void) memset(&cmdblk[0], 0, CDB_GROUP5);
	cmdblk[0] = SCMD_REPORT_LUNS;
	cmdblk[2] = selectReport;

	if (*pOutputBufferLength > MAX_REPORT_LUNS_BUFFER_LEN) {
		buflen = MAX_REPORT_LUNS_BUFFER_LEN;
	} else {
		buflen = *pOutputBufferLength;
	}
	cmdblk[6] = (buflen & 0xff000000) >> 24;
	cmdblk[7] = (buflen & 0x00ff0000) >> 16;
	cmdblk[8] = (buflen & 0x0000ff00) >> 8;
	cmdblk[9] = (buflen & 0x000000ff);

	(void) memset(&uscsi, 0, sizeof (iscsi_uscsi_t));
	uscsi.iu_vers 	= ISCSI_INTERFACE_VERSION;

	/* iu_oid is a session oid in the driver */
	if (deviceId.objectType == IMA_OBJECT_TYPE_TARGET) {
		if (sendToWellKnownLun == IMA_TRUE) {
			/* this optional feature is not supported now */
			return (IMA_ERROR_NOT_SUPPORTED);
		}
		uscsi.iu_oid	= deviceId.objectSequenceNumber;
		uscsi.iu_lun	= 0;
	} else {
		/*
		 * Get LU properties and associated session oid
		 * for this lun(deviceId) and put in uscsi.iu_oid
		 */
		status = getLuProperties(deviceId, &luProps);
		if (status != IMA_STATUS_SUCCESS) {
			return (status);
		}
		uscsi.iu_oid = (uint32_t)luProps.associatedTargetOid.
		    objectSequenceNumber;
		uscsi.iu_lun = luProps.targetLun;
	}

	uscsi.iu_ucmd.uscsi_flags = USCSI_READ;
	uscsi.iu_ucmd.uscsi_timeout = USCSI_TIMEOUT_IN_SEC;
	uscsi.iu_ucmd.uscsi_bufaddr = (char *)pOutputBuffer;
	uscsi.iu_ucmd.uscsi_buflen = buflen;
	uscsi.iu_ucmd.uscsi_rqbuf = (char *)pSenseBuffer;
	uscsi.iu_ucmd.uscsi_rqlen = (pSenseBufferLength != NULL) ?
	    *pSenseBufferLength : 0;
	uscsi.iu_ucmd.uscsi_cdb = (char *)&cmdblk[0];
	uscsi.iu_ucmd.uscsi_cdblen = CDB_GROUP5;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (ioctl(fd, ISCSI_USCSI, &uscsi) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_PROPS_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (uscsi.iu_ucmd.uscsi_status == STATUS_CHECK) {
		if (pSenseBufferLength != NULL) {
			*pSenseBufferLength -= uscsi.iu_ucmd.uscsi_rqresid;
		}
		return (IMA_ERROR_SCSI_STATUS_CHECK_CONDITION);
	}

	*pOutputBufferLength = buflen - uscsi.iu_ucmd.uscsi_resid;
	return (IMA_STATUS_SUCCESS);
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_ExposeLu(
		IMA_OID luId
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_UnexposeLu(
		IMA_OID luId
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

IMA_API	IMA_STATUS IMA_GetAddressKeys(
		IMA_OID targetOid,
		IMA_ADDRESS_KEYS **ppKeys
)
{
	IMA_STATUS status;
	IMA_TARGET_PROPERTIES targetProps;
	SUN_IMA_DISC_ADDR_PROP_LIST *discAddressList;
	SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES *pList;
	int i, j, addressKeyCount = 0;
	int addressKeyIdx = 0;

	status = getTargetProperties(targetOid, &targetProps);
	if (status != IMA_STATUS_SUCCESS) {
		return (status);
	}

	status = getDiscoveryAddressPropertiesList(&discAddressList);
	if (status != IMA_STATUS_SUCCESS) {
		return (status);
	}

	/* Get the number of addresses to allocate */
	for (i = 0; i < discAddressList->discAddrCount; i++) {
		(void) sendTargets(discAddressList->props[i].discoveryAddress,
		    &pList);
		for (j = 0; j < pList->keyCount; j++) {
			if (wcsncmp(pList->keys[j].name, targetProps.name,
			    wslen(pList->keys[j].name)) == 0) {
				addressKeyCount++;
			}
		}
		(void) IMA_FreeMemory(pList);
	}

	*ppKeys = (IMA_ADDRESS_KEYS *)calloc(1, sizeof (IMA_ADDRESS_KEYS) +
	    addressKeyCount * sizeof (IMA_ADDRESS_KEY));
	if (*ppKeys == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppKeys)->addressKeyCount = addressKeyCount;
	addressKeyIdx = 0;

	for (i = 0; i < discAddressList->discAddrCount; i++) {
		(void) sendTargets(discAddressList->props[i].discoveryAddress,
		    &pList);
		for (j = 0; j < pList->keyCount; j++) {
			if (wcsncmp(pList->keys[j].name, targetProps.name,
			    wslen(pList->keys[j].name)) != 0) {
				continue;
			}

			bcopy(&(pList->keys[j].address.ipAddress),
			    &((*ppKeys)->addressKeys[addressKeyIdx].
			    ipAddress), sizeof (IMA_IP_ADDRESS));

			(*ppKeys)->addressKeys[addressKeyIdx++].portNumber =
			    pList->keys[j].address.portNumber;

		}
		(void) IMA_FreeMemory(pList);
	}
	return (IMA_STATUS_SUCCESS);
}

IMA_BOOL isAuthMethodValid(IMA_OID oid, IMA_AUTHMETHOD method) {
	IMA_STATUS status;
	IMA_AUTHMETHOD supportedList[MAX_AUTHMETHODS];
	IMA_UINT i, supportedCount;
	IMA_BOOL supported;
	status = getSupportedAuthMethods(oid, IMA_FALSE, &supportedCount,
			supportedList);
	if (status != IMA_STATUS_SUCCESS)
		return (IMA_FALSE);

	supported = IMA_FALSE;
	for (i = 0; i < supportedCount; i++) {
		if (method == supportedList[i]) {
			supported = IMA_TRUE;
		}
	}

	return (supported);
}

IMA_BOOL isAuthMethodListValid(IMA_OID oid, const IMA_AUTHMETHOD *pMethodList,
				IMA_UINT methodCount) {
	IMA_UINT i, j;

	if (pMethodList == NULL) {
		return (IMA_FALSE);
	}
	/* Check list for duplicates */
	for (i = 0; i < methodCount; i++) {
		for (j = i + 1; j < methodCount; j++) {
			if (pMethodList[i] == pMethodList[j]) {
				return (IMA_FALSE);
			}
		}

		if (isAuthMethodValid(oid, pMethodList[i]) == IMA_FALSE) {
			return (IMA_FALSE);
		}
	}
	return (IMA_TRUE);
}

IMA_API	IMA_STATUS IMA_GetSupportedAuthMethods(
		IMA_OID lhbaOid,
		IMA_BOOL getSettableMethods,
		IMA_UINT *pMethodCount,
		IMA_AUTHMETHOD *pMethodList
)
{
	return (getSupportedAuthMethods(lhbaOid, getSettableMethods,
	    pMethodCount, pMethodList));
}


/*ARGSUSED*/
static IMA_STATUS getSupportedAuthMethods(
		IMA_OID lhbaOid,
		IMA_BOOL getSettableMethods,
		IMA_UINT *pMethodCount,
		IMA_AUTHMETHOD *pMethodList
)
{
	if (pMethodList == NULL) {
		*pMethodCount = 0;
		return (IMA_STATUS_SUCCESS);
	}

	*pMethodCount = NUM_SUPPORTED_AUTH_METHODS;
	if (*pMethodCount > 1) {
		pMethodList[0] = IMA_AUTHMETHOD_NONE;
		pMethodList[1] = IMA_AUTHMETHOD_CHAP;
	}

	return (IMA_STATUS_SUCCESS);
}

IMA_API	IMA_STATUS IMA_GetInUseInitiatorAuthMethods(
		IMA_OID		lhbaOid,
		IMA_UINT	*pMethodCount,
		IMA_AUTHMETHOD *pMethodList
)
{
	return (getAuthMethods(lhbaOid, pMethodCount, pMethodList));
}

/*ARGSUSED*/
IMA_API	IMA_STATUS IMA_GetInitiatorAuthParms(
		IMA_OID lhbaOid,
		IMA_AUTHMETHOD method,
		IMA_INITIATOR_AUTHPARMS *pParms
)
{
	int fd;
	iscsi_chap_props_t  chap_p;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&chap_p, 0, sizeof (iscsi_chap_props_t));
	chap_p.c_vers = ISCSI_INTERFACE_VERSION;
	chap_p.c_oid = (uint32_t)lhbaOid.objectSequenceNumber;

	if (method == IMA_AUTHMETHOD_CHAP) {
		if (ioctl(fd, ISCSI_CHAP_GET, &chap_p) != 0) {
			syslog(LOG_USER|LOG_DEBUG,
			"ISCSI_CHAP_GET ioctl failed, errno: %d", errno);
			(void) close(fd);
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	} else {
		return (IMA_ERROR_INVALID_PARAMETER);
	}

	(void) memcpy(pParms->chapParms.name, chap_p.c_user,
	    chap_p.c_user_len);
	pParms->chapParms.nameLength = chap_p.c_user_len;
	(void) memcpy(pParms->chapParms.challengeSecret, chap_p.c_secret,
	    chap_p.c_secret_len);
	pParms->chapParms.challengeSecretLength = chap_p.c_secret_len;

	return (IMA_STATUS_SUCCESS);
}

IMA_API	IMA_STATUS IMA_SetInitiatorAuthMethods(
		IMA_OID lhbaOid,
		IMA_UINT methodCount,
		const IMA_AUTHMETHOD *pMethodList
)
{
	if (isAuthMethodListValid(lhbaOid, pMethodList,
	    methodCount) == IMA_FALSE)
		return (IMA_ERROR_INVALID_PARAMETER);
	return (setAuthMethods(lhbaOid, &methodCount, pMethodList));
}

/*
 * This function only sets CHAP params since we only support CHAP for now.
 */
IMA_API	IMA_STATUS IMA_SetInitiatorAuthParms(
		IMA_OID lhbaOid,
		IMA_AUTHMETHOD method,
		const IMA_INITIATOR_AUTHPARMS *pParms
)
{
	int fd;
	iscsi_chap_props_t  chap_p;

	if (method != IMA_AUTHMETHOD_CHAP)
		return (IMA_ERROR_INVALID_PARAMETER);

	if (isAuthMethodValid(lhbaOid, method) == IMA_FALSE) {
		return (IMA_ERROR_INVALID_PARAMETER);
	}

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&chap_p, 0, sizeof (iscsi_chap_props_t));
	chap_p.c_vers = ISCSI_INTERFACE_VERSION;
	chap_p.c_oid = (uint32_t)lhbaOid.objectSequenceNumber;

	chap_p.c_user_len = pParms->chapParms.nameLength;
	(void) memcpy(chap_p.c_user, pParms->chapParms.name, chap_p.c_user_len);

	chap_p.c_secret_len = pParms->chapParms.challengeSecretLength;
	(void) memcpy(chap_p.c_secret, pParms->chapParms.challengeSecret,
	    chap_p.c_secret_len);

	if (method == IMA_AUTHMETHOD_CHAP) {
		if (ioctl(fd, ISCSI_CHAP_SET, &chap_p) != 0) {
			(void) close(fd);
			syslog(LOG_USER|LOG_DEBUG,
			    "ISCSI_CHAP_SET ioctl failed, errno: %d", errno);
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}

	return (IMA_STATUS_SUCCESS);
}

/* A helper function to obtain iSCSI node parameters. */
static IMA_STATUS
getISCSINodeParameter(
    int paramType,
    IMA_OID *oid,
    void *pProps,
    uint32_t paramIndex
)
{
	int		    fd;
	iscsi_param_get_t   pg;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&pg, 0, sizeof (iscsi_param_get_t));
	pg.g_vers = ISCSI_INTERFACE_VERSION;
	pg.g_oid = (uint32_t)oid->objectSequenceNumber;
	pg.g_param = paramIndex;
	pg.g_param_type = ISCSI_SESS_PARAM;

	if (ioctl(fd, ISCSI_PARAM_GET, &pg) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_PARAM_GET ioctl failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	switch (paramType) {
		IMA_BOOL_VALUE *bp;
		IMA_MIN_MAX_VALUE *mp;

		case MIN_MAX_PARAM:
			mp = (IMA_MIN_MAX_VALUE *)pProps;

			mp->currentValueValid =
			    (pg.g_value.v_valid == B_TRUE) ?
			    IMA_TRUE : IMA_FALSE;
			mp->currentValue = pg.g_value.v_integer.i_current;
			mp->defaultValue = pg.g_value.v_integer.i_default;
			mp->minimumValue = pg.g_value.v_integer.i_min;
			mp->maximumValue = pg.g_value.v_integer.i_max;
			mp->incrementValue = pg.g_value.v_integer.i_incr;
			break;

		case BOOL_PARAM:
			bp = (IMA_BOOL_VALUE *)pProps;
			bp->currentValueValid =
			    (pg.g_value.v_valid == B_TRUE) ?
			    IMA_TRUE : IMA_FALSE;
			bp->currentValue = pg.g_value.v_bool.b_current;
			bp->defaultValue = pg.g_value.v_bool.b_default;
			break;

		default:
			break;
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

/* A helper function to set iSCSI node parameters. */
static IMA_STATUS
setISCSINodeParameter(
    int paramType,
    IMA_OID *oid,
    void *pProp,
    uint32_t paramIndex
)
{
	int		    fd;
	iscsi_param_set_t   ps;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&ps, 0, sizeof (iscsi_param_set_t));
	ps.s_vers = ISCSI_INTERFACE_VERSION;
	ps.s_oid = (uint32_t)oid->objectSequenceNumber;
	ps.s_param = paramIndex;

	switch (paramType) {
		IMA_BOOL_VALUE *bp;
		IMA_MIN_MAX_VALUE *mp;

		case MIN_MAX_PARAM:
			mp = (IMA_MIN_MAX_VALUE *)pProp;
			ps.s_value.v_integer = mp->currentValue;
			break;
		case BOOL_PARAM:
			bp = (IMA_BOOL_VALUE *)pProp;
			ps.s_value.v_bool =
			    (bp->currentValue == IMA_TRUE) ?
			    B_TRUE : B_FALSE;
			break;

		default:
			break;
	}

	if (ioctl(fd, ISCSI_PARAM_SET, &ps)) {
		int tmpErrno = errno;
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_PARAM_SET ioctl failed, errno: %d", errno);
		(void) close(fd);
		switch (tmpErrno) {
			case ENOTSUP :
				return (IMA_ERROR_NOT_SUPPORTED);
			default :
				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

static int
prepare_discovery_entry(
    IMA_TARGET_ADDRESS discoveryAddress,
    entry_t *entry
)
{
	(void) memset(entry, 0, sizeof (entry_t));
	entry->e_vers = ISCSI_INTERFACE_VERSION;
	entry->e_oid = ISCSI_OID_NOTSET;

	if (discoveryAddress.hostnameIpAddress.id.ipAddress.ipv4Address ==
	    IMA_FALSE) {
		bcopy(discoveryAddress.hostnameIpAddress.id.ipAddress.ipAddress,
		    entry->e_u.u_in6.s6_addr,
		    sizeof (entry->e_u.u_in6.s6_addr));
		entry->e_insize = sizeof (struct in6_addr);
	} else {
		bcopy(discoveryAddress.hostnameIpAddress.id.ipAddress.ipAddress,
		    &entry->e_u.u_in4.s_addr,
		    sizeof (entry->e_u.u_in4.s_addr));
		entry->e_insize = sizeof (struct in_addr);
	}

	entry->e_port = discoveryAddress.portNumber;
	entry->e_tpgt = 0;
	return (DISC_ADDR_OK);
}

static IMA_STATUS configure_discovery_method(
    IMA_BOOL enable,
    iSCSIDiscoveryMethod_t method
)
{
	int fd, status;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	if (enable == IMA_FALSE) {
		if (ioctl(fd, ISCSI_DISCOVERY_CLEAR, &method)) {
			status = errno;
			(void) close(fd);
			syslog(LOG_USER|LOG_DEBUG,
			    "ISCSI_DISCOVERY_CLEAR ioctl failed, errno: %d",
			    status);
			if (status == EBUSY) {
				return (IMA_ERROR_LU_IN_USE);
			} else {
				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
			}
		}

		(void) close(fd);
		return (IMA_STATUS_SUCCESS);
	} else {
		/* Set the discovery method */
		if (ioctl(fd, ISCSI_DISCOVERY_SET, &method)) {
			(void) close(fd);
			syslog(LOG_USER|LOG_DEBUG,
			    "ISCSI_DISCOVERY_SET ioctl failed, errno: %d",
			    errno);
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}

		(void) close(fd);
		return (IMA_STATUS_SUCCESS);
	}
}

static IMA_STATUS get_target_oid_list(
    uint32_t targetListType,
    IMA_OID_LIST **ppList)
{
	int		    fd;
	int		    i;
	int		    target_list_size;
	iscsi_target_list_t *idlp, tl_info;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&tl_info, 0, sizeof (tl_info));
	tl_info.tl_vers = ISCSI_INTERFACE_VERSION;
	tl_info.tl_in_cnt = 0;
	tl_info.tl_tgt_list_type = targetListType;

	/*
	 * Issue ioctl to obtain the number of targets.
	 */
	if (ioctl(fd, ISCSI_TARGET_OID_LIST_GET, &tl_info) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_OID_LIST_GET ioctl %d failed, errno: %d",
		    targetListType, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	target_list_size = sizeof (iscsi_target_list_t);
	if (tl_info.tl_out_cnt > 1) {
		target_list_size += (sizeof (uint32_t) *
		    tl_info.tl_out_cnt - 1);
	}

	idlp = (iscsi_target_list_t *)calloc(1, target_list_size);
	if (idlp == NULL) {
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	idlp->tl_vers = ISCSI_INTERFACE_VERSION;
	idlp->tl_in_cnt = tl_info.tl_out_cnt;
	idlp->tl_tgt_list_type = targetListType;

	/* Issue the same ioctl again to obtain the OIDs. */
	if (ioctl(fd, ISCSI_TARGET_OID_LIST_GET, idlp) != 0) {
		free(idlp);
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TARGET_OID_LIST_GET ioctl %d failed, errno: %d",
		    targetListType, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	*ppList = (IMA_OID_LIST *)calloc(1, sizeof (IMA_OID_LIST) +
	    idlp->tl_out_cnt * sizeof (IMA_OID));
	if (*ppList == NULL) {
		free(idlp);
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->oidCount = idlp->tl_out_cnt;

	for (i = 0; i < idlp->tl_out_cnt; i++) {

		if (targetListType == ISCSI_STATIC_TGT_OID_LIST)
			(*ppList)->oids[i].objectType =
			    IMA_OBJECT_TYPE_STATIC_DISCOVERY_TARGET;
		else
			(*ppList)->oids[i].objectType = IMA_OBJECT_TYPE_TARGET;

		(*ppList)->oids[i].ownerId = pluginOwnerId;
		(*ppList)->oids[i].objectSequenceNumber = idlp->tl_oid_list[i];
	}

	free(idlp);
	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

static IMA_STATUS get_target_lun_oid_list(
    IMA_OID * targetOid,
    iscsi_lun_list_t  **ppLunList)
{
	int			fd;
	iscsi_lun_list_t	*illp, ll_info;
	int			lun_list_size;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&ll_info, 0, sizeof (ll_info));
	ll_info.ll_vers = ISCSI_INTERFACE_VERSION;
	if (targetOid == NULL) {
		/* get lun oid list for all targets */
		ll_info.ll_all_tgts = B_TRUE;
	} else {
		/* get lun oid list for single target */
		ll_info.ll_all_tgts = B_FALSE;
		ll_info.ll_tgt_oid = (uint32_t)targetOid->objectSequenceNumber;
	}
	ll_info.ll_in_cnt = 0;

	/*
	 * Issue ioctl to obtain the number of target LUNs.
	 */
	if (ioctl(fd, ISCSI_LUN_OID_LIST_GET, &ll_info) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_LUN_LIST_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	lun_list_size = sizeof (iscsi_lun_list_t);
	if (ll_info.ll_out_cnt > 1) {
		lun_list_size += (sizeof (iscsi_if_lun_t) *
		    (ll_info.ll_out_cnt - 1));
	}

	illp = (iscsi_lun_list_t *)calloc(1, lun_list_size);
	if (illp == NULL) {
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	illp->ll_vers = ISCSI_INTERFACE_VERSION;
	illp->ll_all_tgts = ll_info.ll_all_tgts;
	illp->ll_tgt_oid = ll_info.ll_tgt_oid;
	illp->ll_in_cnt = ll_info.ll_out_cnt;

	/* Issue the same ioctl again to get the target LUN list */
	if (ioctl(fd, ISCSI_LUN_OID_LIST_GET, illp) != 0) {
		free(illp);
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_LUN_LIST_GET ioctl failed, errno: %d", errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	*ppLunList = illp;

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}


/* A helper function to set authentication method. */
static IMA_STATUS
setAuthMethods(
    IMA_OID oid,
    IMA_UINT *pMethodCount,
    const IMA_AUTHMETHOD *pMethodList
)
{
	int fd;
	int i;
	iscsi_auth_props_t auth;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}
	(void) memset(&auth, 0, sizeof (iscsi_auth_props_t));
	auth.a_vers = ISCSI_INTERFACE_VERSION;
	auth.a_oid = (uint32_t)oid.objectSequenceNumber;
	/* First do a get because other data fields may exist */
	if (ioctl(fd, ISCSI_AUTH_GET, &auth) != 0) {
		/* EMPTY */
		/* It is fine if there is no other data fields. */
	}
	auth.a_auth_method = authMethodNone;

	for (i = 0; i < *pMethodCount; i++) {
		switch (pMethodList[i]) {
			case IMA_AUTHMETHOD_CHAP:
				auth.a_auth_method |= authMethodCHAP;
				break;
			default:
				break;
		}
	}

	if (ioctl(fd, ISCSI_AUTH_SET, &auth) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_AUTH_SET failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

/* A helper function to get authentication method. */
static IMA_STATUS
getAuthMethods(
    IMA_OID oid,
    IMA_UINT	*pMethodCount,
    IMA_AUTHMETHOD *pMethodList
)
{
	int fd, i;
	iscsi_auth_props_t auth;

	if (pMethodList == NULL) {
		*pMethodCount = 0;
		return (IMA_STATUS_SUCCESS);
	}

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&auth, 0, sizeof (iscsi_auth_props_t));
	auth.a_vers = ISCSI_INTERFACE_VERSION;
	auth.a_oid = (uint32_t)oid.objectSequenceNumber;

	if (ioctl(fd, ISCSI_AUTH_GET, &auth) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_AUTH_GET failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	i = 0;
	if (auth.a_auth_method == IMA_AUTHMETHOD_NONE) {
		pMethodList[i++] = IMA_AUTHMETHOD_NONE;
	} else if (auth.a_auth_method & authMethodCHAP) {
		pMethodList[i++] = IMA_AUTHMETHOD_CHAP;
	}
	*pMethodCount = i;

	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_GetPhbaOidList(
		IMA_OID_LIST **ppList
)
{
	*ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST));
	if (*ppList == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->oidCount = 0;
	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetPhbaProperties(
		IMA_OID phbaOid,
		IMA_PHBA_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetPhbaStatus(
		IMA_OID phbaOid,
		IMA_PHBA_STATUS *pStatus
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetPhbaDownloadProperties(
		IMA_OID phbaOid,
		IMA_PHBA_DOWNLOAD_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_IsPhbaDownloadFile(
		IMA_OID phbaOid,
		const IMA_WCHAR *pFileName,
		IMA_PHBA_DOWNLOAD_IMAGE_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_PhbaDownload(
		IMA_OID phbaOid,
		IMA_PHBA_DOWNLOAD_IMAGE_TYPE imageType,
		const IMA_WCHAR *pFileName
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

IMA_API IMA_STATUS IMA_GetPnpOidList(
		IMA_OID pnpOid,
		IMA_OID_LIST **ppList
)
{
	/*
	 * Always return the same object ID for the pnp as the spec
	 * states that this function will always return a list of at least
	 * one element
	 */
	pnpOid.objectType = IMA_OBJECT_TYPE_PNP;
	pnpOid.ownerId = pluginOwnerId;
	pnpOid.objectSequenceNumber = ISCSI_INITIATOR_OID;

	*ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
	    (1* sizeof (IMA_OID)));

	if (*ppList == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	(*ppList)->oidCount = 1;
	(void) memcpy(&(*ppList)->oids[0], &pnpOid, sizeof (pnpOid));
	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetPnpProperties(
		IMA_OID pnpOid,
		IMA_PNP_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetPnpStatistics(
		IMA_OID pnpOid,
		IMA_PNP_STATISTICS *pStats
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetIpProperties(
		IMA_OID oid,
		IMA_IP_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_SetDefaultGateway(
		IMA_OID oid,
		IMA_IP_ADDRESS defaultGateway
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_SetDnsServerAddress(
		IMA_OID oid,
		const IMA_IP_ADDRESS *pPrimaryDnsServerAddress,
		const IMA_IP_ADDRESS *pAlternateDnsServerAddress
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_SetSubnetMask(
		IMA_OID oid,
		IMA_IP_ADDRESS subnetMask
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_SetIpConfigMethod(
		IMA_OID oid,
		IMA_BOOL enableDhcpIpConfiguration
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

IMA_API IMA_STATUS IMA_RegisterForObjectPropertyChanges(
		IMA_OBJECT_PROPERTY_FN pClientFn
)
{
	pObjectPropertyCallback = pClientFn;
	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_DeregisterForObjectPropertyChanges(
		IMA_OBJECT_PROPERTY_FN pClientFn
)
{
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_RegisterForObjectVisibilityChanges(
		IMA_OBJECT_VISIBILITY_FN pClientFn
)
{
	pObjectVisibilityCallback = pClientFn;
	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_DeregisterForObjectVisibilityChanges(
		IMA_OBJECT_VISIBILITY_FN pClientFn
)
{
	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetNetworkPortStatus(
		IMA_OID portOid,
		IMA_NETWORK_PORT_STATUS *pStaus
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetNetworkPortalOidList(
		IMA_OID pnpOid,
		IMA_OID_LIST **ppList
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetNetworkPortalProperties(
		IMA_OID networkPortalOid,
		IMA_NETWORK_PORTAL_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_SetNetworkPortalIpAddress(
		IMA_OID networkPortalOid,
		const IMA_IP_ADDRESS NewIpAddress
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_RemoveStaleData(
		IMA_OID lhbaOid
)
{
	return (IMA_ERROR_NOT_SUPPORTED);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetIpsecProperties(
		IMA_OID oid,
		IMA_IPSEC_PROPERTIES *pProps
)
{
	pProps->ipsecSupported = IMA_TRUE;
	pProps->implementedInHardware = IMA_FALSE;
	pProps->implementedInSoftware = IMA_TRUE;

	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetLhbaProperties(
		IMA_OID lhbaOid,
		IMA_LHBA_PROPERTIES *pProps
)
{

	if (pProps == NULL) {
		return (IMA_ERROR_INVALID_PARAMETER);
	}

	if (lhbaObjectId.objectSequenceNumber != ISCSI_INITIATOR_OID) {
		return (IMA_ERROR_OBJECT_NOT_FOUND);
	}

	(void) memset(pProps, 0, sizeof (IMA_LHBA_PROPERTIES));
	(void) mbstowcs(pProps->osDeviceName, OS_DEVICE_NAME,
	    OS_DEVICE_NAME_LEN);
	pProps->luExposingSupported = IMA_FALSE;
	pProps->isDestroyable = IMA_FALSE;
	pProps->staleDataRemovable = IMA_FALSE;
	pProps->staleDataSize = 0;
	pProps->initiatorAuthMethodsSettable = IMA_TRUE;
	pProps->targetAuthMethodsSettable = IMA_FALSE;

	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS IMA_GetLnpOidList(
		IMA_OID_LIST **ppList
)
{
	*ppList = (IMA_OID_LIST *) calloc(1, (sizeof (IMA_OID_LIST)));
	if (*ppList == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->oidCount = 0;

	return (IMA_STATUS_SUCCESS);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetLnpProperties(
		IMA_OID lnpOid,
		IMA_LNP_PROPERTIES *pProps
)
{
	return (IMA_ERROR_OBJECT_NOT_FOUND);
}

#define	IMA_DISK_DEVICE_NAME_PREFIX	"/dev/rdsk/"
#define	IMA_TAPE_DEVICE_NAME_PREFIX	"/dev/rmt/"
static int
get_lun_devlink(di_devlink_t link, void *osDeviceName)
{
	if ((strncmp(IMA_DISK_DEVICE_NAME_PREFIX, di_devlink_path(link),
	    strlen(IMA_DISK_DEVICE_NAME_PREFIX)) == 0) ||
	    (strncmp(IMA_TAPE_DEVICE_NAME_PREFIX, di_devlink_path(link),
	    strlen(IMA_TAPE_DEVICE_NAME_PREFIX)) == 0)) {
		(void) mbstowcs((wchar_t *)osDeviceName, di_devlink_path(link),
		    MAXPATHLEN);
		return (DI_WALK_TERMINATE);
	}

	return (DI_WALK_CONTINUE);
}

/* ARGSUSED */
IMA_API IMA_STATUS IMA_GetPluginProperties(
	IMA_OID pluginOid,
	IMA_PLUGIN_PROPERTIES *pProps
)
{
	pProps->supportedImaVersion = 1;
	libSwprintf(pProps->vendor, L"%ls", LIBRARY_PROPERTY_VENDOR);
	libSwprintf(pProps->implementationVersion, L"%ls",
	    LIBRARY_PROPERTY_IMPLEMENTATION_VERSION);
	libSwprintf(pProps->fileName, L"%ls", LIBRARY_FILE_NAME);
	GetBuildTime(&(pProps->buildTime));
	pProps->lhbasCanBeCreatedAndDestroyed = IMA_FALSE;
	return (IMA_STATUS_SUCCESS);
}

IMA_STATUS getDiscoveryAddressPropertiesList(
    SUN_IMA_DISC_ADDR_PROP_LIST **ppList
)
{
	int		    fd;
	int		    i;
	int		    discovery_addr_list_size;
	iscsi_addr_list_t   *ialp, al_info;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&al_info, 0, sizeof (al_info));
	al_info.al_vers = ISCSI_INTERFACE_VERSION;
	al_info.al_in_cnt = 0;

	/*
	 * Issue ISCSI_DISCOVERY_ADDR_LIST_GET ioctl to obtain the number of
	 * discovery addresses.
	 */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, &al_info) != 0) {
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl failed, errno: %d",
		    errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	discovery_addr_list_size = sizeof (iscsi_addr_list_t);
	if (al_info.al_out_cnt > 1) {
		discovery_addr_list_size += (sizeof (iscsi_addr_t) *
		    al_info.al_out_cnt - 1);
	}

	ialp = (iscsi_addr_list_t *)calloc(1, discovery_addr_list_size);
	if (ialp == NULL) {
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	ialp->al_vers = ISCSI_INTERFACE_VERSION;
	ialp->al_in_cnt = al_info.al_out_cnt;

	/*
	 * Issue ISCSI_DISCOVERY_ADDR_LIST_GET ioctl again to obtain the
	 * discovery addresses.
	 */
	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, ialp) != 0) {
		free(ialp);
		(void) close(fd);
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl failed, errno: %d",
		    errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	*ppList = (SUN_IMA_DISC_ADDR_PROP_LIST *)
	    calloc(1, sizeof (SUN_IMA_DISC_ADDR_PROP_LIST) +
	    ialp->al_out_cnt * sizeof (IMA_DISCOVERY_ADDRESS_PROPERTIES));

	if (*ppList == NULL) {
		free(ialp);
		(void) close(fd);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	(*ppList)->discAddrCount = ialp->al_out_cnt;

	for (i = 0; i < ialp->al_out_cnt; i++) {
		if (ialp->al_addrs[i].a_addr.i_insize ==
		    sizeof (struct in_addr)) {
			(*ppList)->props[i].discoveryAddress.hostnameIpAddress.
			id.ipAddress.ipv4Address = IMA_TRUE;
		} else if (ialp->al_addrs[i].a_addr.i_insize ==
		    sizeof (struct in6_addr)) {
			(*ppList)->props[i].discoveryAddress.
			hostnameIpAddress.id.ipAddress.ipv4Address = IMA_FALSE;
		} else {
			/* Should not happen */
			syslog(LOG_USER|LOG_DEBUG,
			"ISCSI_STATIC_GET returned bad address");
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}

		bcopy(&ialp->al_addrs[i].a_addr.i_addr,	(*ppList)->props[i].
		    discoveryAddress.hostnameIpAddress.id.ipAddress.ipAddress,
		    sizeof ((*ppList)->props[i].discoveryAddress.
		    hostnameIpAddress.id.ipAddress.ipAddress));

		(*ppList)->props[i].discoveryAddress.portNumber =
		    ialp->al_addrs[i].a_port;
	}

	free(ialp);
	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}


/* ARGSUSED */
IMA_STATUS sendTargets(
    IMA_TARGET_ADDRESS address,
    SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES **ppList
)
{
	char	*colonPos;
	char	discAddrStr[SUN_IMA_IP_ADDRESS_LEN];
	int	fd;
	int	ctr;
	int	stl_sz;
	iscsi_sendtgts_list_t	*stl_hdr = NULL;
	IMA_BOOL		retry = IMA_TRUE;

#define	SENDTGTS_DEFAULT_NUM_TARGETS	10

	stl_sz = sizeof (*stl_hdr) + ((SENDTGTS_DEFAULT_NUM_TARGETS - 1) *
	    sizeof (iscsi_sendtgts_entry_t));
	stl_hdr = (iscsi_sendtgts_list_t *)calloc(1, stl_sz);
	if (stl_hdr == NULL) {
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}
	stl_hdr->stl_entry.e_vers = ISCSI_INTERFACE_VERSION;
	stl_hdr->stl_in_cnt = SENDTGTS_DEFAULT_NUM_TARGETS;

	colonPos = strchr(discAddrStr, ':');
	if (colonPos == NULL) {
		/* IPv4 */
		stl_hdr->stl_entry.e_insize = sizeof (struct in_addr);
	} else {
		/* IPv6 */
		stl_hdr->stl_entry.e_insize = sizeof (struct in6_addr);
	}


	bcopy(address.hostnameIpAddress.id.ipAddress.ipAddress,
	    &stl_hdr->stl_entry.e_u,
	    sizeof (address.hostnameIpAddress.id.ipAddress.ipAddress));
	stl_hdr->stl_entry.e_port = address.portNumber;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

retry_sendtgts:
	/*
	 * Issue ioctl to obtain the SendTargets list
	 */
	if (ioctl(fd, ISCSI_SENDTGTS_GET, stl_hdr) != 0) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_SENDTGTS_GET ioctl failed, errno: %d", errno);
		(void) close(fd);
		free(stl_hdr);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	/* check if all targets received */
	if (stl_hdr->stl_in_cnt < stl_hdr->stl_out_cnt) {
		if (retry == IMA_TRUE) {
			stl_sz = sizeof (*stl_hdr) +
			    ((stl_hdr->stl_out_cnt - 1) *
			    sizeof (iscsi_sendtgts_entry_t));
			stl_hdr = (iscsi_sendtgts_list_t *)
			    realloc(stl_hdr, stl_sz);
			if (stl_hdr == NULL) {
				(void) close(fd);
				return (IMA_ERROR_INSUFFICIENT_MEMORY);
			}
			stl_hdr->stl_in_cnt = stl_hdr->stl_out_cnt;
			retry = IMA_FALSE;
			goto retry_sendtgts;
		} else {
			/*
			 * don't retry after 2 attempts.  The target list
			 * shouldn't continue to growing. Justs continue
			 * on and display what was found.
			 */
			syslog(LOG_USER|LOG_DEBUG,
			    "ISCSI_SENDTGTS_GET overflow: "
			    "failed to obtain all targets");
			stl_hdr->stl_out_cnt = stl_hdr->stl_in_cnt;
		}
	}

	(void) close(fd);

	/* allocate for caller return buffer */
	*ppList = (SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES *)calloc(1,
	    sizeof (SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES) +
	    stl_hdr->stl_out_cnt * sizeof (SUN_IMA_DISC_ADDRESS_KEY));
	if (*ppList == NULL) {
		free(stl_hdr);
		return (IMA_ERROR_INSUFFICIENT_MEMORY);
	}

	(*ppList)->keyCount = stl_hdr->stl_out_cnt;

	for (ctr = 0; ctr < stl_hdr->stl_out_cnt; ctr++) {
		(void) mbstowcs((*ppList)->keys[ctr].name,
		    (char *)stl_hdr->stl_list[ctr].ste_name,
		    IMA_NODE_NAME_LEN);

		(*ppList)->keys[ctr].tpgt = stl_hdr->stl_list[ctr].ste_tpgt;

		(*ppList)->keys[ctr].address.portNumber =
		    stl_hdr->stl_list[ctr].ste_ipaddr.a_port;

		if (stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_insize ==
		    sizeof (struct in_addr)) {
			(*ppList)->keys[ctr].address.ipAddress.ipv4Address =
			    IMA_TRUE;
		} else if (stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_insize ==
		    sizeof (struct in6_addr)) {
			(*ppList)->keys[ctr].address.ipAddress.ipv4Address =
			    IMA_FALSE;
		} else {
			free(stl_hdr);
			syslog(LOG_USER|LOG_DEBUG,
			"ISCSI_STATIC_GET returned bad address");
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}


		(void) memcpy(&(*ppList)->keys[ctr].address.ipAddress.ipAddress,
		    &(stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_addr),
		    stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_insize);
	}
	free(stl_hdr);

	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS SUN_IMA_GetTunableProperties(
	IMA_OID oid,
	ISCSI_TUNABLE_PARAM *param)
{
	int fd;
	iscsi_tunable_object_t pg;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}
	(void) memset(&pg, 0, sizeof (iscsi_tunable_object_t));
	pg.t_param = param->tunable_objectType;
	pg.t_oid = (uint32_t)oid.objectSequenceNumber;
	if (ioctl(fd, ISCSI_TUNABLE_PARAM_GET, &pg) == -1) {
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TUNABLE_PARAM_GET ioctl failed, errno: %d", errno);
		(void) close(fd);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	} else {
		long long value;
		char tmp[MAX_LONG_LONG_STRING_LEN], *ptr = NULL;
		if (pg.t_set == B_FALSE) {
			/* default value */
			(void) close(fd);
			return (IMA_STATUS_SUCCESS);
		}
		value = (long long)pg.t_value.v_integer;
		ptr = lltostr(value, tmp);
		if ((ptr != NULL) && (ptr != tmp)) {
			*(tmp + 1) = '\0';
		} else {
			(void) close(fd);
			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
		switch (param->tunable_objectType) {
			case ISCSI_RX_TIMEOUT_VALUE:
				(void) strlcpy(param->tunable_objectValue,
				    ptr, strlen(ptr));
				break;
			case ISCSI_CONN_DEFAULT_LOGIN_MAX:
				(void) strlcpy(param->tunable_objectValue,
				    ptr, strlen(ptr));
				break;
			case ISCSI_LOGIN_POLLING_DELAY:
				(void) strlcpy(param->tunable_objectValue,
				    ptr, strlen(ptr));
				break;
			default:
				break;
		}
	}
	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}

IMA_API IMA_STATUS SUN_IMA_SetTunableProperties(
	IMA_OID oid,
	ISCSI_TUNABLE_PARAM *param)
{
	int fd;
	iscsi_tunable_object_t	ps;

	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
		    ISCSI_DRIVER_DEVCTL, errno);
		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
	}

	(void) memset(&ps, 0, sizeof (iscsi_tunable_object_t));
	ps.t_oid = oid.objectSequenceNumber;
	ps.t_param = param->tunable_objectType;
	switch (param->tunable_objectType) {
		long tmp;
		case ISCSI_RX_TIMEOUT_VALUE:
		case ISCSI_CONN_DEFAULT_LOGIN_MAX:
		case ISCSI_LOGIN_POLLING_DELAY:
			tmp = strtol(param->tunable_objectValue,
			    NULL, 10);
			if (((tmp == 0) && (errno == EINVAL)) ||
			    ((tmp == LONG_MAX) && (errno == ERANGE)) ||
			    ((tmp == LONG_MIN) && (errno == ERANGE))) {
				(void) close(fd);
				return (IMA_ERROR_INVALID_PARAMETER);
			}
			ps.t_value.v_integer = (uint32_t)tmp;
			break;
		default:
			break;
	}
	if (ioctl(fd, ISCSI_TUNABLE_PARAM_SET, &ps)) {
		int tmpErrno = errno;
		syslog(LOG_USER|LOG_DEBUG,
		    "ISCSI_TUNABLE_PARAM_SET ioctl failed, errno: %d", errno);
		(void) close(fd);
		switch (tmpErrno) {
			case ENOTSUP :
				return (IMA_ERROR_NOT_SUPPORTED);
			default:
				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
		}
	}
	(void) close(fd);
	return (IMA_STATUS_SUCCESS);
}