xref: /illumos-gate/usr/src/uts/common/io/idm/idm_text.c (revision 2fcabb59)
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 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/types.h>
27 #include <sys/conf.h>
28 #include <sys/file.h>
29 #include <sys/ddi.h>
30 #include <sys/sunddi.h>
31 #include <sys/sysmacros.h>
32 #include <sys/socket.h>
33 
34 #include <sys/iscsi_protocol.h>
35 #include <sys/idm/idm.h>
36 #include <sys/idm/idm_text.h>
37 
38 
39 extern int
40 iscsi_base64_str_to_binary(char *hstr, int hstr_len,
41     uint8_t *binary, int binary_buf_len, int *out_len);
42 
43 
44 static const char idm_hex_to_ascii[] = "0123456789abcdefABCDEF";
45 
46 static const idm_kv_xlate_t idm_kvpair_xlate[] = {
47 	/*
48 	 * iSCSI Security Text Keys and Authentication Methods
49 	 */
50 
51 	{ KI_AUTH_METHOD, "AuthMethod", KT_LIST_OF_VALUES, B_FALSE },
52 	/*
53 	 * For values with RFC comments we need to read the RFC to see
54 	 * what type is appropriate.  For now just treat the value as
55 	 * text.
56 	 */
57 
58 	/* Kerberos */
59 	{ KI_KRB_AP_REQ, "KRB_AP_REQ", KT_TEXT /* RFC1510 */, B_TRUE},
60 	{ KI_KRB_AP_REP, "KRB_AP_REP", KT_TEXT /* RFC1510 */, B_TRUE},
61 
62 	/* SPKM */
63 	{ KI_SPKM_REQ, "SPKM_REQ", KT_TEXT /* RFC2025 */, B_TRUE},
64 	{ KI_SPKM_ERROR, "SPKM_ERROR", KT_TEXT /* RFC2025 */, B_TRUE},
65 	{ KI_SPKM_REP_TI, "SPKM_REP_TI", KT_TEXT /* RFC2025 */, B_TRUE},
66 	{ KI_SPKM_REP_IT, "SPKM_REP_IT", KT_TEXT /* RFC2025 */, B_TRUE},
67 
68 	/*
69 	 * SRP
70 	 * U, s, A, B, M, and H(A | M | K) are defined in [RFC2945]
71 	 */
72 	{ KI_SRP_U, "SRP_U", KT_TEXT /* <U> */, B_TRUE},
73 	{ KI_TARGET_AUTH, "TargetAuth", KT_BOOLEAN, B_TRUE},
74 	{ KI_SRP_GROUP, "SRP_GROUP", KT_LIST_OF_VALUES /* <G1,..> */, B_FALSE},
75 	{ KI_SRP_A, "SRP_A", KT_TEXT /* <A> */, B_TRUE},
76 	{ KI_SRP_B, "SRP_B", KT_TEXT /* <B> */, B_TRUE},
77 	{ KI_SRP_M, "SRP_M", KT_TEXT /* <M> */, B_TRUE},
78 	{ KI_SRM_HM, "SRP_HM", KT_TEXT /* <H(A | M | K)> */, B_TRUE},
79 
80 	/*
81 	 * CHAP
82 	 */
83 	{ KI_CHAP_A, "CHAP_A", KT_LIST_OF_VALUES /* <A1,A2,..> */, B_FALSE },
84 	{ KI_CHAP_I, "CHAP_I", KT_NUMERICAL /* <I> */, B_TRUE },
85 	{ KI_CHAP_C, "CHAP_C", KT_BINARY /* <C> */, B_TRUE },
86 	{ KI_CHAP_N, "CHAP_N", KT_TEXT /* <N> */, B_TRUE },
87 	{ KI_CHAP_R, "CHAP_R", KT_BINARY /* <N> */, B_TRUE },
88 
89 
90 	/*
91 	 * ISCSI Operational Parameter Keys
92 	 */
93 	{ KI_HEADER_DIGEST, "HeaderDigest", KT_LIST_OF_VALUES, B_FALSE },
94 	{ KI_DATA_DIGEST, "DataDigest", KT_LIST_OF_VALUES, B_FALSE },
95 	{ KI_MAX_CONNECTIONS, "MaxConnections", KT_NUMERICAL, B_FALSE },
96 	{ KI_SEND_TARGETS, "SendTargets", KT_TEXT, B_FALSE },
97 	{ KI_TARGET_NAME, "TargetName", KT_ISCSI_NAME, B_TRUE},
98 	{ KI_INITIATOR_NAME, "InitiatorName", KT_ISCSI_NAME, B_TRUE},
99 	{ KI_TARGET_ALIAS, "TargetAlias", KT_ISCSI_LOCAL_NAME, B_TRUE},
100 	{ KI_INITIATOR_ALIAS, "InitiatorAlias", KT_ISCSI_LOCAL_NAME, B_TRUE},
101 	{ KI_TARGET_ADDRESS, "TargetAddress", KT_TEXT, B_TRUE},
102 	{ KI_TARGET_PORTAL_GROUP_TAG, "TargetPortalGroupTag",
103 	    KT_NUMERICAL, B_TRUE },
104 	{ KI_INITIAL_R2T, "InitialR2T", KT_BOOLEAN, B_FALSE },
105 	{ KI_IMMEDIATE_DATA, "ImmediateData", KT_BOOLEAN, B_FALSE },
106 	{ KI_MAX_RECV_DATA_SEGMENT_LENGTH, "MaxRecvDataSegmentLength",
107 	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_TRUE },
108 	{ KI_MAX_BURST_LENGTH, "MaxBurstLength",
109 	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
110 	{ KI_FIRST_BURST_LENGTH, "FirstBurstLength",
111 	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
112 	{ KI_DEFAULT_TIME_2_WAIT, "DefaultTime2Wait",
113 	    KT_NUMERICAL /* 0 to 2600 */, B_FALSE },
114 	{ KI_DEFAULT_TIME_2_RETAIN, "DefaultTime2Retain",
115 	    KT_NUMERICAL /* 0 to 2600 */, B_FALSE },
116 	{ KI_MAX_OUTSTANDING_R2T, "MaxOutstandingR2T",
117 	    KT_NUMERICAL /* 1 to 65535 */, B_FALSE },
118 	{ KI_DATA_PDU_IN_ORDER, "DataPDUInOrder", KT_BOOLEAN, B_FALSE },
119 	{ KI_DATA_SEQUENCE_IN_ORDER, "DataSequenceInOrder",
120 	    KT_BOOLEAN, B_FALSE },
121 	{ KI_ERROR_RECOVERY_LEVEL, "ErrorRecoveryLevel",
122 	    KT_NUMERICAL /* 0 to 2 */, B_FALSE },
123 	{ KI_SESSION_TYPE, "SessionType", KT_TEXT, B_TRUE },
124 	{ KI_OFMARKER, "OFMarker", KT_BOOLEAN, B_FALSE },
125 	{ KI_OFMARKERINT, "OFMarkerInt", KT_NUMERIC_RANGE, B_FALSE },
126 	{ KI_IFMARKER, "IFMarker", KT_BOOLEAN, B_FALSE },
127 	{ KI_IFMARKERINT, "IFMarkerInt", KT_NUMERIC_RANGE, B_FALSE },
128 
129 	/*
130 	 * iSER-specific keys
131 	 */
132 	{ KI_RDMA_EXTENSIONS, "RDMAExtensions", KT_BOOLEAN, B_FALSE },
133 	{ KI_TARGET_RECV_DATA_SEGMENT_LENGTH, "TargetRecvDataSegmentLength",
134 	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
135 	{ KI_INITIATOR_RECV_DATA_SEGMENT_LENGTH,
136 	    "InitiatorRecvDataSegmentLength",
137 	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
138 	{ KI_MAX_OUTSTANDING_UNEXPECTED_PDUS, "MaxOutstandingUnexpectedPDUs",
139 	    KT_NUMERICAL /* 2 to 2^32 - 1 | 0 */, B_TRUE },
140 
141 	/*
142 	 * Table terminator. The type KT_TEXT will allow the response
143 	 * value of "NotUnderstood".
144 	 */
145 	{ KI_MAX_KEY, NULL, KT_TEXT, B_TRUE } /* Terminator */
146 };
147 
148 
149 #define	TEXTBUF_CHUNKSIZE 8192
150 
151 typedef struct {
152 	char	*itb_mem;
153 	int	itb_offset;
154 	int	itb_mem_len;
155 } idm_textbuf_t;
156 
157 /*
158  * Ignore all but the following keys during security negotiation
159  *
160  * SessionType
161  * InitiatorName
162  * TargetName
163  * TargetAddress
164  * InitiatorAlias
165  * TargetAlias
166  * TargetPortalGroupTag
167  * AuthMethod and associated auth keys
168  */
169 
170 static int idm_keyvalue_get_next(char **tb_scan, int *tb_len,
171     char **key, int *keylen, char **value);
172 
173 static int idm_nvlist_add_kv(nvlist_t *nvl, const idm_kv_xlate_t *ikvx,
174     char *value);
175 
176 static int idm_nvlist_add_string(nvlist_t *nvl,
177     const idm_kv_xlate_t *ikvx, char *value);
178 
179 static int idm_nvlist_add_boolean(nvlist_t *nvl,
180     const idm_kv_xlate_t *ikvx, char *value);
181 
182 static int idm_nvlist_add_binary(nvlist_t *nvl,
183     const idm_kv_xlate_t *ikvx, char *value);
184 
185 static int idm_nvlist_add_large_numerical(nvlist_t *nvl,
186     const idm_kv_xlate_t *ikvx, char *value);
187 
188 static int idm_nvlist_add_numerical(nvlist_t *nvl,
189     const idm_kv_xlate_t *ikvx, char *value);
190 
191 static int idm_nvlist_add_numeric_range(nvlist_t *nvl,
192     const idm_kv_xlate_t *ikvx, char *value);
193 
194 static int idm_nvlist_add_list_of_values(nvlist_t *nvl,
195     const idm_kv_xlate_t *ikvx, char *value);
196 
197 static int idm_itextbuf_add_nvpair(nvpair_t *nvp, idm_textbuf_t *itb);
198 
199 static int idm_itextbuf_add_string(nvpair_t *nvp,
200     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
201 
202 static int idm_itextbuf_add_boolean(nvpair_t *nvp,
203     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
204 
205 static int idm_itextbuf_add_binary(nvpair_t *nvp,
206     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
207 
208 static int idm_itextbuf_add_large_numerical(nvpair_t *nvp,
209     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
210 
211 static int idm_itextbuf_add_numerical(nvpair_t *nvp,
212     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
213 
214 static int idm_itextbuf_add_numeric_range(nvpair_t *nvp,
215     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
216 
217 static int idm_itextbuf_add_list_of_values(nvpair_t *nvp,
218     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);
219 
220 static void textbuf_memcpy(idm_textbuf_t *itb, void *mem, int mem_len);
221 
222 static void textbuf_strcpy(idm_textbuf_t *itb, char *str);
223 
224 static void textbuf_append_char(idm_textbuf_t *itb, char c);
225 
226 static void textbuf_terminate_kvpair(idm_textbuf_t *itb);
227 
228 static int idm_ascii_to_hex(char *enc_hex_byte, uint8_t *bin_val);
229 
230 static int idm_base16_str_to_binary(char *hstr, int hstr_len,
231     uint8_t *binary, int binary_length);
232 
233 static size_t idm_strcspn(const char *string, const char *charset);
234 
235 static size_t idm_strnlen(const char *str, size_t maxlen);
236 
237 /*
238  * Processes all whole iSCSI name-value pairs in a text buffer and adds
239  * a corresponding Solaris nvpair_t to the provided nvlist.  If the last
240  * iSCSI name-value pair in textbuf is truncated (which can occur when
241  * the request spans multiple PDU's) then upon return textbuf will
242  * point to the truncated iSCSI name-value pair in the buffer and
243  * textbuflen will contain the remaining bytes in the buffer.  The
244  * caller can save off this fragment of the iSCSI name-value pair for
245  * use when the next PDU in the request arrives.
246  *
247  * textbuflen includes the trailing 0x00!
248  */
249 
250 int
idm_textbuf_to_nvlist(nvlist_t * nvl,char ** textbuf,int * textbuflen)251 idm_textbuf_to_nvlist(nvlist_t *nvl, char **textbuf, int *textbuflen)
252 {
253 	int rc = 0;
254 	char *tbscan, *key, *value;
255 	int tblen, keylen;
256 
257 	tbscan = *textbuf;
258 	tblen = *textbuflen;
259 
260 	for (;;) {
261 		if ((rc = idm_keyvalue_get_next(&tbscan, &tblen,
262 		    &key, &keylen, &value)) != 0) {
263 			/* There was a problem reading the key/value pair */
264 			break;
265 		}
266 
267 		if ((rc = idm_nvlist_add_keyvalue(nvl,
268 		    key, keylen, value)) != 0) {
269 			/* Something was wrong with either the key or value */
270 			break;
271 		}
272 
273 		if (tblen == 0) {
274 			/* End of text buffer */
275 			break;
276 		}
277 	}
278 
279 	*textbuf = tbscan;
280 	*textbuflen = tblen;
281 
282 	return (rc);
283 }
284 
285 /*
286  * If a test buffer starts with an ISCSI name-value pair fragment (a
287  * continuation from a previous buffer) return the length of the fragment
288  * contained in this buffer.  We do not handle name-value pairs that span
289  * more than two buffers so if this buffer does not contain the remainder
290  * of the name value pair the function will return 0.  If the first
291  * name-value pair in the buffer is complete the functionw will return 0.
292  */
293 int
idm_textbuf_to_firstfraglen(void * textbuf,int textbuflen)294 idm_textbuf_to_firstfraglen(void *textbuf, int textbuflen)
295 {
296 	return (idm_strnlen(textbuf, textbuflen));
297 }
298 
299 static int
idm_keyvalue_get_next(char ** tb_scan,int * tb_len,char ** key,int * keylen,char ** value)300 idm_keyvalue_get_next(char **tb_scan, int *tb_len,
301     char **key, int *keylen, char **value)
302 {
303 	/*
304 	 * Caller doesn't need "valuelen" returned since "value" will
305 	 * always be a NULL-terminated string.
306 	 */
307 	size_t total_len, valuelen;
308 
309 	/*
310 	 * How many bytes to the first '\0'?  This represents the total
311 	 * length of our iSCSI key/value pair.
312 	 */
313 	total_len = idm_strnlen(*tb_scan, *tb_len);
314 	if (total_len == *tb_len) {
315 		/*
316 		 * No '\0', perhaps this key/value pair is continued in
317 		 * another buffer
318 		 */
319 		return (E2BIG);
320 	}
321 
322 	/*
323 	 * Found NULL, so this is a possible key-value pair.  At
324 	 * the same time we've validated that there is actually a
325 	 * NULL in this string so it's safe to use regular
326 	 * string functions (i.e. strcpy instead of strncpy)
327 	 */
328 	*key = *tb_scan;
329 	*keylen = idm_strcspn(*tb_scan, "=");
330 
331 	if (*keylen == total_len) {
332 		/* No '=', bad format */
333 		return (EINVAL);
334 	}
335 
336 	*tb_scan += *keylen + 1; /* Skip the '=' */
337 	*tb_len -= *keylen + 1;
338 
339 	/*
340 	 * The remaining text after the '=' is the value
341 	 */
342 	*value = *tb_scan;
343 	valuelen = total_len - (*keylen + 1);
344 
345 	*tb_scan += valuelen + 1; /* Skip the '\0' */
346 	*tb_len -= valuelen + 1;
347 
348 	return (0);
349 }
350 
351 const idm_kv_xlate_t *
idm_lookup_kv_xlate(const char * key,int keylen)352 idm_lookup_kv_xlate(const char *key, int keylen)
353 {
354 	const idm_kv_xlate_t *ikvx = &idm_kvpair_xlate[0];
355 
356 	/*
357 	 * Look for a matching key value in the key/value pair table.
358 	 * The matching entry in the table will tell us how to encode
359 	 * the key and value in the nvlist.  If we don't recognize
360 	 * the key then we will simply encode it in string format.
361 	 * The login or text request code can generate the appropriate
362 	 * "not understood" resposne.
363 	 */
364 	while (ikvx->ik_key_id != KI_MAX_KEY) {
365 		/*
366 		 * Compare strings.  "key" is not NULL-terminated so
367 		 * use strncmp.  Since we are using strncmp we
368 		 * need to check that the lengths match, otherwise
369 		 * we might unintentionally lookup "TargetAddress"
370 		 * with a key of "Target" (or something similar).
371 		 *
372 		 * "value" is NULL-terminated so we can use it as
373 		 * a regular string.
374 		 */
375 		if ((strncmp(ikvx->ik_key_name, key, keylen) == 0) &&
376 		    (strlen(ikvx->ik_key_name) == keylen)) {
377 			/* Exit the loop since we found a match */
378 			break;
379 		}
380 
381 		/* No match, look at the next entry */
382 		ikvx++;
383 	}
384 
385 	return (ikvx);
386 }
387 
388 static int
idm_nvlist_add_kv(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value)389 idm_nvlist_add_kv(nvlist_t *nvl,  const idm_kv_xlate_t *ikvx, char *value)
390 {
391 	int rc;
392 
393 	switch (ikvx->ik_idm_type) {
394 	case KT_TEXT:
395 	case KT_SIMPLE:
396 	case KT_ISCSI_NAME:
397 	case KT_ISCSI_LOCAL_NAME:
398 		rc = idm_nvlist_add_string(nvl, ikvx, value);
399 		break;
400 	case KT_BOOLEAN:
401 		rc = idm_nvlist_add_boolean(nvl, ikvx, value);
402 		break;
403 	case KT_REGULAR_BINARY:
404 	case KT_LARGE_BINARY:
405 	case KT_BINARY:
406 		rc = idm_nvlist_add_binary(nvl, ikvx, value);
407 		break;
408 	case KT_LARGE_NUMERICAL:
409 		rc = idm_nvlist_add_large_numerical(nvl, ikvx,
410 		    value);
411 		break;
412 	case KT_NUMERICAL:
413 		rc = idm_nvlist_add_numerical(nvl, ikvx,
414 		    value);
415 		break;
416 	case KT_NUMERIC_RANGE:
417 		rc = idm_nvlist_add_numeric_range(nvl, ikvx,
418 		    value);
419 		break;
420 	case KT_LIST_OF_VALUES:
421 		rc = idm_nvlist_add_list_of_values(nvl, ikvx,
422 		    value);
423 		break;
424 	default:
425 		ASSERT(0); /* This should never happen */
426 		break;
427 	}
428 	if (rc != 0) {
429 		/* could be one of the text constants */
430 		rc = idm_nvlist_add_string(nvl, ikvx, value);
431 	}
432 
433 	return (rc);
434 }
435 
436 static int
idm_nvlist_add_string(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value)437 idm_nvlist_add_string(nvlist_t *nvl,
438     const idm_kv_xlate_t *ikvx, char *value)
439 {
440 	return (nvlist_add_string(nvl, ikvx->ik_key_name, value));
441 }
442 
443 static int
idm_nvlist_add_boolean(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value)444 idm_nvlist_add_boolean(nvlist_t *nvl,
445     const idm_kv_xlate_t *ikvx, char *value)
446 {
447 	int rc;
448 	boolean_t bool_val;
449 
450 	if (strcasecmp(value, "Yes") == 0) {
451 		bool_val = B_TRUE;
452 	} else if (strcasecmp(value, "No") == 0) {
453 		bool_val = B_FALSE;
454 	} else {
455 		return (EINVAL);
456 	}
457 
458 	rc = nvlist_add_boolean_value(nvl, ikvx->ik_key_name, bool_val);
459 
460 	return (rc);
461 }
462 
463 static boolean_t
kv_is_hex(char * value)464 kv_is_hex(char *value)
465 {
466 	return ((strncmp(value, "0x", strlen("0x")) == 0) ||
467 	    (strncmp(value, "0X", strlen("0X")) == 0));
468 }
469 
470 static boolean_t
kv_is_base64(char * value)471 kv_is_base64(char *value)
472 {
473 	return ((strncmp(value, "0b", strlen("0b")) == 0) ||
474 	    (strncmp(value, "0B", strlen("0B")) == 0));
475 }
476 
477 
478 static int
idm_nvlist_add_binary(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value)479 idm_nvlist_add_binary(nvlist_t *nvl,
480     const idm_kv_xlate_t *ikvx, char *value)
481 {
482 	int		rc;
483 	int		value_length;
484 	uint64_t	uint64_value;
485 	int		binary_length;
486 	uchar_t		*binary_array;
487 
488 	/*
489 	 * A binary value can be either decimal, hex or base64.  If it's
490 	 * decimal then the encoded string must be less than 64 bits in
491 	 * length (8 characters).  In all cases we will convert the
492 	 * included value to a byte array starting with the MSB.  The
493 	 * assumption is that values meant to be treated as integers will
494 	 * use the "numerical" and "large numerical" types.
495 	 */
496 	if (kv_is_hex(value)) {
497 		value += strlen("0x");
498 		value_length = strlen(value);
499 		binary_length = (value_length + 1) / 2;
500 		binary_array = kmem_alloc(binary_length, KM_SLEEP);
501 
502 		if (idm_base16_str_to_binary(value, value_length,
503 		    binary_array, binary_length) != 0) {
504 			kmem_free(binary_array, binary_length);
505 			return (EINVAL);
506 		}
507 
508 		rc = nvlist_add_byte_array(nvl, ikvx->ik_key_name,
509 		    binary_array, binary_length);
510 
511 		kmem_free(binary_array, binary_length);
512 
513 		return (rc);
514 
515 	} else if (kv_is_base64(value)) {
516 		value += strlen("0b");
517 		value_length = strlen(value);
518 		binary_array = kmem_alloc(value_length, KM_NOSLEEP);
519 		if (binary_array == NULL) {
520 			return (ENOMEM);
521 		}
522 
523 		if (iscsi_base64_str_to_binary(value, value_length,
524 		    binary_array, value_length, &binary_length) != 0) {
525 			kmem_free(binary_array, value_length);
526 			return (EINVAL);
527 		}
528 
529 		rc = nvlist_add_byte_array(nvl, ikvx->ik_key_name,
530 		    binary_array, binary_length);
531 
532 		kmem_free(binary_array, value_length);
533 
534 		return (rc);
535 	} else {
536 		/*
537 		 * Decimal value (not permitted for "large-binary_value" so
538 		 * it must be smaller than 64 bits.  It's not really
539 		 * clear from the RFC what a decimal-binary-value might
540 		 * represent but presumably it should be treated the same
541 		 * as a hex or base64 value.  Therefore we'll convert it
542 		 * to an array of bytes.
543 		 */
544 		if ((rc = ddi_strtoull(value, NULL, 0,
545 		    (u_longlong_t *)&uint64_value)) != 0)
546 			return (rc);
547 
548 		rc = nvlist_add_byte_array(nvl, ikvx->ik_key_name,
549 		    (uint8_t *)&uint64_value, sizeof (uint64_value));
550 
551 		return (rc);
552 	}
553 
554 	/* NOTREACHED */
555 }
556 
557 
558 static int
idm_nvlist_add_large_numerical(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value)559 idm_nvlist_add_large_numerical(nvlist_t *nvl,
560     const idm_kv_xlate_t *ikvx, char *value)
561 {
562 	/*
563 	 * A "large numerical" value can be larger than 64-bits.  Since
564 	 * there is no upper bound on the size of the value, we will
565 	 * punt and store it in string form.  We could also potentially
566 	 * treat the value as binary data.
567 	 */
568 	return (nvlist_add_string(nvl, ikvx->ik_key_name, value));
569 }
570 
571 
572 static int
idm_nvlist_add_numerical(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value)573 idm_nvlist_add_numerical(nvlist_t *nvl,
574     const idm_kv_xlate_t *ikvx, char *value)
575 {
576 	int rc;
577 	uint64_t uint64_value;
578 
579 	/*
580 	 * "Numerical" values in the iSCSI standard are up to 64-bits wide.
581 	 * On a 32-bit system we could see an overflow here during conversion.
582 	 * This shouldn't happen with real-world values for the current
583 	 * iSCSI parameters of "numerical" type.
584 	 */
585 	rc = ddi_strtoull(value, NULL, 0, (u_longlong_t *)&uint64_value);
586 	if (rc == 0) {
587 		rc = nvlist_add_uint64(nvl, ikvx->ik_key_name, uint64_value);
588 	}
589 
590 	return (rc);
591 }
592 
593 
594 static int
idm_nvlist_add_numeric_range(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * range)595 idm_nvlist_add_numeric_range(nvlist_t *nvl,
596     const idm_kv_xlate_t *ikvx, char *range)
597 {
598 	nvlist_t *range_nvl;
599 	char *val_scan = range;
600 	uint64_t start_val, end_val;
601 	int val_len, range_len;
602 	int rc;
603 
604 	/* We'll store the range an an nvlist with two values */
605 	rc = nvlist_alloc(&range_nvl, NV_UNIQUE_NAME, KM_NOSLEEP);
606 	if (rc != 0) {
607 		return (rc);
608 	}
609 
610 	/*
611 	 * We expect idm_keyvalue_get_next to ensure the string is
612 	 * terminated
613 	 */
614 	range_len = strlen(range);
615 
616 	/*
617 	 * Find range separator
618 	 */
619 	val_len = idm_strcspn(val_scan, "~");
620 
621 	if (val_len == range_len) {
622 		/* invalid range */
623 		nvlist_free(range_nvl);
624 		return (EINVAL);
625 	}
626 
627 	/*
628 	 * Start value
629 	 */
630 	*(val_scan + val_len + 1) = '\0';
631 	rc = ddi_strtoull(val_scan, NULL, 0, (u_longlong_t *)&start_val);
632 	if (rc == 0) {
633 		rc = nvlist_add_uint64(range_nvl, "start", start_val);
634 	}
635 	if (rc != 0) {
636 		nvlist_free(range_nvl);
637 		return (rc);
638 	}
639 
640 	/*
641 	 * End value
642 	 */
643 	val_scan += val_len + 1;
644 	rc = ddi_strtoull(val_scan, NULL, 0, (u_longlong_t *)&end_val);
645 	if (rc == 0) {
646 		rc = nvlist_add_uint64(range_nvl, "start", end_val);
647 	}
648 	if (rc != 0) {
649 		nvlist_free(range_nvl);
650 		return (rc);
651 	}
652 
653 	/*
654 	 * Now add the "range" nvlist to the main nvlist
655 	 */
656 	rc = nvlist_add_nvlist(nvl, ikvx->ik_key_name, range_nvl);
657 	if (rc != 0) {
658 		nvlist_free(range_nvl);
659 		return (rc);
660 	}
661 
662 	nvlist_free(range_nvl);
663 	return (0);
664 }
665 
666 
667 static int
idm_nvlist_add_list_of_values(nvlist_t * nvl,const idm_kv_xlate_t * ikvx,char * value_list)668 idm_nvlist_add_list_of_values(nvlist_t *nvl,
669     const idm_kv_xlate_t *ikvx, char *value_list)
670 {
671 	char value_name[8];
672 	nvlist_t *value_list_nvl;
673 	char *val_scan = value_list;
674 	int value_index = 0;
675 	int val_len, val_list_len;
676 	int rc;
677 
678 	rc = nvlist_alloc(&value_list_nvl, NV_UNIQUE_NAME, KM_NOSLEEP);
679 	if (rc != 0) {
680 		return (rc);
681 	}
682 
683 	/*
684 	 * We expect idm_keyvalue_get_next to ensure the string is
685 	 * terminated
686 	 */
687 	val_list_len = strlen(value_list);
688 	if (val_list_len == 0) {
689 		nvlist_free(value_list_nvl);
690 		return (EINVAL);
691 	}
692 
693 	for (;;) {
694 		(void) snprintf(value_name, 8, "value%d", value_index);
695 
696 		val_len = idm_strcspn(val_scan, ",");
697 
698 		if (*(val_scan + val_len) != '\0') {
699 			*(val_scan + val_len) = '\0';
700 		}
701 		rc = nvlist_add_string(value_list_nvl, value_name, val_scan);
702 		if (rc != 0) {
703 			nvlist_free(value_list_nvl);
704 			return (rc);
705 		}
706 
707 		/*
708 		 * Move to next value, see if we're at the end of the value
709 		 * list
710 		 */
711 		val_scan += val_len + 1;
712 		if (val_scan == value_list + val_list_len + 1) {
713 			break;
714 		}
715 
716 		value_index++;
717 	}
718 
719 	rc = nvlist_add_nvlist(nvl, ikvx->ik_key_name, value_list_nvl);
720 	if (rc != 0) {
721 		nvlist_free(value_list_nvl);
722 		return (rc);
723 	}
724 
725 	nvlist_free(value_list_nvl);
726 	return (0);
727 }
728 
729 /*
730  * Convert an nvlist containing standard iSCSI key names and values into
731  * a text buffer with properly formatted iSCSI key-value pairs ready to
732  * transmit on the wire.  *textbuf should be NULL and will be set to point
733  * the resulting text buffer.
734  */
735 
736 int
idm_nvlist_to_textbuf(nvlist_t * nvl,char ** textbuf,int * textbuflen,int * validlen)737 idm_nvlist_to_textbuf(nvlist_t *nvl, char **textbuf, int *textbuflen,
738     int *validlen)
739 {
740 	int rc = 0;
741 	nvpair_t *nvp = NULL;
742 	idm_textbuf_t itb;
743 
744 	bzero(&itb, sizeof (itb));
745 
746 	for (;;) {
747 		nvp = nvlist_next_nvpair(nvl, nvp);
748 
749 		if (nvp == NULL) {
750 			/* Last nvpair in nvlist, we're done */
751 			break;
752 		}
753 
754 		if ((rc = idm_itextbuf_add_nvpair(nvp, &itb)) != 0) {
755 			/* There was a problem building the key/value pair */
756 			break;
757 		}
758 	}
759 
760 	*textbuf = itb.itb_mem;
761 	*textbuflen = itb.itb_mem_len;
762 	*validlen = itb.itb_offset;
763 
764 	return (rc);
765 }
766 
767 static int
idm_itextbuf_add_nvpair(nvpair_t * nvp,idm_textbuf_t * itb)768 idm_itextbuf_add_nvpair(nvpair_t *nvp,
769     idm_textbuf_t *itb)
770 {
771 	int rc = 0;
772 	char *key;
773 	const idm_kv_xlate_t *ikvx;
774 
775 	key = nvpair_name(nvp);
776 
777 	ikvx = idm_lookup_kv_xlate(key, strlen(key));
778 
779 	/*
780 	 * Any key supplied by the initiator that is not in our table
781 	 * will be responded to with the string value "NotUnderstood".
782 	 * An example is a vendor specific key.
783 	 */
784 	ASSERT((ikvx->ik_key_id != KI_MAX_KEY) ||
785 	    (nvpair_type(nvp) == DATA_TYPE_STRING));
786 
787 	/*
788 	 * Look for a matching key value in the key/value pair table.
789 	 * The matching entry in the table will tell us how to encode
790 	 * the key and value in the nvlist.
791 	 */
792 	switch (ikvx->ik_idm_type) {
793 	case KT_TEXT:
794 	case KT_SIMPLE:
795 	case KT_ISCSI_NAME:
796 	case KT_ISCSI_LOCAL_NAME:
797 		rc = idm_itextbuf_add_string(nvp, ikvx, itb);
798 		break;
799 	case KT_BOOLEAN:
800 		rc = idm_itextbuf_add_boolean(nvp, ikvx, itb);
801 		break;
802 	case KT_REGULAR_BINARY:
803 	case KT_LARGE_BINARY:
804 	case KT_BINARY:
805 		rc = idm_itextbuf_add_binary(nvp, ikvx, itb);
806 		break;
807 	case KT_LARGE_NUMERICAL:
808 		rc = idm_itextbuf_add_large_numerical(nvp, ikvx, itb);
809 		break;
810 	case KT_NUMERICAL:
811 		rc = idm_itextbuf_add_numerical(nvp, ikvx, itb);
812 		break;
813 	case KT_NUMERIC_RANGE:
814 		rc = idm_itextbuf_add_numeric_range(nvp, ikvx, itb);
815 		break;
816 	case KT_LIST_OF_VALUES:
817 		rc = idm_itextbuf_add_list_of_values(nvp, ikvx, itb);
818 		break;
819 	default:
820 		ASSERT(0); /* This should never happen */
821 		break;
822 	}
823 
824 	return (rc);
825 }
826 
827 /* ARGSUSED */
828 static int
idm_itextbuf_add_string(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)829 idm_itextbuf_add_string(nvpair_t *nvp,
830     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
831 {
832 	char	*key_name;
833 	char	*value;
834 	int	rc;
835 
836 	/* Start with the key name */
837 	key_name = nvpair_name(nvp);
838 	textbuf_strcpy(itb, key_name);
839 
840 	/* Add separator */
841 	textbuf_append_char(itb, '=');
842 
843 	/* Add value */
844 	rc = nvpair_value_string(nvp, &value);
845 	ASSERT(rc == 0);
846 	textbuf_strcpy(itb, value);
847 
848 	/* Add trailing 0x00 */
849 	textbuf_terminate_kvpair(itb);
850 
851 	return (0);
852 }
853 
854 
855 /* ARGSUSED */
856 static int
idm_itextbuf_add_boolean(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)857 idm_itextbuf_add_boolean(nvpair_t *nvp,
858     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
859 {
860 	char		*key_name;
861 	boolean_t	value;
862 	int	rc;
863 
864 	/* Start with the key name */
865 	key_name = nvpair_name(nvp);
866 	textbuf_strcpy(itb, key_name);
867 
868 	/* Add separator */
869 	textbuf_append_char(itb, '=');
870 
871 	/* Add value */
872 	rc = nvpair_value_boolean_value(nvp, &value);
873 	ASSERT(rc == 0);
874 	textbuf_strcpy(itb, value ? "Yes" : "No");
875 
876 	/* Add trailing 0x00 */
877 	textbuf_terminate_kvpair(itb);
878 
879 	return (0);
880 }
881 
882 /* ARGSUSED */
883 static int
idm_itextbuf_add_binary(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)884 idm_itextbuf_add_binary(nvpair_t *nvp,
885     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
886 {
887 	char		*key_name;
888 	unsigned char	*value;
889 	unsigned int	len;
890 	unsigned long	n;
891 	int	rc;
892 
893 	/* Start with the key name */
894 	key_name = nvpair_name(nvp);
895 	textbuf_strcpy(itb, key_name);
896 
897 	/* Add separator */
898 	textbuf_append_char(itb, '=');
899 
900 	/* Add value */
901 	rc = nvpair_value_byte_array(nvp, &value, &len);
902 	ASSERT(rc == 0);
903 
904 	textbuf_strcpy(itb, "0x");
905 
906 	while (len > 0) {
907 		n = *value++;
908 		len--;
909 
910 		textbuf_append_char(itb, idm_hex_to_ascii[(n >> 4) & 0xf]);
911 		textbuf_append_char(itb, idm_hex_to_ascii[n & 0xf]);
912 	}
913 
914 	/* Add trailing 0x00 */
915 	textbuf_terminate_kvpair(itb);
916 
917 	return (0);
918 }
919 
920 /* ARGSUSED */
921 static int
idm_itextbuf_add_large_numerical(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)922 idm_itextbuf_add_large_numerical(nvpair_t *nvp,
923     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
924 {
925 	ASSERT(0);
926 	return (0);
927 }
928 
929 /* ARGSUSED */
930 static int
idm_itextbuf_add_numerical(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)931 idm_itextbuf_add_numerical(nvpair_t *nvp,
932     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
933 {
934 	char		*key_name;
935 	uint64_t	value;
936 	int	rc;
937 	char		str[16];
938 
939 	/* Start with the key name */
940 	key_name = nvpair_name(nvp);
941 	textbuf_strcpy(itb, key_name);
942 
943 	/* Add separator */
944 	textbuf_append_char(itb, '=');
945 
946 	/* Add value */
947 	rc = nvpair_value_uint64(nvp, &value);
948 	ASSERT(rc == 0);
949 	(void) sprintf(str, "%llu", (u_longlong_t)value);
950 	textbuf_strcpy(itb, str);
951 
952 	/* Add trailing 0x00 */
953 	textbuf_terminate_kvpair(itb);
954 
955 	return (0);
956 }
957 
958 /* ARGSUSED */
959 static int
idm_itextbuf_add_numeric_range(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)960 idm_itextbuf_add_numeric_range(nvpair_t *nvp,
961     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
962 {
963 	ASSERT(0);
964 	return (0);
965 }
966 
967 /* ARGSUSED */
968 static int
idm_itextbuf_add_list_of_values(nvpair_t * nvp,const idm_kv_xlate_t * ikvx,idm_textbuf_t * itb)969 idm_itextbuf_add_list_of_values(nvpair_t *nvp,
970     const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
971 {
972 	char		*key_name;
973 	nvpair_t	*vchoice = NULL;
974 	char		*vchoice_string = NULL;
975 	int		rc;
976 
977 	/* Start with the key name */
978 	key_name = nvpair_name(nvp);
979 	textbuf_strcpy(itb, key_name);
980 
981 	/* Add separator */
982 	textbuf_append_char(itb, '=');
983 
984 	/* Add value choices */
985 	vchoice = idm_get_next_listvalue(nvp, NULL);
986 	while (vchoice != NULL) {
987 		rc = nvpair_value_string(vchoice, &vchoice_string);
988 		ASSERT(rc == 0);
989 		textbuf_strcpy(itb, vchoice_string);
990 		vchoice = idm_get_next_listvalue(nvp, vchoice);
991 		if (vchoice != NULL) {
992 			/* Add ',' between choices */
993 			textbuf_append_char(itb, ',');
994 		}
995 	}
996 
997 	/* Add trailing 0x00 */
998 	textbuf_terminate_kvpair(itb);
999 
1000 	return (0);
1001 }
1002 
1003 
1004 static void
textbuf_makeroom(idm_textbuf_t * itb,int size)1005 textbuf_makeroom(idm_textbuf_t *itb, int size)
1006 {
1007 	char	*new_mem;
1008 	int	new_mem_len;
1009 
1010 	if (itb->itb_mem == NULL) {
1011 		itb->itb_mem_len = MAX(TEXTBUF_CHUNKSIZE, size);
1012 		itb->itb_mem = kmem_alloc(itb->itb_mem_len, KM_SLEEP);
1013 	} else if ((itb->itb_offset + size) > itb->itb_mem_len) {
1014 		new_mem_len = itb->itb_mem_len + MAX(TEXTBUF_CHUNKSIZE, size);
1015 		new_mem = kmem_alloc(new_mem_len, KM_SLEEP);
1016 		bcopy(itb->itb_mem, new_mem, itb->itb_mem_len);
1017 		kmem_free(itb->itb_mem, itb->itb_mem_len);
1018 		itb->itb_mem = new_mem;
1019 		itb->itb_mem_len = new_mem_len;
1020 	}
1021 }
1022 
1023 static void
textbuf_memcpy(idm_textbuf_t * itb,void * mem,int mem_len)1024 textbuf_memcpy(idm_textbuf_t *itb, void *mem, int mem_len)
1025 {
1026 	textbuf_makeroom(itb, mem_len);
1027 	(void) memcpy(itb->itb_mem + itb->itb_offset, mem, mem_len);
1028 	itb->itb_offset += mem_len;
1029 }
1030 
1031 static void
textbuf_strcpy(idm_textbuf_t * itb,char * str)1032 textbuf_strcpy(idm_textbuf_t *itb, char *str)
1033 {
1034 	textbuf_memcpy(itb, str, strlen(str));
1035 }
1036 
1037 static void
textbuf_append_char(idm_textbuf_t * itb,char c)1038 textbuf_append_char(idm_textbuf_t *itb, char c)
1039 {
1040 	textbuf_makeroom(itb, sizeof (char));
1041 	*(itb->itb_mem + itb->itb_offset) = c;
1042 	itb->itb_offset++;
1043 }
1044 
1045 static void
textbuf_terminate_kvpair(idm_textbuf_t * itb)1046 textbuf_terminate_kvpair(idm_textbuf_t *itb)
1047 {
1048 	textbuf_append_char(itb, '\0');
1049 }
1050 
1051 static int
idm_ascii_to_hex(char * enc_hex_byte,uint8_t * bin_val)1052 idm_ascii_to_hex(char *enc_hex_byte, uint8_t *bin_val)
1053 {
1054 	uint8_t nibble1, nibble2;
1055 	char enc_char = *enc_hex_byte;
1056 
1057 	if (enc_char >= '0' && enc_char <= '9') {
1058 		nibble1 = (enc_char - '0');
1059 	} else if (enc_char >= 'A' && enc_char <= 'F') {
1060 		nibble1 = (0xA + (enc_char - 'A'));
1061 	} else if (enc_char >= 'a' && enc_char <= 'f') {
1062 		nibble1 = (0xA + (enc_char - 'a'));
1063 	} else {
1064 		return (EINVAL);
1065 	}
1066 
1067 	enc_hex_byte++;
1068 	enc_char = *enc_hex_byte;
1069 
1070 	if (enc_char >= '0' && enc_char <= '9') {
1071 		nibble2 = (enc_char - '0');
1072 	} else if (enc_char >= 'A' && enc_char <= 'F') {
1073 		nibble2 = (0xA + (enc_char - 'A'));
1074 	} else if (enc_char >= 'a' && enc_char <= 'f') {
1075 		nibble2 = (0xA + (enc_char - 'a'));
1076 	} else {
1077 		return (EINVAL);
1078 	}
1079 
1080 	*bin_val = (nibble1 << 4) | nibble2;
1081 
1082 	return (0);
1083 }
1084 
1085 
idm_base16_str_to_binary(char * hstr,int hstr_len,uint8_t * binary_array,int binary_length)1086 static int idm_base16_str_to_binary(char *hstr, int hstr_len,
1087     uint8_t *binary_array, int binary_length)
1088 {
1089 	char	tmpstr[2];
1090 	uchar_t *binary_scan;
1091 
1092 	binary_scan = binary_array;
1093 
1094 	/*
1095 	 * If the length of the encoded ascii hex value is a multiple
1096 	 * of two then every two ascii characters correspond to a hex
1097 	 * byte.  If the length of the value is not a multiple of two
1098 	 * then the first character is the first hex byte and then for
1099 	 * the remaining of the string every two ascii characters
1100 	 * correspond to a hex byte
1101 	 */
1102 	if ((hstr_len % 2) != 0) {
1103 
1104 		tmpstr[0] = '0';
1105 		tmpstr[1] = *hstr;
1106 
1107 		if (idm_ascii_to_hex(tmpstr, binary_scan) != 0) {
1108 			return (EINVAL);
1109 		}
1110 
1111 		hstr++;
1112 		binary_scan++;
1113 	}
1114 
1115 	while (binary_scan != binary_array + binary_length) {
1116 		if (idm_ascii_to_hex(hstr, binary_scan) != 0) {
1117 			return (EINVAL);
1118 		}
1119 
1120 		hstr += 2;
1121 		binary_scan++;
1122 	}
1123 
1124 	return (0);
1125 }
1126 
1127 static size_t
idm_strnlen(const char * str,size_t maxlen)1128 idm_strnlen(const char *str, size_t maxlen)
1129 {
1130 	const char *ptr;
1131 
1132 	ptr = memchr(str, 0, maxlen);
1133 	if (ptr == NULL)
1134 		return (maxlen);
1135 
1136 	return ((uintptr_t)ptr - (uintptr_t)str);
1137 }
1138 
1139 
1140 size_t
idm_strcspn(const char * string,const char * charset)1141 idm_strcspn(const char *string, const char *charset)
1142 {
1143 	const char *p, *q;
1144 
1145 	for (q = string; *q != '\0'; ++q) {
1146 		for (p = charset; *p != '\0' && *p != *q; )
1147 			p++;
1148 		if (*p != '\0') {
1149 			break;
1150 		}
1151 	}
1152 	return ((uintptr_t)q - (uintptr_t)string);
1153 }
1154 
1155 /*
1156  * We allow a list of choices to be represented as a single nvpair
1157  * (list with one value choice), or as an nvlist with a single nvpair
1158  * (also a list with on value choice), or as an nvlist with multiple
1159  * nvpairs (a list with multiple value choices).  This function implements
1160  * the "get next" functionality regardless of the choice list structure.
1161  *
1162  * nvpair_t's that contain choices are always strings.
1163  */
1164 nvpair_t *
idm_get_next_listvalue(nvpair_t * value_list,nvpair_t * curr_nvp)1165 idm_get_next_listvalue(nvpair_t *value_list, nvpair_t *curr_nvp)
1166 {
1167 	nvpair_t	*result;
1168 	nvlist_t	*nvl;
1169 	int		nvrc;
1170 	data_type_t	nvp_type;
1171 
1172 	nvp_type = nvpair_type(value_list);
1173 
1174 	switch (nvp_type) {
1175 	case DATA_TYPE_NVLIST:
1176 		nvrc = nvpair_value_nvlist(value_list, &nvl);
1177 		ASSERT(nvrc == 0);
1178 		result = nvlist_next_nvpair(nvl, curr_nvp);
1179 		break;
1180 	case DATA_TYPE_STRING:
1181 		/* Single choice */
1182 		if (curr_nvp == NULL) {
1183 			result = value_list;
1184 		} else {
1185 			result = NULL;
1186 		}
1187 		break;
1188 	default:
1189 		ASSERT(0); /* Malformed choice list */
1190 		result = NULL;
1191 		break;
1192 	}
1193 
1194 	return (result);
1195 }
1196 
1197 kv_status_t
idm_nvstat_to_kvstat(int nvrc)1198 idm_nvstat_to_kvstat(int nvrc)
1199 {
1200 	kv_status_t result;
1201 	switch (nvrc) {
1202 	case 0:
1203 		result = KV_HANDLED;
1204 		break;
1205 	case ENOMEM:
1206 		result = KV_NO_RESOURCES;
1207 		break;
1208 	case EINVAL:
1209 		result = KV_VALUE_ERROR;
1210 		break;
1211 	case EFAULT:
1212 	case ENOTSUP:
1213 	default:
1214 		result = KV_INTERNAL_ERROR;
1215 		break;
1216 	}
1217 
1218 	return (result);
1219 }
1220 
1221 void
idm_kvstat_to_error(kv_status_t kvrc,uint8_t * class,uint8_t * detail)1222 idm_kvstat_to_error(kv_status_t kvrc, uint8_t *class, uint8_t *detail)
1223 {
1224 	switch (kvrc) {
1225 	case KV_HANDLED:
1226 	case KV_HANDLED_NO_TRANSIT:
1227 		*class = ISCSI_STATUS_CLASS_SUCCESS;
1228 		*detail = ISCSI_LOGIN_STATUS_ACCEPT;
1229 		break;
1230 	case KV_UNHANDLED:
1231 	case KV_TARGET_ONLY:
1232 		/* protocol error */
1233 		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
1234 		*detail = ISCSI_LOGIN_STATUS_INVALID_REQUEST;
1235 		break;
1236 	case KV_VALUE_ERROR:
1237 		/* invalid value */
1238 		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
1239 		*detail = ISCSI_LOGIN_STATUS_INIT_ERR;
1240 		break;
1241 	case KV_NO_RESOURCES:
1242 		/* no memory */
1243 		*class = ISCSI_STATUS_CLASS_TARGET_ERR;
1244 		*detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
1245 		break;
1246 	case KV_MISSING_FIELDS:
1247 		/* key/value pair(s) missing */
1248 		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
1249 		*detail = ISCSI_LOGIN_STATUS_MISSING_FIELDS;
1250 		break;
1251 	case KV_AUTH_FAILED:
1252 		/* authentication failed */
1253 		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
1254 		*detail = ISCSI_LOGIN_STATUS_AUTH_FAILED;
1255 		break;
1256 	default:
1257 		/* target error */
1258 		*class = ISCSI_STATUS_CLASS_TARGET_ERR;
1259 		*detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
1260 		break;
1261 	}
1262 }
1263 
1264 int
idm_nvlist_add_keyvalue(nvlist_t * nvl,char * key,int keylen,char * value)1265 idm_nvlist_add_keyvalue(nvlist_t *nvl,
1266     char *key, int keylen, char *value)
1267 {
1268 	const idm_kv_xlate_t *ikvx;
1269 
1270 	ikvx = idm_lookup_kv_xlate(key, keylen);
1271 
1272 	if (ikvx->ik_key_id == KI_MAX_KEY) {
1273 		char *nkey;
1274 		int rc;
1275 		size_t len;
1276 
1277 		/*
1278 		 * key is not a NULL terminated string, so create one
1279 		 */
1280 		len = (size_t)(keylen+1);
1281 		nkey = kmem_zalloc(len, KM_SLEEP);
1282 		(void) strncpy(nkey, key, len-1);
1283 		rc = nvlist_add_string(nvl, nkey, value);
1284 		kmem_free(nkey, len);
1285 		return (rc);
1286 	}
1287 
1288 	return (idm_nvlist_add_kv(nvl, ikvx, value));
1289 }
1290 
1291 int
idm_nvlist_add_id(nvlist_t * nvl,iscsikey_id_t kv_id,char * value)1292 idm_nvlist_add_id(nvlist_t *nvl, iscsikey_id_t kv_id, char *value)
1293 {
1294 	int i;
1295 	for (i = 0; i < KI_MAX_KEY; i++) {
1296 		if (idm_kvpair_xlate[i].ik_key_id == kv_id) {
1297 			return
1298 			    (idm_nvlist_add_kv(nvl,
1299 			    &idm_kvpair_xlate[i], value));
1300 		}
1301 	}
1302 	return (EFAULT);
1303 }
1304 
1305 char *
idm_id_to_name(iscsikey_id_t kv_id)1306 idm_id_to_name(iscsikey_id_t kv_id)
1307 {
1308 	int i;
1309 	for (i = 0; i < KI_MAX_KEY; i++) {
1310 		if (idm_kvpair_xlate[i].ik_key_id == kv_id) {
1311 			return (idm_kvpair_xlate[i].ik_key_name);
1312 		}
1313 	}
1314 	return (NULL);
1315 }
1316 
1317 /*
1318  * return the value in a buffer that must be freed by the caller
1319  */
1320 char *
idm_nvpair_value_to_textbuf(nvpair_t * nvp)1321 idm_nvpair_value_to_textbuf(nvpair_t *nvp)
1322 {
1323 	int rv, len;
1324 	idm_textbuf_t itb;
1325 	char *str;
1326 
1327 	bzero(&itb, sizeof (itb));
1328 	rv = idm_itextbuf_add_nvpair(nvp, &itb);
1329 	if (rv != 0)
1330 		return (NULL);
1331 	str = kmem_alloc(itb.itb_mem_len, KM_SLEEP);
1332 	len = idm_strcspn(itb.itb_mem, "=");
1333 	if (len > strlen(itb.itb_mem)) {
1334 		kmem_free(itb.itb_mem, itb.itb_mem_len);
1335 		return (NULL);
1336 	}
1337 	(void) strcpy(str, &itb.itb_mem[len+1]);
1338 	/* free the allocation done in idm_textbuf_add_nvpair */
1339 	kmem_free(itb.itb_mem, itb.itb_mem_len);
1340 	return (str);
1341 }
1342 
1343 /*
1344  * build an iscsi text buffer - the memory gets freed in
1345  * idm_itextbuf_free
1346  */
1347 void *
idm_nvlist_to_itextbuf(nvlist_t * nvl)1348 idm_nvlist_to_itextbuf(nvlist_t *nvl)
1349 {
1350 	idm_textbuf_t *itb;
1351 	char		*textbuf;
1352 	int		validlen, textbuflen;
1353 
1354 	if (idm_nvlist_to_textbuf(nvl, &textbuf, &textbuflen,
1355 	    &validlen) != IDM_STATUS_SUCCESS) {
1356 		return (NULL);
1357 	}
1358 	itb = kmem_zalloc(sizeof (idm_textbuf_t), KM_SLEEP);
1359 	ASSERT(itb != NULL);
1360 	itb->itb_mem = textbuf;
1361 	itb->itb_mem_len = textbuflen;
1362 	itb->itb_offset = validlen;
1363 	return ((void *)itb);
1364 }
1365 
1366 /*
1367  * Copy as much of the text buffer as will fit in the pdu.
1368  * The first call to this routine should send
1369  * a NULL bufptr. Subsequent calls send in the buffer returned.
1370  * Call this routine until the string returned is NULL
1371  */
1372 char *
idm_pdu_init_text_data(idm_pdu_t * pdu,void * arg,int max_xfer_len,char * bufptr,int * transit)1373 idm_pdu_init_text_data(idm_pdu_t *pdu, void *arg,
1374     int max_xfer_len, char *bufptr, int *transit)
1375 {
1376 	char		*start_ptr, *end_ptr, *ptr;
1377 	idm_textbuf_t	*itb = arg;
1378 	iscsi_hdr_t	*ihp = pdu->isp_hdr;
1379 	int		send = 0;
1380 
1381 	ASSERT(itb != NULL);
1382 	ASSERT(pdu != NULL);
1383 	ASSERT(transit != NULL);
1384 	if (bufptr == NULL) {
1385 		/* first call - check the length */
1386 		if (itb->itb_offset <= max_xfer_len) {
1387 			/*
1388 			 * the entire text buffer fits in the pdu
1389 			 */
1390 			bcopy((uint8_t *)itb->itb_mem, pdu->isp_data,
1391 			    (size_t)itb->itb_offset);
1392 			pdu->isp_datalen = itb->itb_offset;
1393 			ihp->flags &= ~ISCSI_FLAG_TEXT_CONTINUE;
1394 			*transit = 1;
1395 			return (NULL);
1396 		}
1397 		/* we have more data than will fit in one pdu */
1398 		start_ptr = itb->itb_mem;
1399 		end_ptr = &itb->itb_mem[max_xfer_len - 1];
1400 
1401 	} else {
1402 		uint_t len;
1403 
1404 		len =  (uintptr_t)&itb->itb_mem[itb->itb_offset] -
1405 		    (uintptr_t)bufptr;
1406 		if (len <= max_xfer_len) {
1407 			/*
1408 			 * the remaining text fits in the pdu
1409 			 */
1410 			bcopy(bufptr, pdu->isp_data, (size_t)len);
1411 			pdu->isp_datalen = len;
1412 			ihp->flags &= ~ISCSI_FLAG_TEXT_CONTINUE;
1413 			*transit = 1;
1414 			return (NULL);
1415 		}
1416 		/* we still have more data then will fit in one pdu */
1417 		start_ptr = bufptr;
1418 		end_ptr = &bufptr[max_xfer_len - 1];
1419 	}
1420 	/* break after key, after =, after the value or after '\0' */
1421 	ptr = end_ptr;
1422 	if (end_ptr + 1 <= &itb->itb_mem[itb->itb_offset]) {
1423 		/* if next char is an '=' or '\0' send it */
1424 		if (*(end_ptr + 1) == '=' || *(end_ptr + 1) == '\0') {
1425 			send = 1;
1426 		}
1427 	}
1428 	if (!send) {
1429 		while (*ptr != '\0' && *ptr != '=' && ptr != start_ptr) {
1430 			ptr--;
1431 		}
1432 	}
1433 	bcopy(start_ptr, pdu->isp_data,
1434 	    ((uintptr_t)ptr - (uintptr_t)start_ptr) + 1);
1435 	pdu->isp_datalen = ((uintptr_t)ptr - (uintptr_t)start_ptr) + 1;
1436 	ihp->flags |= ISCSI_FLAG_TEXT_CONTINUE;
1437 	*transit = 0;
1438 	return (++ptr);
1439 }
1440 
1441 void
idm_itextbuf_free(void * arg)1442 idm_itextbuf_free(void *arg)
1443 {
1444 	idm_textbuf_t	*itb = arg;
1445 	ASSERT(itb != NULL);
1446 	kmem_free(itb->itb_mem, itb->itb_mem_len);
1447 	kmem_free(itb, sizeof (idm_textbuf_t));
1448 }
1449 
1450 /*
1451  * Allocate an nvlist and poputlate with key=value from the pdu list.
1452  * NOTE: caller must free the list
1453  */
1454 idm_status_t
idm_pdu_list_to_nvlist(list_t * pdu_list,nvlist_t ** nvlist,uint8_t * error_detail)1455 idm_pdu_list_to_nvlist(list_t *pdu_list, nvlist_t **nvlist,
1456     uint8_t *error_detail)
1457 {
1458 	idm_pdu_t		*pdu, *next_pdu;
1459 	boolean_t		split_kv = B_FALSE;
1460 	char			*textbuf, *leftover_textbuf = NULL;
1461 	int			textbuflen, leftover_textbuflen = 0;
1462 	char			*split_kvbuf;
1463 	int			split_kvbuflen, cont_fraglen;
1464 	iscsi_login_hdr_t	*lh;
1465 	int			rc;
1466 	int			ret = IDM_STATUS_SUCCESS;
1467 
1468 	*error_detail = ISCSI_LOGIN_STATUS_ACCEPT;
1469 	/* Allocate a new nvlist for request key/value pairs */
1470 	rc = nvlist_alloc(nvlist, NV_UNIQUE_NAME,
1471 	    KM_NOSLEEP);
1472 	if (rc != 0) {
1473 		*error_detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
1474 		ret = IDM_STATUS_FAIL;
1475 		goto cleanup;
1476 	}
1477 
1478 	/*
1479 	 * A login request can be split across multiple PDU's.  The state
1480 	 * machine has collected all the PDU's that make up this login request
1481 	 * and assembled them on the "icl_pdu_list" queue.  Process each PDU
1482 	 * and convert the text keywords to nvlist form.
1483 	 */
1484 	pdu = list_head(pdu_list);
1485 	while (pdu != NULL) {
1486 		next_pdu = list_next(pdu_list, pdu);
1487 
1488 		lh = (iscsi_login_hdr_t *)pdu->isp_hdr;
1489 
1490 		textbuf = (char *)pdu->isp_data;
1491 		textbuflen = pdu->isp_datalen;
1492 		if (textbuflen == 0) {
1493 			/* This shouldn't really happen but it could.. */
1494 			list_remove(pdu_list, pdu);
1495 			idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
1496 			pdu = next_pdu;
1497 			continue;
1498 		}
1499 
1500 		/*
1501 		 * If we encountered a split key-value pair on the last
1502 		 * PDU then handle it now by grabbing the remainder of the
1503 		 * key-value pair from the next PDU and splicing them
1504 		 * together.  Obviously on the first PDU this will never
1505 		 * happen.
1506 		 */
1507 		if (split_kv) {
1508 			cont_fraglen = idm_textbuf_to_firstfraglen(textbuf,
1509 			    textbuflen);
1510 			if (cont_fraglen == pdu->isp_datalen) {
1511 				/*
1512 				 * This key-value pair spans more than two
1513 				 * PDU's.  We don't handle this.
1514 				 */
1515 				*error_detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
1516 				ret = IDM_STATUS_FAIL;
1517 				goto cleanup;
1518 			}
1519 
1520 			split_kvbuflen = leftover_textbuflen + cont_fraglen;
1521 			split_kvbuf = kmem_alloc(split_kvbuflen, KM_NOSLEEP);
1522 			if (split_kvbuf == NULL) {
1523 				*error_detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
1524 				ret = IDM_STATUS_FAIL;
1525 				goto cleanup;
1526 			}
1527 
1528 			bcopy(leftover_textbuf, split_kvbuf,
1529 			    leftover_textbuflen);
1530 			bcopy(textbuf,
1531 			    (uint8_t *)split_kvbuf + leftover_textbuflen,
1532 			    cont_fraglen);
1533 
1534 
1535 			if (idm_textbuf_to_nvlist(*nvlist,
1536 			    &split_kvbuf, &split_kvbuflen) != 0) {
1537 				/*
1538 				 * Need to handle E2BIG case, indicating that
1539 				 * a key-value pair is split across multiple
1540 				 * PDU's.
1541 				 */
1542 				kmem_free(split_kvbuf, split_kvbuflen);
1543 
1544 				*error_detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
1545 				ret = IDM_STATUS_FAIL;
1546 				goto cleanup;
1547 			}
1548 
1549 			ASSERT(split_kvbuflen != 0);
1550 			kmem_free(split_kvbuf, split_kvbuflen);
1551 
1552 			/* Now handle the remainder of the PDU as normal */
1553 			textbuf += (cont_fraglen + 1);
1554 			textbuflen -= (cont_fraglen + 1);
1555 		}
1556 
1557 		/*
1558 		 * Convert each key-value pair in the text buffer to nvlist
1559 		 * format.  If the list has already been created the nvpair
1560 		 * elements will be added on to the existing list.  Otherwise
1561 		 * a new nvlist will be created.
1562 		 */
1563 		if (idm_textbuf_to_nvlist(*nvlist,
1564 		    &textbuf, &textbuflen) != 0) {
1565 
1566 			*error_detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
1567 			ret = IDM_STATUS_FAIL;
1568 			goto cleanup;
1569 		}
1570 
1571 		ASSERT(
1572 		    ((lh->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
1573 		    (next_pdu != NULL)) ||
1574 		    (!(lh->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
1575 		    (next_pdu == NULL)));
1576 
1577 		if ((lh->flags & ISCSI_FLAG_LOGIN_CONTINUE) &
1578 		    (textbuflen != 0)) {
1579 			/*
1580 			 * Key-value pair is split over two PDU's.  We
1581 			 * assume it willl never be split over more than
1582 			 * two PDU's.
1583 			 */
1584 			split_kv = B_TRUE;
1585 			leftover_textbuf = textbuf;
1586 			leftover_textbuflen = textbuflen;
1587 		} else {
1588 			split_kv = B_FALSE;
1589 			if (textbuflen != 0) {
1590 				/*
1591 				 * Incomplete keyword but no additional
1592 				 * PDU's.  This is a malformed login
1593 				 * request.
1594 				 */
1595 				*error_detail =
1596 				    ISCSI_LOGIN_STATUS_INVALID_REQUEST;
1597 				ret = IDM_STATUS_FAIL;
1598 				goto cleanup;
1599 			}
1600 		}
1601 
1602 		list_remove(pdu_list, pdu);
1603 		idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
1604 		pdu = next_pdu;
1605 	}
1606 
1607 cleanup:
1608 
1609 	/*
1610 	 * Free any remaining PDUs on the list. This will only
1611 	 * happen if there were errors encountered during
1612 	 * processing of the textbuf.
1613 	 */
1614 	pdu = list_head(pdu_list);
1615 	while (pdu != NULL) {
1616 		next_pdu = list_next(pdu_list, pdu);
1617 		list_remove(pdu_list, pdu);
1618 		idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
1619 		pdu = next_pdu;
1620 	}
1621 
1622 	/*
1623 	 * If there were no errors, we have a complete nvlist representing
1624 	 * all the iSCSI key-value pairs in the login request PDU's
1625 	 * that make up this request.
1626 	 */
1627 	return (ret);
1628 }
1629