io/idm/idm_text.c

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

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sysmacros.h>
#include <sys/socket.h>

#include <sys/iscsi_protocol.h>
#include <sys/idm/idm.h>
#include <sys/idm/idm_text.h>


extern int
iscsi_base64_str_to_binary(char *hstr, int hstr_len,
    uint8_t *binary, int binary_buf_len, int *out_len);


static const char idm_hex_to_ascii[] = "0123456789abcdefABCDEF";

static const idm_kv_xlate_t idm_kvpair_xlate[] = {
	/*
	 * iSCSI Security Text Keys and Authentication Methods
	 */

	{ KI_AUTH_METHOD, "AuthMethod", KT_LIST_OF_VALUES, B_FALSE },
	/*
	 * For values with RFC comments we need to read the RFC to see
	 * what type is appropriate.  For now just treat the value as
	 * text.
	 */

	/* Kerberos */
	{ KI_KRB_AP_REQ, "KRB_AP_REQ", KT_TEXT /* RFC1510 */, B_TRUE},
	{ KI_KRB_AP_REP, "KRB_AP_REP", KT_TEXT /* RFC1510 */, B_TRUE},

	/* SPKM */
	{ KI_SPKM_REQ, "SPKM_REQ", KT_TEXT /* RFC2025 */, B_TRUE},
	{ KI_SPKM_ERROR, "SPKM_ERROR", KT_TEXT /* RFC2025 */, B_TRUE},
	{ KI_SPKM_REP_TI, "SPKM_REP_TI", KT_TEXT /* RFC2025 */, B_TRUE},
	{ KI_SPKM_REP_IT, "SPKM_REP_IT", KT_TEXT /* RFC2025 */, B_TRUE},

	/*
	 * SRP
	 * U, s, A, B, M, and H(A | M | K) are defined in [RFC2945]
	 */
	{ KI_SRP_U, "SRP_U", KT_TEXT /* <U> */, B_TRUE},
	{ KI_TARGET_AUTH, "TargetAuth", KT_BOOLEAN, B_TRUE},
	{ KI_SRP_GROUP, "SRP_GROUP", KT_LIST_OF_VALUES /* <G1,..> */, B_FALSE},
	{ KI_SRP_A, "SRP_A", KT_TEXT /* <A> */, B_TRUE},
	{ KI_SRP_B, "SRP_B", KT_TEXT /* <B> */, B_TRUE},
	{ KI_SRP_M, "SRP_M", KT_TEXT /* <M> */, B_TRUE},
	{ KI_SRM_HM, "SRP_HM", KT_TEXT /* <H(A | M | K)> */, B_TRUE},

	/*
	 * CHAP
	 */
	{ KI_CHAP_A, "CHAP_A", KT_LIST_OF_VALUES /* <A1,A2,..> */, B_FALSE },
	{ KI_CHAP_I, "CHAP_I", KT_NUMERICAL /* <I> */, B_TRUE },
	{ KI_CHAP_C, "CHAP_C", KT_BINARY /* <C> */, B_TRUE },
	{ KI_CHAP_N, "CHAP_N", KT_TEXT /* <N> */, B_TRUE },
	{ KI_CHAP_R, "CHAP_R", KT_BINARY /* <N> */, B_TRUE },


	/*
	 * ISCSI Operational Parameter Keys
	 */
	{ KI_HEADER_DIGEST, "HeaderDigest", KT_LIST_OF_VALUES, B_FALSE },
	{ KI_DATA_DIGEST, "DataDigest", KT_LIST_OF_VALUES, B_FALSE },
	{ KI_MAX_CONNECTIONS, "MaxConnections", KT_NUMERICAL, B_FALSE },
	{ KI_SEND_TARGETS, "SendTargets", KT_TEXT, B_FALSE },
	{ KI_TARGET_NAME, "TargetName", KT_ISCSI_NAME, B_TRUE},
	{ KI_INITIATOR_NAME, "InitiatorName", KT_ISCSI_NAME, B_TRUE},
	{ KI_TARGET_ALIAS, "TargetAlias", KT_ISCSI_LOCAL_NAME, B_TRUE},
	{ KI_INITIATOR_ALIAS, "InitiatorAlias", KT_ISCSI_LOCAL_NAME, B_TRUE},
	{ KI_TARGET_ADDRESS, "TargetAddress", KT_TEXT, B_TRUE},
	{ KI_TARGET_PORTAL_GROUP_TAG, "TargetPortalGroupTag",
	    KT_NUMERICAL, B_TRUE },
	{ KI_INITIAL_R2T, "InitialR2T", KT_BOOLEAN, B_FALSE },
	{ KI_IMMEDIATE_DATA, "ImmediateData", KT_BOOLEAN, B_FALSE },
	{ KI_MAX_RECV_DATA_SEGMENT_LENGTH, "MaxRecvDataSegmentLength",
	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_TRUE },
	{ KI_MAX_BURST_LENGTH, "MaxBurstLength",
	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
	{ KI_FIRST_BURST_LENGTH, "FirstBurstLength",
	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
	{ KI_DEFAULT_TIME_2_WAIT, "DefaultTime2Wait",
	    KT_NUMERICAL /* 0 to 2600 */, B_FALSE },
	{ KI_DEFAULT_TIME_2_RETAIN, "DefaultTime2Retain",
	    KT_NUMERICAL /* 0 to 2600 */, B_FALSE },
	{ KI_MAX_OUTSTANDING_R2T, "MaxOutstandingR2T",
	    KT_NUMERICAL /* 1 to 65535 */, B_FALSE },
	{ KI_DATA_PDU_IN_ORDER, "DataPDUInOrder", KT_BOOLEAN, B_FALSE },
	{ KI_DATA_SEQUENCE_IN_ORDER, "DataSequenceInOrder",
	    KT_BOOLEAN, B_FALSE },
	{ KI_ERROR_RECOVERY_LEVEL, "ErrorRecoveryLevel",
	    KT_NUMERICAL /* 0 to 2 */, B_FALSE },
	{ KI_SESSION_TYPE, "SessionType", KT_TEXT, B_TRUE },
	{ KI_OFMARKER, "OFMarker", KT_BOOLEAN, B_FALSE },
	{ KI_OFMARKERINT, "OFMarkerInt", KT_NUMERIC_RANGE, B_FALSE },
	{ KI_IFMARKER, "IFMarker", KT_BOOLEAN, B_FALSE },
	{ KI_IFMARKERINT, "IFMarkerInt", KT_NUMERIC_RANGE, B_FALSE },

	/*
	 * iSER-specific keys
	 */
	{ KI_RDMA_EXTENSIONS, "RDMAExtensions", KT_BOOLEAN, B_FALSE },
	{ KI_TARGET_RECV_DATA_SEGMENT_LENGTH, "TargetRecvDataSegmentLength",
	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
	{ KI_INITIATOR_RECV_DATA_SEGMENT_LENGTH,
	    "InitiatorRecvDataSegmentLength",
	    KT_NUMERICAL /* 512 to 2^24 - 1 */, B_FALSE },
	{ KI_MAX_OUTSTANDING_UNEXPECTED_PDUS, "MaxOutstandingUnexpectedPDUs",
	    KT_NUMERICAL /* 2 to 2^32 - 1 | 0 */, B_TRUE },

	/*
	 * Table terminator. The type KT_TEXT will allow the response
	 * value of "NotUnderstood".
	 */
	{ KI_MAX_KEY, NULL, KT_TEXT, B_TRUE } /* Terminator */
};


#define	TEXTBUF_CHUNKSIZE 8192

typedef struct {
	char	*itb_mem;
	int	itb_offset;
	int	itb_mem_len;
} idm_textbuf_t;

/*
 * Ignore all but the following keys during security negotiation
 *
 * SessionType
 * InitiatorName
 * TargetName
 * TargetAddress
 * InitiatorAlias
 * TargetAlias
 * TargetPortalGroupTag
 * AuthMethod and associated auth keys
 */

static int idm_keyvalue_get_next(char **tb_scan, int *tb_len,
    char **key, int *keylen, char **value);

static int idm_nvlist_add_kv(nvlist_t *nvl, const idm_kv_xlate_t *ikvx,
    char *value);

static int idm_nvlist_add_string(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_nvlist_add_boolean(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_nvlist_add_binary(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_nvlist_add_large_numerical(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_nvlist_add_numerical(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_nvlist_add_numeric_range(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_nvlist_add_list_of_values(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value);

static int idm_itextbuf_add_nvpair(nvpair_t *nvp, idm_textbuf_t *itb);

static int idm_itextbuf_add_string(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static int idm_itextbuf_add_boolean(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static int idm_itextbuf_add_binary(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static int idm_itextbuf_add_large_numerical(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static int idm_itextbuf_add_numerical(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static int idm_itextbuf_add_numeric_range(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static int idm_itextbuf_add_list_of_values(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb);

static void textbuf_memcpy(idm_textbuf_t *itb, void *mem, int mem_len);

static void textbuf_strcpy(idm_textbuf_t *itb, char *str);

static void textbuf_append_char(idm_textbuf_t *itb, char c);

static void textbuf_terminate_kvpair(idm_textbuf_t *itb);

static int idm_ascii_to_hex(char *enc_hex_byte, uint8_t *bin_val);

static int idm_base16_str_to_binary(char *hstr, int hstr_len,
    uint8_t *binary, int binary_length);

static size_t idm_strcspn(const char *string, const char *charset);

static size_t idm_strnlen(const char *str, size_t maxlen);

/*
 * Processes all whole iSCSI name-value pairs in a text buffer and adds
 * a corresponding Solaris nvpair_t to the provided nvlist.  If the last
 * iSCSI name-value pair in textbuf is truncated (which can occur when
 * the request spans multiple PDU's) then upon return textbuf will
 * point to the truncated iSCSI name-value pair in the buffer and
 * textbuflen will contain the remaining bytes in the buffer.  The
 * caller can save off this fragment of the iSCSI name-value pair for
 * use when the next PDU in the request arrives.
 *
 * textbuflen includes the trailing 0x00!
 */

int
idm_textbuf_to_nvlist(nvlist_t *nvl, char **textbuf, int *textbuflen)
{
	int rc = 0;
	char *tbscan, *key, *value;
	int tblen, keylen;

	tbscan = *textbuf;
	tblen = *textbuflen;

	for (;;) {
		if ((rc = idm_keyvalue_get_next(&tbscan, &tblen,
		    &key, &keylen, &value)) != 0) {
			/* There was a problem reading the key/value pair */
			break;
		}

		if ((rc = idm_nvlist_add_keyvalue(nvl,
		    key, keylen, value)) != 0) {
			/* Something was wrong with either the key or value */
			break;
		}

		if (tblen == 0) {
			/* End of text buffer */
			break;
		}
	}

	*textbuf = tbscan;
	*textbuflen = tblen;

	return (rc);
}

/*
 * If a test buffer starts with an ISCSI name-value pair fragment (a
 * continuation from a previous buffer) return the length of the fragment
 * contained in this buffer.  We do not handle name-value pairs that span
 * more than two buffers so if this buffer does not contain the remainder
 * of the name value pair the function will return 0.  If the first
 * name-value pair in the buffer is complete the functionw will return 0.
 */
int
idm_textbuf_to_firstfraglen(void *textbuf, int textbuflen)
{
	return (idm_strnlen(textbuf, textbuflen));
}

static int
idm_keyvalue_get_next(char **tb_scan, int *tb_len,
    char **key, int *keylen, char **value)
{
	/*
	 * Caller doesn't need "valuelen" returned since "value" will
	 * always be a NULL-terminated string.
	 */
	size_t total_len, valuelen;

	/*
	 * How many bytes to the first '\0'?  This represents the total
	 * length of our iSCSI key/value pair.
	 */
	total_len = idm_strnlen(*tb_scan, *tb_len);
	if (total_len == *tb_len) {
		/*
		 * No '\0', perhaps this key/value pair is continued in
		 * another buffer
		 */
		return (E2BIG);
	}

	/*
	 * Found NULL, so this is a possible key-value pair.  At
	 * the same time we've validated that there is actually a
	 * NULL in this string so it's safe to use regular
	 * string functions (i.e. strcpy instead of strncpy)
	 */
	*key = *tb_scan;
	*keylen = idm_strcspn(*tb_scan, "=");

	if (*keylen == total_len) {
		/* No '=', bad format */
		return (EINVAL);
	}

	*tb_scan += *keylen + 1; /* Skip the '=' */
	*tb_len -= *keylen + 1;

	/*
	 * The remaining text after the '=' is the value
	 */
	*value = *tb_scan;
	valuelen = total_len - (*keylen + 1);

	*tb_scan += valuelen + 1; /* Skip the '\0' */
	*tb_len -= valuelen + 1;

	return (0);
}

const idm_kv_xlate_t *
idm_lookup_kv_xlate(const char *key, int keylen)
{
	const idm_kv_xlate_t *ikvx = &idm_kvpair_xlate[0];

	/*
	 * Look for a matching key value in the key/value pair table.
	 * The matching entry in the table will tell us how to encode
	 * the key and value in the nvlist.  If we don't recognize
	 * the key then we will simply encode it in string format.
	 * The login or text request code can generate the appropriate
	 * "not understood" resposne.
	 */
	while (ikvx->ik_key_id != KI_MAX_KEY) {
		/*
		 * Compare strings.  "key" is not NULL-terminated so
		 * use strncmp.  Since we are using strncmp we
		 * need to check that the lengths match, otherwise
		 * we might unintentionally lookup "TargetAddress"
		 * with a key of "Target" (or something similar).
		 *
		 * "value" is NULL-terminated so we can use it as
		 * a regular string.
		 */
		if ((strncmp(ikvx->ik_key_name, key, keylen) == 0) &&
		    (strlen(ikvx->ik_key_name) == keylen)) {
			/* Exit the loop since we found a match */
			break;
		}

		/* No match, look at the next entry */
		ikvx++;
	}

	return (ikvx);
}

static int
idm_nvlist_add_kv(nvlist_t *nvl,  const idm_kv_xlate_t *ikvx, char *value)
{
	int rc;

	switch (ikvx->ik_idm_type) {
	case KT_TEXT:
	case KT_SIMPLE:
	case KT_ISCSI_NAME:
	case KT_ISCSI_LOCAL_NAME:
		rc = idm_nvlist_add_string(nvl, ikvx, value);
		break;
	case KT_BOOLEAN:
		rc = idm_nvlist_add_boolean(nvl, ikvx, value);
		break;
	case KT_REGULAR_BINARY:
	case KT_LARGE_BINARY:
	case KT_BINARY:
		rc = idm_nvlist_add_binary(nvl, ikvx, value);
		break;
	case KT_LARGE_NUMERICAL:
		rc = idm_nvlist_add_large_numerical(nvl, ikvx,
		    value);
		break;
	case KT_NUMERICAL:
		rc = idm_nvlist_add_numerical(nvl, ikvx,
		    value);
		break;
	case KT_NUMERIC_RANGE:
		rc = idm_nvlist_add_numeric_range(nvl, ikvx,
		    value);
		break;
	case KT_LIST_OF_VALUES:
		rc = idm_nvlist_add_list_of_values(nvl, ikvx,
		    value);
		break;
	default:
		ASSERT(0); /* This should never happen */
		break;
	}
	if (rc != 0) {
		/* could be one of the text constants */
		rc = idm_nvlist_add_string(nvl, ikvx, value);
	}

	return (rc);
}

static int
idm_nvlist_add_string(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value)
{
	return (nvlist_add_string(nvl, ikvx->ik_key_name, value));
}

static int
idm_nvlist_add_boolean(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value)
{
	int rc;
	boolean_t bool_val;

	if (strcasecmp(value, "Yes") == 0) {
		bool_val = B_TRUE;
	} else if (strcasecmp(value, "No") == 0) {
		bool_val = B_FALSE;
	} else {
		return (EINVAL);
	}

	rc = nvlist_add_boolean_value(nvl, ikvx->ik_key_name, bool_val);

	return (rc);
}

static boolean_t
kv_is_hex(char *value)
{
	return ((strncmp(value, "0x", strlen("0x")) == 0) ||
	    (strncmp(value, "0X", strlen("0X")) == 0));
}

static boolean_t
kv_is_base64(char *value)
{
	return ((strncmp(value, "0b", strlen("0b")) == 0) ||
	    (strncmp(value, "0B", strlen("0B")) == 0));
}


static int
idm_nvlist_add_binary(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value)
{
	int		rc;
	int		value_length;
	uint64_t	uint64_value;
	int		binary_length;
	uchar_t		*binary_array;

	/*
	 * A binary value can be either decimal, hex or base64.  If it's
	 * decimal then the encoded string must be less than 64 bits in
	 * length (8 characters).  In all cases we will convert the
	 * included value to a byte array starting with the MSB.  The
	 * assumption is that values meant to be treated as integers will
	 * use the "numerical" and "large numerical" types.
	 */
	if (kv_is_hex(value)) {
		value += strlen("0x");
		value_length = strlen(value);
		binary_length = (value_length + 1) / 2;
		binary_array = kmem_alloc(binary_length, KM_SLEEP);

		if (idm_base16_str_to_binary(value, value_length,
		    binary_array, binary_length) != 0) {
			kmem_free(binary_array, binary_length);
			return (EINVAL);
		}

		rc = nvlist_add_byte_array(nvl, ikvx->ik_key_name,
		    binary_array, binary_length);

		kmem_free(binary_array, binary_length);

		return (rc);

	} else if (kv_is_base64(value)) {
		value += strlen("0b");
		value_length = strlen(value);
		binary_array = kmem_alloc(value_length, KM_NOSLEEP);
		if (binary_array == NULL) {
			return (ENOMEM);
		}

		if (iscsi_base64_str_to_binary(value, value_length,
		    binary_array, value_length, &binary_length) != 0) {
			kmem_free(binary_array, value_length);
			return (EINVAL);
		}

		rc = nvlist_add_byte_array(nvl, ikvx->ik_key_name,
		    binary_array, binary_length);

		kmem_free(binary_array, value_length);

		return (rc);
	} else {
		/*
		 * Decimal value (not permitted for "large-binary_value" so
		 * it must be smaller than 64 bits.  It's not really
		 * clear from the RFC what a decimal-binary-value might
		 * represent but presumably it should be treated the same
		 * as a hex or base64 value.  Therefore we'll convert it
		 * to an array of bytes.
		 */
		if ((rc = ddi_strtoull(value, NULL, 0,
		    (u_longlong_t *)&uint64_value)) != 0)
			return (rc);

		rc = nvlist_add_byte_array(nvl, ikvx->ik_key_name,
		    (uint8_t *)&uint64_value, sizeof (uint64_value));

		return (rc);
	}

	/* NOTREACHED */
}


static int
idm_nvlist_add_large_numerical(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value)
{
	/*
	 * A "large numerical" value can be larger than 64-bits.  Since
	 * there is no upper bound on the size of the value, we will
	 * punt and store it in string form.  We could also potentially
	 * treat the value as binary data.
	 */
	return (nvlist_add_string(nvl, ikvx->ik_key_name, value));
}


static int
idm_nvlist_add_numerical(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value)
{
	int rc;
	uint64_t uint64_value;

	/*
	 * "Numerical" values in the iSCSI standard are up to 64-bits wide.
	 * On a 32-bit system we could see an overflow here during conversion.
	 * This shouldn't happen with real-world values for the current
	 * iSCSI parameters of "numerical" type.
	 */
	rc = ddi_strtoull(value, NULL, 0, (u_longlong_t *)&uint64_value);
	if (rc == 0) {
		rc = nvlist_add_uint64(nvl, ikvx->ik_key_name, uint64_value);
	}

	return (rc);
}


static int
idm_nvlist_add_numeric_range(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *range)
{
	nvlist_t *range_nvl;
	char *val_scan = range;
	uint64_t start_val, end_val;
	int val_len, range_len;
	int rc;

	/* We'll store the range an an nvlist with two values */
	rc = nvlist_alloc(&range_nvl, NV_UNIQUE_NAME, KM_NOSLEEP);
	if (rc != 0) {
		return (rc);
	}

	/*
	 * We expect idm_keyvalue_get_next to ensure the string is
	 * terminated
	 */
	range_len = strlen(range);

	/*
	 * Find range separator
	 */
	val_len = idm_strcspn(val_scan, "~");

	if (val_len == range_len) {
		/* invalid range */
		nvlist_free(range_nvl);
		return (EINVAL);
	}

	/*
	 * Start value
	 */
	*(val_scan + val_len + 1) = '\0';
	rc = ddi_strtoull(val_scan, NULL, 0, (u_longlong_t *)&start_val);
	if (rc == 0) {
		rc = nvlist_add_uint64(range_nvl, "start", start_val);
	}
	if (rc != 0) {
		nvlist_free(range_nvl);
		return (rc);
	}

	/*
	 * End value
	 */
	val_scan += val_len + 1;
	rc = ddi_strtoull(val_scan, NULL, 0, (u_longlong_t *)&end_val);
	if (rc == 0) {
		rc = nvlist_add_uint64(range_nvl, "start", end_val);
	}
	if (rc != 0) {
		nvlist_free(range_nvl);
		return (rc);
	}

	/*
	 * Now add the "range" nvlist to the main nvlist
	 */
	rc = nvlist_add_nvlist(nvl, ikvx->ik_key_name, range_nvl);
	if (rc != 0) {
		nvlist_free(range_nvl);
		return (rc);
	}

	nvlist_free(range_nvl);
	return (0);
}


static int
idm_nvlist_add_list_of_values(nvlist_t *nvl,
    const idm_kv_xlate_t *ikvx, char *value_list)
{
	char value_name[8];
	nvlist_t *value_list_nvl;
	char *val_scan = value_list;
	int value_index = 0;
	int val_len, val_list_len;
	int rc;

	rc = nvlist_alloc(&value_list_nvl, NV_UNIQUE_NAME, KM_NOSLEEP);
	if (rc != 0) {
		return (rc);
	}

	/*
	 * We expect idm_keyvalue_get_next to ensure the string is
	 * terminated
	 */
	val_list_len = strlen(value_list);
	if (val_list_len == 0) {
		nvlist_free(value_list_nvl);
		return (EINVAL);
	}

	for (;;) {
		(void) snprintf(value_name, 8, "value%d", value_index);

		val_len = idm_strcspn(val_scan, ",");

		if (*(val_scan + val_len) != '\0') {
			*(val_scan + val_len) = '\0';
		}
		rc = nvlist_add_string(value_list_nvl, value_name, val_scan);
		if (rc != 0) {
			nvlist_free(value_list_nvl);
			return (rc);
		}

		/*
		 * Move to next value, see if we're at the end of the value
		 * list
		 */
		val_scan += val_len + 1;
		if (val_scan == value_list + val_list_len + 1) {
			break;
		}

		value_index++;
	}

	rc = nvlist_add_nvlist(nvl, ikvx->ik_key_name, value_list_nvl);
	if (rc != 0) {
		nvlist_free(value_list_nvl);
		return (rc);
	}

	nvlist_free(value_list_nvl);
	return (0);
}

/*
 * Convert an nvlist containing standard iSCSI key names and values into
 * a text buffer with properly formatted iSCSI key-value pairs ready to
 * transmit on the wire.  *textbuf should be NULL and will be set to point
 * the resulting text buffer.
 */

int
idm_nvlist_to_textbuf(nvlist_t *nvl, char **textbuf, int *textbuflen,
    int *validlen)
{
	int rc = 0;
	nvpair_t *nvp = NULL;
	idm_textbuf_t itb;

	bzero(&itb, sizeof (itb));

	for (;;) {
		nvp = nvlist_next_nvpair(nvl, nvp);

		if (nvp == NULL) {
			/* Last nvpair in nvlist, we're done */
			break;
		}

		if ((rc = idm_itextbuf_add_nvpair(nvp, &itb)) != 0) {
			/* There was a problem building the key/value pair */
			break;
		}
	}

	*textbuf = itb.itb_mem;
	*textbuflen = itb.itb_mem_len;
	*validlen = itb.itb_offset;

	return (rc);
}

static int
idm_itextbuf_add_nvpair(nvpair_t *nvp,
    idm_textbuf_t *itb)
{
	int rc = 0;
	char *key;
	const idm_kv_xlate_t *ikvx;

	key = nvpair_name(nvp);

	ikvx = idm_lookup_kv_xlate(key, strlen(key));

	/*
	 * Any key supplied by the initiator that is not in our table
	 * will be responded to with the string value "NotUnderstood".
	 * An example is a vendor specific key.
	 */
	ASSERT((ikvx->ik_key_id != KI_MAX_KEY) ||
	    (nvpair_type(nvp) == DATA_TYPE_STRING));

	/*
	 * Look for a matching key value in the key/value pair table.
	 * The matching entry in the table will tell us how to encode
	 * the key and value in the nvlist.
	 */
	switch (ikvx->ik_idm_type) {
	case KT_TEXT:
	case KT_SIMPLE:
	case KT_ISCSI_NAME:
	case KT_ISCSI_LOCAL_NAME:
		rc = idm_itextbuf_add_string(nvp, ikvx, itb);
		break;
	case KT_BOOLEAN:
		rc = idm_itextbuf_add_boolean(nvp, ikvx, itb);
		break;
	case KT_REGULAR_BINARY:
	case KT_LARGE_BINARY:
	case KT_BINARY:
		rc = idm_itextbuf_add_binary(nvp, ikvx, itb);
		break;
	case KT_LARGE_NUMERICAL:
		rc = idm_itextbuf_add_large_numerical(nvp, ikvx, itb);
		break;
	case KT_NUMERICAL:
		rc = idm_itextbuf_add_numerical(nvp, ikvx, itb);
		break;
	case KT_NUMERIC_RANGE:
		rc = idm_itextbuf_add_numeric_range(nvp, ikvx, itb);
		break;
	case KT_LIST_OF_VALUES:
		rc = idm_itextbuf_add_list_of_values(nvp, ikvx, itb);
		break;
	default:
		ASSERT(0); /* This should never happen */
		break;
	}

	return (rc);
}

/* ARGSUSED */
static int
idm_itextbuf_add_string(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	char	*key_name;
	char	*value;
	int	rc;

	/* Start with the key name */
	key_name = nvpair_name(nvp);
	textbuf_strcpy(itb, key_name);

	/* Add separator */
	textbuf_append_char(itb, '=');

	/* Add value */
	rc = nvpair_value_string(nvp, &value);
	ASSERT(rc == 0);
	textbuf_strcpy(itb, value);

	/* Add trailing 0x00 */
	textbuf_terminate_kvpair(itb);

	return (0);
}


/* ARGSUSED */
static int
idm_itextbuf_add_boolean(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	char		*key_name;
	boolean_t	value;
	int	rc;

	/* Start with the key name */
	key_name = nvpair_name(nvp);
	textbuf_strcpy(itb, key_name);

	/* Add separator */
	textbuf_append_char(itb, '=');

	/* Add value */
	rc = nvpair_value_boolean_value(nvp, &value);
	ASSERT(rc == 0);
	textbuf_strcpy(itb, value ? "Yes" : "No");

	/* Add trailing 0x00 */
	textbuf_terminate_kvpair(itb);

	return (0);
}

/* ARGSUSED */
static int
idm_itextbuf_add_binary(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	char		*key_name;
	unsigned char	*value;
	unsigned int	len;
	unsigned long	n;
	int	rc;

	/* Start with the key name */
	key_name = nvpair_name(nvp);
	textbuf_strcpy(itb, key_name);

	/* Add separator */
	textbuf_append_char(itb, '=');

	/* Add value */
	rc = nvpair_value_byte_array(nvp, &value, &len);
	ASSERT(rc == 0);

	textbuf_strcpy(itb, "0x");

	while (len > 0) {
		n = *value++;
		len--;

		textbuf_append_char(itb, idm_hex_to_ascii[(n >> 4) & 0xf]);
		textbuf_append_char(itb, idm_hex_to_ascii[n & 0xf]);
	}

	/* Add trailing 0x00 */
	textbuf_terminate_kvpair(itb);

	return (0);
}

/* ARGSUSED */
static int
idm_itextbuf_add_large_numerical(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	ASSERT(0);
	return (0);
}

/* ARGSUSED */
static int
idm_itextbuf_add_numerical(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	char		*key_name;
	uint64_t	value;
	int	rc;
	char		str[16];

	/* Start with the key name */
	key_name = nvpair_name(nvp);
	textbuf_strcpy(itb, key_name);

	/* Add separator */
	textbuf_append_char(itb, '=');

	/* Add value */
	rc = nvpair_value_uint64(nvp, &value);
	ASSERT(rc == 0);
	(void) sprintf(str, "%llu", (u_longlong_t)value);
	textbuf_strcpy(itb, str);

	/* Add trailing 0x00 */
	textbuf_terminate_kvpair(itb);

	return (0);
}

/* ARGSUSED */
static int
idm_itextbuf_add_numeric_range(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	ASSERT(0);
	return (0);
}

/* ARGSUSED */
static int
idm_itextbuf_add_list_of_values(nvpair_t *nvp,
    const idm_kv_xlate_t *ikvx, idm_textbuf_t *itb)
{
	char		*key_name;
	nvpair_t	*vchoice = NULL;
	char		*vchoice_string = NULL;
	int		rc;

	/* Start with the key name */
	key_name = nvpair_name(nvp);
	textbuf_strcpy(itb, key_name);

	/* Add separator */
	textbuf_append_char(itb, '=');

	/* Add value choices */
	vchoice = idm_get_next_listvalue(nvp, NULL);
	while (vchoice != NULL) {
		rc = nvpair_value_string(vchoice, &vchoice_string);
		ASSERT(rc == 0);
		textbuf_strcpy(itb, vchoice_string);
		vchoice = idm_get_next_listvalue(nvp, vchoice);
		if (vchoice != NULL) {
			/* Add ',' between choices */
			textbuf_append_char(itb, ',');
		}
	}

	/* Add trailing 0x00 */
	textbuf_terminate_kvpair(itb);

	return (0);
}


static void
textbuf_makeroom(idm_textbuf_t *itb, int size)
{
	char	*new_mem;
	int	new_mem_len;

	if (itb->itb_mem == NULL) {
		itb->itb_mem_len = MAX(TEXTBUF_CHUNKSIZE, size);
		itb->itb_mem = kmem_alloc(itb->itb_mem_len, KM_SLEEP);
	} else if ((itb->itb_offset + size) > itb->itb_mem_len) {
		new_mem_len = itb->itb_mem_len + MAX(TEXTBUF_CHUNKSIZE, size);
		new_mem = kmem_alloc(new_mem_len, KM_SLEEP);
		bcopy(itb->itb_mem, new_mem, itb->itb_mem_len);
		kmem_free(itb->itb_mem, itb->itb_mem_len);
		itb->itb_mem = new_mem;
		itb->itb_mem_len = new_mem_len;
	}
}

static void
textbuf_memcpy(idm_textbuf_t *itb, void *mem, int mem_len)
{
	textbuf_makeroom(itb, mem_len);
	(void) memcpy(itb->itb_mem + itb->itb_offset, mem, mem_len);
	itb->itb_offset += mem_len;
}

static void
textbuf_strcpy(idm_textbuf_t *itb, char *str)
{
	textbuf_memcpy(itb, str, strlen(str));
}

static void
textbuf_append_char(idm_textbuf_t *itb, char c)
{
	textbuf_makeroom(itb, sizeof (char));
	*(itb->itb_mem + itb->itb_offset) = c;
	itb->itb_offset++;
}

static void
textbuf_terminate_kvpair(idm_textbuf_t *itb)
{
	textbuf_append_char(itb, '\0');
}

static int
idm_ascii_to_hex(char *enc_hex_byte, uint8_t *bin_val)
{
	uint8_t nibble1, nibble2;
	char enc_char = *enc_hex_byte;

	if (enc_char >= '0' && enc_char <= '9') {
		nibble1 = (enc_char - '0');
	} else if (enc_char >= 'A' && enc_char <= 'F') {
		nibble1 = (0xA + (enc_char - 'A'));
	} else if (enc_char >= 'a' && enc_char <= 'f') {
		nibble1 = (0xA + (enc_char - 'a'));
	} else {
		return (EINVAL);
	}

	enc_hex_byte++;
	enc_char = *enc_hex_byte;

	if (enc_char >= '0' && enc_char <= '9') {
		nibble2 = (enc_char - '0');
	} else if (enc_char >= 'A' && enc_char <= 'F') {
		nibble2 = (0xA + (enc_char - 'A'));
	} else if (enc_char >= 'a' && enc_char <= 'f') {
		nibble2 = (0xA + (enc_char - 'a'));
	} else {
		return (EINVAL);
	}

	*bin_val = (nibble1 << 4) | nibble2;

	return (0);
}


static int idm_base16_str_to_binary(char *hstr, int hstr_len,
    uint8_t *binary_array, int binary_length)
{
	char	tmpstr[2];
	uchar_t *binary_scan;

	binary_scan = binary_array;

	/*
	 * If the length of the encoded ascii hex value is a multiple
	 * of two then every two ascii characters correspond to a hex
	 * byte.  If the length of the value is not a multiple of two
	 * then the first character is the first hex byte and then for
	 * the remaining of the string every two ascii characters
	 * correspond to a hex byte
	 */
	if ((hstr_len % 2) != 0) {

		tmpstr[0] = '0';
		tmpstr[1] = *hstr;

		if (idm_ascii_to_hex(tmpstr, binary_scan) != 0) {
			return (EINVAL);
		}

		hstr++;
		binary_scan++;
	}

	while (binary_scan != binary_array + binary_length) {
		if (idm_ascii_to_hex(hstr, binary_scan) != 0) {
			return (EINVAL);
		}

		hstr += 2;
		binary_scan++;
	}

	return (0);
}

static size_t
idm_strnlen(const char *str, size_t maxlen)
{
	const char *ptr;

	ptr = memchr(str, 0, maxlen);
	if (ptr == NULL)
		return (maxlen);

	return ((uintptr_t)ptr - (uintptr_t)str);
}


size_t
idm_strcspn(const char *string, const char *charset)
{
	const char *p, *q;

	for (q = string; *q != '\0'; ++q) {
		for (p = charset; *p != '\0' && *p != *q; )
			p++;
		if (*p != '\0') {
			break;
		}
	}
	return ((uintptr_t)q - (uintptr_t)string);
}

/*
 * We allow a list of choices to be represented as a single nvpair
 * (list with one value choice), or as an nvlist with a single nvpair
 * (also a list with on value choice), or as an nvlist with multiple
 * nvpairs (a list with multiple value choices).  This function implements
 * the "get next" functionality regardless of the choice list structure.
 *
 * nvpair_t's that contain choices are always strings.
 */
nvpair_t *
idm_get_next_listvalue(nvpair_t *value_list, nvpair_t *curr_nvp)
{
	nvpair_t	*result;
	nvlist_t	*nvl;
	int		nvrc;
	data_type_t	nvp_type;

	nvp_type = nvpair_type(value_list);

	switch (nvp_type) {
	case DATA_TYPE_NVLIST:
		nvrc = nvpair_value_nvlist(value_list, &nvl);
		ASSERT(nvrc == 0);
		result = nvlist_next_nvpair(nvl, curr_nvp);
		break;
	case DATA_TYPE_STRING:
		/* Single choice */
		if (curr_nvp == NULL) {
			result = value_list;
		} else {
			result = NULL;
		}
		break;
	default:
		ASSERT(0); /* Malformed choice list */
		result = NULL;
		break;
	}

	return (result);
}

kv_status_t
idm_nvstat_to_kvstat(int nvrc)
{
	kv_status_t result;
	switch (nvrc) {
	case 0:
		result = KV_HANDLED;
		break;
	case ENOMEM:
		result = KV_NO_RESOURCES;
		break;
	case EINVAL:
		result = KV_VALUE_ERROR;
		break;
	case EFAULT:
	case ENOTSUP:
	default:
		result = KV_INTERNAL_ERROR;
		break;
	}

	return (result);
}

void
idm_kvstat_to_error(kv_status_t kvrc, uint8_t *class, uint8_t *detail)
{
	switch (kvrc) {
	case KV_HANDLED:
	case KV_HANDLED_NO_TRANSIT:
		*class = ISCSI_STATUS_CLASS_SUCCESS;
		*detail = ISCSI_LOGIN_STATUS_ACCEPT;
		break;
	case KV_UNHANDLED:
	case KV_TARGET_ONLY:
		/* protocol error */
		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
		*detail = ISCSI_LOGIN_STATUS_INVALID_REQUEST;
		break;
	case KV_VALUE_ERROR:
		/* invalid value */
		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
		*detail = ISCSI_LOGIN_STATUS_INIT_ERR;
		break;
	case KV_NO_RESOURCES:
		/* no memory */
		*class = ISCSI_STATUS_CLASS_TARGET_ERR;
		*detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
		break;
	case KV_MISSING_FIELDS:
		/* key/value pair(s) missing */
		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
		*detail = ISCSI_LOGIN_STATUS_MISSING_FIELDS;
		break;
	case KV_AUTH_FAILED:
		/* authentication failed */
		*class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
		*detail = ISCSI_LOGIN_STATUS_AUTH_FAILED;
		break;
	default:
		/* target error */
		*class = ISCSI_STATUS_CLASS_TARGET_ERR;
		*detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
		break;
	}
}

int
idm_nvlist_add_keyvalue(nvlist_t *nvl,
    char *key, int keylen, char *value)
{
	const idm_kv_xlate_t *ikvx;

	ikvx = idm_lookup_kv_xlate(key, keylen);

	if (ikvx->ik_key_id == KI_MAX_KEY) {
		char *nkey;
		int rc;
		size_t len;

		/*
		 * key is not a NULL terminated string, so create one
		 */
		len = (size_t)(keylen+1);
		nkey = kmem_zalloc(len, KM_SLEEP);
		(void) strncpy(nkey, key, len-1);
		rc = nvlist_add_string(nvl, nkey, value);
		kmem_free(nkey, len);
		return (rc);
	}

	return (idm_nvlist_add_kv(nvl, ikvx, value));
}

int
idm_nvlist_add_id(nvlist_t *nvl, iscsikey_id_t kv_id, char *value)
{
	int i;
	for (i = 0; i < KI_MAX_KEY; i++) {
		if (idm_kvpair_xlate[i].ik_key_id == kv_id) {
			return
			    (idm_nvlist_add_kv(nvl,
			    &idm_kvpair_xlate[i], value));
		}
	}
	return (EFAULT);
}

char *
idm_id_to_name(iscsikey_id_t kv_id)
{
	int i;
	for (i = 0; i < KI_MAX_KEY; i++) {
		if (idm_kvpair_xlate[i].ik_key_id == kv_id) {
			return (idm_kvpair_xlate[i].ik_key_name);
		}
	}
	return (NULL);
}

/*
 * return the value in a buffer that must be freed by the caller
 */
char *
idm_nvpair_value_to_textbuf(nvpair_t *nvp)
{
	int rv, len;
	idm_textbuf_t itb;
	char *str;

	bzero(&itb, sizeof (itb));
	rv = idm_itextbuf_add_nvpair(nvp, &itb);
	if (rv != 0)
		return (NULL);
	str = kmem_alloc(itb.itb_mem_len, KM_SLEEP);
	len = idm_strcspn(itb.itb_mem, "=");
	if (len > strlen(itb.itb_mem)) {
		kmem_free(itb.itb_mem, itb.itb_mem_len);
		return (NULL);
	}
	(void) strcpy(str, &itb.itb_mem[len+1]);
	/* free the allocation done in idm_textbuf_add_nvpair */
	kmem_free(itb.itb_mem, itb.itb_mem_len);
	return (str);
}

/*
 * build an iscsi text buffer - the memory gets freed in
 * idm_itextbuf_free
 */
void *
idm_nvlist_to_itextbuf(nvlist_t *nvl)
{
	idm_textbuf_t *itb;
	char		*textbuf;
	int		validlen, textbuflen;

	if (idm_nvlist_to_textbuf(nvl, &textbuf, &textbuflen,
	    &validlen) != IDM_STATUS_SUCCESS) {
		return (NULL);
	}
	itb = kmem_zalloc(sizeof (idm_textbuf_t), KM_SLEEP);
	ASSERT(itb != NULL);
	itb->itb_mem = textbuf;
	itb->itb_mem_len = textbuflen;
	itb->itb_offset = validlen;
	return ((void *)itb);
}

/*
 * Copy as much of the text buffer as will fit in the pdu.
 * The first call to this routine should send
 * a NULL bufptr. Subsequent calls send in the buffer returned.
 * Call this routine until the string returned is NULL
 */
char *
idm_pdu_init_text_data(idm_pdu_t *pdu, void *arg,
    int max_xfer_len, char *bufptr, int *transit)
{
	char		*start_ptr, *end_ptr, *ptr;
	idm_textbuf_t	*itb = arg;
	iscsi_hdr_t	*ihp = pdu->isp_hdr;
	int		send = 0;

	ASSERT(itb != NULL);
	ASSERT(pdu != NULL);
	ASSERT(transit != NULL);
	if (bufptr == NULL) {
		/* first call - check the length */
		if (itb->itb_offset <= max_xfer_len) {
			/*
			 * the entire text buffer fits in the pdu
			 */
			bcopy((uint8_t *)itb->itb_mem, pdu->isp_data,
			    (size_t)itb->itb_offset);
			pdu->isp_datalen = itb->itb_offset;
			ihp->flags &= ~ISCSI_FLAG_TEXT_CONTINUE;
			*transit = 1;
			return (NULL);
		}
		/* we have more data than will fit in one pdu */
		start_ptr = itb->itb_mem;
		end_ptr = &itb->itb_mem[max_xfer_len - 1];

	} else {
		uint_t len;

		len =  (uintptr_t)&itb->itb_mem[itb->itb_offset] -
		    (uintptr_t)bufptr;
		if (len <= max_xfer_len) {
			/*
			 * the remaining text fits in the pdu
			 */
			bcopy(bufptr, pdu->isp_data, (size_t)len);
			pdu->isp_datalen = len;
			ihp->flags &= ~ISCSI_FLAG_TEXT_CONTINUE;
			*transit = 1;
			return (NULL);
		}
		/* we still have more data then will fit in one pdu */
		start_ptr = bufptr;
		end_ptr = &bufptr[max_xfer_len - 1];
	}
	/* break after key, after =, after the value or after '\0' */
	ptr = end_ptr;
	if (end_ptr + 1 <= &itb->itb_mem[itb->itb_offset]) {
		/* if next char is an '=' or '\0' send it */
		if (*(end_ptr + 1) == '=' || *(end_ptr + 1) == '\0') {
			send = 1;
		}
	}
	if (!send) {
		while (*ptr != '\0' && *ptr != '=' && ptr != start_ptr) {
			ptr--;
		}
	}
	bcopy(start_ptr, pdu->isp_data,
	    ((uintptr_t)ptr - (uintptr_t)start_ptr) + 1);
	pdu->isp_datalen = ((uintptr_t)ptr - (uintptr_t)start_ptr) + 1;
	ihp->flags |= ISCSI_FLAG_TEXT_CONTINUE;
	*transit = 0;
	return (++ptr);
}

void
idm_itextbuf_free(void *arg)
{
	idm_textbuf_t	*itb = arg;
	ASSERT(itb != NULL);
	kmem_free(itb->itb_mem, itb->itb_mem_len);
	kmem_free(itb, sizeof (idm_textbuf_t));
}

/*
 * Allocate an nvlist and poputlate with key=value from the pdu list.
 * NOTE: caller must free the list
 */
idm_status_t
idm_pdu_list_to_nvlist(list_t *pdu_list, nvlist_t **nvlist,
    uint8_t *error_detail)
{
	idm_pdu_t		*pdu, *next_pdu;
	boolean_t		split_kv = B_FALSE;
	char			*textbuf, *leftover_textbuf = NULL;
	int			textbuflen, leftover_textbuflen = 0;
	char			*split_kvbuf;
	int			split_kvbuflen, cont_fraglen;
	iscsi_login_hdr_t	*lh;
	int			rc;
	int			ret = IDM_STATUS_SUCCESS;

	*error_detail = ISCSI_LOGIN_STATUS_ACCEPT;
	/* Allocate a new nvlist for request key/value pairs */
	rc = nvlist_alloc(nvlist, NV_UNIQUE_NAME,
	    KM_NOSLEEP);
	if (rc != 0) {
		*error_detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
		ret = IDM_STATUS_FAIL;
		goto cleanup;
	}

	/*
	 * A login request can be split across multiple PDU's.  The state
	 * machine has collected all the PDU's that make up this login request
	 * and assembled them on the "icl_pdu_list" queue.  Process each PDU
	 * and convert the text keywords to nvlist form.
	 */
	pdu = list_head(pdu_list);
	while (pdu != NULL) {
		next_pdu = list_next(pdu_list, pdu);

		lh = (iscsi_login_hdr_t *)pdu->isp_hdr;

		textbuf = (char *)pdu->isp_data;
		textbuflen = pdu->isp_datalen;
		if (textbuflen == 0) {
			/* This shouldn't really happen but it could.. */
			list_remove(pdu_list, pdu);
			idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
			pdu = next_pdu;
			continue;
		}

		/*
		 * If we encountered a split key-value pair on the last
		 * PDU then handle it now by grabbing the remainder of the
		 * key-value pair from the next PDU and splicing them
		 * together.  Obviously on the first PDU this will never
		 * happen.
		 */
		if (split_kv) {
			cont_fraglen = idm_textbuf_to_firstfraglen(textbuf,
			    textbuflen);
			if (cont_fraglen == pdu->isp_datalen) {
				/*
				 * This key-value pair spans more than two
				 * PDU's.  We don't handle this.
				 */
				*error_detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
				ret = IDM_STATUS_FAIL;
				goto cleanup;
			}

			split_kvbuflen = leftover_textbuflen + cont_fraglen;
			split_kvbuf = kmem_alloc(split_kvbuflen, KM_NOSLEEP);
			if (split_kvbuf == NULL) {
				*error_detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
				ret = IDM_STATUS_FAIL;
				goto cleanup;
			}

			bcopy(leftover_textbuf, split_kvbuf,
			    leftover_textbuflen);
			bcopy(textbuf,
			    (uint8_t *)split_kvbuf + leftover_textbuflen,
			    cont_fraglen);


			if (idm_textbuf_to_nvlist(*nvlist,
			    &split_kvbuf, &split_kvbuflen) != 0) {
				/*
				 * Need to handle E2BIG case, indicating that
				 * a key-value pair is split across multiple
				 * PDU's.
				 */
				kmem_free(split_kvbuf, split_kvbuflen);

				*error_detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
				ret = IDM_STATUS_FAIL;
				goto cleanup;
			}

			ASSERT(split_kvbuflen != 0);
			kmem_free(split_kvbuf, split_kvbuflen);

			/* Now handle the remainder of the PDU as normal */
			textbuf += (cont_fraglen + 1);
			textbuflen -= (cont_fraglen + 1);
		}

		/*
		 * Convert each key-value pair in the text buffer to nvlist
		 * format.  If the list has already been created the nvpair
		 * elements will be added on to the existing list.  Otherwise
		 * a new nvlist will be created.
		 */
		if (idm_textbuf_to_nvlist(*nvlist,
		    &textbuf, &textbuflen) != 0) {

			*error_detail = ISCSI_LOGIN_STATUS_TARGET_ERROR;
			ret = IDM_STATUS_FAIL;
			goto cleanup;
		}

		ASSERT(
		    ((lh->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
		    (next_pdu != NULL)) ||
		    (!(lh->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
		    (next_pdu == NULL)));

		if ((lh->flags & ISCSI_FLAG_LOGIN_CONTINUE) &
		    (textbuflen != 0)) {
			/*
			 * Key-value pair is split over two PDU's.  We
			 * assume it willl never be split over more than
			 * two PDU's.
			 */
			split_kv = B_TRUE;
			leftover_textbuf = textbuf;
			leftover_textbuflen = textbuflen;
		} else {
			split_kv = B_FALSE;
			if (textbuflen != 0) {
				/*
				 * Incomplete keyword but no additional
				 * PDU's.  This is a malformed login
				 * request.
				 */
				*error_detail =
				    ISCSI_LOGIN_STATUS_INVALID_REQUEST;
				ret = IDM_STATUS_FAIL;
				goto cleanup;
			}
		}

		list_remove(pdu_list, pdu);
		idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
		pdu = next_pdu;
	}

cleanup:

	/*
	 * Free any remaining PDUs on the list. This will only
	 * happen if there were errors encountered during
	 * processing of the textbuf.
	 */
	pdu = list_head(pdu_list);
	while (pdu != NULL) {
		next_pdu = list_next(pdu_list, pdu);
		list_remove(pdu_list, pdu);
		idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
		pdu = next_pdu;
	}

	/*
	 * If there were no errors, we have a complete nvlist representing
	 * all the iSCSI key-value pairs in the login request PDU's
	 * that make up this request.
	 */
	return (ret);
}