OpenSolaris_b135/lib/libsun_ima/common/ima.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <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[MAX_LONG_LONG_STRING_LEN -1]);
if ((ptr != NULL) && (ptr != tmp)) {
tmp[MAX_LONG_LONG_STRING_LEN - 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) + 1);
break;
case ISCSI_CONN_DEFAULT_LOGIN_MAX:
(void) strlcpy(param->tunable_objectValue,
ptr, strlen(ptr) + 1);
break;
case ISCSI_LOGIN_POLLING_DELAY:
(void) strlcpy(param->tunable_objectValue,
ptr, strlen(ptr) + 1);
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);
}