xref: /illumos-gate/usr/src/cmd/iscsiadm/sun_ima.c (revision 904e51f6)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 #include <arpa/inet.h>
26 #include <sys/socket.h>
27 #include <sys/types.h>
28 #include <stdarg.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <strings.h>
32 #include <unistd.h>
33 #include <syslog.h>
34 #include <errno.h>
35 
36 #include <fcntl.h>
37 #include <stdio.h>
38 #include <time.h>
39 #include <libdevinfo.h>
40 
41 #include <sys/scsi/adapters/iscsi_if.h>
42 #include <sys/scsi/adapters/iscsi_door.h>
43 #include <sys/iscsi_protocol.h>
44 #include <ima.h>
45 #include "iscsiadm.h"
46 #include "sun_ima.h"
47 
48 #define	LIBRARY_PROPERTY_SUPPORTED_IMA_VERSION	1
49 #define	LIBRARY_PROPERTY_IMPLEMENTATION_VERSION	L"1.0.0"
50 #define	LIBRARY_PROPERTY_VENDOR	L"Sun Microsystems, Inc."
51 #define	DEFAULT_NODE_NAME_FORMAT    "iqn.2003-13.com.ima.%s"
52 #define	PLUGIN_OWNER 1
53 #define	MAX_CHAP_SECRET_LEN	16
54 
55 /* LINTED E_STATIC_UNUSED */
56 static IMA_INT32		number_of_plugins = -1;
57 /* LINTED E_STATIC_UNUSED */
58 static IMA_NODE_NAME		sharedNodeName;
59 /* LINTED E_STATIC_UNUSED */
60 static IMA_NODE_ALIAS		sharedNodeAlias;
61 /* LINTED E_STATIC_UNUSED */
62 static IMA_PLUGIN_PROPERTIES	PluginProperties;
63 
64 /* LINTED E_STATIC_UNUSED */
65 static IMA_OID			pluginOid;
66 static IMA_OID			lhbaObjectId;
67 /* LINTED E_STATIC_UNUSED */
68 static boolean_t		pluginInit = B_FALSE;
69 
70 /* Forward declaration */
71 #define	BOOL_PARAM		1
72 #define	MIN_MAX_PARAM		2
73 #define	PARAM_OP_OK		0
74 #define	PARAM_OP_FAILED		1
75 
76 static int open_driver(int *fd);
77 static IMA_STATUS getISCSINodeParameter(int paramType,
78     IMA_OID *oid,
79     void *pProps,
80     uint32_t paramIndex);
81 static IMA_STATUS setISCSINodeParameter(int paramType,
82     IMA_OID *oid,
83     void *pProps,
84     uint32_t paramIndex);
85 static IMA_STATUS getDigest(IMA_OID oid, int ioctlCmd,
86     SUN_IMA_DIGEST_ALGORITHM_VALUE *algorithm);
87 static IMA_STATUS setAuthMethods(IMA_OID oid, IMA_UINT *pMethodCount,
88     const IMA_AUTHMETHOD *pMethodList);
89 static IMA_STATUS getAuthMethods(IMA_OID oid, IMA_UINT *pMethodCount,
90     IMA_AUTHMETHOD *pMethodList);
91 IMA_STATUS getNegotiatedDigest(int digestType,
92 	SUN_IMA_DIGEST_ALGORITHM_VALUE *algorithm,
93 	SUN_IMA_CONN_PROPERTIES *connProps);
94 
95 /* OK */
96 #define	DISC_ADDR_OK		    0
97 /* Incorrect IP address */
98 #define	DISC_ADDR_INTEGRITY_ERROR   1
99 /* Error converting text IP address to numeric binary form */
100 #define	DISC_ADDR_IP_CONV_ERROR	    2
101 static int prepare_discovery_entry(SUN_IMA_TARGET_ADDRESS discoveryAddress,
102     entry_t *entry);
103 static int prepare_discovery_entry_IMA(IMA_TARGET_ADDRESS discoveryAddress,
104     entry_t *entry);
105 
106 /* LINTED E_STATIC_UNUSED */
107 static IMA_STATUS configure_discovery_method(IMA_BOOL enable,
108     iSCSIDiscoveryMethod_t method);
109 
110 static IMA_STATUS get_target_oid_list(uint32_t targetListType,
111     IMA_OID_LIST **ppList);
112 
113 static IMA_STATUS get_target_lun_oid_list(IMA_OID * targetOid,
114 					    iscsi_lun_list_t  **ppLunList);
115 
116 static int get_lun_devlink(di_devlink_t link, void *arg);
117 
118 static IMA_STATUS getConnOidList(
119 	IMA_OID			*oid,
120 	iscsi_conn_list_t	**ppConnList);
121 
122 static IMA_STATUS getConnProps(
123 	iscsi_if_conn_t		*pConn,
124 	iscsi_conn_props_t	**ppConnProps);
125 
126 /* LINTED E_STATIC_UNUSED */
libSwprintf(wchar_t * wcs,const wchar_t * lpszFormat,...)127 static void libSwprintf(wchar_t *wcs, const wchar_t *lpszFormat, ...)
128 {
129 	va_list args;
130 	va_start(args, lpszFormat);
131 	(void) vswprintf(wcs, 255, lpszFormat, args);
132 	va_end(args);
133 }
134 
135 
136 char *
_strlwr(char * s)137 _strlwr(char *s)
138 {
139 	char *t = s;
140 	while (t != NULL && *t) {
141 		if (*t >= 'A' && *t <= 'Z')
142 			*t += 32;
143 		t++;
144 	}
145 	return (s);
146 }
147 
148 /* LINTED E_STATIC_UNUSED */
GetBuildTime(IMA_DATETIME * pdatetime)149 static void GetBuildTime(IMA_DATETIME* pdatetime)
150 {
151 #if defined(BUILD_DATE)
152 	if (strptime(BUILD_DATE, "%Y/%m/%d %T %Z", pdatetime) == NULL) {
153 		(void) memset(pdatetime, 0, sizeof (IMA_DATETIME));
154 	}
155 #else
156 	(void) memset(pdatetime, 0, sizeof (IMA_DATETIME));
157 #endif
158 }
159 
160 /*
161  * Non-IMA defined function.
162  */
SUN_IMA_GetDiscoveryAddressPropertiesList(SUN_IMA_DISC_ADDR_PROP_LIST ** ppList)163 IMA_API	IMA_STATUS SUN_IMA_GetDiscoveryAddressPropertiesList(
164     SUN_IMA_DISC_ADDR_PROP_LIST	**ppList
165 )
166 {
167 	char		    discovery_addr_str[256];
168 	int		    fd;
169 	int		    i;
170 	int		    discovery_addr_list_size;
171 	int		    status;
172 	int		    out_cnt;
173 	iscsi_addr_list_t   *ialp;
174 	/* LINTED E_FUNC_SET_NOT_USED */
175 	IMA_IP_ADDRESS	    *ipAddr;
176 
177 	if ((status = open_driver(&fd))) {
178 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
179 	}
180 
181 	ialp = (iscsi_addr_list_t *)calloc(1, sizeof (iscsi_addr_list_t));
182 	if (ialp == NULL) {
183 		(void) close(fd);
184 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
185 	}
186 
187 	ialp->al_vers = ISCSI_INTERFACE_VERSION;
188 	ialp->al_in_cnt = ialp->al_out_cnt = 1;
189 
190 	/*
191 	 * Issue ISCSI_DISCOVERY_ADDR_LIST_GET ioctl
192 	 * We have allocated space for one entry, if more than one
193 	 * address is going to be returned, we will re-issue the ioctl
194 	 */
195 	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, ialp) != 0) {
196 		(void) close(fd);
197 		syslog(LOG_USER|LOG_DEBUG,
198 		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl failed, errno: %d",
199 		    errno);
200 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
201 	}
202 
203 	if (ialp->al_out_cnt > 1) {
204 		/*
205 		 * we need to allocate more space, save off the out_cnt
206 		 * and free ialp
207 		 */
208 		out_cnt = ialp->al_out_cnt;
209 		free(ialp);
210 
211 		discovery_addr_list_size = sizeof (iscsi_addr_list_t);
212 		discovery_addr_list_size += (sizeof (iscsi_addr_t) *
213 		    out_cnt - 1);
214 		ialp = (iscsi_addr_list_t *)calloc(1, discovery_addr_list_size);
215 		if (ialp == NULL) {
216 			(void) close(fd);
217 			return (IMA_ERROR_INSUFFICIENT_MEMORY);
218 		}
219 		ialp->al_vers = ISCSI_INTERFACE_VERSION;
220 		ialp->al_in_cnt = out_cnt;
221 
222 		/*
223 		 * Issue ISCSI_DISCOVERY_ADDR_LIST_GET ioctl again to obtain all
224 		 * the discovery addresses.
225 		 */
226 		if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, ialp) != 0) {
227 #define	ERROR_STR "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl failed, errno :%d"
228 			free(ialp);
229 			(void) close(fd);
230 			syslog(LOG_USER|LOG_DEBUG,
231 			    ERROR_STR, errno);
232 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
233 #undef ERROR_STR
234 
235 		}
236 	}
237 
238 	*ppList = (SUN_IMA_DISC_ADDR_PROP_LIST *)calloc(1,
239 	    sizeof (SUN_IMA_DISC_ADDR_PROP_LIST) +
240 	    ialp->al_out_cnt * sizeof (IMA_DISCOVERY_ADDRESS_PROPERTIES));
241 	if (*ppList == NULL) {
242 		free(ialp);
243 		(void) close(fd);
244 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
245 	}
246 	(*ppList)->discAddrCount = ialp->al_out_cnt;
247 
248 	for (i = 0; i < ialp->al_out_cnt; i++) {
249 		if (ialp->al_addrs[i].a_addr.i_insize ==
250 		    sizeof (struct in_addr)) {
251 
252 			(*ppList)->props[i].discoveryAddress.hostnameIpAddress.
253 			id.ipAddress.ipv4Address = IMA_TRUE;
254 
255 		} else if (ialp->al_addrs[i].a_addr.i_insize ==
256 		    sizeof (struct in6_addr)) {
257 
258 			(*ppList)->props[i].discoveryAddress.hostnameIpAddress.
259 			id.ipAddress.ipv4Address = IMA_FALSE;
260 
261 		} else {
262 			(void) strlcpy(discovery_addr_str, "unknown",
263 			    sizeof (discovery_addr_str));
264 		}
265 
266 		ipAddr = &(*ppList)->props[i].discoveryAddress.
267 		    hostnameIpAddress.id.ipAddress;
268 
269 		bcopy(&ialp->al_addrs[i].a_addr.i_addr,
270 		    (*ppList)->props[i].discoveryAddress.hostnameIpAddress.id.
271 		    ipAddress.ipAddress,
272 		    sizeof (ipAddr->ipAddress));
273 
274 		(*ppList)->props[i].discoveryAddress.portNumber =
275 		    ialp->al_addrs[i].a_port;
276 	}
277 
278 	free(ialp);
279 	(void) close(fd);
280 	return (IMA_STATUS_SUCCESS);
281 }
282 
SUN_IMA_GetStaticTargetProperties(IMA_OID staticTargetOid,SUN_IMA_STATIC_TARGET_PROPERTIES * pProps)283 IMA_API IMA_STATUS SUN_IMA_GetStaticTargetProperties(
284 		IMA_OID	staticTargetOid,
285 		SUN_IMA_STATIC_TARGET_PROPERTIES *pProps
286 )
287 {
288 	int fd;
289 	int status;
290 	iscsi_static_property_t prop;
291 	/* LINTED */
292 	IMA_IP_ADDRESS	    *ipAddr;
293 
294 	if ((status = open_driver(&fd))) {
295 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
296 	}
297 
298 	(void) memset(&prop, 0, sizeof (iscsi_static_property_t));
299 	prop.p_vers = ISCSI_INTERFACE_VERSION;
300 	prop.p_oid = (uint32_t)staticTargetOid.objectSequenceNumber;
301 	if (ioctl(fd, ISCSI_STATIC_GET, &prop) != 0) {
302 		status = errno;
303 		(void) close(fd);
304 		syslog(LOG_USER|LOG_DEBUG,
305 		    "ISCSI_STATIC_GET ioctl failed, errno: %d", status);
306 		if (status == ENOENT) {
307 			return (IMA_ERROR_OBJECT_NOT_FOUND);
308 		} else {
309 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
310 		}
311 	}
312 	(void) close(fd);
313 
314 	(void) mbstowcs(pProps->staticTarget.targetName, (char *)prop.p_name,
315 	    sizeof (pProps->staticTarget.targetName)/sizeof (IMA_WCHAR));
316 
317 	if (prop.p_addr_list.al_addrs[0].a_addr.i_insize ==
318 	    sizeof (struct in_addr)) {
319 		/* IPv4 */
320 		pProps->staticTarget.targetAddress.imaStruct.hostnameIpAddress.
321 			id.ipAddress.ipv4Address = IMA_TRUE;
322 	} else if (prop.p_addr_list.al_addrs[0].a_addr.i_insize ==
323 	    sizeof (struct in6_addr)) {
324 		/* IPv6 */
325 		pProps->staticTarget.targetAddress.imaStruct.hostnameIpAddress.
326 			id.ipAddress.ipv4Address = IMA_FALSE;
327 	} else {
328 		/* Should not happen */
329 		syslog(LOG_USER|LOG_DEBUG,
330 		    "ISCSI_STATIC_GET returned bad address");
331 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
332 	}
333 
334 	ipAddr = &pProps->staticTarget.targetAddress.imaStruct.
335 	    hostnameIpAddress.id.ipAddress;
336 
337 	bcopy(&prop.p_addr_list.al_addrs[0].a_addr.i_addr,
338 	    pProps->staticTarget.targetAddress.imaStruct.hostnameIpAddress.id.
339 	    ipAddress.ipAddress, sizeof (ipAddr->ipAddress));
340 
341 	pProps->staticTarget.targetAddress.imaStruct.portNumber =
342 	    prop.p_addr_list.al_addrs[0].a_port;
343 
344 
345 	if (prop.p_addr_list.al_tpgt == (uint32_t)ISCSI_DEFAULT_TPGT) {
346 		pProps->staticTarget.targetAddress.defaultTpgt = IMA_TRUE;
347 		pProps->staticTarget.targetAddress.tpgt = 0;
348 	} else {
349 		pProps->staticTarget.targetAddress.defaultTpgt = IMA_FALSE;
350 		pProps->staticTarget.targetAddress.tpgt =
351 		    prop.p_addr_list.al_tpgt;
352 	}
353 
354 	return (IMA_STATUS_SUCCESS);
355 }
356 
357 /*ARGSUSED*/
SUN_IMA_AddStaticTarget(IMA_OID lhbaOid,const SUN_IMA_STATIC_DISCOVERY_TARGET staticConfig,IMA_OID * pTargetOid)358 IMA_API IMA_STATUS SUN_IMA_AddStaticTarget(
359 		IMA_OID lhbaOid,
360 		const SUN_IMA_STATIC_DISCOVERY_TARGET staticConfig,
361 		IMA_OID *pTargetOid
362 )
363 {
364 	iscsi_target_entry_t	target;
365 	int			fd;
366 	int			target_in_addr_size;
367 	int			status;
368 	union {
369 		struct in_addr	u_in4;
370 		struct in6_addr	u_in6;
371 	}			target_in;
372 
373 	/*
374 	 * staticConfig.address may come in with port number at its trailer.
375 	 * Parse it to separate the IP address and port number.
376 	 * Also translate the hostname to IP address if needed.
377 	 */
378 
379 	if (staticConfig.targetAddress.imaStruct.hostnameIpAddress.id.ipAddress.
380 	    ipv4Address == IMA_FALSE) {
381 
382 		bcopy(staticConfig.targetAddress.imaStruct.hostnameIpAddress.
383 		    id.ipAddress.ipAddress, &target_in.u_in6,
384 		    sizeof (target_in.u_in6));
385 
386 		target_in_addr_size = sizeof (struct in6_addr);
387 	} else {
388 
389 		bcopy(staticConfig.targetAddress.imaStruct.hostnameIpAddress.
390 		    id.ipAddress.ipAddress, &target_in.u_in4,
391 		    sizeof (target_in.u_in4));
392 
393 		target_in_addr_size = sizeof (struct in_addr);
394 	}
395 
396 	(void) memset(&target, 0, sizeof (iscsi_target_entry_t));
397 	target.te_entry.e_vers = ISCSI_INTERFACE_VERSION;
398 	target.te_entry.e_oid = ISCSI_OID_NOTSET;
399 
400 	(void) wcstombs((char *)target.te_name, staticConfig.targetName,
401 	    ISCSI_MAX_NAME_LEN);
402 
403 	target.te_entry.e_insize = target_in_addr_size;
404 	if (target.te_entry.e_insize == sizeof (struct in_addr)) {
405 		target.te_entry.e_u.u_in4.s_addr = target_in.u_in4.s_addr;
406 	} else if (target.te_entry.e_insize == sizeof (struct in6_addr)) {
407 		bcopy(target_in.u_in6.s6_addr,
408 		    target.te_entry.e_u.u_in6.s6_addr,
409 		    sizeof (struct in6_addr));
410 	} else {
411 		return (IMA_ERROR_INVALID_PARAMETER);
412 	}
413 
414 	target.te_entry.e_port =
415 	    staticConfig.targetAddress.imaStruct.portNumber;
416 
417 	if (staticConfig.targetAddress.defaultTpgt == IMA_TRUE) {
418 		target.te_entry.e_tpgt = ISCSI_DEFAULT_TPGT;
419 	} else {
420 		target.te_entry.e_tpgt = staticConfig.targetAddress.tpgt;
421 	}
422 
423 	if ((status = open_driver(&fd))) {
424 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
425 	}
426 
427 	if (ioctl(fd, ISCSI_STATIC_SET, &target)) {
428 		/*
429 		 * Encountered problem setting the IP address and port for
430 		 * the target just added.
431 		 */
432 		syslog(LOG_USER|LOG_DEBUG,
433 		    "ISCSI_STATIC_SET ioctl failed, errno: %d", errno);
434 		(void) close(fd);
435 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
436 	}
437 
438 	pTargetOid->objectType = IMA_OBJECT_TYPE_TARGET;
439 	pTargetOid->ownerId = 1;
440 	pTargetOid->objectSequenceNumber = target.te_entry.e_oid;
441 
442 	(void) close(fd);
443 	return (IMA_STATUS_SUCCESS);
444 }
445 
SUN_IMA_GetTargetProperties(IMA_OID targetId,SUN_IMA_TARGET_PROPERTIES * pProps)446 IMA_API	IMA_STATUS SUN_IMA_GetTargetProperties(
447 		IMA_OID targetId,
448 		SUN_IMA_TARGET_PROPERTIES *pProps
449 )
450 {
451 	int		    fd;
452 	int			status;
453 	iscsi_property_t    prop;
454 
455 	if ((status = open_driver(&fd))) {
456 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
457 	}
458 
459 	(void) memset(&prop, 0, sizeof (iscsi_property_t));
460 	prop.p_vers = ISCSI_INTERFACE_VERSION;
461 	prop.p_oid = (uint32_t)targetId.objectSequenceNumber;
462 
463 	if (ioctl(fd, ISCSI_TARGET_PROPS_GET, &prop) != 0) {
464 		syslog(LOG_USER|LOG_DEBUG,
465 		    "ISCSI_TARGET_PROPS_GET ioctl failed, errno: %d", errno);
466 		(void) close(fd);
467 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
468 	}
469 
470 	(void) mbstowcs(pProps->imaProps.name,
471 	    (char *)prop.p_name, IMA_NODE_NAME_LEN);
472 	(void) memset(pProps->imaProps.alias, 0,
473 	    (sizeof (IMA_WCHAR) * SUN_IMA_NODE_ALIAS_LEN));
474 	if (prop.p_alias_len > 0) {
475 		(void) mbstowcs(pProps->imaProps.alias, (char *)prop.p_alias,
476 		    SUN_IMA_NODE_ALIAS_LEN);
477 	}
478 
479 	/* Initialize the discovery method to unknown method. */
480 	pProps->imaProps.discoveryMethodFlags =
481 	    IMA_TARGET_DISCOVERY_METHOD_UNKNOWN;
482 	if (!((prop.p_discovery & iSCSIDiscoveryMethodStatic) ^
483 	    iSCSIDiscoveryMethodStatic)) {
484 		pProps->imaProps.discoveryMethodFlags |=
485 		    IMA_TARGET_DISCOVERY_METHOD_STATIC;
486 	}
487 
488 	if (!((prop.p_discovery & iSCSIDiscoveryMethodSLP) ^
489 	    iSCSIDiscoveryMethodSLP)) {
490 		pProps->imaProps.discoveryMethodFlags |=
491 		    IMA_TARGET_DISCOVERY_METHOD_SLP;
492 	}
493 
494 	if (!((prop.p_discovery & iSCSIDiscoveryMethodISNS) ^
495 	    iSCSIDiscoveryMethodISNS)) {
496 		pProps->imaProps.discoveryMethodFlags |=
497 		    iSCSIDiscoveryMethodISNS;
498 	}
499 
500 	if (!((prop.p_discovery & iSCSIDiscoveryMethodSendTargets) ^
501 	    iSCSIDiscoveryMethodSendTargets)) {
502 		pProps->imaProps.discoveryMethodFlags |=
503 		    iSCSIDiscoveryMethodSendTargets;
504 	}
505 
506 	if (prop.p_tpgt_conf == ISCSI_DEFAULT_TPGT) {
507 		pProps->defaultTpgtConf = IMA_TRUE;
508 		pProps->tpgtConf = 0;
509 	} else {
510 		pProps->defaultTpgtConf = IMA_FALSE;
511 		pProps->tpgtConf = prop.p_tpgt_conf;
512 	}
513 
514 	if (prop.p_tpgt_nego == ISCSI_DEFAULT_TPGT) {
515 		pProps->defaultTpgtNego = IMA_TRUE;
516 		pProps->tpgtNego = 0;
517 	} else {
518 		pProps->defaultTpgtNego = IMA_FALSE;
519 		pProps->tpgtNego = prop.p_tpgt_nego;
520 	}
521 
522 	bcopy(prop.p_isid, pProps->isid, ISCSI_ISID_LEN);
523 
524 	(void) close(fd);
525 	return (IMA_STATUS_SUCCESS);
526 }
527 
528 /*
529  * This function only sets CHAP params since we only support CHAP for now.
530  */
SUN_IMA_SetTargetAuthParams(IMA_OID targetOid,IMA_AUTHMETHOD method,const IMA_INITIATOR_AUTHPARMS * pParms)531 IMA_STATUS SUN_IMA_SetTargetAuthParams(
532     IMA_OID targetOid,
533     IMA_AUTHMETHOD method,
534     const IMA_INITIATOR_AUTHPARMS *pParms
535 )
536 {
537 	int fd;
538 	iscsi_chap_props_t  chap_p;
539 
540 	if (method != IMA_AUTHMETHOD_CHAP)
541 		return (IMA_ERROR_INVALID_PARAMETER);
542 
543 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
544 		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
545 		    ISCSI_DRIVER_DEVCTL, errno);
546 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
547 	}
548 
549 	(void) memset(&chap_p, 0, sizeof (iscsi_chap_props_t));
550 	chap_p.c_vers = ISCSI_INTERFACE_VERSION;
551 	chap_p.c_oid = (uint32_t)targetOid.objectSequenceNumber;
552 
553 	chap_p.c_user_len =
554 	    pParms->chapParms.nameLength;
555 	(void) memcpy(chap_p.c_user,
556 	    pParms->chapParms.name, chap_p.c_user_len);
557 
558 	chap_p.c_secret_len =
559 	    pParms->chapParms.challengeSecretLength;
560 	(void) memcpy(chap_p.c_secret,
561 	    pParms->chapParms.challengeSecret,
562 	    chap_p.c_secret_len);
563 
564 	if (ioctl(fd, ISCSI_CHAP_SET, &chap_p) != 0) {
565 		syslog(LOG_USER|LOG_DEBUG,
566 		    "ISCSI_CHAP_SET ioctl failed, errno: %d", errno);
567 		(void) close(fd);
568 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
569 	}
570 
571 	return (IMA_STATUS_SUCCESS);
572 }
573 
SUN_IMA_GetTargetAuthMethods(IMA_OID lhbaOid,IMA_OID targetOid,IMA_UINT * pMethodCount,IMA_AUTHMETHOD * pMethodList)574 IMA_STATUS SUN_IMA_GetTargetAuthMethods(
575     IMA_OID		lhbaOid,
576     IMA_OID		targetOid,
577     IMA_UINT	*pMethodCount,
578     IMA_AUTHMETHOD *pMethodList
579 )
580 {
581 	if (getAuthMethods(targetOid, pMethodCount, pMethodList)
582 	    != IMA_STATUS_SUCCESS) {
583 		return (getAuthMethods(lhbaOid, pMethodCount, pMethodList));
584 	}
585 	return (IMA_STATUS_SUCCESS);
586 }
587 
SUN_IMA_SetInitiatorRadiusConfig(IMA_OID lhbaOid,SUN_IMA_RADIUS_CONFIG * config)588 IMA_STATUS SUN_IMA_SetInitiatorRadiusConfig(
589 		IMA_OID	lhbaOid,
590 		SUN_IMA_RADIUS_CONFIG *config
591 )
592 {
593 	int			af;
594 	int			fd;
595 	int			status;
596 	iscsi_radius_props_t	radius;
597 	union {
598 		struct in_addr	u_in4;
599 		struct in6_addr	u_in6;
600 	}	radius_in;
601 
602 	if ((status = open_driver(&fd))) {
603 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
604 	}
605 
606 	(void) memset(&radius, 0, sizeof (iscsi_radius_props_t));
607 	radius.r_vers = ISCSI_INTERFACE_VERSION;
608 	radius.r_oid = (uint32_t)lhbaOid.objectSequenceNumber;
609 	/* Get first because other data fields may already exist */
610 	if (ioctl(fd, ISCSI_RADIUS_GET, &radius) != 0) {
611 		/* EMPTY */
612 		/* It's fine if other data fields are not there. */
613 	}
614 
615 	if (config->isIpv6 == IMA_TRUE) {
616 		af = AF_INET6;
617 	} else {
618 		af = AF_INET;
619 	}
620 
621 	if (inet_pton(af, config->hostnameIpAddress, &radius_in.u_in4) != 1) {
622 		return (IMA_ERROR_INVALID_PARAMETER);
623 	}
624 
625 	switch (af) {
626 		case AF_INET:
627 			radius.r_addr.u_in4.s_addr = radius_in.u_in4.s_addr;
628 			radius.r_insize = sizeof (struct in_addr);
629 			break;
630 		case AF_INET6:
631 			(void) memcpy(radius.r_addr.u_in6.s6_addr,
632 			    radius_in.u_in6.s6_addr, 16);
633 			radius.r_insize = sizeof (struct in6_addr);
634 			break;
635 	}
636 	radius.r_port = config->port;
637 	radius.r_radius_config_valid = B_TRUE;
638 	/* Allow resetting the RADIUS shared secret to NULL */
639 	if (config->sharedSecretValid == IMA_TRUE) {
640 		radius.r_shared_secret_len = config->sharedSecretLength;
641 		(void) memset(&radius.r_shared_secret[0], 0,
642 		    MAX_RAD_SHARED_SECRET_LEN);
643 		(void) memcpy(&radius.r_shared_secret[0], config->sharedSecret,
644 		    config->sharedSecretLength);
645 	}
646 
647 	if (ioctl(fd, ISCSI_RADIUS_SET, &radius) != 0) {
648 		syslog(LOG_USER|LOG_DEBUG,
649 		    "ISCSI_RADIUS_SET ioctl failed, errno: %d", errno);
650 		(void) close(fd);
651 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
652 	}
653 
654 	(void) close(fd);
655 	return (IMA_STATUS_SUCCESS);
656 }
657 
SUN_IMA_GetInitiatorRadiusConfig(IMA_OID lhbaOid,SUN_IMA_RADIUS_CONFIG * config)658 IMA_STATUS SUN_IMA_GetInitiatorRadiusConfig(
659 		IMA_OID	lhbaOid,
660 		SUN_IMA_RADIUS_CONFIG *config
661 )
662 {
663 	int			af;
664 	int			fd;
665 	int			status;
666 	iscsi_radius_props_t	radius;
667 
668 	if ((status = open_driver(&fd))) {
669 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
670 	}
671 
672 	(void) memset(&radius, 0, sizeof (iscsi_radius_props_t));
673 	radius.r_vers = ISCSI_INTERFACE_VERSION;
674 	radius.r_oid = (uint32_t)lhbaOid.objectSequenceNumber;
675 
676 	if (ioctl(fd, ISCSI_RADIUS_GET, &radius) != 0) {
677 		(void) close(fd);
678 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
679 	}
680 
681 	(void) memset(config, 0, sizeof (SUN_IMA_RADIUS_CONFIG));
682 	if (radius.r_insize == sizeof (struct in_addr)) {
683 		/* IPv4 */
684 		af = AF_INET;
685 	} else if (radius.r_insize == sizeof (struct in6_addr)) {
686 		/* IPv6 */
687 		af = AF_INET6;
688 	} else {
689 		/*
690 		 * It's legitimate that the existing RADIUS record does not
691 		 * have configuration data.
692 		 */
693 		config->hostnameIpAddress[0] = '\0';
694 		config->port = 0;
695 		(void) close(fd);
696 		return (IMA_STATUS_SUCCESS);
697 	}
698 	(void) inet_ntop(af, (void *)&radius.r_addr.u_in4,
699 	    config->hostnameIpAddress, 256);
700 	config->port = radius.r_port;
701 	(void) memcpy(config->sharedSecret, &radius.r_shared_secret[0],
702 	    radius.r_shared_secret_len);
703 	config->sharedSecretLength = radius.r_shared_secret_len;
704 	config->sharedSecretValid = B_TRUE;
705 
706 	(void) close(fd);
707 	return (IMA_STATUS_SUCCESS);
708 }
709 
SUN_IMA_SetInitiatorRadiusAccess(IMA_OID lhbaOid,IMA_BOOL radiusAccess)710 IMA_STATUS SUN_IMA_SetInitiatorRadiusAccess(
711     IMA_OID lhbaOid,
712     IMA_BOOL radiusAccess
713 )
714 {
715 	int			fd;
716 	int			status;
717 	iscsi_radius_props_t	radius;
718 
719 	if ((status = open_driver(&fd))) {
720 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
721 	}
722 
723 	(void) memset(&radius, 0, sizeof (iscsi_radius_props_t));
724 	radius.r_vers = ISCSI_INTERFACE_VERSION;
725 	radius.r_oid = (uint32_t)lhbaOid.objectSequenceNumber;
726 	/* Get first because other data fields may already exist */
727 	if (ioctl(fd, ISCSI_RADIUS_GET, &radius) != 0) {
728 		if (radiusAccess == IMA_TRUE) {
729 			/*
730 			 * Cannot enable RADIUS if no RADIUS configuration
731 			 * can be found.
732 			 */
733 			syslog(LOG_USER|LOG_DEBUG,
734 			    "RADIUS config data not found - "
735 			    "cannot enable RADIUS, errno: %d", errno);
736 			(void) close(fd);
737 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
738 		} else {
739 			/* EMPTY */
740 			/* Otherwise it's fine to disable RADIUS */
741 		}
742 	}
743 
744 	if ((radius.r_insize != sizeof (struct in_addr)) &&
745 		(radius.r_insize != sizeof (struct in6_addr))) {
746 		/*
747 		 * Cannot enable RADIUS if no RADIUS configuration
748 		 * can be found.
749 		 */
750 		if (radiusAccess == IMA_TRUE) {
751 			syslog(LOG_USER|LOG_DEBUG,
752 				"RADIUS config data not found - "
753 				"cannot enable RADIUS");
754 			(void) close(fd);
755 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
756 		}
757 	}
758 
759 	radius.r_radius_access = (radiusAccess == IMA_TRUE) ?
760 	    B_TRUE : B_FALSE;
761 
762 	if (ioctl(fd, ISCSI_RADIUS_SET, &radius) != 0) {
763 		syslog(LOG_USER|LOG_DEBUG,
764 		    "ISCSI_RADIUS_SET ioctl failed, errno: %d", errno);
765 		(void) close(fd);
766 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
767 	}
768 
769 	(void) close(fd);
770 	return (IMA_STATUS_SUCCESS);
771 }
772 
SUN_IMA_GetInitiatorRadiusAccess(IMA_OID lhbaOid,IMA_BOOL * radiusAccess)773 IMA_STATUS SUN_IMA_GetInitiatorRadiusAccess(
774     IMA_OID lhbaOid,
775     IMA_BOOL *radiusAccess
776 )
777 {
778 	int			fd;
779 	int			status;
780 	iscsi_radius_props_t	radius;
781 
782 	if ((status = open_driver(&fd))) {
783 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
784 	}
785 
786 	(void) memset(&radius, 0, sizeof (iscsi_radius_props_t));
787 	radius.r_vers = ISCSI_INTERFACE_VERSION;
788 	radius.r_oid = (uint32_t)lhbaOid.objectSequenceNumber;
789 
790 	if (ioctl(fd, ISCSI_RADIUS_GET, &radius) != 0) {
791 		(void) close(fd);
792 		if (errno == ENOENT) {
793 			return (IMA_ERROR_OBJECT_NOT_FOUND);
794 		} else {
795 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
796 		}
797 	}
798 
799 	*radiusAccess = (radius.r_radius_access == B_TRUE) ?
800 	    IMA_TRUE : IMA_FALSE;
801 
802 	(void) close(fd);
803 	return (IMA_STATUS_SUCCESS);
804 }
805 
SUN_IMA_SendTargets(IMA_NODE_NAME nodeName,IMA_TARGET_ADDRESS address,SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES ** ppList)806 IMA_STATUS SUN_IMA_SendTargets(
807     IMA_NODE_NAME nodeName,
808     IMA_TARGET_ADDRESS address,
809     SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES **ppList
810 )
811 {
812 	char	*colonPos;
813 	char	discAddrStr[256];
814 	char	nodeNameStr[ISCSI_MAX_NAME_LEN];
815 	int	fd;
816 	int	ctr;
817 	int	stl_sz;
818 	int status;
819 	iscsi_sendtgts_list_t	*stl_hdr = NULL;
820 	IMA_BOOL		retry = IMA_TRUE;
821 	/* LINTED */
822 	IMA_IP_ADDRESS	    *ipAddr;
823 
824 #define	SENDTGTS_DEFAULT_NUM_TARGETS	10
825 
826 	stl_sz = sizeof (*stl_hdr) + ((SENDTGTS_DEFAULT_NUM_TARGETS - 1) *
827 	    sizeof (iscsi_sendtgts_entry_t));
828 	stl_hdr = (iscsi_sendtgts_list_t *)calloc(1, stl_sz);
829 	if (stl_hdr == NULL) {
830 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
831 	}
832 	stl_hdr->stl_entry.e_vers = ISCSI_INTERFACE_VERSION;
833 	stl_hdr->stl_in_cnt = SENDTGTS_DEFAULT_NUM_TARGETS;
834 
835 	(void) wcstombs(nodeNameStr, nodeName, ISCSI_MAX_NAME_LEN);
836 
837 	colonPos = strchr(discAddrStr, ':');
838 	if (colonPos == NULL) {
839 		/* IPv4 */
840 		stl_hdr->stl_entry.e_insize = sizeof (struct in_addr);
841 	} else {
842 		/* IPv6 */
843 		stl_hdr->stl_entry.e_insize = sizeof (struct in6_addr);
844 	}
845 
846 	ipAddr = &address.hostnameIpAddress.id.ipAddress;
847 
848 	bcopy(address.hostnameIpAddress.id.ipAddress.ipAddress,
849 	    &stl_hdr->stl_entry.e_u, sizeof (ipAddr->ipAddress));
850 
851 	stl_hdr->stl_entry.e_port = address.portNumber;
852 
853 	if ((status = open_driver(&fd))) {
854 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
855 	}
856 
857 retry_sendtgts:
858 	/*
859 	 * Issue ioctl to obtain the SendTargets list
860 	 */
861 	if (ioctl(fd, ISCSI_SENDTGTS_GET, stl_hdr) != 0) {
862 		syslog(LOG_USER|LOG_DEBUG,
863 		    "ISCSI_SENDTGTS_GET ioctl failed, errno: %d", errno);
864 		(void) close(fd);
865 		free(stl_hdr);
866 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
867 	}
868 
869 	/* check if all targets received */
870 	if (stl_hdr->stl_in_cnt < stl_hdr->stl_out_cnt) {
871 		if (retry == IMA_TRUE) {
872 			stl_sz = sizeof (*stl_hdr) +
873 			    ((stl_hdr->stl_out_cnt - 1) *
874 			    sizeof (iscsi_sendtgts_entry_t));
875 			stl_hdr = (iscsi_sendtgts_list_t *)
876 			    realloc(stl_hdr, stl_sz);
877 			if (stl_hdr == NULL) {
878 				(void) close(fd);
879 				return (IMA_ERROR_INSUFFICIENT_MEMORY);
880 			}
881 			stl_hdr->stl_in_cnt = stl_hdr->stl_out_cnt;
882 			retry = IMA_FALSE;
883 			goto retry_sendtgts;
884 		} else {
885 			/*
886 			 * don't retry after 2 attempts.  The target list
887 			 * shouldn't continue to growing. Justs continue
888 			 * on and display what was found.
889 			 */
890 			syslog(LOG_USER|LOG_DEBUG,
891 			    "ISCSI_SENDTGTS_GET overflow: "
892 			    "failed to obtain all targets");
893 			stl_hdr->stl_out_cnt = stl_hdr->stl_in_cnt;
894 		}
895 	}
896 
897 	(void) close(fd);
898 
899 	/* allocate for caller return buffer */
900 	*ppList = (SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES *)calloc(1,
901 	    sizeof (SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES) +
902 	    stl_hdr->stl_out_cnt * sizeof (SUN_IMA_DISC_ADDRESS_KEY));
903 	if (*ppList == NULL) {
904 		free(stl_hdr);
905 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
906 	}
907 
908 	(*ppList)->keyCount = stl_hdr->stl_out_cnt;
909 
910 	for (ctr = 0; ctr < stl_hdr->stl_out_cnt; ctr++) {
911 		(void) mbstowcs((*ppList)->keys[ctr].name,
912 		    (char *)stl_hdr->stl_list[ctr].ste_name,
913 		    IMA_NODE_NAME_LEN);
914 
915 		(*ppList)->keys[ctr].tpgt = stl_hdr->stl_list[ctr].ste_tpgt;
916 
917 		(*ppList)->keys[ctr].address.portNumber =
918 		    stl_hdr->stl_list[ctr].ste_ipaddr.a_port;
919 
920 		if (stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_insize ==
921 		    sizeof (struct in_addr)) {
922 			(*ppList)->keys[ctr].address.ipAddress.ipv4Address =
923 			    IMA_TRUE;
924 		} else if (stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_insize ==
925 		    sizeof (struct in6_addr)) {
926 			(*ppList)->keys[ctr].address.ipAddress.ipv4Address =
927 			    IMA_FALSE;
928 		} else {
929 			free(stl_hdr);
930 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
931 		}
932 
933 		(void) memcpy(&(*ppList)->keys[ctr].address.ipAddress.ipAddress,
934 		    &(stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_addr),
935 		    stl_hdr->stl_list[ctr].ste_ipaddr.a_addr.i_insize);
936 	}
937 	free(stl_hdr);
938 
939 	return (IMA_STATUS_SUCCESS);
940 }
941 
SUN_IMA_SetTargetBidirAuthFlag(IMA_OID targetOid,IMA_BOOL * bidirAuthFlag)942 IMA_STATUS SUN_IMA_SetTargetBidirAuthFlag(
943     IMA_OID targetOid,
944     IMA_BOOL *bidirAuthFlag
945 )
946 {
947 	int fd;
948 	int status;
949 	iscsi_auth_props_t auth;
950 
951 	if ((status = open_driver(&fd))) {
952 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
953 	}
954 
955 	(void) memset(&auth, 0, sizeof (iscsi_auth_props_t));
956 	auth.a_vers = ISCSI_INTERFACE_VERSION;
957 	auth.a_oid = (uint32_t)targetOid.objectSequenceNumber;
958 	/* Get first because other data fields may already exist */
959 	if (ioctl(fd, ISCSI_AUTH_GET, &auth) != 0) {
960 		/* EMPTY */
961 		/* It is fine if there is no other data fields. */
962 	}
963 	auth.a_bi_auth = (*bidirAuthFlag == IMA_TRUE) ? B_TRUE : B_FALSE;
964 	if (ioctl(fd, ISCSI_AUTH_SET, &auth) != 0) {
965 		syslog(LOG_USER|LOG_DEBUG,
966 		    "ISCSI_AUTH_SET ioctl failed, errno: %d", errno);
967 		(void) close(fd);
968 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
969 	}
970 
971 	(void) close(fd);
972 	return (IMA_STATUS_SUCCESS);
973 }
974 
SUN_IMA_GetTargetBidirAuthFlag(IMA_OID targetOid,IMA_BOOL * bidirAuthFlag)975 IMA_STATUS SUN_IMA_GetTargetBidirAuthFlag(
976     IMA_OID targetOid,
977     IMA_BOOL *bidirAuthFlag
978 )
979 {
980 	int fd;
981 	int status;
982 	iscsi_auth_props_t auth;
983 
984 	if ((status = open_driver(&fd))) {
985 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
986 	}
987 
988 	(void) memset(&auth, 0, sizeof (iscsi_auth_props_t));
989 	auth.a_vers = ISCSI_INTERFACE_VERSION;
990 	auth.a_oid = (uint32_t)targetOid.objectSequenceNumber;
991 
992 	if (ioctl(fd, ISCSI_AUTH_GET, &auth) != 0) {
993 		(void) close(fd);
994 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
995 	}
996 
997 	*bidirAuthFlag = (auth.a_bi_auth == B_TRUE) ?
998 	    IMA_TRUE : IMA_FALSE;
999 
1000 	(void) close(fd);
1001 	return (IMA_STATUS_SUCCESS);
1002 }
1003 
SUN_IMA_CreateTargetOid(IMA_NODE_NAME targetName,IMA_OID * targetOid)1004 IMA_STATUS SUN_IMA_CreateTargetOid(
1005     IMA_NODE_NAME targetName,
1006     IMA_OID *targetOid
1007 )
1008 {
1009 	int	    fd;
1010 	int		status;
1011 	iscsi_oid_t oid;
1012 
1013 	if ((status = open_driver(&fd))) {
1014 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1015 	}
1016 
1017 	(void) memset(&oid, 0, sizeof (iscsi_oid_t));
1018 	(void) wcstombs((char *)oid.o_name, targetName, ISCSI_MAX_NAME_LEN);
1019 	oid.o_tpgt = ISCSI_DEFAULT_TPGT;
1020 	oid.o_vers = ISCSI_INTERFACE_VERSION;
1021 	if (ioctl(fd, ISCSI_CREATE_OID, &oid) == -1) {
1022 		syslog(LOG_USER|LOG_DEBUG,
1023 		    "ISCSI_CREATE_OID ioctl failed, errno: %d", errno);
1024 		(void) close(fd);
1025 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1026 	}
1027 
1028 	targetOid->objectType = IMA_OBJECT_TYPE_TARGET;
1029 	targetOid->ownerId = 1;
1030 	targetOid->objectSequenceNumber = oid.o_oid;
1031 
1032 	(void) close(fd);
1033 	return (IMA_STATUS_SUCCESS);
1034 }
1035 
SUN_IMA_RemoveTargetParam(IMA_OID targetOid)1036 IMA_STATUS SUN_IMA_RemoveTargetParam(
1037 		IMA_OID targetOid
1038 )
1039 {
1040 	entry_t	entry;
1041 	int	fd;
1042 	int status;
1043 	iscsi_auth_props_t auth_p;
1044 	iscsi_chap_props_t chap_p;
1045 
1046 	if ((status = open_driver(&fd))) {
1047 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1048 	}
1049 
1050 	(void) memset(&entry, 0, sizeof (entry_t));
1051 	entry.e_vers = ISCSI_INTERFACE_VERSION;
1052 	entry.e_oid = (uint32_t)targetOid.objectSequenceNumber;
1053 	if (ioctl(fd, ISCSI_TARGET_PARAM_CLEAR, &entry)) {
1054 		/*
1055 		 * It could be that the target exists but the associated
1056 		 * target_param does not, and that is legitimate.
1057 		 */
1058 		syslog(LOG_USER|LOG_DEBUG,
1059 		    "ISCSI_TARGET_PARAM_CLEAR ioctl failed, errno: %d", errno);
1060 	}
1061 
1062 	/* Issue ISCSI_CHAP_CLEAR ioctl */
1063 	(void) memset(&chap_p, 0, sizeof (iscsi_chap_props_t));
1064 	chap_p.c_vers = ISCSI_INTERFACE_VERSION;
1065 	chap_p.c_oid = (uint32_t)targetOid.objectSequenceNumber;
1066 	if (ioctl(fd, ISCSI_CHAP_CLEAR, &chap_p) != 0) {
1067 		/*
1068 		 * It could be that the CHAP of this target has never
1069 		 * been set.
1070 		 */
1071 		syslog(LOG_USER|LOG_DEBUG,
1072 		    "ISCSI_CHAP_CLEAR ioctl failed, errno: %d", errno);
1073 	}
1074 
1075 	/*
1076 	 * Issue ISCSI_AUTH_CLEAR ioctl, in which the authentication information
1077 	 * is removed and the target that is not discovered by initiator
1078 	 * is removed from the memory. So this ioctl should be called at last
1079 	 */
1080 	(void) memset(&auth_p, 0, sizeof (iscsi_auth_props_t));
1081 	auth_p.a_vers = ISCSI_INTERFACE_VERSION;
1082 	auth_p.a_oid = (uint32_t)targetOid.objectSequenceNumber;
1083 	if (ioctl(fd, ISCSI_AUTH_CLEAR, &auth_p) != 0) {
1084 		/*
1085 		 * It could be that the auth data of this target has
1086 		 * never been set.
1087 		 */
1088 		syslog(LOG_USER|LOG_DEBUG,
1089 		    "ISCSI_AUTH_CLEAR ioctl failed, errno: %d", errno);
1090 	}
1091 
1092 	(void) close(fd);
1093 	return (IMA_STATUS_SUCCESS);
1094 }
1095 
SUN_IMA_SetHeaderDigest(IMA_OID oid,IMA_UINT algorithmCount,const SUN_IMA_DIGEST_ALGORITHM * algorithmList)1096 IMA_API IMA_STATUS SUN_IMA_SetHeaderDigest(
1097 	IMA_OID oid,
1098 	IMA_UINT algorithmCount,
1099 	const SUN_IMA_DIGEST_ALGORITHM *algorithmList
1100 )
1101 {
1102 	IMA_MIN_MAX_VALUE mv;
1103 	uint32_t digest_algorithm;
1104 
1105 	/* We only support one preference of digest algorithm. */
1106 	if (algorithmCount > 1) {
1107 		syslog(LOG_USER|LOG_DEBUG,
1108 		    "More than one digest algorithm specified.");
1109 		return (IMA_ERROR_NOT_SUPPORTED);
1110 	}
1111 	switch (algorithmList[0]) {
1112 	case SUN_IMA_DIGEST_NONE:
1113 		digest_algorithm = ISCSI_DIGEST_NONE;
1114 		break;
1115 	case SUN_IMA_DIGEST_CRC32:
1116 		digest_algorithm = ISCSI_DIGEST_CRC32C;
1117 		break;
1118 	default:
1119 		digest_algorithm = ISCSI_DIGEST_NONE;
1120 		break;
1121 	}
1122 	mv.currentValue = digest_algorithm;
1123 	return (setISCSINodeParameter(MIN_MAX_PARAM, &oid, &mv,
1124 	    ISCSI_LOGIN_PARAM_HEADER_DIGEST));
1125 }
1126 
SUN_IMA_SetDataDigest(IMA_OID oid,IMA_UINT algorithmCount,const SUN_IMA_DIGEST_ALGORITHM * algorithmList)1127 IMA_API IMA_STATUS SUN_IMA_SetDataDigest(
1128 	IMA_OID oid,
1129 	IMA_UINT algorithmCount,
1130 	const SUN_IMA_DIGEST_ALGORITHM *algorithmList
1131 )
1132 {
1133 	IMA_MIN_MAX_VALUE mv;
1134 	uint32_t digest_algorithm;
1135 
1136 	/* We only support one preference of digest algorithm. */
1137 	if (algorithmCount > 1) {
1138 		syslog(LOG_USER|LOG_DEBUG,
1139 		    "More than one digest algorithm specified.");
1140 		return (IMA_ERROR_NOT_SUPPORTED);
1141 	}
1142 	switch (algorithmList[0]) {
1143 	case SUN_IMA_DIGEST_NONE:
1144 		digest_algorithm = ISCSI_DIGEST_NONE;
1145 		break;
1146 	case SUN_IMA_DIGEST_CRC32:
1147 		digest_algorithm = ISCSI_DIGEST_CRC32C;
1148 		break;
1149 	default:
1150 		digest_algorithm = ISCSI_DIGEST_NONE;
1151 		break;
1152 	}
1153 	mv.currentValue = digest_algorithm;
1154 	return (setISCSINodeParameter(MIN_MAX_PARAM, &oid, &mv,
1155 	    ISCSI_LOGIN_PARAM_DATA_DIGEST));
1156 }
1157 
SUN_IMA_GetHeaderDigest(IMA_OID oid,SUN_IMA_DIGEST_ALGORITHM_VALUE * algorithm)1158 IMA_API IMA_STATUS SUN_IMA_GetHeaderDigest(
1159 	IMA_OID oid,
1160 	SUN_IMA_DIGEST_ALGORITHM_VALUE *algorithm
1161 )
1162 {
1163 	return (getDigest(oid, ISCSI_LOGIN_PARAM_HEADER_DIGEST, algorithm));
1164 }
1165 
SUN_IMA_GetDataDigest(IMA_OID oid,SUN_IMA_DIGEST_ALGORITHM_VALUE * algorithm)1166 IMA_API IMA_STATUS SUN_IMA_GetDataDigest(
1167 	IMA_OID oid,
1168 	SUN_IMA_DIGEST_ALGORITHM_VALUE *algorithm
1169 )
1170 {
1171 	return (getDigest(oid, ISCSI_LOGIN_PARAM_DATA_DIGEST, algorithm));
1172 }
1173 
1174 typedef struct walk_devlink {
1175 	char *path;
1176 	size_t len;
1177 	char **linkpp;
1178 } walk_devlink_t;
1179 
SUN_IMA_GetLuProperties(IMA_OID luId,SUN_IMA_LU_PROPERTIES * pProps)1180 IMA_STATUS SUN_IMA_GetLuProperties(
1181 		IMA_OID luId,
1182 		SUN_IMA_LU_PROPERTIES *pProps
1183 )
1184 {
1185 	IMA_STATUS		status;
1186 	iscsi_lun_list_t	*pLunList;
1187 	int			j;
1188 	IMA_BOOL		lunMatch = IMA_FALSE;
1189 	int			fd;
1190 	int			openStatus;
1191 	iscsi_lun_props_t	lun;
1192 	di_devlink_handle_t	hdl;
1193 	walk_devlink_t		warg;
1194 	char			*minor_path, *devlinkp, lunpath[MAXPATHLEN];
1195 
1196 	if (luId.objectType != IMA_OBJECT_TYPE_LU) {
1197 		return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1198 	}
1199 
1200 	/*
1201 	 * get list of lun oids for all targets
1202 	 */
1203 	status = get_target_lun_oid_list(NULL, &pLunList);
1204 	if (!IMA_SUCCESS(status)) {
1205 		return (status);
1206 	}
1207 	for (j = 0; j < pLunList->ll_out_cnt; j++) {
1208 		/*
1209 		 * for each lun, check if match is found
1210 		 */
1211 		if (pLunList->ll_luns[j].l_oid == luId.objectSequenceNumber) {
1212 			/*
1213 			 * match found, break out of lun loop
1214 			 */
1215 			lunMatch = IMA_TRUE;
1216 			break;
1217 		}
1218 	}
1219 
1220 	if (lunMatch == IMA_TRUE) {
1221 		(void) memset(&lun, 0, sizeof (iscsi_lun_props_t));
1222 		lun.lp_vers = ISCSI_INTERFACE_VERSION;
1223 		lun.lp_tgt_oid = pLunList->ll_luns[j].l_tgt_oid;
1224 		lun.lp_oid = pLunList->ll_luns[j].l_oid;
1225 	}
1226 
1227 	free(pLunList);
1228 
1229 	if (lunMatch == IMA_FALSE) {
1230 		return (IMA_ERROR_OBJECT_NOT_FOUND);
1231 	}
1232 
1233 	/*
1234 	 * get lun properties
1235 	 */
1236 	if ((openStatus = open_driver(&fd))) {
1237 		return (SUN_IMA_ERROR_SYSTEM_ERROR | openStatus);
1238 	}
1239 
1240 	if (ioctl(fd, ISCSI_LUN_PROPS_GET, &lun)) {
1241 		syslog(LOG_USER|LOG_DEBUG,
1242 		    "ISCSI_LUN_PROPS_GET ioctl failed, errno: %d", errno);
1243 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1244 	}
1245 
1246 	(void) close(fd);
1247 
1248 	/*
1249 	 * set property values
1250 	 */
1251 	pProps->imaProps.associatedTargetOid.objectType =
1252 	    IMA_OBJECT_TYPE_TARGET;
1253 	pProps->imaProps.associatedTargetOid.ownerId = 1;
1254 	pProps->imaProps.associatedTargetOid.objectSequenceNumber = lun.lp_oid;
1255 	pProps->imaProps.targetLun = (IMA_UINT64)lun.lp_num;
1256 	(void) strncpy(pProps->vendorId, lun.lp_vid, SUN_IMA_LU_VENDOR_ID_LEN);
1257 	(void) strncpy(pProps->productId, lun.lp_pid,
1258 	    SUN_IMA_LU_PRODUCT_ID_LEN);
1259 	/*
1260 	 * lun.lp_status is defined as
1261 	 *	LunValid = 0
1262 	 *	LunDoesNotExist = 1
1263 	 * IMA_LU_PROPS.exposedtoOS is defined as an IMA_BOOL
1264 	 *	IMA_TRUE = 1
1265 	 *	IMA_FALSE = 0
1266 	 */
1267 	pProps->imaProps.exposedToOs = !lun.lp_status;
1268 	if (gmtime_r(&lun.lp_time_online, &pProps->imaProps.timeExposedToOs)
1269 	    == NULL) {
1270 		(void) memset(&pProps->imaProps.timeExposedToOs, 0,
1271 		    sizeof (pProps->imaProps.timeExposedToOs));
1272 	}
1273 
1274 	if (lun.lp_status == LunValid) {
1275 		if ((strlen(lun.lp_pathname) + strlen("/devices")) >
1276 		    (MAXPATHLEN -1)) {
1277 			/*
1278 			 * lun.lp_pathname length too long
1279 			 */
1280 			pProps->imaProps.osDeviceNameValid = IMA_FALSE;
1281 			pProps->imaProps.osParallelIdsValid = IMA_FALSE;
1282 			return (IMA_STATUS_SUCCESS);
1283 		}
1284 		if ((strstr(lun.lp_pathname, "st@") != NULL) ||
1285 		    (strstr(lun.lp_pathname, "tape@") != NULL)) {
1286 			(void) strlcat(lun.lp_pathname, ":n", MAXPATHLEN);
1287 		} else if ((strstr(lun.lp_pathname, "sd@") != NULL) ||
1288 		    (strstr(lun.lp_pathname, "ssd@") != NULL) ||
1289 		    (strstr(lun.lp_pathname, "disk@") != NULL)) {
1290 			/*
1291 			 * modify returned pathname to obtain the 2nd slice
1292 			 * of the raw disk
1293 			 */
1294 			(void) strlcat(lun.lp_pathname, ":c,raw", MAXPATHLEN);
1295 		} else if ((strstr(lun.lp_pathname, "ses@") != NULL) ||
1296 		    (strstr(lun.lp_pathname, "enclosure@") != NULL)) {
1297 			(void) strlcat(lun.lp_pathname, ":0", MAXPATHLEN);
1298 		}
1299 
1300 		(void) snprintf(lunpath, sizeof (lun.lp_pathname),
1301 		    "/devices%s", lun.lp_pathname);
1302 		if (strchr(lunpath, ':')) {
1303 			minor_path = lunpath;
1304 			if (strstr(minor_path, "/devices") != NULL) {
1305 				minor_path = lunpath +
1306 				    strlen("/devices");
1307 			} else {
1308 				minor_path = lunpath;
1309 			}
1310 			warg.path = NULL;
1311 		} else {
1312 			minor_path = NULL;
1313 			warg.len = strlen(lunpath);
1314 			warg.path = lunpath;
1315 		}
1316 		devlinkp = NULL;
1317 		warg.linkpp = &devlinkp;
1318 
1319 		/*
1320 		 * Pathname returned by driver is the physical device path.
1321 		 * This name needs to be converted to the OS device name.
1322 		 */
1323 		if (hdl = di_devlink_init(lun.lp_pathname, DI_MAKE_LINK)) {
1324 			pProps->imaProps.osDeviceName[0] = L'\0';
1325 			(void) di_devlink_walk(hdl, NULL, minor_path,
1326 			    DI_PRIMARY_LINK, (void *)&warg, get_lun_devlink);
1327 			if (devlinkp != NULL) {
1328 				(void) mbstowcs(pProps->imaProps.osDeviceName,
1329 				    devlinkp, MAXPATHLEN);
1330 				free(devlinkp);
1331 				pProps->imaProps.osDeviceNameValid = IMA_TRUE;
1332 			} else {
1333 				/* OS device name is asynchronously made */
1334 				pProps->imaProps.osDeviceNameValid = IMA_FALSE;
1335 			}
1336 
1337 			(void) di_devlink_fini(&hdl);
1338 
1339 		} else {
1340 			pProps->imaProps.osDeviceNameValid = IMA_FALSE;
1341 		}
1342 
1343 	} else {
1344 		pProps->imaProps.osDeviceNameValid = IMA_FALSE;
1345 	}
1346 
1347 	pProps->imaProps.osParallelIdsValid = IMA_FALSE;
1348 
1349 	return (IMA_STATUS_SUCCESS);
1350 }
1351 
1352 static int
get_lun_devlink(di_devlink_t link,void * arg)1353 get_lun_devlink(di_devlink_t link, void *arg)
1354 {
1355 	walk_devlink_t *warg = (walk_devlink_t *)arg;
1356 	if (warg->path) {
1357 		char *content = (char *)di_devlink_content(link);
1358 		char *start = strstr(content, "/devices");
1359 		if (start == NULL ||
1360 		    strncmp(start, warg->path, warg->len) != 0 ||
1361 		    start[warg->len] != ':')
1362 			return (DI_WALK_CONTINUE);
1363 	}
1364 
1365 	*(warg->linkpp) = strdup(di_devlink_path(link));
1366 	return (DI_WALK_TERMINATE);
1367 
1368 }
1369 
1370 /*
1371  * SUN_IMA_GetConnectionOidList -
1372  *
1373  * Non-IMA defined function.
1374  */
SUN_IMA_GetConnOidList(IMA_OID * oid,IMA_OID_LIST ** ppList)1375 IMA_API	IMA_STATUS SUN_IMA_GetConnOidList(
1376 	IMA_OID			*oid,
1377 	IMA_OID_LIST		**ppList
1378 )
1379 {
1380 	IMA_STATUS		imaStatus;
1381 	IMA_OID_LIST		*imaOidList;
1382 	iscsi_conn_list_t	*iscsiConnList = NULL;
1383 	int			i;
1384 	size_t			allocLen;
1385 
1386 	if ((lhbaObjectId.objectType == oid->objectType) &&
1387 	    (lhbaObjectId.ownerId == oid->ownerId) &&
1388 	    (lhbaObjectId.objectSequenceNumber == oid->objectSequenceNumber)) {
1389 		imaStatus = getConnOidList(NULL, &iscsiConnList);
1390 	} else {
1391 		if (oid->objectType == IMA_OBJECT_TYPE_TARGET) {
1392 			imaStatus = getConnOidList(oid, &iscsiConnList);
1393 		} else {
1394 			return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1395 		}
1396 	}
1397 	if (imaStatus != IMA_STATUS_SUCCESS) {
1398 		return (imaStatus);
1399 	}
1400 
1401 	/*
1402 	 * Based on the results a SUN_IMA_CONN_LIST structure is allocated.
1403 	 */
1404 	allocLen  = iscsiConnList->cl_out_cnt * sizeof (IMA_OID);
1405 	allocLen += sizeof (IMA_OID_LIST) - sizeof (IMA_OID);
1406 	imaOidList = (IMA_OID_LIST *)calloc(1, allocLen);
1407 
1408 	if (imaOidList == NULL) {
1409 		free(iscsiConnList);
1410 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
1411 	}
1412 
1413 	/* The data is transfered from iscsiConnList to imaConnList. */
1414 	imaOidList->oidCount = iscsiConnList->cl_out_cnt;
1415 	for (i = 0; i < iscsiConnList->cl_out_cnt; i++) {
1416 		imaOidList->oids[i].objectType = SUN_IMA_OBJECT_TYPE_CONN;
1417 		imaOidList->oids[i].ownerId = 1;
1418 		imaOidList->oids[i].objectSequenceNumber =
1419 		    iscsiConnList->cl_list[i].c_oid;
1420 	}
1421 	/* The pointer to the SUN_IMA_CONN_LIST structure is returned. */
1422 	*ppList = imaOidList;
1423 
1424 	free(iscsiConnList);
1425 	return (IMA_STATUS_SUCCESS);
1426 }
1427 
1428 /*
1429  * SUN_IMA_GetConnProperties -
1430  *
1431  * Non-IMA defined function.
1432  */
SUN_IMA_GetConnProperties(IMA_OID * connOid,SUN_IMA_CONN_PROPERTIES ** pProps)1433 IMA_API	IMA_STATUS SUN_IMA_GetConnProperties(
1434 	IMA_OID			*connOid,
1435 	SUN_IMA_CONN_PROPERTIES	**pProps
1436 )
1437 {
1438 	iscsi_conn_list_t	*pConnList;
1439 	iscsi_conn_props_t	*pConnProps;
1440 	/* LINTED */
1441 	struct sockaddr_in6	*addrIn6;
1442 	/* LINTED */
1443 	struct sockaddr_in	*addrIn;
1444 	SUN_IMA_CONN_PROPERTIES	*pImaConnProps;
1445 	IMA_STATUS		imaStatus;
1446 	int			i;
1447 
1448 	/* If there is any error *pProps should be set to NULL */
1449 	*pProps = NULL;
1450 
1451 	pImaConnProps = (SUN_IMA_CONN_PROPERTIES *)calloc(1,
1452 	    sizeof (SUN_IMA_CONN_PROPERTIES));
1453 
1454 	if (pImaConnProps == NULL) {
1455 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
1456 	}
1457 
1458 	imaStatus = getConnOidList(NULL, &pConnList);
1459 
1460 	if (imaStatus != IMA_STATUS_SUCCESS) {
1461 		free(pImaConnProps);
1462 		return (imaStatus);
1463 	}
1464 
1465 	/*
1466 	 * Walk the list returned to find our connection.
1467 	 */
1468 	for (i = 0; i < pConnList->cl_out_cnt; i++) {
1469 
1470 		if (pConnList->cl_list[i].c_oid ==
1471 		    (uint32_t)connOid->objectSequenceNumber) {
1472 
1473 			/* This is our connection. */
1474 			imaStatus = getConnProps(&pConnList->cl_list[i],
1475 			    &pConnProps);
1476 
1477 			if (imaStatus != IMA_STATUS_SUCCESS) {
1478 				free(pConnList);
1479 				free(pImaConnProps);
1480 				return (imaStatus);
1481 			}
1482 			pImaConnProps->connectionID = pConnProps->cp_cid;
1483 
1484 			/*
1485 			 * Local Propeties
1486 			 */
1487 			if (pConnProps->cp_local.soa4.sin_family == AF_INET) {
1488 
1489 				pImaConnProps->local.ipAddress.ipv4Address =
1490 				    IMA_TRUE;
1491 				pImaConnProps->local.portNumber =
1492 				    pConnProps->cp_local.soa4.sin_port;
1493 				addrIn = &(pConnProps->cp_local.soa4);
1494 				bcopy(&pConnProps->cp_local.soa4.sin_addr,
1495 				    pImaConnProps->local.ipAddress.ipAddress,
1496 				    sizeof (addrIn->sin_addr));
1497 
1498 			} else {
1499 				pImaConnProps->local.ipAddress.ipv4Address =
1500 				    IMA_FALSE;
1501 				pImaConnProps->local.portNumber =
1502 				    pConnProps->cp_local.soa6.sin6_port;
1503 				addrIn6 = &(pConnProps->cp_local.soa6);
1504 				bcopy(&pConnProps->cp_local.soa6.sin6_addr,
1505 				    pImaConnProps->local.ipAddress.ipAddress,
1506 				    sizeof (addrIn6->sin6_addr));
1507 
1508 			}
1509 
1510 			/*
1511 			 * Peer Propeties
1512 			 */
1513 			if (pConnProps->cp_peer.soa4.sin_family == AF_INET) {
1514 
1515 				pImaConnProps->peer.ipAddress.ipv4Address =
1516 				    IMA_TRUE;
1517 				pImaConnProps->peer.portNumber =
1518 				    pConnProps->cp_peer.soa4.sin_port;
1519 				addrIn = &(pConnProps->cp_local.soa4);
1520 				bcopy(&pConnProps->cp_peer.soa4.sin_addr,
1521 				    pImaConnProps->peer.ipAddress.ipAddress,
1522 				    sizeof (addrIn->sin_addr));
1523 
1524 			} else {
1525 				pImaConnProps->peer.ipAddress.ipv4Address =
1526 				    IMA_FALSE;
1527 				pImaConnProps->peer.portNumber =
1528 				    pConnProps->cp_peer.soa6.sin6_port;
1529 
1530 				addrIn6 = &pConnProps->cp_local.soa6;
1531 				bcopy(&pConnProps->cp_peer.soa6.sin6_addr,
1532 				    pImaConnProps->peer.ipAddress.ipAddress,
1533 				    sizeof (addrIn6->sin6_addr));
1534 			}
1535 
1536 
1537 			pImaConnProps->valuesValid =
1538 			    pConnProps->cp_params_valid;
1539 			pImaConnProps->defaultTime2Retain =
1540 			    pConnProps->cp_params.default_time_to_retain;
1541 			pImaConnProps->defaultTime2Wait =
1542 			    pConnProps->cp_params.default_time_to_wait;
1543 			pImaConnProps->errorRecoveryLevel =
1544 			    pConnProps->cp_params.error_recovery_level;
1545 			pImaConnProps->firstBurstLength =
1546 			    pConnProps->cp_params.first_burst_length;
1547 			pImaConnProps->maxBurstLength =
1548 			    pConnProps->cp_params.max_burst_length;
1549 			pImaConnProps->maxConnections =
1550 			    pConnProps->cp_params.max_connections;
1551 			pImaConnProps->maxOutstandingR2T =
1552 			    pConnProps->cp_params.max_outstanding_r2t;
1553 			pImaConnProps->maxRecvDataSegmentLength =
1554 			    pConnProps->cp_params.max_recv_data_seg_len;
1555 
1556 			pImaConnProps->dataPduInOrder =
1557 			    pConnProps->cp_params.data_pdu_in_order;
1558 			pImaConnProps->dataSequenceInOrder =
1559 			    pConnProps->cp_params.data_sequence_in_order;
1560 			pImaConnProps->immediateData =
1561 			    pConnProps->cp_params.immediate_data;
1562 			pImaConnProps->initialR2T =
1563 			    pConnProps->cp_params.initial_r2t;
1564 
1565 			pImaConnProps->headerDigest =
1566 			    pConnProps->cp_params.header_digest;
1567 			pImaConnProps->dataDigest =
1568 			    pConnProps->cp_params.data_digest;
1569 
1570 			free(pConnProps);
1571 			break;
1572 		}
1573 	}
1574 	free(pConnList);
1575 	*pProps = pImaConnProps;
1576 	return (IMA_STATUS_SUCCESS);
1577 }
1578 
1579 
1580 /*
1581  * SUN_IMA_GetConfigSessions -
1582  *
1583  * Non-IMA defined function.
1584  */
SUN_IMA_GetConfigSessions(IMA_OID targetOid,SUN_IMA_CONFIG_SESSIONS ** pConfigSessions)1585 IMA_API IMA_STATUS SUN_IMA_GetConfigSessions(
1586     IMA_OID targetOid,
1587     SUN_IMA_CONFIG_SESSIONS **pConfigSessions
1588 )
1589 {
1590 	int			fd;
1591 	int			status;
1592 	iscsi_config_sess_t	*ics;
1593 	int			size, idx;
1594 
1595 	/* Allocate and setup initial buffer */
1596 	size = sizeof (*ics);
1597 	ics = (iscsi_config_sess_t *)calloc(1, size);
1598 	if (ics == NULL) {
1599 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
1600 	}
1601 	ics->ics_ver = ISCSI_INTERFACE_VERSION;
1602 	ics->ics_oid = targetOid.objectSequenceNumber;
1603 	ics->ics_in  = 1;
1604 
1605 	/* Open driver devctl for ioctl */
1606 	if ((status = open_driver(&fd))) {
1607 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1608 	}
1609 
1610 	/* Issue ioctl request */
1611 	if (ioctl(fd, ISCSI_GET_CONFIG_SESSIONS, ics) != 0) {
1612 		syslog(LOG_USER|LOG_DEBUG,
1613 		    "ISCSI_GET_CONFIG_SESSIONS ioctl failed, errno: %d",
1614 		    errno);
1615 		(void) close(fd);
1616 		free(ics);
1617 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1618 	}
1619 
1620 	/* Check if we need to collect more information */
1621 	idx = ics->ics_out;
1622 	if (idx > 1) {
1623 
1624 		/* Free old buffer and reallocate re-sized buffer */
1625 		free(ics);
1626 		size = ISCSI_SESSION_CONFIG_SIZE(idx);
1627 		ics = (iscsi_config_sess_t *)calloc(1, size);
1628 		if (ics == NULL) {
1629 			return (IMA_ERROR_INSUFFICIENT_MEMORY);
1630 		}
1631 		ics->ics_ver = ISCSI_INTERFACE_VERSION;
1632 		ics->ics_oid = targetOid.objectSequenceNumber;
1633 		ics->ics_in = idx;
1634 
1635 		/* Issue ioctl request */
1636 		if (ioctl(fd, ISCSI_GET_CONFIG_SESSIONS, ics) != 0) {
1637 			syslog(LOG_USER|LOG_DEBUG,
1638 			    "ISCSI_GET_CONFIG_SESSIONS ioctl failed, errno: %d",
1639 			    errno);
1640 			(void) close(fd);
1641 			free(ics);
1642 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1643 		}
1644 	}
1645 	(void) close(fd);
1646 
1647 	/* Allocate output buffer */
1648 	size = sizeof (SUN_IMA_CONFIG_SESSIONS) +
1649 	    ((ics->ics_out - 1) * sizeof (IMA_ADDRESS_KEY));
1650 	*pConfigSessions = (SUN_IMA_CONFIG_SESSIONS *)calloc(1, size);
1651 	if ((*pConfigSessions) == NULL) {
1652 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
1653 	}
1654 
1655 	/* Copy output information */
1656 	(*pConfigSessions)->bound =
1657 	    (ics->ics_bound == B_TRUE ?  IMA_TRUE : IMA_FALSE);
1658 	(*pConfigSessions)->in = ics->ics_in;
1659 	(*pConfigSessions)->out = ics->ics_out;
1660 	for (idx = 0; idx < ics->ics_in; idx++) {
1661 		if (ics->ics_bindings[idx].i_insize ==
1662 		    sizeof (struct in_addr)) {
1663 			(*pConfigSessions)->bindings[idx].ipAddress.
1664 			    ipv4Address = IMA_TRUE;
1665 			bcopy(&ics->ics_bindings[idx].i_addr.in4,
1666 			    (*pConfigSessions)->bindings[idx].ipAddress.
1667 			    ipAddress, sizeof (struct in_addr));
1668 		} else {
1669 			(*pConfigSessions)->bindings[idx].ipAddress.
1670 			    ipv4Address = IMA_FALSE;
1671 			bcopy(&ics->ics_bindings[idx].i_addr.in6,
1672 			    (*pConfigSessions)->bindings[idx].ipAddress.
1673 			    ipAddress, sizeof (struct in6_addr));
1674 		}
1675 	}
1676 
1677 	free(ics);
1678 	return (IMA_STATUS_SUCCESS);
1679 }
1680 
1681 /*
1682  * SUN_IMA_SetConfigSessions -
1683  *
1684  * Non-IMA defined function.
1685  */
SUN_IMA_SetConfigSessions(IMA_OID targetOid,SUN_IMA_CONFIG_SESSIONS * pConfigSessions)1686 IMA_API IMA_STATUS SUN_IMA_SetConfigSessions(
1687     IMA_OID targetOid,
1688     SUN_IMA_CONFIG_SESSIONS *pConfigSessions
1689 )
1690 {
1691 	int		    fd;
1692 	int		    status;
1693 	iscsi_config_sess_t *ics;
1694 	int		    idx, size;
1695 
1696 	/* verify allowed range of sessions */
1697 	if ((pConfigSessions->in < ISCSI_MIN_CONFIG_SESSIONS) ||
1698 	    (pConfigSessions->in > ISCSI_MAX_CONFIG_SESSIONS)) {
1699 		return (IMA_ERROR_INVALID_PARAMETER);
1700 	}
1701 
1702 	/* allocate record config_sess size */
1703 	size = ISCSI_SESSION_CONFIG_SIZE(pConfigSessions->in);
1704 	ics = (iscsi_config_sess_t *)malloc(size);
1705 
1706 	/* setup config_sess information */
1707 	(void) memset(ics, 0, sizeof (iscsi_config_sess_t));
1708 	ics->ics_ver = ISCSI_INTERFACE_VERSION;
1709 	ics->ics_oid = targetOid.objectSequenceNumber;
1710 	ics->ics_bound =
1711 	    (pConfigSessions->bound == IMA_TRUE ?  B_TRUE : B_FALSE);
1712 	ics->ics_in  = pConfigSessions->in;
1713 	for (idx = 0; idx < ics->ics_in; idx++) {
1714 		if (pConfigSessions->bindings[idx].ipAddress.
1715 		    ipv4Address == IMA_TRUE) {
1716 			ics->ics_bindings[idx].i_insize =
1717 			    sizeof (struct in_addr);
1718 			bcopy(pConfigSessions->bindings[idx].
1719 			    ipAddress.ipAddress,
1720 			    &ics->ics_bindings[idx].i_addr.in4,
1721 			    sizeof (struct in_addr));
1722 		} else {
1723 			ics->ics_bindings[idx].i_insize =
1724 			    sizeof (struct in6_addr);
1725 			bcopy(pConfigSessions->bindings[idx].
1726 			    ipAddress.ipAddress,
1727 			    &ics->ics_bindings[idx].i_addr.in6,
1728 			    sizeof (struct in6_addr));
1729 		}
1730 	}
1731 
1732 	/* open driver */
1733 	if ((status = open_driver(&fd))) {
1734 		free(ics);
1735 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1736 	}
1737 
1738 	/* issue ioctl request */
1739 	if (ioctl(fd, ISCSI_SET_CONFIG_SESSIONS, ics) != 0) {
1740 		syslog(LOG_USER|LOG_DEBUG,
1741 		    "ISCSI_SET_CONFIG_SESSIONS ioctl failed, errno: %d",
1742 		    errno);
1743 		(void) close(fd);
1744 		free(ics);
1745 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1746 	}
1747 	(void) close(fd);
1748 	free(ics);
1749 	return (IMA_STATUS_SUCCESS);
1750 }
1751 
1752 /* A helper function to obtain iSCSI node parameters. */
1753 static IMA_STATUS
getISCSINodeParameter(int paramType,IMA_OID * oid,void * pProps,uint32_t paramIndex)1754 getISCSINodeParameter(
1755     int paramType,
1756     IMA_OID *oid,
1757     void *pProps,
1758     uint32_t paramIndex
1759 )
1760 {
1761 	int		    fd;
1762 	int 		status;
1763 	iscsi_param_get_t   pg;
1764 
1765 	if ((status = open_driver(&fd))) {
1766 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1767 	}
1768 
1769 	(void) memset(&pg, 0, sizeof (iscsi_param_get_t));
1770 	pg.g_vers = ISCSI_INTERFACE_VERSION;
1771 	pg.g_oid = (uint32_t)oid->objectSequenceNumber;
1772 	pg.g_param = paramIndex;
1773 	pg.g_param_type = ISCSI_SESS_PARAM;
1774 
1775 	if (ioctl(fd, ISCSI_PARAM_GET, &pg) != 0) {
1776 		syslog(LOG_USER|LOG_DEBUG,
1777 		    "ISCSI_PARAM_GET ioctl failed, errno: %d", errno);
1778 		(void) close(fd);
1779 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1780 	}
1781 
1782 	switch (paramType) {
1783 		IMA_BOOL_VALUE *bp;
1784 		IMA_MIN_MAX_VALUE *mp;
1785 
1786 		case MIN_MAX_PARAM:
1787 			mp = (IMA_MIN_MAX_VALUE *)pProps;
1788 
1789 			mp->currentValueValid =
1790 			    (pg.g_value.v_valid == B_TRUE) ?
1791 			    IMA_TRUE : IMA_FALSE;
1792 			mp->currentValue = pg.g_value.v_integer.i_current;
1793 			mp->defaultValue = pg.g_value.v_integer.i_default;
1794 			mp->minimumValue = pg.g_value.v_integer.i_min;
1795 			mp->maximumValue = pg.g_value.v_integer.i_max;
1796 			mp->incrementValue = pg.g_value.v_integer.i_incr;
1797 			break;
1798 
1799 		case BOOL_PARAM:
1800 			bp = (IMA_BOOL_VALUE *)pProps;
1801 			bp->currentValueValid =
1802 			    (pg.g_value.v_valid == B_TRUE) ?
1803 			    IMA_TRUE : IMA_FALSE;
1804 			bp->currentValue = pg.g_value.v_bool.b_current;
1805 			bp->defaultValue = pg.g_value.v_bool.b_default;
1806 			break;
1807 
1808 		default:
1809 			break;
1810 	}
1811 
1812 	/* Issue ISCSI_PARAM_GET ioctl again to obtain connection parameters. */
1813 	pg.g_param_type = ISCSI_CONN_PARAM;
1814 	if (ioctl(fd, ISCSI_PARAM_GET, &pg) != 0) {
1815 		syslog(LOG_USER|LOG_DEBUG,
1816 		    "ISCSI_PARAM_GET ioctl failed, errno: %d", errno);
1817 		(void) close(fd);
1818 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1819 	}
1820 
1821 	(void) close(fd);
1822 	return (IMA_STATUS_SUCCESS);
1823 }
1824 
1825 /* A helper function to set iSCSI node parameters. */
1826 static IMA_STATUS
setISCSINodeParameter(int paramType,IMA_OID * oid,void * pProp,uint32_t paramIndex)1827 setISCSINodeParameter(
1828     int paramType,
1829     IMA_OID *oid,
1830     void *pProp,
1831     uint32_t paramIndex
1832 )
1833 {
1834 	int		    fd;
1835 	int			status;
1836 	iscsi_param_set_t   ps;
1837 
1838 	if ((status = open_driver(&fd))) {
1839 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1840 	}
1841 
1842 	(void) memset(&ps, 0, sizeof (iscsi_param_set_t));
1843 	ps.s_vers = ISCSI_INTERFACE_VERSION;
1844 	ps.s_oid = (uint32_t)oid->objectSequenceNumber;
1845 	ps.s_param = paramIndex;
1846 
1847 	switch (paramType) {
1848 		IMA_BOOL_VALUE *bp;
1849 		IMA_MIN_MAX_VALUE *mp;
1850 
1851 		case MIN_MAX_PARAM:
1852 			mp = (IMA_MIN_MAX_VALUE *)pProp;
1853 			ps.s_value.v_integer = mp->currentValue;
1854 			break;
1855 		case BOOL_PARAM:
1856 			bp = (IMA_BOOL_VALUE *)pProp;
1857 			ps.s_value.v_bool =
1858 			    (bp->currentValue == IMA_TRUE) ?
1859 			    B_TRUE : B_FALSE;
1860 			break;
1861 
1862 		default:
1863 			break;
1864 	}
1865 	if (ioctl(fd, ISCSI_PARAM_SET, &ps)) {
1866 		(void) close(fd);
1867 		syslog(LOG_USER|LOG_DEBUG,
1868 		    "ISCSI_PARAM_SET ioctl failed, errno: %d", errno);
1869 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1870 	}
1871 
1872 	(void) close(fd);
1873 	return (IMA_STATUS_SUCCESS);
1874 }
1875 
1876 static int
prepare_discovery_entry(SUN_IMA_TARGET_ADDRESS discoveryAddress,entry_t * entry)1877 prepare_discovery_entry(
1878     SUN_IMA_TARGET_ADDRESS discoveryAddress,
1879     entry_t *entry
1880 )
1881 {
1882 	return (prepare_discovery_entry_IMA(discoveryAddress.imaStruct, entry));
1883 }
1884 
1885 static int
prepare_discovery_entry_IMA(IMA_TARGET_ADDRESS discoveryAddress,entry_t * entry)1886 prepare_discovery_entry_IMA(
1887     IMA_TARGET_ADDRESS discoveryAddress,
1888     entry_t *entry
1889 )
1890 {
1891 	(void) memset(entry, 0, sizeof (entry_t));
1892 	entry->e_vers = ISCSI_INTERFACE_VERSION;
1893 	entry->e_oid = ISCSI_OID_NOTSET;
1894 
1895 	if (discoveryAddress.hostnameIpAddress.id.ipAddress.
1896 	    ipv4Address == IMA_FALSE) {
1897 
1898 		bcopy(discoveryAddress.hostnameIpAddress.id.ipAddress.
1899 		    ipAddress, entry->e_u.u_in6.s6_addr,
1900 		    sizeof (entry->e_u.u_in6.s6_addr));
1901 
1902 		entry->e_insize = sizeof (struct in6_addr);
1903 	} else {
1904 
1905 		bcopy(discoveryAddress.hostnameIpAddress.id.ipAddress.
1906 		    ipAddress, &entry->e_u.u_in4.s_addr,
1907 		    sizeof (entry->e_u.u_in4.s_addr));
1908 
1909 		entry->e_insize = sizeof (struct in_addr);
1910 	}
1911 
1912 	entry->e_port = discoveryAddress.portNumber;
1913 	entry->e_tpgt = 0;
1914 	return (DISC_ADDR_OK);
1915 }
1916 
configure_discovery_method(IMA_BOOL enable,iSCSIDiscoveryMethod_t method)1917 static IMA_STATUS configure_discovery_method(
1918     IMA_BOOL enable,
1919     iSCSIDiscoveryMethod_t method
1920 )
1921 {
1922 	int	fd, status;
1923 
1924 	if ((status = open_driver(&fd))) {
1925 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1926 	}
1927 
1928 	if (enable == IMA_FALSE) {
1929 		if (ioctl(fd, ISCSI_DISCOVERY_CLEAR, &method)) {
1930 			status = errno;
1931 			(void) close(fd);
1932 			syslog(LOG_USER|LOG_DEBUG,
1933 			    "ISCSI_DISCOVERY_CLEAR ioctl failed, errno: %d",
1934 			    status);
1935 			if (status == EBUSY) {
1936 				return (IMA_ERROR_LU_IN_USE);
1937 			} else {
1938 				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1939 			}
1940 		}
1941 
1942 		(void) close(fd);
1943 		return (IMA_STATUS_SUCCESS);
1944 	} else {
1945 		/* Set the discovery method */
1946 		if (ioctl(fd, ISCSI_DISCOVERY_SET, &method)) {
1947 			status = errno;
1948 			(void) close(fd);
1949 			syslog(LOG_USER|LOG_DEBUG,
1950 			    "ISCSI_DISCOVERY_SET ioctl failed, errno: %d",
1951 			    status);
1952 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1953 		}
1954 
1955 		(void) close(fd);
1956 		return (IMA_STATUS_SUCCESS);
1957 	}
1958 }
1959 
1960 /* LINTED E_STATIC_UNUSED */
authMethodMatch(IMA_AUTHMETHOD matchingMethod,IMA_AUTHMETHOD * methodList,IMA_UINT maxEntries)1961 static IMA_BOOL authMethodMatch(
1962     IMA_AUTHMETHOD matchingMethod,
1963     IMA_AUTHMETHOD *methodList,
1964     IMA_UINT maxEntries
1965 )
1966 {
1967 	IMA_UINT i;
1968 
1969 	for (i = 0; i < maxEntries; i++) {
1970 		if (methodList[i] == matchingMethod) {
1971 			return (IMA_TRUE);
1972 		}
1973 	}
1974 
1975 	return (IMA_FALSE);
1976 }
1977 
get_target_oid_list(uint32_t targetListType,IMA_OID_LIST ** ppList)1978 static IMA_STATUS get_target_oid_list(
1979     uint32_t targetListType,
1980     IMA_OID_LIST **ppList)
1981 {
1982 	int		    fd;
1983 	int		    i;
1984 	int		    target_list_size;
1985 	int		    status;
1986 	int		    out_cnt;
1987 	iscsi_target_list_t *idlp;
1988 
1989 	if ((status = open_driver(&fd))) {
1990 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
1991 	}
1992 
1993 	idlp = (iscsi_target_list_t *)calloc(1, sizeof (iscsi_target_list_t));
1994 	if (idlp == NULL) {
1995 		(void) close(fd);
1996 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
1997 	}
1998 	idlp->tl_vers = ISCSI_INTERFACE_VERSION;
1999 	idlp->tl_in_cnt = idlp->tl_out_cnt = 1;
2000 	idlp->tl_tgt_list_type = targetListType;
2001 
2002 	/*
2003 	 * Issue ioctl.  Space has been allocted for one entry.
2004 	 * If more than one entry should be returned, we will re-issue the
2005 	 * entry with the right amount of space allocted
2006 	 */
2007 	if (ioctl(fd, ISCSI_TARGET_OID_LIST_GET, idlp) != 0) {
2008 		(void) close(fd);
2009 		syslog(LOG_USER|LOG_DEBUG,
2010 		    "ISCSI_TARGET_OID_LIST_GET ioctl %d failed, errno: %d",
2011 		    targetListType, errno);
2012 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2013 	}
2014 	if (idlp->tl_out_cnt > 1) {
2015 		out_cnt = idlp->tl_out_cnt;
2016 		free(idlp);
2017 
2018 		target_list_size = sizeof (iscsi_target_list_t);
2019 		target_list_size += (sizeof (uint32_t) * out_cnt - 1);
2020 		idlp = (iscsi_target_list_t *)calloc(1, target_list_size);
2021 		if (idlp == NULL) {
2022 			(void) close(fd);
2023 			return (IMA_ERROR_INSUFFICIENT_MEMORY);
2024 		}
2025 		idlp->tl_vers = ISCSI_INTERFACE_VERSION;
2026 		idlp->tl_in_cnt = out_cnt;
2027 		idlp->tl_tgt_list_type = targetListType;
2028 
2029 		/* Issue the same ioctl again to obtain all the OIDs. */
2030 		if (ioctl(fd, ISCSI_TARGET_OID_LIST_GET, idlp) != 0) {
2031 #define	ERROR_STR "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl failed, errno :%d"
2032 			free(idlp);
2033 			(void) close(fd);
2034 			syslog(LOG_USER|LOG_DEBUG,
2035 			    ERROR_STR, targetListType, errno);
2036 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2037 #undef ERROR_STR
2038 
2039 		}
2040 	}
2041 
2042 	*ppList = (IMA_OID_LIST *)calloc(1, sizeof (IMA_OID_LIST) +
2043 	    idlp->tl_out_cnt * sizeof (IMA_OID));
2044 	(*ppList)->oidCount = idlp->tl_out_cnt;
2045 	for (i = 0; i < idlp->tl_out_cnt; i++) {
2046 		(*ppList)->oids[i].objectType = IMA_OBJECT_TYPE_TARGET;
2047 		(*ppList)->oids[i].ownerId = 1;
2048 		(*ppList)->oids[i].objectSequenceNumber = idlp->tl_oid_list[i];
2049 	}
2050 
2051 	free(idlp);
2052 	(void) close(fd);
2053 	return (IMA_STATUS_SUCCESS);
2054 }
2055 
get_target_lun_oid_list(IMA_OID * targetOid,iscsi_lun_list_t ** ppLunList)2056 static IMA_STATUS get_target_lun_oid_list(
2057     IMA_OID * targetOid,
2058     iscsi_lun_list_t  **ppLunList)
2059 {
2060 	int			fd;
2061 	iscsi_lun_list_t	*illp, *illp_saved;
2062 	int			lun_list_size;
2063 	int			status;
2064 
2065 	if ((status = open_driver(&fd))) {
2066 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2067 	}
2068 
2069 	illp = (iscsi_lun_list_t *)calloc(1, sizeof (iscsi_lun_list_t));
2070 	if (illp == NULL) {
2071 		(void) close(fd);
2072 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2073 	}
2074 	illp->ll_vers = ISCSI_INTERFACE_VERSION;
2075 	if (targetOid == NULL) {
2076 		/* get lun oid list for all targets */
2077 		illp->ll_all_tgts = B_TRUE;
2078 	} else {
2079 		/* get lun oid list for single target */
2080 		illp->ll_all_tgts = B_FALSE;
2081 		illp->ll_tgt_oid = (uint32_t)targetOid->objectSequenceNumber;
2082 	}
2083 	illp->ll_in_cnt = illp->ll_out_cnt = 1;
2084 
2085 	/*
2086 	 * Issue ioctl to retrieve the target luns.  Space has been allocted
2087 	 * for one entry.  If more than one entry should be returned, we
2088 	 * will re-issue the entry with the right amount of space allocted
2089 	 */
2090 	if (ioctl(fd, ISCSI_LUN_OID_LIST_GET, illp) != 0) {
2091 		(void) close(fd);
2092 		syslog(LOG_USER|LOG_DEBUG,
2093 		    "ISCSI_LUN_LIST_GET ioctl failed, errno: %d", errno);
2094 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2095 	}
2096 
2097 	if (illp->ll_out_cnt > 1) {
2098 		illp_saved = illp;
2099 		lun_list_size = sizeof (iscsi_lun_list_t);
2100 		lun_list_size += (sizeof (iscsi_if_lun_t) *
2101 		    (illp->ll_out_cnt - 1));
2102 		illp = (iscsi_lun_list_t *)calloc(1, lun_list_size);
2103 		if (illp == NULL) {
2104 			(void) close(fd);
2105 			return (IMA_ERROR_INSUFFICIENT_MEMORY);
2106 		}
2107 		illp->ll_vers = ISCSI_INTERFACE_VERSION;
2108 		illp->ll_all_tgts = illp_saved->ll_all_tgts;
2109 		illp->ll_tgt_oid = illp_saved->ll_tgt_oid;
2110 		illp->ll_in_cnt = illp_saved->ll_out_cnt;
2111 
2112 		free(illp_saved);
2113 
2114 		/* Issue the same ioctl again to get all the target LUN list */
2115 		if (ioctl(fd, ISCSI_LUN_OID_LIST_GET, illp) != 0) {
2116 			free(illp);
2117 			(void) close(fd);
2118 			syslog(LOG_USER|LOG_DEBUG,
2119 			    "ISCSI_LUN_LIST_GET ioctl failed, errno: %d",
2120 			    errno);
2121 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2122 
2123 		}
2124 	}
2125 	*ppLunList = illp;
2126 
2127 
2128 	(void) close(fd);
2129 	return (IMA_STATUS_SUCCESS);
2130 }
2131 
2132 /* A helper function to obtain digest algorithms. */
2133 static IMA_STATUS
getDigest(IMA_OID oid,int ioctlCmd,SUN_IMA_DIGEST_ALGORITHM_VALUE * algorithm)2134 getDigest(
2135     IMA_OID oid,
2136     int ioctlCmd,
2137     SUN_IMA_DIGEST_ALGORITHM_VALUE *algorithm
2138 )
2139 {
2140 	IMA_MIN_MAX_VALUE pProps;
2141 	IMA_STATUS status;
2142 
2143 	if ((status = getISCSINodeParameter(MIN_MAX_PARAM, &oid, &pProps,
2144 	    ioctlCmd)) != IMA_STATUS_SUCCESS) {
2145 		return (status);
2146 	}
2147 
2148 	switch (pProps.defaultValue) {
2149 		case ISCSI_DIGEST_NONE:
2150 			algorithm->defaultAlgorithms[0] = ISCSI_DIGEST_NONE;
2151 			algorithm->defaultAlgorithmCount = 1;
2152 			break;
2153 		case ISCSI_DIGEST_CRC32C:
2154 			algorithm->defaultAlgorithms[0] = ISCSI_DIGEST_CRC32C;
2155 			algorithm->defaultAlgorithmCount = 1;
2156 			break;
2157 
2158 		case ISCSI_DIGEST_CRC32C_NONE:
2159 			algorithm->defaultAlgorithms[0] = ISCSI_DIGEST_CRC32C;
2160 			algorithm->defaultAlgorithms[1] = ISCSI_DIGEST_NONE;
2161 			algorithm->defaultAlgorithmCount = 2;
2162 			break;
2163 		case ISCSI_DIGEST_NONE_CRC32C:
2164 			algorithm->defaultAlgorithms[0] = ISCSI_DIGEST_NONE;
2165 			algorithm->defaultAlgorithms[1] = ISCSI_DIGEST_CRC32C;
2166 			algorithm->defaultAlgorithmCount = 2;
2167 			break;
2168 		default:
2169 			/* Error */
2170 			syslog(LOG_USER|LOG_DEBUG,
2171 			    "Invalid default digest: %d", pProps.defaultValue);
2172 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2173 	}
2174 
2175 	/* The configured value */
2176 	if (pProps.currentValueValid == IMA_TRUE) {
2177 		algorithm->currentValid = IMA_TRUE;
2178 
2179 		switch (pProps.currentValue) {
2180 			case ISCSI_DIGEST_NONE:
2181 				algorithm->currentAlgorithms[0] =
2182 				    ISCSI_DIGEST_NONE;
2183 				algorithm->currentAlgorithmCount = 1;
2184 				break;
2185 			case ISCSI_DIGEST_CRC32C:
2186 				algorithm->currentAlgorithms[0] =
2187 				    ISCSI_DIGEST_CRC32C;
2188 				algorithm->currentAlgorithmCount = 1;
2189 				break;
2190 
2191 			case ISCSI_DIGEST_CRC32C_NONE:
2192 				algorithm->currentAlgorithms[0] =
2193 				    ISCSI_DIGEST_CRC32C;
2194 				algorithm->currentAlgorithms[1] =
2195 				    ISCSI_DIGEST_NONE;
2196 				algorithm->currentAlgorithmCount = 2;
2197 				break;
2198 			case ISCSI_DIGEST_NONE_CRC32C:
2199 				algorithm->currentAlgorithms[0] =
2200 				    ISCSI_DIGEST_NONE;
2201 				algorithm->currentAlgorithms[1] =
2202 				    ISCSI_DIGEST_CRC32C;
2203 				algorithm->currentAlgorithmCount = 2;
2204 				break;
2205 			default:
2206 				/* Error */
2207 				syslog(LOG_USER|LOG_DEBUG,
2208 				    "Invalid configured digest: %d",
2209 				    pProps.defaultValue);
2210 				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2211 		}
2212 
2213 	} else {
2214 		algorithm->currentValid = IMA_FALSE;
2215 	}
2216 
2217 	return (IMA_STATUS_SUCCESS);
2218 }
2219 
2220 /*
2221  * getConnOidList -
2222  */
getConnOidList(IMA_OID * sessOid,iscsi_conn_list_t ** ppConnList)2223 static IMA_STATUS getConnOidList(
2224 	IMA_OID			*sessOid,
2225 	iscsi_conn_list_t	**ppConnList
2226 )
2227 {
2228 	iscsi_conn_list_t	*iscsiConnList = NULL;
2229 	size_t			allocLen;
2230 	int			fd;
2231 	int			status;
2232 	int			out_cnt;
2233 
2234 	/* Preset it to NULL to prepare for the case of failure */
2235 	*ppConnList = NULL;
2236 
2237 	/* We try to open the driver now. */
2238 	if ((status = open_driver(&fd))) {
2239 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2240 	}
2241 
2242 	iscsiConnList = (iscsi_conn_list_t *)calloc(1,
2243 	    sizeof (iscsi_conn_list_t));
2244 	if (iscsiConnList == NULL) {
2245 		(void) close(fd);
2246 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2247 	}
2248 	iscsiConnList->cl_vers = ISCSI_INTERFACE_VERSION;
2249 	iscsiConnList->cl_in_cnt = iscsiConnList->cl_out_cnt = 1;
2250 	if (sessOid == NULL) {
2251 		iscsiConnList->cl_all_sess = B_TRUE;
2252 	} else {
2253 		iscsiConnList->cl_all_sess = B_FALSE;
2254 		iscsiConnList->cl_sess_oid =
2255 		    (uint32_t)sessOid->objectSequenceNumber;
2256 	}
2257 	/*
2258 	 * Issue ioctl to retrieve the connection OIDs.  Space has been
2259 	 * allocated for one entry.  If more than one entry should be
2260 	 * returned, we will re-issue the entry with the right amount of
2261 	 * space allocted
2262 	 */
2263 	if (ioctl(fd, ISCSI_CONN_OID_LIST_GET, iscsiConnList) != 0) {
2264 		syslog(LOG_USER|LOG_DEBUG,
2265 		    "ISCSI_CONN_OID_LIST_GET ioctl failed, errno: %d", errno);
2266 		*ppConnList = NULL;
2267 		(void) close(fd);
2268 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2269 	}
2270 	if (iscsiConnList->cl_out_cnt > 1) {
2271 		out_cnt = iscsiConnList->cl_out_cnt;
2272 		free(iscsiConnList);
2273 
2274 		allocLen = sizeof (iscsi_conn_list_t);
2275 		allocLen += (sizeof (iscsi_if_conn_t) * out_cnt - 1);
2276 		iscsiConnList = (iscsi_conn_list_t *)calloc(1, allocLen);
2277 		if (iscsiConnList == NULL) {
2278 			*ppConnList = NULL;
2279 			(void) close(fd);
2280 			return (IMA_ERROR_INSUFFICIENT_MEMORY);
2281 		}
2282 		iscsiConnList->cl_vers = ISCSI_INTERFACE_VERSION;
2283 		iscsiConnList->cl_in_cnt = out_cnt;
2284 		if (sessOid == NULL) {
2285 			iscsiConnList->cl_all_sess = B_TRUE;
2286 		} else {
2287 			iscsiConnList->cl_all_sess = B_FALSE;
2288 			iscsiConnList->cl_sess_oid =
2289 			    (uint32_t)sessOid->objectSequenceNumber;
2290 		}
2291 		/* Issue the same ioctl again to obtain all the OIDs */
2292 		if (ioctl(fd, ISCSI_CONN_OID_LIST_GET, iscsiConnList) != 0) {
2293 
2294 			syslog(LOG_USER|LOG_DEBUG,
2295 			    "ISCSI_CONN_OID_LIST_GET ioctl failed, errno: %d",
2296 			    errno);
2297 			*ppConnList = NULL;
2298 			free(iscsiConnList);
2299 			(void) close(fd);
2300 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2301 
2302 		}
2303 
2304 		if (out_cnt < iscsiConnList->cl_out_cnt) {
2305 			/*
2306 			 * The connection list grew between the first and second
2307 			 * ioctls.
2308 			 */
2309 			syslog(LOG_USER|LOG_DEBUG,
2310 			    "The connection list has grown. There could be "
2311 			    "more connections than listed.");
2312 		}
2313 	}
2314 
2315 
2316 	(void) close(fd);
2317 	*ppConnList = iscsiConnList;
2318 	return (IMA_STATUS_SUCCESS);
2319 }
2320 
2321 /*
2322  * getConnProps -
2323  */
getConnProps(iscsi_if_conn_t * pConn,iscsi_conn_props_t ** ppConnProps)2324 static IMA_STATUS getConnProps(
2325 	iscsi_if_conn_t		*pConn,
2326 	iscsi_conn_props_t	**ppConnProps
2327 )
2328 {
2329 	iscsi_conn_props_t	*iscsiConnProps;
2330 	int			fd;
2331 	int			status;
2332 
2333 	/* We try to open the driver. */
2334 	if ((status = open_driver(&fd))) {
2335 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2336 	}
2337 
2338 	iscsiConnProps = (iscsi_conn_props_t *)calloc(1,
2339 	    sizeof (*iscsiConnProps));
2340 
2341 	if (iscsiConnProps == NULL) {
2342 		(void) close(fd);
2343 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2344 	}
2345 
2346 	iscsiConnProps->cp_vers = ISCSI_INTERFACE_VERSION;
2347 	iscsiConnProps->cp_oid = pConn->c_oid;
2348 	iscsiConnProps->cp_cid = pConn->c_cid;
2349 	iscsiConnProps->cp_sess_oid = pConn->c_sess_oid;
2350 
2351 	/* The IOCTL is submitted. */
2352 	if (ioctl(fd, ISCSI_CONN_PROPS_GET, iscsiConnProps) != 0) {
2353 		/* IOCTL failed */
2354 		syslog(LOG_USER|LOG_DEBUG,
2355 		    "ISCSI_AUTH_CLEAR ioctl failed, errno: %d", errno);
2356 		free(iscsiConnProps);
2357 		(void) close(fd);
2358 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2359 	}
2360 	(void) close(fd);
2361 	*ppConnProps = iscsiConnProps;
2362 	return (IMA_STATUS_SUCCESS);
2363 }
2364 
2365 /* A helper function to set authentication method. */
2366 static IMA_STATUS
setAuthMethods(IMA_OID oid,IMA_UINT * pMethodCount,const IMA_AUTHMETHOD * pMethodList)2367 setAuthMethods(
2368     IMA_OID oid,
2369     IMA_UINT *pMethodCount,
2370     const IMA_AUTHMETHOD *pMethodList
2371 )
2372 {
2373 	int fd;
2374 	int i;
2375 	int status;
2376 	iscsi_auth_props_t auth;
2377 
2378 	if ((status = open_driver(&fd))) {
2379 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2380 	}
2381 	(void) memset(&auth, 0, sizeof (iscsi_auth_props_t));
2382 	auth.a_vers = ISCSI_INTERFACE_VERSION;
2383 	auth.a_oid = (uint32_t)oid.objectSequenceNumber;
2384 
2385 	/*
2386 	 * Get the current auth fields so they don't need to be reset
2387 	 * here.
2388 	 */
2389 	if (ioctl(fd, ISCSI_AUTH_GET, &auth) != 0) {
2390 	    /* EMPTY */
2391 	    /* Initializing auth structure with current settings */
2392 	}
2393 	auth.a_auth_method = authMethodNone;
2394 
2395 	for (i = 0; i < *pMethodCount; i++) {
2396 		switch (pMethodList[i]) {
2397 			case IMA_AUTHMETHOD_CHAP:
2398 				auth.a_auth_method |= authMethodCHAP;
2399 				break;
2400 			default:
2401 				break;
2402 		}
2403 	}
2404 
2405 	if (ioctl(fd, ISCSI_AUTH_SET, &auth) != 0) {
2406 		syslog(LOG_USER|LOG_DEBUG,
2407 		    "ISCSI_AUTH_SET failed, errno: %d", errno);
2408 		(void) close(fd);
2409 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2410 	}
2411 
2412 	(void) close(fd);
2413 	return (IMA_STATUS_SUCCESS);
2414 }
2415 
2416 /* A helper function to set authentication method. */
getAuthMethods(IMA_OID oid,IMA_UINT * pMethodCount,IMA_AUTHMETHOD * pMethodList)2417 static IMA_STATUS getAuthMethods(
2418     IMA_OID oid,
2419     IMA_UINT	*pMethodCount,
2420     IMA_AUTHMETHOD *pMethodList
2421 )
2422 {
2423 	int fd;
2424 	int status;
2425 	iscsi_auth_props_t auth;
2426 
2427 	if ((status = open_driver(&fd))) {
2428 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2429 	}
2430 
2431 	(void) memset(&auth, 0, sizeof (iscsi_auth_props_t));
2432 	auth.a_vers = ISCSI_INTERFACE_VERSION;
2433 	auth.a_oid = (uint32_t)oid.objectSequenceNumber;
2434 
2435 	if (ioctl(fd, ISCSI_AUTH_GET, &auth) != 0) {
2436 		syslog(LOG_USER|LOG_DEBUG,
2437 		    "ISCSI_AUTH_GET failed, errno: %d", errno);
2438 		(void) close(fd);
2439 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2440 	}
2441 
2442 	if (auth.a_auth_method == authMethodNone) {
2443 		pMethodList[0] = IMA_AUTHMETHOD_NONE;
2444 		*pMethodCount = 1;
2445 	} else {
2446 		int i = 0;
2447 		if (!((auth.a_auth_method & authMethodCHAP)^authMethodCHAP)) {
2448 			pMethodList[i++] = IMA_AUTHMETHOD_CHAP;
2449 		}
2450 		*pMethodCount = i;
2451 	}
2452 
2453 	(void) close(fd);
2454 	return (IMA_STATUS_SUCCESS);
2455 }
2456 
2457 /* Helper function to open driver */
open_driver(int * fd)2458 int open_driver(
2459 	int *fd
2460 )
2461 {
2462 	int ret = 0;
2463 	if ((*fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
2464 		ret = errno;
2465 		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
2466 		    ISCSI_DRIVER_DEVCTL, ret);
2467 	}
2468 	return (ret);
2469 }
2470 
2471 /*
2472  * Iscsi driver does not support OID for discovery address. Create
2473  * a modified version of IMA_RemoveDiscoveryAddress that takes
2474  * discoveryAddress (instead of an OID) as input argument.
2475  */
SUN_IMA_RemoveDiscoveryAddress(SUN_IMA_TARGET_ADDRESS discoveryAddress)2476 IMA_API	IMA_STATUS SUN_IMA_RemoveDiscoveryAddress(
2477     SUN_IMA_TARGET_ADDRESS discoveryAddress
2478 )
2479 {
2480 	entry_t	entry;
2481 	int	fd;
2482 	int status, i, addr_list_size, insize;
2483 	iscsi_addr_list_t *idlp, al_info;
2484 	iscsi_addr_t *matched_addr = NULL;
2485 
2486 	if ((status = open_driver(&fd))) {
2487 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2488 	}
2489 
2490 	if (prepare_discovery_entry(discoveryAddress, &entry) !=
2491 	    DISC_ADDR_OK) {
2492 		(void) close(fd);
2493 		return (IMA_ERROR_INVALID_PARAMETER);
2494 	}
2495 
2496 	(void) memset(&al_info, 0, sizeof (al_info));
2497 	al_info.al_vers = ISCSI_INTERFACE_VERSION;
2498 	al_info.al_in_cnt = 0;
2499 	/*
2500 	 * Issue ioctl to get the number of discovery address.
2501 	 */
2502 	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, &al_info) != 0) {
2503 		syslog(LOG_USER|LOG_DEBUG,
2504 		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl %d failed, errno: %d",
2505 		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
2506 		(void) close(fd);
2507 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2508 	}
2509 
2510 	if (al_info.al_out_cnt == 0) {
2511 		(void) close(fd);
2512 		return (IMA_ERROR_OBJECT_NOT_FOUND);
2513 	}
2514 
2515 	addr_list_size = sizeof (iscsi_addr_list_t);
2516 	if (al_info.al_out_cnt > 1) {
2517 		addr_list_size += (sizeof (iscsi_addr_t) *
2518 		    (al_info.al_out_cnt - 1));
2519 	}
2520 
2521 	idlp = (iscsi_addr_list_t *)calloc(1, addr_list_size);
2522 	if (idlp == NULL) {
2523 		(void) close(fd);
2524 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2525 	}
2526 
2527 	idlp->al_vers = ISCSI_INTERFACE_VERSION;
2528 	idlp->al_in_cnt = al_info.al_out_cnt;
2529 
2530 	/* issue the same ioctl to get all the discovery addresses */
2531 	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_LIST_GET, idlp) != 0) {
2532 		syslog(LOG_USER|LOG_DEBUG,
2533 		    "ISCSI_DISCOVERY_ADDR_LIST_GET ioctl %d failed, errno: %d",
2534 		    ISCSI_DISCOVERY_ADDR_LIST_GET, errno);
2535 		free(idlp);
2536 		(void) close(fd);
2537 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2538 	}
2539 
2540 	/*
2541 	 * find the matched discovery address
2542 	 */
2543 	for (i = 0; i < idlp->al_out_cnt; i++) {
2544 		insize = idlp->al_addrs[i].a_addr.i_insize;
2545 		if (insize != entry.e_insize) {
2546 			continue;
2547 		}
2548 		if (insize == sizeof (struct in_addr)) {
2549 			if (idlp->al_addrs[i].a_addr.i_addr.in4.s_addr ==
2550 			    entry.e_u.u_in4.s_addr) {
2551 				matched_addr = &(idlp->al_addrs[i]);
2552 				break;
2553 			}
2554 		}
2555 		if (insize == sizeof (struct in6_addr)) {
2556 			if (bcmp(entry.e_u.u_in6.s6_addr,
2557 			    idlp->al_addrs[i].a_addr.i_addr.in6.s6_addr,
2558 			    insize) == 0) {
2559 				matched_addr = &(idlp->al_addrs[i]);
2560 				break;
2561 			}
2562 		}
2563 	}
2564 
2565 	free(idlp);
2566 
2567 	if (matched_addr == NULL) {
2568 		(void) close(fd);
2569 		return (IMA_ERROR_OBJECT_NOT_FOUND);
2570 	}
2571 
2572 	if (ioctl(fd, ISCSI_DISCOVERY_ADDR_CLEAR, &entry)) {
2573 		status = errno;
2574 		(void) close(fd);
2575 		syslog(LOG_USER|LOG_DEBUG,
2576 		    "ISCSI_DISCOVERY_ADDR_CLEAR ioctl failed, errno: %d",
2577 		    errno);
2578 		if (status == EBUSY) {
2579 			return (IMA_ERROR_LU_IN_USE);
2580 		} else {
2581 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2582 		}
2583 	}
2584 
2585 	(void) close(fd);
2586 	return (IMA_STATUS_SUCCESS);
2587 }
2588 
SUN_IMA_SetTargetAuthMethods(IMA_OID targetOid,IMA_UINT * methodCount,const IMA_AUTHMETHOD * pMethodList)2589 IMA_STATUS SUN_IMA_SetTargetAuthMethods(
2590 		IMA_OID targetOid,
2591 		IMA_UINT *methodCount,
2592 		const IMA_AUTHMETHOD *pMethodList
2593 )
2594 {
2595 	return (setAuthMethods(targetOid, methodCount, pMethodList));
2596 }
2597 
getNegotiatedDigest(int digestType,SUN_IMA_DIGEST_ALGORITHM_VALUE * algorithm,SUN_IMA_CONN_PROPERTIES * connProps)2598 IMA_STATUS getNegotiatedDigest(
2599 	int digestType,
2600 	SUN_IMA_DIGEST_ALGORITHM_VALUE *algorithm,
2601 	SUN_IMA_CONN_PROPERTIES *connProps) {
2602 
2603 	IMA_UINT digest;
2604 
2605 	if (connProps->valuesValid == IMA_TRUE) {
2606 		algorithm->negotiatedValid = IMA_TRUE;
2607 
2608 		if (digestType == ISCSI_LOGIN_PARAM_HEADER_DIGEST) {
2609 			digest = connProps->headerDigest;
2610 		} else {
2611 			digest = connProps->dataDigest;
2612 		}
2613 
2614 		switch (digest) {
2615 			case ISCSI_DIGEST_NONE:
2616 				algorithm->negotiatedAlgorithms[0] =
2617 				    ISCSI_DIGEST_NONE;
2618 				algorithm->negotiatedAlgorithmCount = 1;
2619 				break;
2620 			case ISCSI_DIGEST_CRC32C:
2621 				algorithm->negotiatedAlgorithms[0] =
2622 				    ISCSI_DIGEST_CRC32C;
2623 				algorithm->negotiatedAlgorithmCount = 1;
2624 				break;
2625 
2626 			case ISCSI_DIGEST_CRC32C_NONE:
2627 				algorithm->negotiatedAlgorithms[0] =
2628 				    ISCSI_DIGEST_CRC32C;
2629 				algorithm->negotiatedAlgorithms[1] =
2630 				    ISCSI_DIGEST_NONE;
2631 				algorithm->negotiatedAlgorithmCount = 2;
2632 				break;
2633 			case ISCSI_DIGEST_NONE_CRC32C:
2634 				algorithm->negotiatedAlgorithms[0] =
2635 				    ISCSI_DIGEST_NONE;
2636 				algorithm->negotiatedAlgorithms[1] =
2637 				    ISCSI_DIGEST_CRC32C;
2638 				algorithm->negotiatedAlgorithmCount = 2;
2639 				break;
2640 			default:
2641 				syslog(LOG_USER|LOG_DEBUG,
2642 				    "Invalid negotiated digest: %d",
2643 				    digest);
2644 				return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2645 		}
2646 	} else {
2647 		algorithm->negotiatedValid = IMA_FALSE;
2648 	}
2649 	return (IMA_STATUS_SUCCESS);
2650 }
2651 
2652 /*
2653  * Non-IMA defined function.
2654  */
SUN_IMA_GetISNSServerAddressPropertiesList(SUN_IMA_DISC_ADDR_PROP_LIST ** ppList)2655 IMA_API	IMA_STATUS SUN_IMA_GetISNSServerAddressPropertiesList(
2656     SUN_IMA_DISC_ADDR_PROP_LIST	**ppList
2657 )
2658 {
2659 	char		    isns_server_addr_str[256];
2660 	int		    fd;
2661 	int		    i;
2662 	int		    isns_server_addr_list_size;
2663 	int		    status;
2664 	int		    out_cnt;
2665 	iscsi_addr_list_t   *ialp;
2666 	/* LINTED */
2667 	IMA_IP_ADDRESS	    *ipAddr;
2668 
2669 	if ((status = open_driver(&fd))) {
2670 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2671 	}
2672 
2673 	ialp = (iscsi_addr_list_t *)calloc(1, sizeof (iscsi_addr_list_t));
2674 	if (ialp == NULL) {
2675 		(void) close(fd);
2676 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2677 	}
2678 	ialp->al_vers = ISCSI_INTERFACE_VERSION;
2679 	ialp->al_in_cnt = ialp->al_out_cnt = 1;
2680 
2681 	/*
2682 	 * Issue ioctl to retrieve the isns server addresses.  Space has been
2683 	 * allocted for one entry.  If more than one entry should be returned,
2684 	 * we will re-issue the entry with the right amount of space allocted
2685 	 */
2686 	if (ioctl(fd, ISCSI_ISNS_SERVER_ADDR_LIST_GET, ialp) != 0) {
2687 		(void) close(fd);
2688 		syslog(LOG_USER|LOG_DEBUG,
2689 		    "ISCSI_ISNS_SERVER_ADDR_LIST_GET ioctl failed, errno: %d",
2690 		    errno);
2691 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2692 	}
2693 
2694 	isns_server_addr_list_size = sizeof (iscsi_addr_list_t);
2695 	if (ialp->al_out_cnt > 1) {
2696 		out_cnt = ialp->al_out_cnt;
2697 		free(ialp);
2698 
2699 		isns_server_addr_list_size += (sizeof (iscsi_addr_t) *
2700 		    out_cnt - 1);
2701 		ialp = (iscsi_addr_list_t *)calloc(1,
2702 		    isns_server_addr_list_size);
2703 		if (ialp == NULL) {
2704 			(void) close(fd);
2705 			return (IMA_ERROR_INSUFFICIENT_MEMORY);
2706 		}
2707 		ialp->al_vers = ISCSI_INTERFACE_VERSION;
2708 		ialp->al_in_cnt = out_cnt;
2709 
2710 		/*
2711 		 * Issue ISCSI_ISNS_SERVER_ADDR_LIST_GET ioctl again to obtain
2712 		 * the list of all the iSNS server addresses
2713 		 */
2714 		if (ioctl(fd, ISCSI_ISNS_SERVER_ADDR_LIST_GET, ialp) != 0) {
2715 			free(ialp);
2716 			(void) close(fd);
2717 			syslog(LOG_USER|LOG_DEBUG,
2718 			    "ISCSI_ISNS_SERVER_ADDR_LIST_GET ioctl failed, "
2719 			    "errno: %d", errno);
2720 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2721 
2722 		}
2723 	}
2724 
2725 	*ppList = (SUN_IMA_DISC_ADDR_PROP_LIST *)calloc(1,
2726 	    sizeof (SUN_IMA_DISC_ADDR_PROP_LIST) +
2727 	    ialp->al_out_cnt * sizeof (IMA_DISCOVERY_ADDRESS_PROPERTIES));
2728 	if (*ppList == NULL) {
2729 		free(ialp);
2730 		(void) close(fd);
2731 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2732 	}
2733 	(*ppList)->discAddrCount = ialp->al_out_cnt;
2734 
2735 	for (i = 0; i < ialp->al_out_cnt; i++) {
2736 		if (ialp->al_addrs[i].a_addr.i_insize ==
2737 		    sizeof (struct in_addr)) {
2738 			(*ppList)->props[i].discoveryAddress.hostnameIpAddress.
2739 			id.ipAddress.ipv4Address = IMA_TRUE;
2740 		} else if (ialp->al_addrs[i].a_addr.i_insize ==
2741 		    sizeof (struct in6_addr)) {
2742 			(*ppList)->props[i].discoveryAddress.hostnameIpAddress.
2743 			    id.ipAddress.ipv4Address = IMA_FALSE;
2744 		} else {
2745 			(void) strlcpy(isns_server_addr_str, "unknown",
2746 			    sizeof (isns_server_addr_str));
2747 		}
2748 
2749 		ipAddr = &(*ppList)->props[i].discoveryAddress.
2750 		    hostnameIpAddress.id.ipAddress;
2751 		bcopy(&ialp->al_addrs[i].a_addr.i_addr,
2752 		    (*ppList)->props[i].discoveryAddress.hostnameIpAddress.id.
2753 		    ipAddress.ipAddress,
2754 		    sizeof (ipAddr->ipAddress));
2755 		(*ppList)->props[i].discoveryAddress.portNumber =
2756 		    ialp->al_addrs[i].a_port;
2757 	}
2758 
2759 	free(ialp);
2760 	(void) close(fd);
2761 	return (IMA_STATUS_SUCCESS);
2762 }
2763 
2764 /*ARGSUSED*/
2765 /*
2766  * Remove iSNS Server Address
2767  */
SUN_IMA_RemoveISNSServerAddress(SUN_IMA_TARGET_ADDRESS isnsServerAddress)2768 IMA_API	IMA_STATUS SUN_IMA_RemoveISNSServerAddress(
2769     SUN_IMA_TARGET_ADDRESS isnsServerAddress
2770 )
2771 {
2772 	entry_t	entry;
2773 	int	fd, status;
2774 
2775 	if ((status = open_driver(&fd))) {
2776 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2777 	}
2778 
2779 	if (prepare_discovery_entry(isnsServerAddress, &entry) !=
2780 	    DISC_ADDR_OK) {
2781 		(void) close(fd);
2782 		return (IMA_ERROR_INVALID_PARAMETER);
2783 	}
2784 
2785 	if (ioctl(fd, ISCSI_ISNS_SERVER_ADDR_CLEAR, &entry)) {
2786 		status = errno;
2787 		(void) close(fd);
2788 		syslog(LOG_USER|LOG_DEBUG,
2789 		    "ISCSI_ISNS_SERVER_ADDR_CLEAR ioctl failed, errno: %d",
2790 		    status);
2791 		if (status == EBUSY) {
2792 			return (IMA_ERROR_LU_IN_USE);
2793 		} else {
2794 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2795 		}
2796 	}
2797 
2798 	(void) close(fd);
2799 	return (IMA_STATUS_SUCCESS);
2800 }
2801 
2802 /*ARGSUSED*/
SUN_IMA_AddISNSServerAddress(const SUN_IMA_TARGET_ADDRESS isnsServerAddress)2803 IMA_API IMA_STATUS SUN_IMA_AddISNSServerAddress(
2804 		const SUN_IMA_TARGET_ADDRESS isnsServerAddress
2805 )
2806 {
2807 	entry_t			    entry;
2808 	int			    fd;
2809 	int			    status;
2810 
2811 	if ((status = open_driver(&fd))) {
2812 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2813 	}
2814 
2815 	if (prepare_discovery_entry(isnsServerAddress, &entry) !=
2816 	    DISC_ADDR_OK) {
2817 		(void) close(fd);
2818 		return (IMA_ERROR_INVALID_PARAMETER);
2819 	}
2820 
2821 	if (ioctl(fd, ISCSI_ISNS_SERVER_ADDR_SET, &entry)) {
2822 		/*
2823 		 * Encountered problem setting the discovery address.
2824 		 */
2825 		(void) close(fd);
2826 		syslog(LOG_USER|LOG_DEBUG,
2827 		    "ISCSI_ISNS_SERVER_ADDR_SET ioctl failed, errno: %d",
2828 		    errno);
2829 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2830 	}
2831 
2832 	(void) close(fd);
2833 	return (IMA_STATUS_SUCCESS);
2834 }
2835 
SUN_IMA_RetrieveISNSServerTargets(IMA_TARGET_ADDRESS serverAddress,SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES ** ppList)2836 IMA_STATUS SUN_IMA_RetrieveISNSServerTargets(
2837     IMA_TARGET_ADDRESS serverAddress,
2838     SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES **ppList
2839 )
2840 {
2841 	int				    fd;
2842 	int				    ctr;
2843 	int				    server_pg_list_sz;
2844 	int				    status;
2845 	isns_server_portal_group_list_t	    *server_pg_list = NULL;
2846 	isns_portal_group_list_t	    *pg_list = NULL;
2847 	IMA_BOOL			    retry = IMA_TRUE;
2848 	entry_t				    entry;
2849 
2850 #define	ISNS_SERVER_DEFAULT_NUM_TARGETS	50
2851 
2852 	server_pg_list_sz = sizeof (*server_pg_list) +
2853 	    ((ISNS_SERVER_DEFAULT_NUM_TARGETS - 1) *
2854 	    sizeof (isns_portal_group_t));
2855 
2856 	server_pg_list = (isns_server_portal_group_list_t *)calloc(1,
2857 	    server_pg_list_sz);
2858 	if (server_pg_list == NULL) {
2859 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2860 	}
2861 	server_pg_list->addr_port_list.pg_in_cnt =
2862 	    ISNS_SERVER_DEFAULT_NUM_TARGETS;
2863 
2864 	if ((prepare_discovery_entry_IMA(serverAddress, &entry)
2865 	    != DISC_ADDR_OK)) {
2866 		free(server_pg_list);
2867 		return (IMA_ERROR_INVALID_PARAMETER);
2868 	}
2869 	server_pg_list->addr.a_port = entry.e_port;
2870 	server_pg_list->addr.a_addr.i_insize = entry.e_insize;
2871 	if (entry.e_insize == sizeof (struct in_addr)) {
2872 		server_pg_list->addr.a_addr.i_addr.in4.s_addr =
2873 		    (entry.e_u.u_in4.s_addr);
2874 	} else if (entry.e_insize == sizeof (struct in6_addr)) {
2875 		bcopy(&entry.e_u.u_in6.s6_addr,
2876 		    server_pg_list->addr.a_addr.i_addr.in6.s6_addr, 16);
2877 	}
2878 
2879 	if ((status = open_driver(&fd))) {
2880 		free(server_pg_list);
2881 		return (SUN_IMA_ERROR_SYSTEM_ERROR | status);
2882 	}
2883 
2884 retry_isns:
2885 	/*
2886 	 * Issue ioctl to obtain the ISNS Portal Group List list
2887 	 */
2888 	if (ioctl(fd, ISCSI_ISNS_SERVER_GET, server_pg_list) != 0) {
2889 		int tmp_errno = errno;
2890 		IMA_STATUS return_status;
2891 
2892 		syslog(LOG_USER|LOG_DEBUG,
2893 		    "ISCSI_ISNS_SERVER_GET ioctl failed, errno: %d", tmp_errno);
2894 		if (tmp_errno == EACCES) {
2895 			return_status = IMA_ERROR_OBJECT_NOT_FOUND;
2896 		} else {
2897 			return_status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2898 		}
2899 		(void) close(fd);
2900 		free(server_pg_list);
2901 		return (return_status);
2902 	}
2903 	pg_list = &server_pg_list->addr_port_list;
2904 
2905 	/* check if all targets received */
2906 	if (pg_list->pg_in_cnt < pg_list->pg_out_cnt) {
2907 		if (retry == IMA_TRUE) {
2908 			server_pg_list_sz = sizeof (*server_pg_list) +
2909 			    ((pg_list->pg_out_cnt - 1) *
2910 			    sizeof (isns_server_portal_group_list_t));
2911 			server_pg_list = (isns_server_portal_group_list_t *)
2912 			    realloc(server_pg_list, server_pg_list_sz);
2913 			if (server_pg_list == NULL) {
2914 				(void) close(fd);
2915 				return (IMA_ERROR_INSUFFICIENT_MEMORY);
2916 			}
2917 			pg_list = &server_pg_list->addr_port_list;
2918 			pg_list->pg_in_cnt = pg_list->pg_out_cnt;
2919 			retry = IMA_FALSE;
2920 			goto retry_isns;
2921 		} else {
2922 			/*
2923 			 * don't retry after 2 attempts.  The target list
2924 			 * shouldn't continue growing. Just continue
2925 			 * on and display what was found.
2926 			 */
2927 			syslog(LOG_USER|LOG_DEBUG,
2928 			    "ISCSI_SENDTGTS_GET overflow: "
2929 			    "failed to obtain all targets");
2930 			pg_list->pg_out_cnt = pg_list->pg_in_cnt;
2931 		}
2932 	}
2933 
2934 	(void) close(fd);
2935 
2936 	/* allocate for caller return buffer */
2937 	*ppList = (SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES *)calloc(1,
2938 	    sizeof (SUN_IMA_DISC_ADDRESS_KEY_PROPERTIES) +
2939 	    pg_list->pg_out_cnt * sizeof (SUN_IMA_DISC_ADDRESS_KEY));
2940 	if (*ppList == NULL) {
2941 		free(server_pg_list);
2942 		return (IMA_ERROR_INSUFFICIENT_MEMORY);
2943 	}
2944 
2945 	(*ppList)->keyCount = pg_list->pg_out_cnt;
2946 
2947 	for (ctr = 0; ctr < pg_list->pg_out_cnt; ctr++) {
2948 		(void) mbstowcs((*ppList)->keys[ctr].name,
2949 		    (char *)pg_list->pg_list[ctr].pg_iscsi_name,
2950 		    IMA_NODE_NAME_LEN);
2951 
2952 		(*ppList)->keys[ctr].tpgt = pg_list->pg_list[ctr].pg_tag;
2953 
2954 		(*ppList)->keys[ctr].address.portNumber =
2955 		    pg_list->pg_list[ctr].pg_port;
2956 
2957 		if (pg_list->pg_list[ctr].insize == sizeof (struct in_addr)) {
2958 			(*ppList)->keys[ctr].address.ipAddress.ipv4Address =
2959 			    IMA_TRUE;
2960 		} else if (pg_list->pg_list[ctr].insize ==
2961 		    sizeof (struct in6_addr)) {
2962 			(*ppList)->keys[ctr].address.ipAddress.ipv4Address =
2963 			    IMA_FALSE;
2964 		} else {
2965 			free(pg_list);
2966 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
2967 		}
2968 
2969 		(void) memcpy(&(*ppList)->keys[ctr].address.ipAddress.ipAddress,
2970 		    &(pg_list->pg_list[ctr].pg_ip_addr),
2971 		    pg_list->pg_list[ctr].insize);
2972 	}
2973 	free(server_pg_list);
2974 
2975 	return (IMA_STATUS_SUCCESS);
2976 }
2977 
2978 /* ARGSUSED */
SUN_IMA_GetSessionOidList(IMA_OID initiatorOid,IMA_OID_LIST ** ppList)2979 IMA_STATUS SUN_IMA_GetSessionOidList(
2980     IMA_OID initiatorOid,
2981     IMA_OID_LIST **ppList
2982 )
2983 {
2984 	return (get_target_oid_list(ISCSI_TGT_OID_LIST, ppList));
2985 }
2986 
2987 /*ARGSUSED*/
SUN_IMA_GetTargetAuthParms(IMA_OID oid,IMA_AUTHMETHOD method,IMA_INITIATOR_AUTHPARMS * pParms)2988 IMA_API	IMA_STATUS SUN_IMA_GetTargetAuthParms(
2989 	IMA_OID oid,
2990 	IMA_AUTHMETHOD method,
2991 	IMA_INITIATOR_AUTHPARMS *pParms
2992 )
2993 {
2994 	int fd;
2995 	iscsi_chap_props_t  chap_p;
2996 
2997 	if (pParms == NULL) {
2998 		return (IMA_ERROR_INVALID_PARAMETER);
2999 	}
3000 
3001 	if (oid.objectType != IMA_OBJECT_TYPE_TARGET) {
3002 		return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3003 	}
3004 
3005 	if (method != IMA_AUTHMETHOD_CHAP) {
3006 		return (IMA_ERROR_INVALID_PARAMETER);
3007 	}
3008 
3009 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
3010 		syslog(LOG_USER|LOG_DEBUG, "Cannot open %s (%d)",
3011 		    ISCSI_DRIVER_DEVCTL, errno);
3012 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3013 	}
3014 
3015 	(void) memset(&chap_p, 0, sizeof (iscsi_chap_props_t));
3016 	chap_p.c_vers = ISCSI_INTERFACE_VERSION;
3017 	chap_p.c_oid = (uint32_t)oid.objectSequenceNumber;
3018 
3019 	if (ioctl(fd, ISCSI_CHAP_GET, &chap_p) != 0) {
3020 		syslog(LOG_USER|LOG_DEBUG,
3021 
3022 		    "ISCSI_CHAP_GET ioctl failed, errno: %d",
3023 		    errno);
3024 		(void) close(fd);
3025 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3026 	}
3027 
3028 	(void) memcpy(pParms->chapParms.name, chap_p.c_user,
3029 	    chap_p.c_user_len);
3030 
3031 	pParms->chapParms.nameLength = chap_p.c_user_len;
3032 	(void) memcpy(pParms->chapParms.challengeSecret, chap_p.c_secret,
3033 	    chap_p.c_secret_len);
3034 
3035 	pParms->chapParms.challengeSecretLength = chap_p.c_secret_len;
3036 
3037 	return (IMA_STATUS_SUCCESS);
3038 }
3039 
SUN_IMA_GetBootTargetName(IMA_NODE_NAME tgtName)3040 IMA_API IMA_STATUS SUN_IMA_GetBootTargetName(
3041     IMA_NODE_NAME tgtName
3042 )
3043 {
3044 	int fd;
3045 	IMA_STATUS rtn;
3046 	iscsi_boot_property_t bootProp;
3047 
3048 	bootProp.tgt_name.n_name[0] = '\0';
3049 	bootProp.tgt_chap.c_user[0] = '\0';
3050 	tgtName[0] = L'\0';
3051 	rtn = IMA_ERROR_UNEXPECTED_OS_ERROR;
3052 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
3053 		syslog(LOG_USER|LOG_DEBUG, "Unable to open %s (%d)",
3054 		    ISCSI_DRIVER_DEVCTL, errno);
3055 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3056 	}
3057 
3058 	if (ioctl(fd, ISCSI_BOOTPROP_GET, &bootProp) != 0) {
3059 		syslog(LOG_USER|LOG_DEBUG,
3060 		    "ISCSI_BOOTPROP_GET ioctl failed, errno: %d",
3061 		    errno);
3062 		(void) close(fd);
3063 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3064 	}
3065 
3066 	if ((bootProp.tgt_name.n_name[0] != '\0') && (tgtName != NULL)) {
3067 		if (mbstowcs(tgtName, (const char *)bootProp.tgt_name.n_name,
3068 		    IMA_NODE_NAME_LEN) == (size_t)-1) {
3069 			syslog(LOG_USER|LOG_DEBUG,
3070 			    "ISCSI Target name covert to WCHAR fail");
3071 			return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3072 		} else {
3073 			rtn = IMA_STATUS_SUCCESS;
3074 		}
3075 	}
3076 
3077 	return (rtn);
3078 }
3079 
SUN_IMA_GetBootTargetAuthParams(IMA_INITIATOR_AUTHPARMS * pTgtCHAP)3080 IMA_API IMA_STATUS SUN_IMA_GetBootTargetAuthParams(
3081     IMA_INITIATOR_AUTHPARMS *pTgtCHAP
3082 )
3083 {
3084 	int fd;
3085 	IMA_STATUS rtn;
3086 	iscsi_boot_property_t bootProp;
3087 
3088 	bootProp.tgt_name.n_name[0] = '\0';
3089 	bootProp.tgt_chap.c_user[0] = '\0';
3090 	bootProp.tgt_chap.c_secret[0] = '\0';
3091 	rtn = IMA_ERROR_UNEXPECTED_OS_ERROR;
3092 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
3093 		syslog(LOG_USER|LOG_DEBUG, "Unable to open %s (%d)",
3094 		    ISCSI_DRIVER_DEVCTL, errno);
3095 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3096 	}
3097 
3098 	if (ioctl(fd, ISCSI_BOOTPROP_GET, &bootProp) != 0) {
3099 		syslog(LOG_USER|LOG_DEBUG,
3100 		    "ISCSI_BOOTPROP_GET ioctl failed, errno: %d",
3101 		    errno);
3102 		(void) close(fd);
3103 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3104 	}
3105 
3106 	if (pTgtCHAP != NULL) {
3107 		if (bootProp.tgt_chap.c_user[0] != '\0') {
3108 			(void) memcpy(pTgtCHAP->chapParms.name,
3109 			    bootProp.tgt_chap.c_user, ISCSI_MAX_NAME_LEN);
3110 		} else {
3111 			pTgtCHAP->chapParms.name[0] = '\0';
3112 		}
3113 		if (bootProp.tgt_chap.c_secret[0] != '\0') {
3114 			(void) memcpy(pTgtCHAP->chapParms.challengeSecret,
3115 			    bootProp.tgt_chap.c_secret, MAX_CHAP_SECRET_LEN);
3116 		} else {
3117 			pTgtCHAP->chapParms.challengeSecret[0] = '\0';
3118 		}
3119 		rtn = IMA_STATUS_SUCCESS;
3120 	}
3121 	return (rtn);
3122 }
3123 
SUN_IMA_GetBootMpxio(IMA_BOOL * pMpxioEnabled)3124 IMA_STATUS SUN_IMA_GetBootMpxio(
3125     IMA_BOOL *pMpxioEnabled
3126 )
3127 {
3128 	int fd;
3129 	iscsi_boot_property_t bootProp;
3130 
3131 	bootProp.hba_mpxio_enabled = B_FALSE;
3132 	*pMpxioEnabled = IMA_UNKNOWN;
3133 
3134 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
3135 		syslog(LOG_USER|LOG_DEBUG, "Unable to open %s (%d)",
3136 		    ISCSI_DRIVER_DEVCTL, errno);
3137 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3138 	}
3139 
3140 	if (ioctl(fd, ISCSI_BOOTPROP_GET, &bootProp) != 0) {
3141 		syslog(LOG_USER|LOG_DEBUG,
3142 		    "ISCSI_BOOTPROP_GET ioctl failed, errno: %d",
3143 		    errno);
3144 		(void) close(fd);
3145 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3146 	}
3147 
3148 	if (bootProp.hba_mpxio_enabled) {
3149 		*pMpxioEnabled = IMA_TRUE;
3150 	} else {
3151 		*pMpxioEnabled = IMA_FALSE;
3152 	}
3153 
3154 	(void) close(fd);
3155 	return (IMA_STATUS_SUCCESS);
3156 }
3157 
SUN_IMA_GetBootIscsi(IMA_BOOL * pIscsiBoot)3158 IMA_STATUS SUN_IMA_GetBootIscsi(
3159     IMA_BOOL *pIscsiBoot
3160 )
3161 {
3162 	int fd;
3163 	iscsi_boot_property_t bootProp;
3164 
3165 	bootProp.iscsiboot = 0;
3166 	*pIscsiBoot = 0;
3167 
3168 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
3169 		syslog(LOG_USER|LOG_DEBUG, "Unable to open %s (%d)",
3170 		    ISCSI_DRIVER_DEVCTL, errno);
3171 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3172 	}
3173 
3174 	if (ioctl(fd, ISCSI_BOOTPROP_GET, &bootProp) != 0) {
3175 		syslog(LOG_USER|LOG_DEBUG,
3176 		    "ISCSI_BOOTPROP_GET ioctl failed, errno: %d",
3177 		    errno);
3178 		(void) close(fd);
3179 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3180 	}
3181 
3182 	*pIscsiBoot = bootProp.iscsiboot;
3183 
3184 	(void) close(fd);
3185 	return (IMA_STATUS_SUCCESS);
3186 }
3187 
SUN_IMA_GetSvcStatus(IMA_BOOL * pSvcEnabled)3188 IMA_STATUS SUN_IMA_GetSvcStatus(
3189     IMA_BOOL *pSvcEnabled)
3190 {
3191 	int		fd;
3192 	uint32_t	status = ISCSI_SERVICE_DISABLED;
3193 
3194 	if (pSvcEnabled == NULL)
3195 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3196 	*pSvcEnabled = 0;
3197 
3198 	if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) == -1) {
3199 		syslog(LOG_USER|LOG_DEBUG, "Unable to open %s (%d)",
3200 		    ISCSI_DRIVER_DEVCTL, errno);
3201 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3202 	}
3203 
3204 	if (ioctl(fd, ISCSI_SMF_GET, &status) != 0) {
3205 		syslog(LOG_USER|LOG_DEBUG,
3206 		    "ISCSI_SVC_GET ioctl failed, errno: %d",
3207 		    errno);
3208 		(void) close(fd);
3209 		return (IMA_ERROR_UNEXPECTED_OS_ERROR);
3210 	}
3211 
3212 	if (status == ISCSI_SERVICE_ENABLED) {
3213 		*pSvcEnabled = 1;
3214 	}
3215 
3216 	(void) close(fd);
3217 	return (IMA_STATUS_SUCCESS);
3218 }
3219 
SUN_IMA_ReEnumeration(IMA_OID targetId)3220 IMA_STATUS SUN_IMA_ReEnumeration(
3221 	IMA_OID targetId
3222 )
3223 {
3224 	int		fd;
3225 	int