[SERVER] iscsi: Finish login handling, add NOP-In/Out handling

Also a couple bug fixes and other minor improvements

2 files changed, 1448 insertions, 261 deletions

diff --git a/src/server/iscsi.c b/src/server/iscsi.c
index baee49c..bfda85b 100644
--- a/src/server/iscsi.c
+++ b/src/server/iscsi.c
@@ -24,6 +24,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
+#include <strings.h>
 #include <sys/socket.h>
 #include <dnbd3/shared/log.h>
 #include <time.h>
@@ -42,6 +43,310 @@
  * @see https://www.rfc-editor.org/rfc/rfc7143
  */
 
+/// iSCSI connection negotation key and value pair lookup table.
+static const iscsi_key_value_pair_lut_entry iscsi_connection_key_value_pair_lut[] = {
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_HEADER_DIGEST, (uint8_t *) "None", (uint8_t *) "CRC32C\0None\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_LIST, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_DIGEST, (uint8_t *) "None", (uint8_t *) "CRC32C\0None\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_LIST, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_RECV_DS_LEN, (uint8_t *) "8192", (uint8_t *) "512\016777215\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_MULTI_NEGOTIATION | ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_OVERRIDE_DEFAULT },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_OF_MARKER, (uint8_t *) "No", (uint8_t *) "Yes\0No\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_AND, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_IF_MARKER, (uint8_t *) "No", (uint8_t *) "Yes\0No\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_AND, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_OF_MARK_INT, (uint8_t *) "1", (uint8_t *) "1\0""65535\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_IF_MARK_INT, (uint8_t *) "1", (uint8_t *) "1\0""65535\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD, (uint8_t *) "None", (uint8_t *) "CHAP\0None\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_LIST, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD_CHAP_CHAP_A, (uint8_t *) "5", (uint8_t *) "5\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_LIST, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD_CHAP_CHAP_N, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD_CHAP_CHAP_R, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD_CHAP_CHAP_I, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD_CHAP_CHAP_C, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE },
+	{ NULL, NULL, NULL, ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_INVALID, 0L }
+};
+
+/// iSCSI session negotation key and value pair lookup table.
+static const iscsi_key_value_pair_lut_entry iscsi_session_key_value_pair_lut[] = {
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_CONNECTIONS, (uint8_t *) "1", (uint8_t *) "1\065535\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_SEND_TARGETS, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_SPECIAL_HANDLING },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_NAME, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_TARGET_DECLARATIVE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_INITIATOR_NAME, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ALIAS, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_INITIATOR_ALIAS, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, (uint8_t *) "", (uint8_t *) "\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_TARGET_DECLARATIVE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_PORTAL_GROUP_TAG, (uint8_t *) "1", (uint8_t *) "1\0""65535\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_DECLARATIVE, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_TARGET_DECLARATIVE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_INITIAL_R2T, (uint8_t *) "Yes", (uint8_t *) "Yes\0No\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_OR, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_IMMEDIATE_DATA, (uint8_t *) "Yes", (uint8_t *) "Yes\0No\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_AND, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_BURST_LEN, (uint8_t *) "262144", (uint8_t *) "512\0""16777215\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE | ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_OTHER_MAX_VALUE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_FIRST_BURST_LEN, (uint8_t *) "65536", (uint8_t *) "512\0""16777215\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE | ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_PREVIOUS_VALUE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DEFAULT_TIME_WAIT, (uint8_t *) "2", (uint8_t *) "0\0""3600\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MAX, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DEFAULT_TIME_RETAIN, (uint8_t *) "20", (uint8_t *) "0\0""3600\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_OUTSTANDING_R2T, (uint8_t *) "1", (uint8_t *) "1\0""65536\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_PDU_IN_ORDER, (uint8_t *) "Yes", (uint8_t *) "Yes\0No\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_OR, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_SEQ_IN_ORDER, (uint8_t *) "Yes", (uint8_t *) "Yes\0No\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_OR, ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_ERR_RECOVERY_LEVEL, (uint8_t *) "0", (uint8_t *) "0\0""2\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN, 0L },
+	{ (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_SESSION_TYPE, (uint8_t *) "Normal", (uint8_t *) "Normal\0Discovery\0", ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE, 0L },
+	{ NULL, NULL, NULL, ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_INVALID, 0L }
+};
+
+/**
+ * @brief Initializes a global key and value pair with type and list / range informations for fast access.
+ *
+ * This function is used to initialize the iSCSI
+ * global key and value pair list containing
+ * the key types and allowed values.
+ *
+ * @param[in] key_value_pairs Pointer to key and value pair hash map
+ * which should store the global key and value
+ * informations, may NOT be NULL, so take caution.
+ * @param[in] lut Lookup table to use for initialization.
+ * NULL is not allowed here, so be careful.
+ * @return 0 on success, a negative error code otherwise.
+ */
+static int iscsi_global_key_value_pair_init(iscsi_hashmap *key_value_pairs, const iscsi_key_value_pair_lut_entry *lut)
+{
+	for ( uint i = 0; lut[i].key != NULL; i++ ) {
+		const uint key_len = (uint) strlen( (char *) lut[i].key ) + 1;
+		uint8_t *hash_key = iscsi_hashmap_key_create( lut[i].key, key_len );
+
+		if ( hash_key == NULL ) {
+			logadd( LOG_ERROR, "iscsi_global_key_value_pair_init: Out of memory allocating key" );
+
+			return -1L;
+		}
+
+		iscsi_key_value_pair *key_value_pair = (iscsi_key_value_pair *) malloc( sizeof(struct iscsi_key_value_pair) );
+
+		if ( key_value_pair == NULL ) {
+			logadd( LOG_ERROR, "iscsi_global_key_value_pair_init: Out of memory allocating key value pair" );
+
+			iscsi_hashmap_key_destroy( hash_key );
+
+			return -1L;
+		}
+
+		key_value_pair->value       = lut[i].value;
+		key_value_pair->list_range  = lut[i].list_range;
+		key_value_pair->type        = lut[i].type;
+		key_value_pair->flags       = lut[i].flags;
+		key_value_pair->state_mask  = (1UL << i);
+
+		const int rc = iscsi_hashmap_put( key_value_pairs, hash_key, key_len, (uint8_t *) key_value_pair );
+
+		if ( rc < 0 ) {
+			free( key_value_pair );
+			iscsi_hashmap_key_destroy( hash_key );
+
+			return rc;
+		}
+	}
+
+	return 0L;
+}
+
+/**
+ * @brief Allocates and initializes the iSCSI global vector structure.
+ *
+ * This function MUST be called before any iSCSI
+ * related functions are used.\n
+ * It is safe to call this function if the iSCSI
+ * global vector already has been initialized
+ * in which case this function does nothing.
+ *
+ * @return 0 if the iSCSI global vector has been initialized
+ * successfully and is ready to use, a negative
+ * error code otherwise (memory exhausted).
+ */
+int iscsi_create()
+{
+	if ( iscsi_globvec == NULL ) {
+		iscsi_globals *globvec = (iscsi_globals *) malloc( sizeof(struct iscsi_globals) );
+
+		if ( globvec == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector" );
+
+			return -1L;
+		}
+
+		globvec->devices = iscsi_hashmap_create( 0UL );
+
+		if ( globvec->devices == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector devices hash map" );
+
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->portal_groups = iscsi_hashmap_create( 0UL );
+
+		if ( globvec->portal_groups == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector portal groups hash map" );
+
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->target_nodes = iscsi_hashmap_create( 0UL );
+
+		if ( globvec->target_nodes == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector target nodes hash map" );
+
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->sessions = iscsi_hashmap_create( 0UL );
+
+		if ( globvec->sessions == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector sessions hash map" );
+
+			iscsi_hashmap_destroy( globvec->target_nodes );
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->session_key_value_pairs = iscsi_hashmap_create( 32UL );
+
+		if ( globvec->session_key_value_pairs == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector session key and value pairs hash map" );
+
+			iscsi_hashmap_destroy( globvec->sessions );
+			iscsi_hashmap_destroy( globvec->target_nodes );
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		int rc = iscsi_global_key_value_pair_init( globvec->session_key_value_pairs, &iscsi_session_key_value_pair_lut[1] );
+
+		if ( globvec->connection_key_value_pairs == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while initializing iSCSI global vector session key and value pairs hash map" );
+
+			iscsi_hashmap_iterate( globvec->session_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+			iscsi_hashmap_destroy( globvec->session_key_value_pairs );
+			iscsi_hashmap_destroy( globvec->sessions );
+			iscsi_hashmap_destroy( globvec->target_nodes );
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->connections = iscsi_hashmap_create( 0UL );
+
+		if ( globvec->connections == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector connections hash map" );
+
+			iscsi_hashmap_iterate( globvec->session_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+			iscsi_hashmap_destroy( globvec->session_key_value_pairs );
+			iscsi_hashmap_destroy( globvec->sessions );
+			iscsi_hashmap_destroy( globvec->target_nodes );
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->connection_key_value_pairs = iscsi_hashmap_create( 32UL );
+
+		if ( globvec->connection_key_value_pairs == NULL ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while allocating iSCSI global vector connection key and value pairs hash map" );
+
+			iscsi_hashmap_destroy( globvec->connections );
+			iscsi_hashmap_iterate( globvec->session_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+			iscsi_hashmap_destroy( globvec->session_key_value_pairs );
+			iscsi_hashmap_destroy( globvec->sessions );
+			iscsi_hashmap_destroy( globvec->target_nodes );
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		rc = iscsi_global_key_value_pair_init( globvec->connection_key_value_pairs, &iscsi_connection_key_value_pair_lut[0] );
+
+		if ( rc < 0 ) {
+			logadd( LOG_ERROR, "iscsi_create: Out of memory while initializing iSCSI global vector connection key and value pairs hash map" );
+
+			iscsi_hashmap_iterate( globvec->connection_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+			iscsi_hashmap_destroy( globvec->connection_key_value_pairs );
+			iscsi_hashmap_destroy( globvec->connections );
+			iscsi_hashmap_iterate( globvec->session_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+			iscsi_hashmap_destroy( globvec->session_key_value_pairs );
+			iscsi_hashmap_destroy( globvec->sessions );
+			iscsi_hashmap_destroy( globvec->target_nodes );
+			iscsi_hashmap_destroy( globvec->portal_groups );
+			iscsi_hashmap_destroy( globvec->devices );
+			free( globvec );
+
+			return -1L;
+		}
+
+		globvec->flags        = 0L;
+		globvec->max_sessions = 0UL;
+		globvec->chap_group   = 0L;
+
+		iscsi_globvec = globvec;
+	}
+
+	return 0L;
+}
+
+/**
+ * @brief Deallocates all resources acquired by iscsi_create.
+ *
+ * This function MUST be called before program termination
+ * for ensuring proper clean up.\n
+ * After this function returns, calling any iSCSI related
+ * function except iscsi_create is strictly forbidden.\n
+ * It is safe to call this function if the iSCSI global
+ * vector already has been destroyed in which case this
+ * function does nothing.
+ */
+void iscsi_destroy()
+{
+	iscsi_globals *globvec = iscsi_globvec;
+
+	if ( globvec != NULL ) {
+		iscsi_globvec = NULL;
+
+		iscsi_hashmap_iterate( globvec->connection_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+		iscsi_hashmap_destroy( globvec->connection_key_value_pairs );
+		globvec->connection_key_value_pairs = NULL;
+
+		iscsi_hashmap_destroy( globvec->connections );
+		globvec->connections = NULL;
+
+		iscsi_hashmap_iterate( globvec->session_key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+		iscsi_hashmap_destroy( globvec->session_key_value_pairs );
+		globvec->session_key_value_pairs = NULL;
+
+		iscsi_hashmap_destroy( globvec->sessions );
+		globvec->sessions = NULL;
+
+		iscsi_hashmap_destroy( globvec->target_nodes );
+		globvec->target_nodes = NULL;
+
+		iscsi_hashmap_destroy( globvec->portal_groups );
+		globvec->portal_groups = NULL;
+
+		iscsi_hashmap_destroy( globvec->devices );
+		globvec->devices = NULL;
+
+		free( globvec );
+	}
+}
+
 /**
  * @brief Allocates and appends a buffer and sprintf's it.
  *
@@ -874,7 +1179,7 @@ iscsi_bhs_packet *iscsi_append_ahs_packet(iscsi_bhs_packet *packet_data, const u
 	const uint32_t old_pkt_size = (const uint32_t) sizeof(struct iscsi_bhs_packet) + (packet_data->total_ahs_len << 2UL);
 	const uint32_t new_pkt_size = (uint32_t) (old_pkt_size + iscsi_align(ahs_len, ISCSI_ALIGN_SIZE));
 
-	if ( new_pkt_size > (sizeof(struct iscsi_bhs_packet) + 1020UL) ) {
+	if ( new_pkt_size > (sizeof(struct iscsi_bhs_packet) + ISCSI_MAX_AHS_SIZE) ) {
 		logadd( LOG_ERROR, "iscsi_append_ahs_packet: Total numer of AHS packet size exceeds 255 DWORDs" );
 
 		return NULL;
@@ -1369,7 +1674,7 @@ int iscsi_validate_packet(const struct iscsi_bhs_packet *packet_data, const uint
 			if ( (ISCSI_VERSION_MIN < login_req_pkt->version_min) || (ISCSI_VERSION_MAX > login_req_pkt->version_max) )
 				return ISCSI_VALIDATE_PACKET_RESULT_ERROR_UNSUPPORTED_VERSION;
 
-			if ( (ISCSI_LOGIN_REQ_FLAGS_GET_CURRENT_STAGE(login_req_pkt->flags) == ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_RESERVED) || ((ISCSI_LOGIN_REQ_FLAGS_GET_NEXT_STAGE(login_req_pkt->flags) == ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_RESERVED) && ((login_req_pkt->flags & ISCSI_LOGIN_REQ_FLAGS_TRANSMIT) != 0)) || ((login_req_pkt->flags < 0) && ((login_req_pkt->flags & ISCSI_LOGIN_REQ_FLAGS_CONTINUE) != 0)) || (login_req_pkt->flags & ~(ISCSI_LOGIN_REQ_FLAGS_CONTINUE | ISCSI_LOGIN_REQ_FLAGS_TRANSMIT) != 0) || (login_req_pkt->reserved != 0) || (login_req_pkt->reserved2[0] != 0) || (login_req_pkt->reserved2[1] != 0) )
+			if ( (ISCSI_LOGIN_REQ_FLAGS_GET_CURRENT_STAGE(login_req_pkt->flags) == ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_RESERVED) || ((ISCSI_LOGIN_REQ_FLAGS_GET_NEXT_STAGE(login_req_pkt->flags) == ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_RESERVED) && ((login_req_pkt->flags & ISCSI_LOGIN_REQ_FLAGS_TRANSIT) != 0)) || ((login_req_pkt->flags < 0) && ((login_req_pkt->flags & ISCSI_LOGIN_REQ_FLAGS_CONTINUE) != 0)) || (login_req_pkt->flags & ~(ISCSI_LOGIN_REQ_FLAGS_CONTINUE | ISCSI_LOGIN_REQ_FLAGS_TRANSIT) != 0) || (login_req_pkt->reserved != 0) || (login_req_pkt->reserved2[0] != 0) || (login_req_pkt->reserved2[1] != 0) )
 				return ISCSI_VALIDATE_PACKET_RESULT_ERROR_PROTOCOL_SPECS; // Current Stage (CSG) is set to reserved and Next Stage (NSG) is reserved and T bit is set, if C bit is set, T MUST be cleared and reserved fields need all to be zero, but are NOT -> invalid iSCSI packet data
 
 			return iscsi_validate_key_value_pairs( ((const uint8_t *) login_req_pkt) + iscsi_align(ds_len, ISCSI_ALIGN_SIZE), ds_len );
@@ -1469,7 +1774,7 @@ int iscsi_validate_packet(const struct iscsi_bhs_packet *packet_data, const uint
 			if ( (ISCSI_VERSION_MIN < login_response_pkt->version_max) || (ISCSI_VERSION_MAX > login_response_pkt->version_max) || (ISCSI_VERSION_MIN < login_response_pkt->version_active) || (ISCSI_VERSION_MAX > login_response_pkt->version_active) )
 				return ISCSI_VALIDATE_PACKET_RESULT_ERROR_UNSUPPORTED_VERSION;
 
-			if ( (ISCSI_LOGIN_RESPONSES_FLAGS_GET_CURRENT_STAGE(login_response_pkt->flags) == ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_RESERVED) || ((ISCSI_LOGIN_RESPONSES_FLAGS_GET_NEXT_STAGE(login_response_pkt->flags) == ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_RESERVED) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT) != 0)) || ((login_response_pkt->flags < 0) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_CONTINUE) != 0)) || (login_response_pkt->flags & ~(ISCSI_LOGIN_RESPONSE_FLAGS_CONTINUE | ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT) != 0) || (login_response_pkt->reserved != 0) || (login_response_pkt->reserved2 != 0) || (login_response_pkt->reserved3 != 0) )
+			if ( (ISCSI_LOGIN_RESPONSE_FLAGS_GET_CURRENT_STAGE(login_response_pkt->flags) == ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_RESERVED) || ((ISCSI_LOGIN_RESPONSE_FLAGS_GET_NEXT_STAGE(login_response_pkt->flags) == ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_RESERVED) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT) != 0)) || ((login_response_pkt->flags < 0) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_CONTINUE) != 0)) || (login_response_pkt->flags & ~(ISCSI_LOGIN_RESPONSE_FLAGS_CONTINUE | ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT) != 0) || (login_response_pkt->reserved != 0) || (login_response_pkt->reserved2 != 0) || (login_response_pkt->reserved3 != 0) )
 				return ISCSI_VALIDATE_PACKET_RESULT_ERROR_PROTOCOL_SPECS; // Current Stage (CSG) is set to reserved and Next Stage (NSG) is reserved and T bit is set, if C bit is set, T MUST be cleared and reserved fields need all to be zero, but are NOT -> invalid iSCSI packet data
 
 			return iscsi_validate_key_value_pairs( ((const uint8_t *) login_response_pkt) + iscsi_align(ds_len, ISCSI_ALIGN_SIZE), ds_len );
@@ -1633,7 +1938,7 @@ static int iscsi_parse_text_key_value_pair(iscsi_hashmap *pairs, const uint8_t *
 		return -1L;
 	}
 
-	uint8_t *hash_val = (uint8_t *) malloc( val_len + 1UL );
+	uint8_t *hash_val = (uint8_t *) malloc( iscsi_align(val_len + 1UL, ISCSI_HASHMAP_VALUE_ALIGN) );
 
 	if ( hash_val == NULL ) {
 		logadd( LOG_ERROR, "iscsi_parse_text_key_value_pair: Out of memory allocating memory for value string" );
@@ -1747,118 +2052,6 @@ int iscsi_parse_key_value_pairs(iscsi_hashmap *pairs, const uint8_t *packet_data
 }
 
 /**
- * @brief Creates a single partial iSCSI packet stream out of a single text key and value pair.
- *
- * Callback function for constructing an iSCSI packet data
- * stream for a single key=value text pair.
- *
- * @param[in] key Pointer to zero padded key. NULL is
- * an invalid pointer here, so be careful.
- * @param[in] key_size Number of bytes for the key, MUST
- * be a multiple of 8 bytes which is NOT checked, so
- * be careful.
- * @param[in] value Value of the key, NULL creates an
- * empty key assignment.
- * @param[in,out] user_data Pointer to a data structure
- * containing the memory buffer and length for the
- * iSCSI packet data (iscsi_key_value_pair_packet
- * structure), may NOT be NULL, so be careful.
- * @retval 0 The NUL terminated key=value pair has been
- * generated successfully.
- * @retval -1 The NUL terminated key=value pair could
- * NOT be created (probably due to memory exhaustion).
- */
-int iscsi_create_key_value_pair_packet_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data)
-{
-	iscsi_key_value_pair_packet *packet_data = (iscsi_key_value_pair_packet *) user_data;
-	uint8_t *buf = iscsi_sprintf_alloc( "%s=%s", key, ((value != NULL) ? value : (uint8_t *) "") );
-
-	if ( buf == NULL ) {
-		logadd( LOG_ERROR, "iscsi_create_key_value_pair_packet_callback: Out of memory generating text key / value pair DataSegment" );
-
-		return -1L;
-	}
-
-	const uint len = (uint) strlen( (char *) buf ) + 1;
-	const uint new_len = packet_data->len + len;
-
-	uint8_t *new_buf = realloc( packet_data->buf, new_len );
-
-	if ( new_buf == NULL ) {
-		logadd( LOG_ERROR, "iscsi_create_key_value_pair_packet_callback: Out of memory generating text key / value pair DataSegment" );
-
-		free( buf );
-
-		return -1L;
-	}
-
-	memcpy( (new_buf + packet_data->len), buf, len );
-
-	packet_data->buf = new_buf;
-	packet_data->len = new_len;
-
-	return 0L;
-}
-
-/**
- * @brief Creates a properly aligned iSCSI packet DataSegment out of a hash map containing text key and value pairs.
- *
- * Creates a properly aligned iSCSI DataSegment
- * containing NUL terminated key=value pairs
- * out of an hash map. The result can directly
- * be attached to a BHS/AHS packet and sent
- * via TCP/IP.
- *
- * @param[in] key_value_pairs Pointer to hash map containing
- * the key and value pairs to construct the
- * DataSegment from, may NOT be NULL, so be careful.
- * @return Pointer to iscsi_key_value_pair_packet
- * structure containing the properly aligned
- * DataSegment buffer and its unaligned length or
- * NULL in case of an error (most likely due to
- * memory exhaustion).
- */
-iscsi_key_value_pair_packet *iscsi_create_key_value_pairs_packet(iscsi_hashmap *key_value_pairs)
-{
-	iscsi_key_value_pair_packet *packet_data = (iscsi_key_value_pair_packet *) malloc( sizeof(struct iscsi_key_value_pair_packet) );
-
-	if ( packet_data == NULL ) {
-		logadd( LOG_ERROR, "iscsi_create_key_value_pairs: Out of memory generating text key / value pair DataSegment" );
-
-		return NULL;
-	}
-
-	packet_data->buf = NULL;
-	packet_data->len = 0UL;
-
-	if ( iscsi_hashmap_iterate( key_value_pairs, iscsi_create_key_value_pair_packet_callback, (uint8_t *) packet_data ) < 0L ) {
-		if ( packet_data->buf != NULL )
-			free( packet_data->buf );
-
-		free( packet_data );
-
-		return NULL;
-	}
-
-	if ( (packet_data->len & (ISCSI_ALIGN_SIZE - 1UL)) != 0 ) {
-		uint8_t *new_buf = realloc( packet_data->buf, iscsi_align(packet_data->len, ISCSI_ALIGN_SIZE) );
-
-		if ( new_buf == NULL ) {
-			logadd( LOG_ERROR, "iscsi_create_key_value_pairs: Out of memory generating text key / value pair DataSegment" );
-
-			free( packet_data->buf );
-			free( packet_data );
-
-			return NULL;
-		}
-
-		memset( (packet_data->buf + packet_data->len), 0, (packet_data->len & (ISCSI_ALIGN_SIZE - 1UL)) );
-	}
-
-	return packet_data;
-}
-
-/**
  * @brief Extracts a string from a key and value pair.
  *
  * This function calculates the length of the key
@@ -1887,8 +2080,8 @@ static int iscsi_get_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_
  * and its string value.
  *
  * @param[in] key_value_pairs Pointer to the hash map which should
- * contain the added string key and value pair. NULL is NOT
- * allowed here, so be careful.
+ * contain the added string key and value pair.
+ * NULL is NOT allowed here, so be careful.
  * @param[in] key String containing the key name as string. May
  * NOT be NULL, so take caution.
  * @param[in] value String containing the value to be stored.
@@ -1901,16 +2094,18 @@ static int iscsi_add_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_
 	uint8_t *hash_key = iscsi_hashmap_key_create( key, key_len );
 
 	if ( hash_key == NULL ) {
-		logadd( LOG_ERROR, "iscsi_add_key_value_pair: Out of memory allocating key." );
+		logadd( LOG_ERROR, "iscsi_add_key_value_pair: Out of memory allocating key" );
 
 		return -1L;
 	}
 
 	const uint val_len = (uint) strlen( (char *) value ) + 1;
-	uint8_t *hash_val = (uint8_t *) malloc( val_len );
+	uint8_t *hash_val = (uint8_t *) malloc( iscsi_align(val_len, ISCSI_HASHMAP_VALUE_ALIGN) );
 
 	if ( hash_val == NULL ) {
-		logadd( LOG_ERROR, "iscsi_add_key_value_pair: Out of memory allocating string value." );
+		logadd( LOG_ERROR, "iscsi_add_key_value_pair: Out of memory allocating string value" );
+
+		iscsi_hashmap_key_destroy( hash_key );
 
 		return -1L;
 	}
@@ -1921,6 +2116,50 @@ static int iscsi_add_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_
 }
 
 /**
+ * @brief Allocates and updates a string value of a key / value hash map pair.
+ *
+ * This function allocates memory for a string key
+ * and its string value.\n
+ * If the key does not exist, it will be added as
+ * a new one.
+ *
+ * @param[in] key_value_pairs Pointer to the hash map which should
+ * contain the updated string key and value pair.
+ * NULL is NOT allowed here, so be careful.
+ * @param[in] key String containing the key name as string. May
+ * NOT be NULL, so take caution.
+ * @param[in] value String containing the value to be stored.
+ * @return 0 on successful operation, or a negative value on
+ * error (memory exhaustion).
+ */
+static int iscsi_update_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_t *key, const uint8_t *value)
+{
+	const uint key_len = (uint) strlen( (char *) key ) + 1;
+	uint8_t *hash_key = iscsi_hashmap_key_create( key, key_len );
+
+	if ( hash_key == NULL ) {
+		logadd( LOG_ERROR, "iscsi_update_key_value_pair: Out of memory allocating key" );
+
+		return -1L;
+	}
+
+	const uint val_len = (uint) strlen( (char *) value ) + 1;
+	uint8_t *hash_val = (uint8_t *) malloc( iscsi_align(val_len, ISCSI_HASHMAP_VALUE_ALIGN) );
+
+	if ( hash_val == NULL ) {
+		logadd( LOG_ERROR, "iscsi_update_key_value_pair: Out of memory allocating string value" );
+
+		iscsi_hashmap_key_destroy( hash_key );
+
+		return -1L;
+	}
+
+	memcpy( hash_val, value, val_len );
+
+	return iscsi_hashmap_put_free( key_value_pairs, hash_key, key_len, hash_val, iscsi_hashmap_key_destroy_value_callback, NULL );
+}
+
+/**
  * @brief Extracts an integer value from a key and value pair.
  *
  * This function converts a string representation of a
@@ -1953,8 +2192,8 @@ static int iscsi_get_int_key_value_pair(iscsi_hashmap *key_value_pairs, const ui
  * and its integer representation as string value.
  *
  * @param[in] key_value_pairs Pointer to the hash map which should
- * contain the added integer key and value pair. NULL is NOT
- * allowed here, so be careful.
+ * contain the added integer key and value pair.
+ * NULL is NOT allowed here, so be careful.
  * @param[in] key String containing the key name as string. May
  * NOT be NULL, so take caution.
  * @param[in] value Integer containing the value to be stored.
@@ -1963,7 +2202,7 @@ static int iscsi_get_int_key_value_pair(iscsi_hashmap *key_value_pairs, const ui
  */
 static int iscsi_add_int_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_t *key, const int value)
 {
-	const uint8_t *hash_val = iscsi_sprintf_alloc( "%ld", value );
+	const uint8_t *hash_val = iscsi_sprintf_alloc( "%d", value );
 
 	if ( hash_val == NULL ) {
 		logadd( LOG_ERROR, "iscsi_add_int_key_value_pair: Out of memory allocating integer value." );
@@ -1975,6 +2214,36 @@ static int iscsi_add_int_key_value_pair(iscsi_hashmap *key_value_pairs, const ui
 }
 
 /**
+ * @brief Allocates and updates an integer value of a key / value hash map pair.
+ *
+ * This function allocates memory for a string key
+ * and its integer representation as string value.\n
+ * If the key does not exist, it will be added as
+ * a new one.
+ *
+ * @param[in] key_value_pairs Pointer to the hash map which should
+ * contain the updated integer key and value pair.
+ * NULL is NOT allowed here, so be careful.
+ * @param[in] key String containing the key name as string. May
+ * NOT be NULL, so take caution.
+ * @param[in] value Integer containing the value to be stored.
+ * @return 0 on successful operation, or a negative value on
+ * error (memory exhaustion).
+ */
+static int iscsi_update_int_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_t *key, const int value)
+{
+	const uint8_t *hash_val = iscsi_sprintf_alloc( "%d", value );
+
+	if ( hash_val == NULL ) {
+		logadd( LOG_ERROR, "iscsi_update_int_key_value_pair: Out of memory allocating integer value." );
+
+		return -1L;
+	}
+
+	return iscsi_update_key_value_pair( key_value_pairs, key, hash_val );
+}
+
+/**
  * @brief Extracts a boolean value from a key and value pair.
  *
  * This function converts a string representation of a
@@ -2009,8 +2278,8 @@ static int iscsi_get_bool_key_value_pair(iscsi_hashmap *key_value_pairs, const u
  * The string representation for false is: No
  *
  * @param[in] key_value_pairs Pointer to the hash map which should
- * contain the added boolean key and value pair. NULL is NOT
- * allowed here, so be careful.
+ * contain the added boolean key and value pair.
+ * NULL is NOT allowed here, so be careful.
  * @param[in] key String containing the key name as string. May
  * NOT be NULL, so take caution.
  * @param[in] value Boolean containing the value to be stored
@@ -2026,6 +2295,33 @@ static int iscsi_add_bool_key_value_pair(iscsi_hashmap *key_value_pairs, const u
 }
 
 /**
+ * @brief Allocates and updates an boolean value of a key / value hash map pair.
+ *
+ * This function allocates memory for a string key
+ * and its integer value.\n
+ * The string representation for true is: Yes\n
+ * The string representation for false is: No\n
+ * If the key does not exist, it will be added as
+ * a new one.
+ *
+ * @param[in] key_value_pairs Pointer to the hash map which should
+ * contain the updated boolean key and value pair.
+ * NULL is NOT allowed here, so be careful.
+ * @param[in] key String containing the key name as string. May
+ * NOT be NULL, so take caution.
+ * @param[in] value Boolean containing the value to be stored
+ * as string.
+ * @return 0 on successful operation, or a negative value on
+ * error (memory exhaustion).
+ */
+static int iscsi_update_bool_key_value_pair(iscsi_hashmap *key_value_pairs, const uint8_t *key, const int value)
+{
+	const uint8_t *hash_val = (uint8_t *) ((value != 0) ? "Yes" : "No");
+
+	return iscsi_update_key_value_pair( key_value_pairs, key, hash_val );
+}
+
+/**
  * @brief Creates and initializes an iSCSI portal group.
  *
  * Specified tag and flags are used for portal group
@@ -2586,7 +2882,7 @@ iscsi_session *iscsi_session_create(iscsi_connection *conn, iscsi_target_node *t
 	session->type                       = type;
 	session->current_text_init_task_tag = 0xFFFFFFFFUL;
 
-	session->key_value_pairs = iscsi_hashmap_create( 0UL );
+	session->key_value_pairs = iscsi_hashmap_create( 32UL );
 
 	if ( session->key_value_pairs == NULL ) {
 		logadd( LOG_ERROR, "iscsi_session_create: Out of memory allocating iSCSI session key and value pairs hash map" );
@@ -2598,17 +2894,18 @@ iscsi_session *iscsi_session_create(iscsi_connection *conn, iscsi_target_node *t
 		return NULL;
 	}
 
-	int rc = iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_CONNECTIONS, session->max_conns );
-	rc    |= iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_OUTSTANDING_R2T, session->max_outstanding_r2t );
-	rc    |= iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DEFAULT_TIME_WAIT, session->default_time_to_wait );
-	rc    |= iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DEFAULT_TIME_RETAIN, session->default_time_to_retain );
-	rc    |= iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_FIRST_BURST_LEN, session->first_burst_len );
-	rc    |= iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_BURST_LEN, session->max_burst_len );
-	rc    |= iscsi_add_bool_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_IMMEDIATE_DATA, session->immediate_data );
-	rc    |= iscsi_add_bool_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_PDU_IN_ORDER, session->data_pdu_in_order );
-	rc    |= iscsi_add_bool_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_SEQ_IN_ORDER, session->data_seq_in_order );
-	rc    |= iscsi_add_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_ERR_RECOVERY_LEVEL, session->err_recovery_level );
-	rc    |= iscsi_add_int_key_value_pair( conn->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_RECV_DS_LEN, conn->max_recv_ds_len );
+	int rc = iscsi_session_init_key_value_pairs( session->key_value_pairs );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_CONNECTIONS, session->max_conns );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_OUTSTANDING_R2T, session->max_outstanding_r2t );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DEFAULT_TIME_WAIT, session->default_time_to_wait );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DEFAULT_TIME_RETAIN, session->default_time_to_retain );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_FIRST_BURST_LEN, session->first_burst_len );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_BURST_LEN, session->max_burst_len );
+	rc    |= iscsi_update_bool_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_IMMEDIATE_DATA, session->immediate_data );
+	rc    |= iscsi_update_bool_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_PDU_IN_ORDER, session->data_pdu_in_order );
+	rc    |= iscsi_update_bool_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_SEQ_IN_ORDER, session->data_seq_in_order );
+	rc    |= iscsi_update_int_key_value_pair( session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_ERR_RECOVERY_LEVEL, session->err_recovery_level );
+	rc    |= iscsi_update_int_key_value_pair( conn->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_RECV_DS_LEN, conn->max_recv_ds_len );
 
 	if ( rc != 0 ) {
 		logadd( LOG_ERROR, "iscsi_session_create: Out of memory adding iSCSI session key and integer value pair" );
@@ -2666,6 +2963,50 @@ void iscsi_session_destroy(iscsi_session *session)
 }
 
 /**
+ * @brief Initializes a key and value pair hash table with default values.
+ *
+ * This function is used by iSCSI connections and
+ * sessions with default values for required keys.\n
+ * The iSCSI global key and value pair allowed
+ * values and ranges for fast
+ * access
+ *
+ * @param[in] key_value_pairs Pointer to key and value pair hash map
+ * which should store all the default values for
+ * its keys and may NOT be NULL, so take caution.
+ * @param[in] lut Lookup table to use for initialization.
+ * NULL is not allowed here, so be careful.
+ * @return 0 on success, a negative error code otherwise.
+ */
+static int iscsi_init_key_value_pairs(iscsi_hashmap *key_value_pairs, const iscsi_key_value_pair_lut_entry *lut)
+{
+	for ( uint i = 0; lut[i].key != NULL; i++ ) {
+		const int rc = iscsi_add_key_value_pair( key_value_pairs, lut[i].key, lut[i].value );
+
+		if ( rc < 0 )
+			return rc;
+	}
+
+	return 0L;
+}
+
+/**
+ * @brief Initializes a key and value pair hash table with default values for an iSCSI session.
+ *
+ * This function only initializes the default key
+ * and value pairs used by iSCSI sessions.
+ *
+ * @param[in] key_value_pairs Pointer to key and value pair hash map
+ * which should store all the default values for
+ * its keys and may NOT be NULL, so take caution.
+ * @return 0 on success, a negative error code otherwise.
+ */
+int iscsi_session_init_key_value_pairs(iscsi_hashmap *key_value_pairs)
+{
+	return iscsi_init_key_value_pairs( key_value_pairs, &iscsi_session_key_value_pair_lut[0] );
+}
+
+/**
  * @brief Creates data structure for an iSCSI connection from iSCSI portal and TCP/IP socket.
  *
  * Creates a data structure for incoming iSCSI connection
@@ -2698,6 +3039,16 @@ iscsi_connection *iscsi_connection_create(iscsi_portal *portal, const int sock)
 		return NULL;
 	}
 
+	const int rc = iscsi_connection_init_key_value_pairs( conn->key_value_pairs );
+
+	if ( rc < 0 ) {
+		iscsi_hashmap_iterate( conn->key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
+		iscsi_hashmap_destroy( conn->key_value_pairs );
+		free( conn );
+
+		return NULL;
+	}
+
 	conn->partial_pairs      = NULL;
 	conn->device             = NULL;
 	conn->init_port          = NULL;
@@ -2712,10 +3063,12 @@ iscsi_connection *iscsi_connection_create(iscsi_portal *portal, const int sock)
 	conn->data_digest        = 0L;
     conn->pdu_processing     = NULL;
 	conn->login_response_pdu = NULL;
+	conn->id                 = 0L;
 	conn->sock               = sock;
 	conn->pdu_recv_state     = ISCSI_CONNECT_PDU_RECV_STATE_WAIT_PDU_READY;
 	conn->flags              = 0L;
 	conn->state              = ISCSI_CONNECT_STATE_INVALID;
+	conn->login_phase        = ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_SECURITY_NEGOTIATION;
 	conn->max_recv_ds_len    = ISCSI_DEFAULT_RECV_DS_LEN;
 	conn->pg_tag             = portal->group->tag;
 	conn->isid.a             = 0;
@@ -2897,6 +3250,477 @@ int iscsi_connection_write(const iscsi_connection *conn, uint8_t *buf, const uin
 }
 
 /**
+ * @brief Initializes a key and value pair hash table with default values for an iSCSI connection.
+ *
+ * This function only initializes the default key
+ * and value pairs used by iSCSI connectionss.
+ *
+ * @param[in] key_value_pairs Pointer to key and value pair hash map
+ * which should store all the default values for
+ * its keys and may NOT be NULL, so take caution.
+ * @return 0 on success, a negative error code otherwise.
+ */
+int iscsi_connection_init_key_value_pairs(iscsi_hashmap *key_value_pairs)
+{
+	return iscsi_init_key_value_pairs( key_value_pairs, &iscsi_connection_key_value_pair_lut[0] );
+}
+
+/**
+ * @brief Appends a special key and value pair to DataSegment packet data.
+ *
+ * This function adds MaxRecvDataSegmentLength,
+ * FirstBurstLength and MaxBurstLength, which
+ * require special handling to an output
+ * DataSegment buffer and truncates if
+ * necessary.
+ *
+ * @param[in] conn Pointer to iSCSI connection to handle the
+ * special key and value pair for. NULL is
+ * a forbidden value here, so take caution.
+ * @param[in] key_value_pair Pointer to special key and value pair
+ * containing its attributes and may NOT
+ * be NULL, so be careful.
+ * @param[in] key Pointer to special key to be written to
+ * output buffer. NULL is NOT allowed,
+ * take caution.
+ * @param[in] buf Pointer to output buffer to write the
+ * special key and value pair to. NULL is
+ * prohibited, so be careful.
+ * @param[in] pos Position of buffer in bytes to start
+ * writing to.
+ * @param[in] len Total length of buffer in bytes.
+ * @return New buffer position in bytes or a negative
+ * error code.
+ */
+static int iscsi_append_special_key_value_pair_packet(iscsi_connection *conn, iscsi_key_value_pair *key_value_pair, const uint8_t *key, uint8_t *buf, uint pos, const uint len)
+{
+	if ( (key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_OVERRIDE_DEFAULT) != 0 ) {
+		if ( (int) (len - pos) < 1L )
+			return -1L;
+
+		pos += snprintf( (char *) (buf + pos), (len - pos), "%s=%ld", key, ISCSI_DEFAULT_MAX_RECV_DS_LEN ) + 1;
+	}
+
+	if ( (key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_OTHER_MAX_VALUE) != 0 ) {
+		if ( (int) (len - pos) < 1L )
+			return -1L;
+
+		uint8_t *first_burst_len_val = NULL;
+		int rc = iscsi_get_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_FIRST_BURST_LEN, &first_burst_len_val );
+		uint first_burst_len = (rc < 0) ? ISCSI_SESSION_DEFAULT_FIRST_BURST_LEN : (uint) atol( (char *) first_burst_len_val );
+
+		uint8_t *max_burst_len_val;
+		rc = iscsi_get_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_BURST_LEN, &max_burst_len_val );
+		uint max_burst_len = (rc < 0) ? ISCSI_SESSION_DEFAULT_MAX_BURST_LEN : (uint) atol( (char *) max_burst_len_val );
+
+		if ( first_burst_len > max_burst_len ) {
+			first_burst_len = max_burst_len;
+
+			if ( first_burst_len_val != NULL ) {
+				sprintf( (char *) first_burst_len_val, "%d", first_burst_len );
+			}
+		}
+
+		pos += snprintf( (char *) (buf + pos), (len - pos), "%s=%d", key, first_burst_len ) + 1;
+	}
+
+	return pos;
+
+}
+
+/**
+ * @brief Appends a key and value pair to DataSegment packet data.
+ *
+ * This function adds any non-declarative key
+ * and value pair to an output DataSegment
+ * buffer and truncates if necessary.
+ *
+ * @param[in] key_value_pair Pointer to key and value pair containing
+ * its attributes and may NOT be NULL, so be
+ * careful.
+ * @param[in] key Pointer to key to be written to output
+ * buffer. NULL is NOT allowed, take caution.
+ * @param[in] value Pointer to value of the key that should
+ * be written to output buffer which may
+ * NOT be NULL, so take caution.
+ * @param[in] buf Pointer to output buffer to write the
+ * key and value pair to. NULL is
+ * prohibited, so be careful.
+ * @param[in] pos Position of buffer in bytes to start
+ * writing to.
+ * @param[in] len Total length of buffer in bytes.
+ * @return New buffer position in bytes or a negative
+ * error code.
+ */
+static int iscsi_append_key_value_pair_packet(const iscsi_key_value_pair *key_value_pair, const uint8_t *key, const uint8_t *value, uint8_t *buf, uint pos, const uint len)
+{
+	if ( (key_value_pair->type != ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_DECLARATIVE) && (key_value_pair->type != ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_DECLARATIVE) ) {
+		if ( (int) (len - pos) < 1L )
+			return -1L;
+
+		pos += snprintf( (char *) (buf + pos), (len - pos), "%s=%s", key, value ) + 1;
+	}
+
+	return pos;
+}
+
+/**
+ * @brief Negotiates key and value pair of list type.
+ *
+ * This function checks if a key of list type has a
+ * valid value according to the iSCSI specification.
+ *
+ * @param[in] key_value_pair Pointer to key and value pair. May NOT
+ * be NULL, so be careful.
+ * @param[in] old_value Pointer to string containing the old
+ * value. NULL is not allowed, so take caution.
+ * @return Pointer to original value, if the value is
+ * allowed or NULL otherwise.
+ */
+static uint8_t *iscsi_negotiate_key_value_pair_list(const iscsi_key_value_pair *key_value_pair, uint8_t *old_value)
+{
+	const uint8_t *list = key_value_pair->list_range;
+
+	do {
+		if ( strcasecmp( (char *) list, (char *) old_value ) == 0 )
+			return old_value;
+
+		list += (strlen( (char *) list ) + 1);
+	} while ( list[0] != '\0' );
+
+	return NULL;
+}
+
+/**
+ * @brief Negotiates key and value pair of numeric type.
+ *
+ * This function checks if a key of numeric type has
+ * a valid interger value and clamps within the
+ * allowed minimum and maximum range according to
+ * the iSCSI specification.
+ *
+ * @param[in] key_value_pair Pointer to key and value pair. May NOT
+ * be NULL, so be careful.
+ * @param[in] old_value Pointer to string containing the old
+ * value. NULL is not allowed, take caution.
+ * @param[in] value Pointer to string containing the current
+ * value which may NOT be NULL, so be careful.
+ * @return Pointer to original value, if the value is
+ * allowed or NULL otherwise.
+ */
+static uint8_t *iscsi_negotiate_key_value_pair_num(const iscsi_key_value_pair *key_value_pair, uint8_t *old_value, uint8_t *value)
+{
+	int old_int_val = (int) atol( (char *) key_value_pair->value );
+
+	if ( (key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_PREVIOUS_VALUE) != 0 )
+		old_int_val = (int) atol( (char *) old_value );
+
+	int int_val = (int) atol( (char *) value );
+
+	const uint8_t *range = key_value_pair->list_range;
+	const int range_min = (int) atol( (char *) range );
+	const int range_max = (int) atol( (char *) (range + strlen( (char *) range ) + 1) );
+
+	if ( (old_int_val < range_min) || (old_int_val > range_max) )
+		return NULL;
+
+	switch ( key_value_pair->type ) {
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN : {
+			if ( old_int_val > int_val )
+				old_int_val = int_val;
+
+			break;
+		}
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MAX : {
+			if ( old_int_val < int_val )
+				old_int_val = int_val;
+
+			break;
+		}
+		default : {
+			return old_value;
+
+			break;
+		}
+	}
+
+	sprintf( (char *) old_value, "%d", old_int_val );
+
+	return old_value;
+}
+
+/**
+ * @brief Negotiates key and value pair of boolean type.
+ *
+ * This function checks if a key of boolean type
+ * has a valid value according to the iSCSI
+ * specification and also applies the boolean
+ * OR / AND function to the current value.
+ *
+ * @param[in] key_value_pair Pointer to key and value pair. May NOT
+ * be NULL, so be careful.
+ * @param[in] old_value Pointer to string containing the old
+ * value. NULL is not allowed, so take caution.
+ * @param[in] value Pointer to string containing the
+ * current value which may NOT be NULL, so be
+ * careful.
+ * @param[in] bool_value Pointer to string containing the
+ * boolean OR / AND value where NULL is
+ * prohibited, so take caution.
+ * @param[out] update_key_value_pair Pointer to integer which
+ * marks if the key and value pair should be
+ * updated. May NOT be NULL, so be careful.
+ * @return Pointer to either boolean AND / OR result,
+ * default value or NULL in case of invalid
+ * boolean value.
+ */
+static uint8_t *iscsi_negotiate_key_value_pair_bool(const iscsi_key_value_pair *key_value_pair, uint8_t *old_value, uint8_t *value, uint8_t *bool_value, int *update_key_value_pair)
+{
+	const uint8_t *list_bool_true  = key_value_pair->list_range;
+	const uint8_t *list_bool_false = list_bool_true + strlen( (char *) list_bool_true ) + 1;
+
+	if ( (strcasecmp( (char *) old_value, (char *) list_bool_true ) == 0) || (strcasecmp( (char *) old_value, (char *) list_bool_false ) == 0) ) {
+		*update_key_value_pair = 0L;
+
+		return (uint8_t *) "Reject";
+	}
+
+	if ( strcasecmp( (char *) value, (char *) bool_value ) == 0 )
+		return bool_value;
+
+	return key_value_pair->value;
+}
+
+/**
+ * @brief Negotiates key and value pair of all types.
+ *
+ * This function determines the key type and
+ * calls the suitable negotation handler
+ * for checking iSCSI standard compliance.
+ *
+ * @param[in] key_value_pair Pointer to key and value pair. May NOT
+ * be NULL, so be careful.
+ * @param[in] old_value Pointer to string containing the old
+ * value. NULL is not allowed, so take caution.
+ * @param[in] value Pointer to string containing the
+ * current value which may NOT be NULL, so be
+ * careful.
+ * @param[out] update_key_value_pair Pointer to integer which
+ * marks if the key and value pair should be
+ * updated. NULL is not allowed, take caution.
+ * @return Pointer to new negotiated value or NULL
+ * in case of an invalid negation status.
+ */
+static uint8_t *iscsi_negotiate_key_value_pair_all(const iscsi_key_value_pair *key_value_pair, uint8_t *old_value, uint8_t *value, int *update_key_value_pair)
+{
+	switch ( key_value_pair->type ) {
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_LIST : {
+			return iscsi_negotiate_key_value_pair_list( key_value_pair, old_value );
+
+			break;
+		}
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MIN :
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_MAX :
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_NUM_DECLARATIVE : {
+			return iscsi_negotiate_key_value_pair_num( key_value_pair, old_value, value );
+
+			break;
+		}
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_AND : {
+			return iscsi_negotiate_key_value_pair_bool( key_value_pair, old_value, value, key_value_pair->list_range, update_key_value_pair );
+
+			break;
+		}
+		case ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_OR : {
+			uint8_t *list_bool_true  = key_value_pair->list_range;
+			uint8_t *list_bool_false = list_bool_true + strlen( (char *) list_bool_true ) + 1;
+
+			return iscsi_negotiate_key_value_pair_bool( key_value_pair, old_value, value, list_bool_false, update_key_value_pair );
+
+			break;
+		}
+		default : {
+			break;
+		}
+	}
+
+	return key_value_pair->value;
+}
+
+/**
+ * @brief Negotiates either iSCSI session or connection state.
+ *
+ * This function checks and sets the state mask
+ * of either an iSCSI connection or session
+ * key and value pair.
+ *
+ * @param[in] conn Pointer to iSCSI connection of which to
+ * determine the key type. NULL is NOT allowed,
+ * so be careful.
+ * @param[in] key_value_pair Pointer to key and value pair
+ * containing the key and value pair attributes.
+ * NULL is NOT allowed, so be careful.
+ * @param[in] type Type of key and value pair to negotiate.
+ * 0 is iSCSI connection key and value pair,
+ * any other value indicates an iSCSI session
+ * key and value pair.
+ * @return 0 on successful state negotation, a
+ * negative error code otherwise.
+ */
+static int iscsi_negotiate_key_value_pairs_state(iscsi_connection *conn, const iscsi_key_value_pair *key_value_pair, const int type)
+{
+	if ( type != 0 ) {
+		const uint32_t state_mask = (uint32_t) key_value_pair->state_mask;
+
+		if ( ((conn->session_state_negotiated & state_mask) != 0) && ((key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_TARGET_DECLARATIVE) == 0) )
+			return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER_XCHG_NOT_ONCE;
+
+		conn->session_state_negotiated |= state_mask;
+	} else {
+		const uint16_t state_mask = (uint16_t) key_value_pair->state_mask;
+
+		if ( ((conn->state_negotiated & state_mask) != 0) && ((key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_MULTI_NEGOTIATION) == 0) )
+			return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER_XCHG_NOT_ONCE;
+
+		conn->state_negotiated |= state_mask;
+	}
+
+	return ISCSI_CONNECT_PDU_READ_OK;
+}
+
+/**
+ * @brief Callback which negotiates a single key and value pairs required for session authentication.
+ *
+ * This function is called for each key and value
+ * pair which needs connection or session
+ * authentication.
+ *
+ * @param[in] key Pointer to zero padded key. NULL is
+ * an invalid pointer here, so be careful.
+ * @param[in] key_size Number of bytes for the key, MUST
+ * be a multiple of 8 bytes which is NOT checked, so
+ * be careful.
+ * @param[in] value Value of the key, NULL is allowed.
+ * @param[in,out] user_data Pointer to integer value which is
+ * 1 is this is discovery, or 0 if not.
+ * @return Always returns 0 as this function cannot fail.
+ */
+int iscsi_negotiate_key_value_pair_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data)
+{
+	iscsi_key_value_pair_packet *key_value_pair_packet = (iscsi_key_value_pair_packet *) user_data;
+	iscsi_connection *conn = key_value_pair_packet->conn;
+	iscsi_hashmap *key_value_pairs = conn->key_value_pairs;
+	iscsi_key_value_pair *key_value_pair = NULL;
+	int type = 0L;
+	int rc = iscsi_hashmap_get( iscsi_globvec->connection_key_value_pairs, key, key_size, (uint8_t **) &key_value_pair);
+
+	if ( rc < 0 ) {
+		key_value_pairs = conn->session->key_value_pairs;
+		type = 1L;
+
+		rc = iscsi_hashmap_get( iscsi_globvec->session_key_value_pairs, key, key_size, (uint8_t **) &key_value_pair);
+	}
+
+	if ( (rc == 0) && (key_value_pair->flags & (ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE | ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_SPECIAL_HANDLING)) != 0 )
+		return 0L;
+
+	int update_key_value_pair = 1L;
+	uint8_t *conn_sess_val;
+
+	if ( rc < 0 ) {
+		conn_sess_val = (uint8_t *) "NotUnderstood";
+
+		update_key_value_pair = 0L;
+	} else if ( (key_value_pair_packet->discovery != 0) && ((key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE) != 0) ) {
+		conn_sess_val = (uint8_t *) "Irrelevant";
+
+		update_key_value_pair = 0L;
+	} else {
+		rc = iscsi_negotiate_key_value_pairs_state( conn, key_value_pair, type );
+
+		if ( rc < 0 )
+			return rc;
+
+		rc = iscsi_hashmap_get( key_value_pairs, key, key_size, &conn_sess_val );
+	}
+
+	if ( (key_value_pair != NULL) && (key_value_pair->type > ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_UNSPECIFIED) ) {
+		if ( (key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_PREVIOUS_VALUE) != 0 ) {
+			uint8_t *max_burst_len_val;
+			uint first_burst_len = (uint) atol( (char *) value );
+			uint max_burst_len;
+
+			rc = iscsi_get_key_value_pair( key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_MAX_BURST_LEN, &max_burst_len_val );
+
+			max_burst_len = (rc < 0) ? ISCSI_SESSION_DEFAULT_MAX_BURST_LEN : (uint) atol( (char *) max_burst_len_val );
+
+			if ( (first_burst_len < ISCSI_MAX_DS_SIZE) && (first_burst_len > max_burst_len) )
+				sprintf( (char *) value, "%d", first_burst_len );
+		}
+
+		if ( (key_value_pair->flags & ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_TARGET_DECLARATIVE) != 0 )
+			update_key_value_pair = 0L;
+
+		conn_sess_val = iscsi_negotiate_key_value_pair_all( key_value_pair, value, conn_sess_val, &update_key_value_pair );
+	}
+
+	if ( conn_sess_val != NULL ) {
+		if ( update_key_value_pair != 0 )
+			iscsi_update_key_value_pair( key_value_pairs, key, conn_sess_val );
+
+		key_value_pair_packet->pos = iscsi_append_key_value_pair_packet( key_value_pair, key, conn_sess_val, key_value_pair_packet->buf, key_value_pair_packet->pos, key_value_pair_packet->len );
+
+		if ( (int) key_value_pair_packet->pos < 0 )
+			return key_value_pair_packet->pos;
+
+		key_value_pair_packet->pos = iscsi_append_special_key_value_pair_packet( conn, key_value_pair, key, key_value_pair_packet->buf, key_value_pair_packet->pos, key_value_pair_packet->len );
+
+		if ( (int) key_value_pair_packet->pos < 0 )
+			return key_value_pair_packet->pos;
+	}
+
+	return 0L;
+}
+
+/**
+ * @brief Negotiates all key and value pairs required for session authentication.
+ *
+ * @param[in] conn Pointer to iSCSI connection to be
+ * negotiated, may NOT be NULL, so be careful.
+ * @param[in] key_value_pairs Pointer to key and value pair hash map
+ * which contains the negotiation pairs. NULL
+ * is prohibited, so take caution.
+ * @param[in] buf Pointer to output buffer which may NOT
+ * be NULL, so be careful.
+ * @param[in] pos Number of bytes already written.
+ * @param[in] len Length of DataSegment in bytes.
+ * @return New buffer length in bytes if all keys
+ * could be negotiated, a negative error
+ * code otherwise.
+ */
+int iscsi_negotiate_key_value_pairs(iscsi_connection *conn, iscsi_hashmap *key_value_pairs, uint8_t *buf, const uint pos, const uint len)
+{
+	if ( pos > len ) {
+		buf[len - 1] = '\0';
+
+		return len;
+	}
+
+	uint8_t *type;
+	int rc = iscsi_get_key_value_pair( key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_SESSION_TYPE, &type );
+
+	if ( rc < 0 )
+		rc = iscsi_get_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_SESSION_TYPE, &type );
+
+	const int discovery = ((rc == 0) && (strcasecmp( (char *) type, "Discovery" ) == 0)) ? 1L : 0L;
+
+	iscsi_key_value_pair_packet key_value_pair_packet = {conn, buf, pos, len, discovery};
+	iscsi_hashmap_iterate( key_value_pairs, iscsi_negotiate_key_value_pair_callback, (uint8_t *) &key_value_pair_packet );
+
+	return key_value_pair_packet.pos;
+}
+
+/**
  * @brief Copies retrieved key and value pairs into SCSI connection and session structures.
  *
  * This function converts string representations of
@@ -2984,6 +3808,36 @@ int iscsi_connection_copy_key_value_pairs(iscsi_connection *conn)
 }
 
 /**
+ * @brief Handles stages of CHAP and other authentication methods.
+ *
+ * This function handles the various stages of the
+ * various authentication methods supported by the
+ * iSCSI protocol.\n
+ * Currently, only CHAP is implemented.
+ *
+ * @param[in] conn Pointer to iSCSI connection which may NOT
+ * be NULL, so be careful.
+ * @param[in] key_value_pairs Pointer to hash map containing the
+ * authentication key and value pairs. NULL
+ * is NOT allowed here, so take caution.
+ * @param[in] auth_method Pointer to string containing the
+ * authentication method. NULL is forbidden,
+ * so be careful.
+ * @param[in] buf Pointer to DataSegment buffer. May NOT be
+ * NULL, so take caution.
+ * @param[in] pos Remaining number of bytes to read.
+ * @param[in] len Total number of bytes of DataSegment buffer.
+ * @return 0 if authentication methods were handled successfully,
+ * a negative error code otherwise.
+ */
+static int iscsi_connection_auth_key_value_pairs(iscsi_connection *conn, iscsi_hashmap *key_value_pairs, const uint8_t *auth_method, uint8_t *buf, const uint pos, const uint len)
+{
+	// TODO: Implement CHAP and other authentication methods.
+
+	return 0L;
+}
+
+/**
  * @brief Checks buffer sizes of an iSCSI connection with it's associated session for consistency.
  *
  * This function ensures that, for example, first
@@ -3000,9 +3854,9 @@ int iscsi_connection_copy_key_value_pairs(iscsi_connection *conn)
 static int iscsi_connection_check_key_value_pairs(iscsi_connection *conn)
 {
 	if ( (conn->session->first_burst_len > conn->session->max_burst_len) || (conn->session->first_burst_len < 512) || (conn->session->max_burst_len < 512) || (conn->session->max_burst_len > ISCSI_SESSION_DEFAULT_MAX_BURST_LEN) || (conn->max_recv_ds_len < 512) || (conn->max_recv_ds_len > ISCSI_SESSION_DEFAULT_MAX_BURST_LEN) )
-		return -1;
+		return -1L;
 
-	return 0;
+	return 0L;
 }
 
 /**
@@ -3048,7 +3902,7 @@ static int iscsi_connection_update_key_value_pairs(iscsi_connection *conn)
 	else if ( recv_buf_len > 8192 )
 		recv_buf_len = 8192UL;
 
-	recv_buf_len  += (uint) (sizeof(struct iscsi_bhs_packet) + 1020UL + conn->header_digest + conn->data_digest); // BHS + maximum AHS size + header and data digest overhead
+	recv_buf_len  += (uint) (sizeof(struct iscsi_bhs_packet) + ISCSI_MAX_AHS_SIZE + conn->header_digest + conn->data_digest); // BHS + maximum AHS size + header and data digest overhead
 	recv_buf_len <<= 2UL; // Receive up to four streams at once.
 
 	setsockopt( conn->sock, SOL_SOCKET, SO_RCVBUF, &recv_buf_len, sizeof(recv_buf_len)); // Not being able to set the buffer is NOT fatal, so ignore error.
@@ -3090,7 +3944,7 @@ static void iscsi_connection_pdu_login_response(iscsi_connection *conn, iscsi_pd
 	}
 
 	if ( login_response_pkt->status_class != ISCSI_LOGIN_RESPONSE_STATUS_CLASS_SUCCESS )
-		login_response_pkt->flags &= (int8_t) ~(ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT | ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK | ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK );
+		login_response_pkt->flags &= (int8_t) ~(ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT | ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK | ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK );
 
 	iscsi_hashmap_iterate( key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL );
 	iscsi_hashmap_destroy( key_value_pairs );
@@ -3174,9 +4028,9 @@ static int iscsi_login_response_init(iscsi_pdu *login_response_pdu, const iscsi_
 	login_response_pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) login_response_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->header_digest_size);
 	login_response_pdu->ds_len      = ISCSI_DEFAULT_RECV_DS_LEN;
 
-	login_response_pkt->flags |= (int8_t) (login_req_pkt->flags & (ISCSI_LOGIN_REQ_FLAGS_TRANSMIT | ISCSI_LOGIN_REQ_FLAGS_CONTINUE | ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_MASK));
+	login_response_pkt->flags |= (int8_t) (login_req_pkt->flags & (ISCSI_LOGIN_REQ_FLAGS_TRANSIT | ISCSI_LOGIN_REQ_FLAGS_CONTINUE | ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_MASK));
 
-	if ( (login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT) != 0 )
+	if ( (login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT) != 0 )
 		login_response_pkt->flags |= (login_req_pkt->flags & ISCSI_LOGIN_REQ_FLAGS_NEXT_STAGE_MASK);
 
 	login_response_pkt->isid.a        = login_req_pkt->isid.a;
@@ -3190,7 +4044,7 @@ static int iscsi_login_response_init(iscsi_pdu *login_response_pdu, const iscsi_
 	if ( login_response_pkt->tsih != 0 )
 		login_response_pkt->stat_sn = login_req_pkt->exp_stat_sn; // Copying over doesn't change endianess.'
 
-	if ( ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT) != 0) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_CONTINUE) != 0) ) {
+	if ( ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT) != 0) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_CONTINUE) != 0) ) {
 		login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
 		login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISC;
 
@@ -3200,8 +4054,8 @@ static int iscsi_login_response_init(iscsi_pdu *login_response_pdu, const iscsi_
 		login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_WRONG_VERSION;
 
 		return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
-	} else if ( (ISCSI_LOGIN_RESPONSES_FLAGS_GET_NEXT_STAGE(login_response_pkt->flags) == ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_RESERVED) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT) != 0) ) {
-		login_response_pkt->flags        &= (int8_t) ~(ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK | ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT | ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK);
+	} else if ( (ISCSI_LOGIN_RESPONSE_FLAGS_GET_NEXT_STAGE(login_response_pkt->flags) == ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_RESERVED) && ((login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT) != 0) ) {
+		login_response_pkt->flags        &= (int8_t) ~(ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK | ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT | ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK);
 		login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
 		login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISC;
 
@@ -3424,7 +4278,7 @@ static int iscsi_connection_login_check_target(iscsi_connection *conn, iscsi_pdu
 	uint8_t *redirect_adr = iscsi_target_node_get_redirect( conn, *target );
 
 	if ( redirect_adr != NULL ) {
-		if ( iscsi_add_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, redirect_adr ) == 0 ) {
+		if ( iscsi_update_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, redirect_adr ) == 0 ) {
 			login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_REDIRECT;
 			login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_REDIRECT_TEMP;
 
@@ -3618,7 +4472,7 @@ iscsi_pdu *iscsi_connection_pdu_create(iscsi_connection *conn)
 	pdu->ahs_len                = 0UL;
 	pdu->ahs_read_len           = 0UL;
 	pdu->ds_len                 = 0UL;
-	pdu->buf_len                = 0UL;
+	pdu->pos                    = 0UL;
 	pdu->conn                   = conn;
 	pdu->cmd_sn                 = 0UL;
 
@@ -3717,20 +4571,20 @@ static int iscsi_connection_handle_reject(iscsi_connection *conn, iscsi_pdu *pdu
 	iscsi_pdu *response_pdu = iscsi_connection_pdu_create( conn );
 
 	if ( response_pdu == NULL ) {
-		logadd( LOG_ERROR, "iscsi_pdu_create: Out of memory while allocating iSCSI reject response PDU" );
+		logadd( LOG_ERROR, "iscsi_connection_handle_reject: Out of memory while allocating iSCSI reject response PDU" );
 
-		return -1L;
+		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
 	}
 
 	const uint32_t ds_len = (uint32_t) sizeof(struct iscsi_bhs_packet) + ((uint32_t) pdu->bhs_pkt->total_ahs_len << 2UL) + conn->header_digest;
-	iscsi_reject_packet *reject_pkt = (iscsi_reject_packet *) iscsi_append_ds_packet( pdu->bhs_pkt, conn->header_digest, ds_len, conn->data_digest );
+	iscsi_reject_packet *reject_pkt = (iscsi_reject_packet *) iscsi_append_ds_packet( response_pdu->bhs_pkt, conn->header_digest, ds_len, conn->data_digest );
 
 	if ( reject_pkt == NULL ) {
-		logadd( LOG_ERROR, "iscsi_pdu_create: Out of memory while allocating iSCSI reject packet data" );
+		logadd( LOG_ERROR, "iscsi_connection_handle_reject: Out of memory while allocating iSCSI reject packet data" );
 
 		iscsi_connection_pdu_destroy( response_pdu );
 
-		return -1L;
+		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
 	}
 
 	response_pdu->bhs_pkt = (iscsi_bhs_packet *) reject_pkt;
@@ -3767,7 +4621,7 @@ static int iscsi_connection_handle_reject(iscsi_connection *conn, iscsi_pdu *pdu
 
 	iscsi_connection_pdu_write( conn, response_pdu, NULL, NULL );
 
-	return 0L;
+	return ISCSI_CONNECT_PDU_READ_OK;
 }
 
 /**
@@ -3853,9 +4707,23 @@ static int iscsi_connection_pdu_header_handle_login_req(iscsi_connection *conn,
  */
 static int iscsi_connection_pdu_header_handle_nop_out(iscsi_connection *conn, iscsi_pdu *pdu)
 {
-	// TODO: Implement opcode.
+	if ( conn->session->type == ISCSI_SESSION_TYPE_DISCOVERY )
+		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
 
-	return 0;
+	if ( pdu->ds_len > ISCSI_DEFAULT_MAX_RECV_DS_LEN )
+		return iscsi_connection_handle_reject( conn, pdu, ISCSI_REJECT_REASON_PROTOCOL_ERR );
+
+	iscsi_nop_out_packet *nop_out_pkt = (iscsi_nop_out_packet *) pdu->bhs_pkt;
+	const uint32_t init_task_tag   = iscsi_get_be32(nop_out_pkt->init_task_tag);
+	const uint32_t target_xfer_tag = iscsi_get_be32(nop_out_pkt->target_xfer_tag);
+
+	if ( (target_xfer_tag != 0xFFFFFFFFUL) && (target_xfer_tag != conn->id) )
+		return iscsi_connection_handle_reject( conn, pdu, ISCSI_REJECT_REASON_INVALID_PDU_FIELD ); // TODO: Check if this is the correct error code.
+
+	if ( (init_task_tag == 0xFFFFFFFFUL) && (nop_out_pkt->opcode & 0x40) == 0 )
+		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
+
+	return 0L;
 }
 
 /**
@@ -4097,9 +4965,72 @@ static int iscsi_connection_pdu_header_handle(iscsi_connection *conn, iscsi_pdu
  */
 static int iscsi_connection_pdu_data_handle_nop_out(iscsi_connection *conn, iscsi_pdu *pdu)
 {
-	// TODO: Implement opcode.
+	iscsi_nop_out_packet *nop_out_pkt = (iscsi_nop_out_packet *) pdu->bhs_pkt;
+	uint32_t ds_len = pdu->ds_len;
 
-	return 0L;
+	if ( ds_len > conn->max_recv_ds_len )
+		ds_len = conn->max_recv_ds_len;
+
+	const uint64_t lun           = iscsi_get_be64(nop_out_pkt->lun);
+	const uint32_t init_task_tag = iscsi_get_be32(nop_out_pkt->init_task_tag);
+
+	conn->flags &= ~ISCSI_CONNECT_FLAGS_NOP_OUTSTANDING;
+
+	if ( init_task_tag == 0xFFFFFFFFUL )
+		return ISCSI_CONNECT_PDU_READ_OK;
+
+	iscsi_pdu *response_pdu = iscsi_connection_pdu_create( conn );
+
+	if ( response_pdu == NULL ) {
+		logadd( LOG_ERROR, "iscsi_connection_pdu_data_handle_nop_out: Out of memory while allocating iSCSI NOP-In response PDU" );
+
+		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
+	}
+
+	iscsi_nop_in_packet *nop_in_pkt = (iscsi_nop_in_packet *) iscsi_append_ds_packet( response_pdu->bhs_pkt, conn->header_digest, ds_len, conn->data_digest );
+
+	if ( nop_in_pkt == NULL ) {
+		logadd( LOG_ERROR, "iscsi_connection_pdu_data_handle_nop_out: Out of memory while allocating iSCSI NOP-In packet data" );
+
+		iscsi_connection_pdu_destroy( response_pdu );
+
+		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
+	}
+
+	response_pdu->bhs_pkt = (iscsi_bhs_packet *) nop_in_pkt;
+
+	if ( conn->header_digest != 0 ) {
+		response_pdu->header_digest      = (iscsi_header_digest *) (((iscsi_bhs_packet *) nop_in_pkt) + 1);
+		response_pdu->header_digest_size = conn->header_digest;
+	}
+
+	response_pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) nop_in_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest);
+	response_pdu->ds_len      = ds_len;
+
+	if ( conn->data_digest != 0 ) {
+		response_pdu->data_digest      = (iscsi_data_digest *) (((uint8_t *) response_pdu->ds_cmd_data) + iscsi_align(ds_len, ISCSI_ALIGN_SIZE));
+		response_pdu->data_digest_size = conn->data_digest;
+	}
+
+	nop_in_pkt->opcode          = ISCSI_SERVER_NOP_IN;
+	nop_in_pkt->flags           = -0x80;
+	iscsi_put_be24( (uint8_t *) &nop_in_pkt->ds_len, ds_len );
+	iscsi_put_be64( (uint8_t *) &nop_in_pkt->lun, lun );
+	nop_in_pkt->target_xfer_tag = 0xFFFFFFFFUL;
+	iscsi_put_be32( (uint8_t *) &nop_in_pkt->init_task_tag, init_task_tag );
+	iscsi_put_be32( (uint8_t *) &nop_in_pkt->stat_sn, conn->stat_sn++ );
+
+	if ( (nop_out_pkt->opcode & 0x40) == 0 )
+		conn->session->max_cmd_sn++;
+
+	iscsi_put_be32( (uint8_t *) &nop_in_pkt->exp_cmd_sn, conn->session->exp_cmd_sn );
+	iscsi_put_be32( (uint8_t *) &nop_in_pkt->max_cmd_sn, conn->session->max_cmd_sn );
+
+	iscsi_connection_pdu_write( conn, response_pdu, NULL, NULL );
+
+	// conn->nop_in_last = iscsi_get_ticks();
+
+	return ISCSI_CONNECT_PDU_READ_OK;
 }
 
 /**
@@ -4125,50 +5056,6 @@ static int iscsi_connection_pdu_data_handle_scsi_cmd(iscsi_connection *conn, isc
 }
 
 /**
- * @brief Allocates and replaces a string value to a key / value hash map pair.
- *
- * This function allocates memory for a string key
- * and its string value and replaces a original
- * key and value pair if it exists.
- *
- * @param[in] conn Pointer to iSCSI connection to update the
- * login key and value pair for and may NOT
- * be NULL, so take care.
- * @param[in] key_value_pairs Pointer to the hash map which should
- * contain the replaced string key and value pair. NULL is NOT
- * allowed here, so be careful.
- * @param[in] key String containing the key name as string. May
- * NOT be NULL, so take caution.
- * @param[in] value String containing the value to be stored.
- * @return 0 on successful operation, or a negative value on
- * error (memory exhaustion).
- */
-static int iscsi_connection_login_update_key_value_pair(iscsi_connection *conn, const uint8_t *key, const uint8_t *value)
-{
-	const uint key_len = (uint) strlen( (char *) key ) + 1;
-	uint8_t *hash_key = iscsi_hashmap_key_create( key, key_len );
-
-	if ( hash_key == NULL ) {
-		logadd( LOG_ERROR, "iscsi_connection_login_update_key_value_pair: Out of memory allocating key." );
-
-		return -1L;
-	}
-
-	const uint val_len = (uint) strlen( (char *) value ) + 1;
-	uint8_t *hash_val = (uint8_t *) malloc( val_len );
-
-	if ( hash_val == NULL ) {
-		logadd( LOG_ERROR, "iscsi_connection_login_update_key_value_pair: Out of memory allocating string value." );
-
-		return -1L;
-	}
-
-	memcpy( hash_val, value, val_len );
-
-	return iscsi_hashmap_put_free( conn->key_value_pairs, hash_key, key_len, hash_val, iscsi_hashmap_key_destroy_value_callback, NULL );
-}
-
-/**
  * @brief Negotiates connection authentication method (none or CHAP).
  *
  * This function updates the key and value pairs if, and only if
@@ -4180,12 +5067,12 @@ static int iscsi_connection_login_update_key_value_pair(iscsi_connection *conn,
  */
 static int iscsi_connection_chap_negotiate(iscsi_connection *conn)
 {
-	int rc = 0;
+	int rc = 0L;
 
 	if ( (conn->flags & ISCSI_CONNECT_FLAGS_CHAP_DISABLE) != 0 )
-		rc = iscsi_connection_login_update_key_value_pair( conn, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD, (uint8_t *) "None" );
+		rc = iscsi_update_key_value_pair( conn->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD, (uint8_t *) "None" );
 	else if ( (conn->flags & ISCSI_CONNECT_FLAGS_CHAP_REQUIRE) != 0 )
-		rc = iscsi_connection_login_update_key_value_pair( conn, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD, (uint8_t *) "CHAP" );
+		rc = iscsi_update_key_value_pair( conn->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD, (uint8_t *) "CHAP" );
 
 	return rc;
 }
@@ -4267,19 +5154,15 @@ static int iscsi_connection_login_chap_negotiate(iscsi_connection *conn, const i
  */
 static int iscsi_connection_login_digest_negotiate(iscsi_connection *conn, const iscsi_target_node *target)
 {
-	if ( target->header_digest != 0 ) {
-		const int rc = iscsi_connection_login_update_key_value_pair( conn, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_HEADER_DIGEST, (uint8_t *) "CRC32C" );
-
-		return rc;
-	}
+	int rc = 0L;
 
-	if ( target->data_digest != 0 ) {
-		const int rc = iscsi_connection_login_update_key_value_pair( conn, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_DIGEST, (uint8_t *) "CRC32C" );
+	if ( target->header_digest != 0 )
+		rc = iscsi_update_key_value_pair( conn->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_HEADER_DIGEST, (uint8_t *) "CRC32C" );
 
-		return rc;
-	}
+	if ( target->data_digest != 0 )
+		rc = iscsi_update_key_value_pair( conn->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SESSION_TEXT_KEY_DATA_DIGEST, (uint8_t *) "CRC32C" );
 
-	return 0L;
+	return rc;
 }
 
 /**
@@ -4434,7 +5317,7 @@ static int iscsi_connection_login_set_target_info(iscsi_connection *conn, iscsi_
 	int rc;
 
 	if ( target != NULL ) {
-		rc = iscsi_add_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ALIAS, ((target->alias != NULL) ? target->alias : (uint8_t *) "") );
+		rc = iscsi_update_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ALIAS, ((target->alias != NULL) ? target->alias : (uint8_t *) "") );
 
 		if ( rc < 0 )
 			return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER;
@@ -4445,14 +5328,14 @@ static int iscsi_connection_login_set_target_info(iscsi_connection *conn, iscsi_
 	if ( tmp_buf == NULL )
 		return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
 
-	rc = iscsi_add_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, tmp_buf );
+	rc = iscsi_update_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, tmp_buf );
 
 	free( tmp_buf );
 
 	if ( rc < 0 )
 		return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER;
 
-	rc = iscsi_add_int_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_PORTAL_GROUP_TAG, conn->pg_tag );
+	rc = iscsi_update_int_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_PORTAL_GROUP_TAG, conn->pg_tag );
 
 	if ( rc < 0 )
 		return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER;
@@ -4461,7 +5344,7 @@ static int iscsi_connection_login_set_target_info(iscsi_connection *conn, iscsi_
 		rc = iscsi_get_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ALIAS, &tmp_buf );
 
 		if ( (rc == 0) && (strlen( (char *) tmp_buf ) != 0) ) {
-			rc = iscsi_add_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ALIAS, tmp_buf );
+			rc = iscsi_update_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ALIAS, tmp_buf );
 
 			if ( rc < 0 )
 				return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
@@ -4471,7 +5354,7 @@ static int iscsi_connection_login_set_target_info(iscsi_connection *conn, iscsi_
 			rc = iscsi_get_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, &tmp_buf );
 
 			if ( (rc == 0) && (strlen( (char *) tmp_buf ) != 0) ) {
-				rc = iscsi_add_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, tmp_buf );
+				rc = iscsi_update_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_ADDRESS, tmp_buf );
 
 				if ( rc < 0 )
 					return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
@@ -4481,7 +5364,7 @@ static int iscsi_connection_login_set_target_info(iscsi_connection *conn, iscsi_
 		rc = iscsi_get_key_value_pair( conn->session->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_PORTAL_GROUP_TAG, &tmp_buf );
 
 		if ( rc == 0 ) {
-			rc = iscsi_add_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_PORTAL_GROUP_TAG, tmp_buf );
+			rc = iscsi_update_key_value_pair( login_response_pdu->key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_TARGET_PORTAL_GROUP_TAG, tmp_buf );
 
 			if ( rc < 0 )
 				return ISCSI_CONNECT_PDU_READ_ERR_FATAL;
@@ -4560,6 +5443,185 @@ static int iscsi_connection_handle_login_phase_none(iscsi_connection *conn, iscs
 }
 
 /**
+ * @brief Handles the Current Stage (CSG) bit of login response.
+ *
+ * This function determines the authentication method
+ * and processes the various authentication stages.
+ *
+ * @param[in] conn Pointer to iSCSI connection, may NOT be
+ * NULL, so take caution.
+ * @param[in] login_response_pdu Pointer to login response PDU.
+ * NULL is NOT an allowed value here, so be careful.
+ * @param[in] key_value_pairs Pointer to key and value pairs to
+ * retrieve authentication details from. This
+ * is NOT allowed to be NULL. Be careful!
+ * @return 0 if authentication has been handled successfully,
+ * a negative error code otherwise.
+ */
+static int iscsi_connecction_handle_login_response_csg_bit(iscsi_connection *conn, iscsi_pdu *login_response_pdu, iscsi_hashmap *key_value_pairs)
+{
+	iscsi_login_response_packet *login_response_pkt = (iscsi_login_response_packet *) login_response_pdu->bhs_pkt;
+
+	switch ( ISCSI_LOGIN_RESPONSE_FLAGS_GET_NEXT_STAGE(login_response_pkt->flags) ) {
+		case ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_SECURITY_NEGOTIATION : {
+			uint8_t *auth_method;
+			const int rc = iscsi_get_key_value_pair( key_value_pairs, (uint8_t *) ISCSI_LOGIN_AUTH_SECURITY_TEXT_KEY_AUTH_METHOD, (uint8_t **) &auth_method );
+
+			if ( rc < 0 ) {
+				login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+				login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISSING_PARAMETER;
+
+				return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+			}
+
+			if ( strcasecmp( (char *) auth_method, "None" ) == 0 ) {
+				conn->flags |= ISCSI_CONNECT_FLAGS_AUTH;
+			} else {
+				const int ds_len = iscsi_connection_auth_key_value_pairs( conn, key_value_pairs, auth_method, (uint8_t *) login_response_pdu->ds_cmd_data, login_response_pdu->pos, login_response_pdu->ds_len );
+
+				if ( ds_len < 0 ) {
+					login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+					login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_AUTH_ERR;
+
+					return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+				}
+
+				login_response_pdu->ds_len = ds_len;
+
+				if ( (conn->flags & ISCSI_CONNECT_FLAGS_AUTH) == 0 )
+					login_response_pkt->flags &= (int8_t) ~ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT;
+			}
+
+			break;
+		}
+		case ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_LOGIN_OPERATIONAL_NEGOTIATION : {
+			if ( conn->state == ISCSI_CONNECT_STATE_INVALID ) {
+				if ( conn->flags & ISCSI_CONNECT_FLAGS_CHAP_REQUIRE ) {
+					login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+					login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_AUTH_ERR;
+
+					return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+				} else {
+					conn->flags |= ISCSI_CONNECT_FLAGS_AUTH;
+				}
+			}
+
+			if ( (conn->flags & ISCSI_CONNECT_FLAGS_AUTH) == 0 ) {
+				login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+				login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_AUTH_ERR;
+
+				return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+			}
+
+			break;
+		}
+		case ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_FULL_FEATURE_PHASE : {
+			login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+			login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISC;
+
+			return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+
+			break;
+		}
+		default : {
+			login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+			login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISC;
+
+			return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+
+			break;
+		}
+	}
+
+	return ISCSI_CONNECT_PDU_READ_OK;
+}
+
+/**
+ *
+ * @brief Checks whether the session type is valid.
+ *
+ * This function also can be used to output
+ * debugging info about the session, which
+ * is currently not implemented.
+ *
+ * @param[in] conn Pointer to iSCSI connection to be checked for
+ * validity. May NOT be NULL, so be careful.
+ * @param[in] login_response_pdu Pointer to login response PDU to
+ * set status class and detail in case of an error.
+ * NULL is not an allowed value here, take caution.
+ * @return 0 if the session type is valid, a negative error code
+ * otherwise.
+ */
+static int iscsi_connection_login_session_info_notify(iscsi_connection *conn, iscsi_pdu *login_response_pdu)
+{
+	if ( (conn->session->type != ISCSI_SESSION_TYPE_NORMAL) && (conn->session->type != ISCSI_SESSION_TYPE_DISCOVERY) ) {
+		iscsi_login_response_packet *login_response_pkt = (iscsi_login_response_packet *) login_response_pdu->bhs_pkt;
+
+		login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+		login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISC;
+
+		return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+	}
+
+	return ISCSI_CONNECT_PDU_READ_OK;
+}
+
+/**
+ * @brief Handles the Transit (T) bit of login response.
+ *
+ * This function handles the transitional stages
+ * of the authentication process.
+ *
+ * @param[in] conn Pointer to iSCSI connection, may NOT be
+ * NULL, so take caution.
+ * @param[in] login_response_pdu Pointer to login response PDU.
+ * NULL is NOT an allowed value here, so be careful.
+ * @return 0 if transition has been handled successfully,
+ * a negative error code otherwise.
+ */
+static int iscsi_connecction_handle_login_response_t_bit(iscsi_connection *conn, iscsi_pdu *login_response_pdu)
+{
+	iscsi_login_response_packet *login_response_pkt = (iscsi_login_response_packet *) login_response_pdu->bhs_pkt;
+
+	switch ( ISCSI_LOGIN_RESPONSE_FLAGS_GET_NEXT_STAGE(login_response_pkt->flags) ) {
+		case ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_SECURITY_NEGOTIATION : {
+			conn->login_phase = ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_SECURITY_NEGOTIATION;
+
+			break;
+		}
+		case ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_LOGIN_OPERATIONAL_NEGOTIATION : {
+			conn->login_phase = ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_LOGIN_OPERATIONAL_NEGOTIATION;
+
+			break;
+		}
+		case ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_FULL_FEATURE_PHASE : {
+			conn->login_phase = ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_FULL_FEATURE_PHASE;
+
+			iscsi_put_be16( (uint8_t *) &login_response_pkt->tsih, conn->session->tsih );
+
+			const int rc = iscsi_connection_login_session_info_notify( conn, login_response_pdu );
+
+			if ( rc < 0 )
+				return rc;
+
+			conn->flags |= ISCSI_CONNECT_FLAGS_FULL_FEATURE;
+
+			break;
+		}
+		default : {
+			login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+			login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_MISC;
+
+			return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+
+			break;
+		}
+	}
+
+	return ISCSI_CONNECT_PDU_READ_OK;
+}
+
+/**
  * @brief Handles iSCSI connection login response.
  *
  * This function negotiates the login parameters
@@ -4575,9 +5637,27 @@ static int iscsi_connection_handle_login_phase_none(iscsi_connection *conn, iscs
  */
 static int iscsi_connecction_handle_login_response(iscsi_connection *conn, iscsi_pdu *login_response_pdu, iscsi_hashmap *key_value_pairs)
 {
-	// TODO: Implement function.
+	iscsi_login_response_packet *login_response_pkt = (iscsi_login_response_packet *) login_response_pdu->bhs_pkt;
+	const int ds_len = iscsi_negotiate_key_value_pairs( conn, key_value_pairs, (uint8_t *) login_response_pdu->ds_cmd_data, login_response_pdu->pos, login_response_pdu->ds_len );
 
-	return 0L;
+	if ( ds_len < 0 ) {
+		login_response_pkt->status_class  = ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR;
+		login_response_pkt->status_detail = ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_AUTH_ERR;
+
+		return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE;
+	}
+
+	login_response_pdu->ds_len = (uint) ds_len;
+
+	int rc = iscsi_connecction_handle_login_response_csg_bit( conn, login_response_pdu, key_value_pairs );
+
+	if ( rc < 0 )
+		return rc;
+
+	if ( (login_response_pkt->flags & ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT) != 0)
+		rc = iscsi_connecction_handle_login_response_t_bit( conn, login_response_pdu );
+
+	return rc;
 }
 
 /**
@@ -4831,7 +5911,7 @@ static int iscsi_connection_pdu_read(iscsi_connection *conn)
 				}
 
 				pdu->ds_len  = iscsi_align(pdu->ds_len, ISCSI_ALIGN_SIZE);
-				pdu->buf_len = pdu->ds_len;
+				pdu->pos     = pdu->ds_len;
 
 				const uint ahs_len = (uint) pdu->bhs_pkt->total_ahs_len << 2UL;
 
diff --git a/src/server/iscsi.h b/src/server/iscsi.h
index 56e09f9..5990d69 100644
--- a/src/server/iscsi.h
+++ b/src/server/iscsi.h
@@ -141,6 +141,12 @@ uint8_t *iscsi_sprintf_alloc(const char *format, ... ); // Allocates a buffer an
 /// Key data size must be multiple of 8 bytes by now.
 #define ISCSI_HASHMAP_KEY_ALIGN (1UL << (ISCSI_HASHMAP_KEY_ALIGN_SHIFT))
 
+/// Value data shift value for alignment enforcement.
+#define ISCSI_HASHMAP_VALUE_ALIGN_SHIFT 4UL
+
+/// Value data size is a multiple of 16 bytes for key and value pairs, which allows us to change their integer values without reallocation of memory.
+#define ISCSI_HASHMAP_VALUE_ALIGN (1UL << (ISCSI_HASHMAP_VALUE_ALIGN_SHIFT))
+
 
 /// Initial hash code.
 #define ISCSI_HASHMAP_HASH_INITIAL 0x811C9DC5UL
@@ -253,9 +259,21 @@ int iscsi_hashmap_iterate(iscsi_hashmap *map, iscsi_hashmap_callback callback, u
 /* iSCSI protocol stuff (all WORD/DWORD/QWORD values are big endian by default
    unless specified otherwise). */
 
-/// iSCSI Basic Header Segment size.
+/// iSCSI Basic Header Segment (BHS) size.
 #define ISCSI_BHS_SIZE 48UL
 
+/// iSCSI Advanced Header Segment (AHS) maximum allowed size.
+#define ISCSI_MAX_AHS_SIZE (255UL << 2UL)
+
+/// iSCSI DataSegment maximum allowed size.
+#define ISCSI_MAX_DS_SIZE 16777215UL
+
+/// iSCSI packet data alignment (BHS, AHS and DataSegment).
+#define ISCSI_ALIGN_SIZE 4UL
+
+/// iSCSI header and data digest size (CRC32C).
+#define ISCSI_DIGEST_SIZE 4UL
+
 
 /// iSCSI Default receive DataSegment (DS) size in bytes.
 #define ISCSI_DEFAULT_RECV_DS_LEN 8192UL
@@ -267,13 +285,6 @@ int iscsi_hashmap_iterate(iscsi_hashmap *map, iscsi_hashmap_callback callback, u
 #define ISCSI_DEFAULT_MAX_DATA_OUT_PER_CONNECTION 16UL
 
 
-/// iSCSI header and data digest size (CRC32C).
-#define ISCSI_DIGEST_SIZE 4UL
-
-/// iSCSI packet data alignment (BHS, AHS and DataSegment).
-#define ISCSI_ALIGN_SIZE 4UL
-
-
 /// Current minimum iSCSI protocol version supported by this implementation.
 #define ISCSI_VERSION_MIN 0
 
@@ -381,6 +392,7 @@ int iscsi_hashmap_iterate(iscsi_hashmap *map, iscsi_hashmap_callback callback, u
 /// Macro which extracts iSCSI packet data opcode out of opcode byte
 #define ISCSI_GET_OPCODE(x) ((x) & ISCSI_OPCODE_MASK)
 
+
 /**
  * @brief iSCSI Basic Header Segment packet data.
  *
@@ -4317,7 +4329,7 @@ typedef struct __attribute__((packed)) iscsi_isid {
  * this also indicates that the initiator is ready for the Login
  * Final-Response.
  */
-#define ISCSI_LOGIN_REQ_FLAGS_TRANSMIT (1 << 7)
+#define ISCSI_LOGIN_REQ_FLAGS_TRANSIT  (1 << 7)
 
 
 /**
@@ -4487,7 +4499,7 @@ typedef struct __attribute__((packed)) iscsi_login_req_packet {
 #define ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK ((1 << (ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_FIRST_BIT)) | (1 << (ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_SECOND_BIT)))
 
 /// Login response flags: Extracts the Next Stage (NSG) bits.
-#define ISCSI_LOGIN_RESPONSES_FLAGS_GET_NEXT_STAGE(x) (((x) & ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK) >> ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_FIRST_BIT)
+#define ISCSI_LOGIN_RESPONSE_FLAGS_GET_NEXT_STAGE(x) (((x) & ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_MASK) >> ISCSI_LOGIN_RESPONSE_FLAGS_NEXT_STAGE_FIRST_BIT)
 
 
 
@@ -4527,7 +4539,7 @@ typedef struct __attribute__((packed)) iscsi_login_req_packet {
 #define ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK ((1 << (ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_FIRST_BIT)) | (1 << (ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_SECOND_BIT)))
 
 /// Login request flags: Extracts the Current Stage (CSG) bits.
-#define ISCSI_LOGIN_RESPONSES_FLAGS_GET_CURRENT_STAGE(x) (((x) & ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK) >> ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_FIRST_BIT)
+#define ISCSI_LOGIN_RESPONSE_FLAGS_GET_CURRENT_STAGE(x) (((x) & ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_MASK) >> ISCSI_LOGIN_RESPONSE_FLAGS_CURRENT_STAGE_FIRST_BIT)
 
 
 /**
@@ -4554,7 +4566,7 @@ typedef struct __attribute__((packed)) iscsi_login_req_packet {
  * If the Status-Class is 0, the T bit MUST NOT be set to 1 if the T bit
  * in the request was set to 0.
  */
-#define ISCSI_LOGIN_RESPONSE_FLAGS_TRANSMIT      (1 << 7)
+#define ISCSI_LOGIN_RESPONSE_FLAGS_TRANSIT       (1 << 7)
 
 
 /**
@@ -5688,6 +5700,7 @@ int iscsi_validate_packet(const struct iscsi_bhs_packet *packet_data, const uint
 /// Maximum length of value for a normal key.
 #define ISCSI_TEXT_VALUE_MAX_LEN        8192UL
 
+
 /// iSCSI text key=value pair type: Invalid.
 #define ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_INVALID         -1L
 
@@ -5716,6 +5729,55 @@ int iscsi_validate_packet(const struct iscsi_bhs_packet *packet_data, const uint
 #define ISCSI_TEXT_KEY_VALUE_PAIR_TYPE_BOOL_AND         7L
 
 
+/// iSCSI key value pair flags: Discovery ignored.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_DISCOVERY_IGNORE    (1 << 0L)
+
+/// iSCSI key value pair flags: Multi negotiation.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_MULTI_NEGOTIATION   (1 << 1L)
+
+/// iSCSI key value pair flags: Target declarative.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_TARGET_DECLARATIVE  (1 << 2L)
+
+/// iSCSI key value pair flags: CHAP type.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_CHAP_TYPE           (1 << 3L)
+
+/// iSCSI key value pair flags: Requires special handling.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_SPECIAL_HANDLING    (1 << 4L)
+
+/// iSCSI key value pair flags: Use previous default value.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_PREVIOUS_VALUE  (1 << 5L)
+
+/// iSCSI key value pair flags: Override with default value.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_OVERRIDE_DEFAULT    (1 << 6L)
+
+/// iSCSI key value pair flags: Uses maximum value depending on secondary key.
+#define ISCSI_TEXT_KEY_VALUE_PAIR_FLAGS_USE_OTHER_MAX_VALUE (1 << 7L)
+
+
+/**
+ * @brief iSCSI connection and session lookup table entry, used for allowed key values and determining key type.
+ *
+ * This structure is shared by the iSCSI session
+ * and the iSCSI connection lookup table.
+ */
+typedef struct iscsi_key_value_pair_lut_entry {
+    /// Name of key.
+    uint8_t *key;
+
+    /// Default value of the key, always in string representation.
+    uint8_t *value;
+
+    /// NUL separated list of allowed string values. If key type is numeric: NUL separated minimum and maximum integer range. End is marked with another NUL.
+    uint8_t *list_range;
+
+    /// Type of key and value pair.
+    const int type;
+
+    /// Flags indicating special key attributes.
+    const int flags;
+} iscsi_key_value_pair_lut_entry;
+
+
 /**
  * @brief iSCSI Text / Login extracted key=value pair.
  *
@@ -5724,14 +5786,20 @@ int iscsi_validate_packet(const struct iscsi_bhs_packet *packet_data, const uint
  * Text or Login packet data.
  */
 typedef struct iscsi_key_value_pair {
+    /// Value of the key which is stored in the hash map.
+	uint8_t *value;
+
+    /// NUL separated list of allowed string values. If key type is numeric: NUL separated minimum and maximum integer range. End is marked with another NUL.
+    uint8_t *list_range;
+
     /// Type of key and value pair.
-	int type;
+    int type;
 
-    /// State index.
-	int state_index;
+    /// Flags indicating special key attributes.
+    int flags;
 
-    /// Value of the key which is stored in the hash map.
-	uint8_t *value;
+    /// State bit mask.
+	uint state_mask;
 } iscsi_key_value_pair;
 
 /**
@@ -5741,16 +5809,23 @@ typedef struct iscsi_key_value_pair {
  * pairs for sending as DataSegment packet data to the client.
  */
 typedef struct iscsi_key_value_pair_packet {
+    /// Associated iSCSI connection.
+    struct iscsi_connection *conn;
+
     /// Current text buffer containing multiple key=value + NUL terminator pairs.
     uint8_t *buf;
 
+    /// Position of output buffer for next write.
+    uint pos;
+
     /// Current length of buffer including final NUL terminator without iSCSI zero padding.
     uint len;
+
+    /// Discovery mode.
+    int discovery;
 } iscsi_key_value_pair_packet;
 
 int iscsi_parse_key_value_pairs(iscsi_hashmap *pairs, const uint8_t *packet_data, uint len, int c_bit, uint8_t **partial_pairs); // Extracts all text key / value pairs out of an iSCSI packet into a hash map
-int iscsi_create_key_value_pair_packet_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // Creates a single partial iSCSI packet stream out of a single text key and value pair
-iscsi_key_value_pair_packet *iscsi_create_key_value_pairs_packet(iscsi_hashmap *key_value_pairs); // Creates a properly aligned iSCSI packet DataSegment out of a hash map containing text key and value pairs
 
 
 /// iSCSI main global data flags: Allow duplicate ISIDs.
@@ -5785,9 +5860,15 @@ typedef struct iscsi_globals {
     /// Hash map containing all iSCSI sessions.
     iscsi_hashmap *sessions;
 
+    /// Hash map containing session key and value pair types and allowed values or ranges.
+    iscsi_hashmap *session_key_value_pairs;
+
     /// Hash map containing connections not associated with an iSCSI sessions.
     iscsi_hashmap *connections;
 
+    /// Hash map containing connection key and value pair types and allowed values or ranges.
+    iscsi_hashmap *connection_key_value_pairs;
+
     /// Global flags.
     int flags;
 
@@ -5799,10 +5880,14 @@ typedef struct iscsi_globals {
 } iscsi_globals;
 
 
-/// iSCSI vector for global access.
+/// iSCSI global vector. MUST be initialized with iscsi_create before any iSCSI functions are used.
 iscsi_globals *iscsi_globvec = NULL;
 
 
+int iscsi_create(); // Allocates and initializes the iSCSI global vector structure
+int iscsi_global_key_value_pair_destroy_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // iSCSI global key and value pair destructor callback for hash map
+void iscsi_destroy(); // Deallocates all resources acquired by iscsi_create
+
 /**
  * @brief iSCSI portal group: Private portal group if set, public otherwise.
  *
@@ -6179,44 +6264,50 @@ typedef struct iscsi_session {
 
 
 /// iSCSI connection read packet data return code from iscsi_connection_pdu_read function: Packet parsed successfully.
-#define ISCSI_CONNECT_PDU_READ_OK                   0L
+#define ISCSI_CONNECT_PDU_READ_OK                                 0L
 
 /// iSCSI connection read packet data return code from iscsi_connection_pdu_read function: Packet processed successfully.
-#define ISCSI_CONNECT_PDU_READ_PROCESSED            1L
+#define ISCSI_CONNECT_PDU_READ_PROCESSED                          1L
 
 /// iSCSI connection read packet data return code from iscsi_connection_pdu_read function: Fatail error during packet parsing.
-#define ISCSI_CONNECT_PDU_READ_ERR_FATAL           -1L
+#define ISCSI_CONNECT_PDU_READ_ERR_FATAL                         -1L
 
 /// iSCSI connection read packet data return code from iscsi_connection_pdu_read function: Login error response.
-#define ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE  -2L
+#define ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE                -2L
 
 /// iSCSI connection read packet data return code from iscsi_connection_pdu_read function: Login parameter error.
-#define ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER -3L
+#define ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER               -3L
+
+/// iSCSI connection read packet data return code from iscsi_connection_pdu_read function: Login parameter not exchanged once error.
+#define ISCSI_CONNECT_PDU_READ_ERR_LOGIN_PARAMETER_XCHG_NOT_ONCE -4L
 
 
 /// iSCSI connection flags: Stopped.
-#define ISCSI_CONNECT_FLAGS_STOPPED      (1 << 0L)
+#define ISCSI_CONNECT_FLAGS_STOPPED         (1 << 0L)
 
 /// iSCSI connection flags: Rejected.
-#define ISCSI_CONNECT_FLAGS_REJECTED     (1 << 1L)
+#define ISCSI_CONNECT_FLAGS_REJECTED        (1 << 1L)
 
 /// iSCSI connection flags: Logged out.
-#define ISCSI_CONNECT_FLAGS_LOGGED_OUT   (1 << 2L)
+#define ISCSI_CONNECT_FLAGS_LOGGED_OUT      (1 << 2L)
 
 /// iSCSI connection flags: Full feature.
-#define ISCSI_CONNECT_FLAGS_FULL_FEATURE (1 << 3L)
+#define ISCSI_CONNECT_FLAGS_FULL_FEATURE    (1 << 3L)
 
 /// iSCSI connection flags: CHAP authentication is disabled.
-#define ISCSI_CONNECT_FLAGS_CHAP_DISABLE (1 << 4L)
+#define ISCSI_CONNECT_FLAGS_CHAP_DISABLE    (1 << 4L)
 
 /// iSCSI connection flags: CHAP authentication is required.
-#define ISCSI_CONNECT_FLAGS_CHAP_REQUIRE (1 << 5L)
+#define ISCSI_CONNECT_FLAGS_CHAP_REQUIRE    (1 << 5L)
 
 /// iSCSI connection flags: CHAP authentication is mutual.
-#define ISCSI_CONNECT_FLAGS_CHAP_MUTUAL  (1 << 6L)
+#define ISCSI_CONNECT_FLAGS_CHAP_MUTUAL     (1 << 6L)
 
 /// iSCSI connection flags: Authenticated.
-#define ISCSI_CONNECT_FLAGS_AUTH         (1 << 7L)
+#define ISCSI_CONNECT_FLAGS_AUTH            (1 << 7L)
+
+/// iSCSI connection flags: Oustanding NOP.
+#define ISCSI_CONNECT_FLAGS_NOP_OUTSTANDING (1 << 8L)
 
 
 /// Ready to wait for PDU.
@@ -6302,6 +6393,9 @@ typedef struct iscsi_connection {
     /// Login response PDU.
     struct iscsi_pdu *login_response_pdu;
 
+    /// Internal connection identifier (key of iSCSI global vector hash map).
+    int id;
+
     /// Connected TCP/IP socket.
     int sock;
 
@@ -6314,6 +6408,9 @@ typedef struct iscsi_connection {
     /// iSCSI connection state.
     int state;
 
+    /// iSCSI connection login phase.
+    int login_phase;
+
     /// Maximum receive DataSegment length in bytes.
     uint max_recv_ds_len;
 
@@ -6329,6 +6426,12 @@ typedef struct iscsi_connection {
     /// Connection ID (CID).
     uint16_t cid;
 
+    /// Bit mask for connection state key negotiation.
+    uint16_t state_negotiated;
+
+    /// Bit mask for session state key negotiation.
+    uint32_t session_state_negotiated;
+
     /// Initiator Task Tag (ITT).
     uint32_t init_task_tag;
 
@@ -6403,10 +6506,10 @@ typedef struct iscsi_pdu {
     /// DataSegmentLength.
     uint ds_len;
 
-    /// Remaining bytes of DataSegment buffer to read.
-    uint buf_len;
+    /// Position of DataSegment buffer for next read.
+    uint pos;
 
-    /// Associated connection.
+    /// Associated iSCSI connection.
     iscsi_connection *conn;
 
     /// CmdSN.
@@ -6423,6 +6526,8 @@ int iscsi_target_node_access(iscsi_connection *conn, iscsi_target_node *target,
 iscsi_session *iscsi_session_create(iscsi_connection *conn, iscsi_target_node *target, const int type); // Creates and initializes an iSCSI session
 void iscsi_session_destroy(iscsi_session *session); // Deallocates all resources acquired by iscsi_session_create
 
+int iscsi_session_init_key_value_pairs(iscsi_hashmap *key_value_pairs); // Initializes a key and value pair hash table with default values
+
 iscsi_connection *iscsi_connection_create(iscsi_portal *portal, const int sock); // Creates data structure for an iSCSI connection from iSCSI portal and TCP/IP socket
 int iscsi_connection_destroy_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // iSCSI connection destructor callback for hash map
 void iscsi_connection_destroy(iscsi_connection *conn); // Deallocates all resources acquired by iscsi_connection_create
@@ -6433,6 +6538,8 @@ void iscsi_connection_schedule(iscsi_connection *conn); // Schedules an iSCSI co
 int iscsi_connection_read(const iscsi_connection *conn, uint8_t *buf, const uint len); // Reads data for the specified iSCSI connection from its TCP socket
 int iscsi_connection_write(const iscsi_connection *conn, uint8_t *buf, const uint len); // Writes data for the specified iSCSI connection to its TCP socket
 
+int iscsi_connection_init_key_value_pairs(iscsi_hashmap *key_value_pairs); // Initializes a key and value pair hash table with default values for an iSCSI connection
+int iscsi_negotiate_key_value_pairs(iscsi_connection *conn, iscsi_hashmap *key_value_pairs, uint8_t *buf, const uint pos, const uint len); // Negotiates all key and value pairs required for session authentication
 int iscsi_connection_copy_key_value_pairs(iscsi_connection *conn); // Copies retrieved key and value pairs into SCSI connection and session structures
 int iscsi_connection_save_incoming_key_value_pairs(iscsi_connection *conn, iscsi_hashmap *key_value_pairs, iscsi_pdu *login_response_pdu, const iscsi_pdu *pdu); // Saves incoming key / value pairs from the client of a login request PDU