1a6d42e7dSPeter Dunlap /*
2a6d42e7dSPeter Dunlap  * CDDL HEADER START
3a6d42e7dSPeter Dunlap  *
4a6d42e7dSPeter Dunlap  * The contents of this file are subject to the terms of the
5a6d42e7dSPeter Dunlap  * Common Development and Distribution License (the "License").
6a6d42e7dSPeter Dunlap  * You may not use this file except in compliance with the License.
7a6d42e7dSPeter Dunlap  *
8a6d42e7dSPeter Dunlap  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9a6d42e7dSPeter Dunlap  * or http://www.opensolaris.org/os/licensing.
10a6d42e7dSPeter Dunlap  * See the License for the specific language governing permissions
11a6d42e7dSPeter Dunlap  * and limitations under the License.
12a6d42e7dSPeter Dunlap  *
13a6d42e7dSPeter Dunlap  * When distributing Covered Code, include this CDDL HEADER in each
14a6d42e7dSPeter Dunlap  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15a6d42e7dSPeter Dunlap  * If applicable, add the following below this CDDL HEADER, with the
16a6d42e7dSPeter Dunlap  * fields enclosed by brackets "[]" replaced with your own identifying
17a6d42e7dSPeter Dunlap  * information: Portions Copyright [yyyy] [name of copyright owner]
18a6d42e7dSPeter Dunlap  *
19a6d42e7dSPeter Dunlap  * CDDL HEADER END
20a6d42e7dSPeter Dunlap  */
21483b029bSYuri Pankov 
22a6d42e7dSPeter Dunlap /*
234558d122SViswanathan Kannappan  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
241ef61828SYuri Pankov  * Copyright 2016 Nexenta Systems, Inc.
25a6d42e7dSPeter Dunlap  */
26a6d42e7dSPeter Dunlap 
27a6d42e7dSPeter Dunlap #include <sys/cpuvar.h>
28a6d42e7dSPeter Dunlap #include <sys/types.h>
29a6d42e7dSPeter Dunlap #include <sys/conf.h>
30a6d42e7dSPeter Dunlap #include <sys/file.h>
31a6d42e7dSPeter Dunlap #include <sys/ddi.h>
32a6d42e7dSPeter Dunlap #include <sys/sunddi.h>
33a6d42e7dSPeter Dunlap #include <sys/modctl.h>
34716c1805SNattuvetty Bhavyan #include <sys/scsi/generic/persist.h>
351ef61828SYuri Pankov #include <sys/scsi/scsi_names.h>
36a6d42e7dSPeter Dunlap 
37a6d42e7dSPeter Dunlap #include <sys/socket.h>
38a6d42e7dSPeter Dunlap #include <sys/strsubr.h>
39a6d42e7dSPeter Dunlap #include <sys/sysmacros.h>
40a6d42e7dSPeter Dunlap #include <sys/note.h>
41a6d42e7dSPeter Dunlap #include <sys/sdt.h>
421ef61828SYuri Pankov #include <sys/errno.h>
43a6d42e7dSPeter Dunlap 
44a6d42e7dSPeter Dunlap #include <sys/stmf.h>
45a6d42e7dSPeter Dunlap #include <sys/stmf_ioctl.h>
46a6d42e7dSPeter Dunlap #include <sys/portif.h>
47a6d42e7dSPeter Dunlap #include <sys/idm/idm.h>
48a6d42e7dSPeter Dunlap #include <sys/idm/idm_text.h>
49*61dfa509SRick McNeal #include <sys/idm/idm_so.h>
50a6d42e7dSPeter Dunlap 
51a6d42e7dSPeter Dunlap #define	ISCSIT_LOGIN_SM_STRINGS
524558d122SViswanathan Kannappan #include "iscsit.h"
534558d122SViswanathan Kannappan #include "iscsit_auth.h"
54a6d42e7dSPeter Dunlap 
55a6d42e7dSPeter Dunlap typedef struct {
56a6d42e7dSPeter Dunlap 	list_node_t		le_ctx_node;
57a6d42e7dSPeter Dunlap 	iscsit_login_event_t	le_ctx_event;
58a6d42e7dSPeter Dunlap 	idm_pdu_t		*le_pdu;
59a6d42e7dSPeter Dunlap } login_event_ctx_t;
60a6d42e7dSPeter Dunlap 
61a6d42e7dSPeter Dunlap #ifndef TRUE
62a6d42e7dSPeter Dunlap #define	TRUE B_TRUE
63a6d42e7dSPeter Dunlap #endif
64a6d42e7dSPeter Dunlap 
65a6d42e7dSPeter Dunlap #ifndef FALSE
66a6d42e7dSPeter Dunlap #define	FALSE B_FALSE
67a6d42e7dSPeter Dunlap #endif
68a6d42e7dSPeter Dunlap 
69a6d42e7dSPeter Dunlap #define	DEFAULT_RADIUS_PORT	1812
70a6d42e7dSPeter Dunlap 
71a6d42e7dSPeter Dunlap static void
72a6d42e7dSPeter Dunlap login_sm_complete(void *ict_void);
73a6d42e7dSPeter Dunlap 
74a6d42e7dSPeter Dunlap static void
75a6d42e7dSPeter Dunlap login_sm_event_dispatch(iscsit_conn_login_t *lsm, iscsit_conn_t *ict,
76a6d42e7dSPeter Dunlap     login_event_ctx_t *ctx);
77a6d42e7dSPeter Dunlap 
78a6d42e7dSPeter Dunlap static void
79a6d42e7dSPeter Dunlap login_sm_init(iscsit_conn_t *ict, login_event_ctx_t *ctx);
80a6d42e7dSPeter Dunlap 
81a6d42e7dSPeter Dunlap static void
82a6d42e7dSPeter Dunlap login_sm_waiting(iscsit_conn_t *ict, login_event_ctx_t *ctx);
83a6d42e7dSPeter Dunlap 
84a6d42e7dSPeter Dunlap static void
85a6d42e7dSPeter Dunlap login_sm_processing(iscsit_conn_t *ict, login_event_ctx_t *ctx);
86a6d42e7dSPeter Dunlap 
87a6d42e7dSPeter Dunlap static void
88a6d42e7dSPeter Dunlap login_sm_responding(iscsit_conn_t *ict, login_event_ctx_t *ctx);
89a6d42e7dSPeter Dunlap 
90a6d42e7dSPeter Dunlap static void
91a6d42e7dSPeter Dunlap login_sm_responded(iscsit_conn_t *ict, login_event_ctx_t *ctx);
92a6d42e7dSPeter Dunlap 
93a6d42e7dSPeter Dunlap static void
94a6d42e7dSPeter Dunlap login_sm_ffp(iscsit_conn_t *ict, login_event_ctx_t *ctx);
95a6d42e7dSPeter Dunlap 
96a6d42e7dSPeter Dunlap static void
97a6d42e7dSPeter Dunlap login_sm_done(iscsit_conn_t *ict, login_event_ctx_t *ctx);
98a6d42e7dSPeter Dunlap 
99a6d42e7dSPeter Dunlap static void
100a6d42e7dSPeter Dunlap login_sm_error(iscsit_conn_t *ict, login_event_ctx_t *ctx);
101a6d42e7dSPeter Dunlap 
102a6d42e7dSPeter Dunlap static void
103a6d42e7dSPeter Dunlap login_sm_new_state(iscsit_conn_t *ict, login_event_ctx_t *ctx,
104a6d42e7dSPeter Dunlap     iscsit_login_state_t new_state);
105a6d42e7dSPeter Dunlap 
106a6d42e7dSPeter Dunlap static void
107a6d42e7dSPeter Dunlap login_sm_send_ack(iscsit_conn_t *ict, idm_pdu_t *pdu);
108a6d42e7dSPeter Dunlap 
109a6d42e7dSPeter Dunlap static idm_status_t
110a6d42e7dSPeter Dunlap login_sm_validate_ack(iscsit_conn_t *ict, idm_pdu_t *pdu);
111a6d42e7dSPeter Dunlap 
112a6d42e7dSPeter Dunlap static boolean_t
1134142b486SJames Moore login_sm_is_last_response(idm_pdu_t *pdu);
114a6d42e7dSPeter Dunlap 
115a6d42e7dSPeter Dunlap static void
116a6d42e7dSPeter Dunlap login_sm_handle_initial_login(iscsit_conn_t *ict, idm_pdu_t *pdu);
117a6d42e7dSPeter Dunlap 
118a6d42e7dSPeter Dunlap static void
1194142b486SJames Moore login_sm_send_next_response(iscsit_conn_t *ict, idm_pdu_t *pdu);
120a6d42e7dSPeter Dunlap 
121a6d42e7dSPeter Dunlap static void
122a6d42e7dSPeter Dunlap login_sm_process_request(iscsit_conn_t *ict);
123a6d42e7dSPeter Dunlap 
124a6d42e7dSPeter Dunlap static idm_status_t
125a6d42e7dSPeter Dunlap login_sm_req_pdu_check(iscsit_conn_t *ict, idm_pdu_t *pdu);
126a6d42e7dSPeter Dunlap 
127a6d42e7dSPeter Dunlap static idm_status_t
128a6d42e7dSPeter Dunlap login_sm_process_nvlist(iscsit_conn_t *ict);
129a6d42e7dSPeter Dunlap 
130a6d42e7dSPeter Dunlap static idm_status_t
131a6d42e7dSPeter Dunlap login_sm_check_security(iscsit_conn_t *ict);
132a6d42e7dSPeter Dunlap 
1334142b486SJames Moore static idm_pdu_t *
134a6d42e7dSPeter Dunlap login_sm_build_login_response(iscsit_conn_t *ict);
135a6d42e7dSPeter Dunlap 
136a6d42e7dSPeter Dunlap static void
137a6d42e7dSPeter Dunlap login_sm_ffp_actions(iscsit_conn_t *ict);
138a6d42e7dSPeter Dunlap 
139a6d42e7dSPeter Dunlap static idm_status_t
140a6d42e7dSPeter Dunlap login_sm_validate_initial_parameters(iscsit_conn_t *ict);
141a6d42e7dSPeter Dunlap 
142a6d42e7dSPeter Dunlap static idm_status_t
143a6d42e7dSPeter Dunlap login_sm_session_bind(iscsit_conn_t *ict);
144a6d42e7dSPeter Dunlap 
145a6d42e7dSPeter Dunlap static idm_status_t
146a6d42e7dSPeter Dunlap login_sm_set_auth(iscsit_conn_t *ict);
147a6d42e7dSPeter Dunlap 
148a6d42e7dSPeter Dunlap static idm_status_t
149a6d42e7dSPeter Dunlap login_sm_session_register(iscsit_conn_t *ict);
150a6d42e7dSPeter Dunlap 
151a6d42e7dSPeter Dunlap static kv_status_t
152a6d42e7dSPeter Dunlap iscsit_handle_key(iscsit_conn_t *ict, nvpair_t *nvp, char *nvp_name);
153a6d42e7dSPeter Dunlap 
154a6d42e7dSPeter Dunlap static kv_status_t
155a6d42e7dSPeter Dunlap iscsit_handle_common_key(iscsit_conn_t *ict, nvpair_t *nvp,
156a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx);
157a6d42e7dSPeter Dunlap 
158a6d42e7dSPeter Dunlap static kv_status_t
159a6d42e7dSPeter Dunlap iscsit_handle_security_key(iscsit_conn_t *ict, nvpair_t *nvp,
160a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx);
161a6d42e7dSPeter Dunlap 
162a6d42e7dSPeter Dunlap static kv_status_t
163a6d42e7dSPeter Dunlap iscsit_reply_security_key(iscsit_conn_t *ict);
164a6d42e7dSPeter Dunlap 
165a6d42e7dSPeter Dunlap static kv_status_t
166a6d42e7dSPeter Dunlap iscsit_handle_operational_key(iscsit_conn_t *ict, nvpair_t *nvp,
167a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx);
168a6d42e7dSPeter Dunlap 
169a6d42e7dSPeter Dunlap static kv_status_t
170a6d42e7dSPeter Dunlap iscsit_reply_numerical(iscsit_conn_t *ict,
171a6d42e7dSPeter Dunlap     const char *nvp_name, const uint64_t value);
172a6d42e7dSPeter Dunlap 
173a6d42e7dSPeter Dunlap static kv_status_t
174a6d42e7dSPeter Dunlap iscsit_reply_string(iscsit_conn_t *ict,
175a6d42e7dSPeter Dunlap     const char *nvp_name, const char *text);
176a6d42e7dSPeter Dunlap 
177a6d42e7dSPeter Dunlap static kv_status_t
178a6d42e7dSPeter Dunlap iscsit_handle_digest(iscsit_conn_t *ict, nvpair_t *choices,
179a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx);
180a6d42e7dSPeter Dunlap 
181a6d42e7dSPeter Dunlap static kv_status_t
182a6d42e7dSPeter Dunlap iscsit_handle_boolean(iscsit_conn_t *ict, nvpair_t *nvp, boolean_t value,
183a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx, boolean_t iscsit_value);
184a6d42e7dSPeter Dunlap 
185a6d42e7dSPeter Dunlap static kv_status_t
186a6d42e7dSPeter Dunlap iscsit_handle_numerical(iscsit_conn_t *ict, nvpair_t *nvp, uint64_t value,
187a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx,
188a6d42e7dSPeter Dunlap     uint64_t iscsi_min_value, uint64_t iscsi_max_value,
189a6d42e7dSPeter Dunlap     uint64_t iscsit_max_value);
190a6d42e7dSPeter Dunlap 
191a6d42e7dSPeter Dunlap static void
192a6d42e7dSPeter Dunlap iscsit_process_negotiated_values(iscsit_conn_t *ict);
193a6d42e7dSPeter Dunlap 
194a6d42e7dSPeter Dunlap static void
195a6d42e7dSPeter Dunlap login_resp_complete_cb(idm_pdu_t *pdu, idm_status_t status);
196a6d42e7dSPeter Dunlap 
19756261083SCharles Ting static idm_status_t
19856261083SCharles Ting iscsit_add_declarative_keys(iscsit_conn_t *ict);
19956261083SCharles Ting 
2001ef61828SYuri Pankov static char *
2011ef61828SYuri Pankov iscsit_fold_name(char *name, size_t *buflen);
2021ef61828SYuri Pankov 
20356261083SCharles Ting uint64_t max_dataseglen_target = ISCSIT_MAX_RECV_DATA_SEGMENT_LENGTH;
20456261083SCharles Ting 
2053fc1e17eSPriya Krishnan /*
2063fc1e17eSPriya Krishnan  * global mutex defined in iscsit.c to enforce
2073fc1e17eSPriya Krishnan  * login_sm_session_bind as a critical section
2083fc1e17eSPriya Krishnan  */
2093fc1e17eSPriya Krishnan extern kmutex_t login_sm_session_mutex;
2103fc1e17eSPriya Krishnan 
211a6d42e7dSPeter Dunlap idm_status_t
iscsit_login_sm_init(iscsit_conn_t * ict)212a6d42e7dSPeter Dunlap iscsit_login_sm_init(iscsit_conn_t *ict)
213a6d42e7dSPeter Dunlap {
214a6d42e7dSPeter Dunlap 	iscsit_conn_login_t *lsm = &ict->ict_login_sm;
215a6d42e7dSPeter Dunlap 
216a6d42e7dSPeter Dunlap 	bzero(lsm, sizeof (iscsit_conn_login_t));
217a6d42e7dSPeter Dunlap 
218a6d42e7dSPeter Dunlap 	(void) nvlist_alloc(&lsm->icl_negotiated_values, NV_UNIQUE_NAME,
219a6d42e7dSPeter Dunlap 	    KM_SLEEP);
220a6d42e7dSPeter Dunlap 
221a6d42e7dSPeter Dunlap 	/*
222a6d42e7dSPeter Dunlap 	 * Hold connection until the login state machine completes
223a6d42e7dSPeter Dunlap 	 */
224a6d42e7dSPeter Dunlap 	iscsit_conn_hold(ict);
225a6d42e7dSPeter Dunlap 
226a6d42e7dSPeter Dunlap 	/*
227a6d42e7dSPeter Dunlap 	 * Pre-allocating a login response PDU means we will always be
228a6d42e7dSPeter Dunlap 	 * able to respond to a login request -- even if we can't allocate
229a6d42e7dSPeter Dunlap 	 * a data buffer to hold the text responses we can at least send
230a6d42e7dSPeter Dunlap 	 * a login failure.
231a6d42e7dSPeter Dunlap 	 */
232a6d42e7dSPeter Dunlap 	lsm->icl_login_resp_tmpl = kmem_zalloc(sizeof (iscsi_login_rsp_hdr_t),
233a6d42e7dSPeter Dunlap 	    KM_SLEEP);
234a6d42e7dSPeter Dunlap 
235a6d42e7dSPeter Dunlap 	idm_sm_audit_init(&lsm->icl_state_audit);
236a6d42e7dSPeter Dunlap 	mutex_init(&lsm->icl_mutex, NULL, MUTEX_DEFAULT, NULL);
237a6d42e7dSPeter Dunlap 	list_create(&lsm->icl_login_events, sizeof (login_event_ctx_t),
238a6d42e7dSPeter Dunlap 	    offsetof(login_event_ctx_t, le_ctx_node));
239a6d42e7dSPeter Dunlap 	list_create(&lsm->icl_pdu_list, sizeof (idm_pdu_t),
240a6d42e7dSPeter Dunlap 	    offsetof(idm_pdu_t, isp_client_lnd));
241a6d42e7dSPeter Dunlap 
242a6d42e7dSPeter Dunlap 	lsm->icl_login_state = ILS_LOGIN_INIT;
243a6d42e7dSPeter Dunlap 	lsm->icl_login_last_state = ILS_LOGIN_INIT;
244a6d42e7dSPeter Dunlap 
245a6d42e7dSPeter Dunlap 	/*
246a6d42e7dSPeter Dunlap 	 * Initialize operational parameters to default values.  Anything
247a6d42e7dSPeter Dunlap 	 * we don't specifically negotiate stays at the default.
248a6d42e7dSPeter Dunlap 	 */
249a6d42e7dSPeter Dunlap 	ict->ict_op.op_discovery_session = B_FALSE;
250a6d42e7dSPeter Dunlap 	ict->ict_op.op_initial_r2t = ISCSI_DEFAULT_INITIALR2T;
251a6d42e7dSPeter Dunlap 	ict->ict_op.op_immed_data = ISCSI_DEFAULT_IMMEDIATE_DATA;
252a6d42e7dSPeter Dunlap 	ict->ict_op.op_data_pdu_in_order = ISCSI_DEFAULT_DATA_PDU_IN_ORDER;
253a6d42e7dSPeter Dunlap 	ict->ict_op.op_data_sequence_in_order =
254a6d42e7dSPeter Dunlap 	    ISCSI_DEFAULT_DATA_SEQUENCE_IN_ORDER;
255a6d42e7dSPeter Dunlap 	ict->ict_op.op_max_connections = ISCSI_DEFAULT_MAX_CONNECTIONS;
256a6d42e7dSPeter Dunlap 	ict->ict_op.op_max_recv_data_segment_length =
257a6d42e7dSPeter Dunlap 	    ISCSI_DEFAULT_MAX_RECV_SEG_LEN;
258a6d42e7dSPeter Dunlap 	ict->ict_op.op_max_burst_length = ISCSI_DEFAULT_MAX_BURST_LENGTH;
259a6d42e7dSPeter Dunlap 	ict->ict_op.op_first_burst_length = ISCSI_DEFAULT_FIRST_BURST_LENGTH;
260a6d42e7dSPeter Dunlap 	ict->ict_op.op_default_time_2_wait = ISCSI_DEFAULT_TIME_TO_WAIT;
261a6d42e7dSPeter Dunlap 	ict->ict_op.op_default_time_2_retain = ISCSI_DEFAULT_TIME_TO_RETAIN;
262a6d42e7dSPeter Dunlap 	ict->ict_op.op_max_outstanding_r2t = ISCSI_DEFAULT_MAX_OUT_R2T;
263a6d42e7dSPeter Dunlap 	ict->ict_op.op_error_recovery_level =
264a6d42e7dSPeter Dunlap 	    ISCSI_DEFAULT_ERROR_RECOVERY_LEVEL;
265a6d42e7dSPeter Dunlap 
266a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
267a6d42e7dSPeter Dunlap }
268a6d42e7dSPeter Dunlap 
269a6d42e7dSPeter Dunlap static void
login_resp_complete_cb(idm_pdu_t * pdu,idm_status_t status)270a6d42e7dSPeter Dunlap login_resp_complete_cb(idm_pdu_t *pdu, idm_status_t status)
271a6d42e7dSPeter Dunlap {
272a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = pdu->isp_private;
273a6d42e7dSPeter Dunlap 
274a6d42e7dSPeter Dunlap 	/*
2754142b486SJames Moore 	 * Check that this is a login pdu
276a6d42e7dSPeter Dunlap 	 */
277a6d42e7dSPeter Dunlap 	ASSERT((pdu->isp_flags & IDM_PDU_LOGIN_TX) != 0);
2784142b486SJames Moore 	idm_pdu_free(pdu);
279a6d42e7dSPeter Dunlap 
280a6d42e7dSPeter Dunlap 	if ((status != IDM_STATUS_SUCCESS) ||
281a6d42e7dSPeter Dunlap 	    (ict->ict_login_sm.icl_login_resp_err_class != 0)) {
2824142b486SJames Moore 		/*
2834142b486SJames Moore 		 * Transport or login error occurred.
2844142b486SJames Moore 		 */
285a6d42e7dSPeter Dunlap 		iscsit_login_sm_event(ict, ILE_LOGIN_ERROR, NULL);
286a6d42e7dSPeter Dunlap 	}
2874142b486SJames Moore 	iscsit_conn_rele(ict);
288a6d42e7dSPeter Dunlap }
289a6d42e7dSPeter Dunlap 
290a6d42e7dSPeter Dunlap void
iscsit_login_sm_fini(iscsit_conn_t * ict)291a6d42e7dSPeter Dunlap iscsit_login_sm_fini(iscsit_conn_t *ict)
292a6d42e7dSPeter Dunlap {
293a6d42e7dSPeter Dunlap 	iscsit_conn_login_t *lsm = &ict->ict_login_sm;
294a6d42e7dSPeter Dunlap 
295a6d42e7dSPeter Dunlap 	mutex_enter(&lsm->icl_mutex);
296a6d42e7dSPeter Dunlap 	list_destroy(&lsm->icl_pdu_list);
297a6d42e7dSPeter Dunlap 	list_destroy(&lsm->icl_login_events);
298a6d42e7dSPeter Dunlap 
299a6d42e7dSPeter Dunlap 	kmem_free(lsm->icl_login_resp_tmpl, sizeof (iscsi_login_rsp_hdr_t));
300a6d42e7dSPeter Dunlap 
301a6d42e7dSPeter Dunlap 	/* clean up the login response idm text buffer */
302a6d42e7dSPeter Dunlap 	if (lsm->icl_login_resp_itb != NULL) {
303a6d42e7dSPeter Dunlap 		idm_itextbuf_free(lsm->icl_login_resp_itb);
304a6d42e7dSPeter Dunlap 		lsm->icl_login_resp_itb = NULL;
305a6d42e7dSPeter Dunlap 	}
306a6d42e7dSPeter Dunlap 
307a6d42e7dSPeter Dunlap 	nvlist_free(lsm->icl_negotiated_values);
3084142b486SJames Moore 	mutex_destroy(&lsm->icl_mutex);
309a6d42e7dSPeter Dunlap }
310a6d42e7dSPeter Dunlap 
311a6d42e7dSPeter Dunlap void
iscsit_login_sm_event(iscsit_conn_t * ict,iscsit_login_event_t event,idm_pdu_t * pdu)312a6d42e7dSPeter Dunlap iscsit_login_sm_event(iscsit_conn_t *ict, iscsit_login_event_t event,
313a6d42e7dSPeter Dunlap     idm_pdu_t *pdu)
314a6d42e7dSPeter Dunlap {
315a6d42e7dSPeter Dunlap 	/*
316a6d42e7dSPeter Dunlap 	 * This is a bit ugly but if we're already in ILS_LOGIN_ERROR
317a6d42e7dSPeter Dunlap 	 * or ILS_LOGIN_DONE then just drop any additional events.  They
318a6d42e7dSPeter Dunlap 	 * won't change the state and it's possible we've already called
319a6d42e7dSPeter Dunlap 	 * iscsit_login_sm_fini in which case the mutex is destroyed.
320a6d42e7dSPeter Dunlap 	 */
321a6d42e7dSPeter Dunlap 	if ((ict->ict_login_sm.icl_login_state == ILS_LOGIN_ERROR) ||
322a6d42e7dSPeter Dunlap 	    (ict->ict_login_sm.icl_login_state == ILS_LOGIN_DONE))
323a6d42e7dSPeter Dunlap 		return;
324a6d42e7dSPeter Dunlap 
325a6d42e7dSPeter Dunlap 	mutex_enter(&ict->ict_login_sm.icl_mutex);
326a6d42e7dSPeter Dunlap 	iscsit_login_sm_event_locked(ict, event, pdu);
327a6d42e7dSPeter Dunlap 	mutex_exit(&ict->ict_login_sm.icl_mutex);
328a6d42e7dSPeter Dunlap }
329a6d42e7dSPeter Dunlap void
iscsit_login_sm_event_locked(iscsit_conn_t * ict,iscsit_login_event_t event,idm_pdu_t * pdu)330a6d42e7dSPeter Dunlap iscsit_login_sm_event_locked(iscsit_conn_t *ict, iscsit_login_event_t event,
331a6d42e7dSPeter Dunlap     idm_pdu_t *pdu)
332a6d42e7dSPeter Dunlap {
333a6d42e7dSPeter Dunlap 	iscsit_conn_login_t *lsm = &ict->ict_login_sm;
334a6d42e7dSPeter Dunlap 	login_event_ctx_t *ctx;
335a6d42e7dSPeter Dunlap 
3364142b486SJames Moore 	ASSERT(mutex_owned(&lsm->icl_mutex));
337a6d42e7dSPeter Dunlap 	ctx = kmem_zalloc(sizeof (*ctx), KM_SLEEP);
338a6d42e7dSPeter Dunlap 
339a6d42e7dSPeter Dunlap 	ctx->le_ctx_event = event;
340a6d42e7dSPeter Dunlap 	ctx->le_pdu = pdu;
341a6d42e7dSPeter Dunlap 
342a6d42e7dSPeter Dunlap 	list_insert_tail(&lsm->icl_login_events, ctx);
343a6d42e7dSPeter Dunlap 
344a6d42e7dSPeter Dunlap 	/*
345a6d42e7dSPeter Dunlap 	 * Use the icl_busy flag to keep the state machine single threaded.
346a6d42e7dSPeter Dunlap 	 * This also serves as recursion avoidance since this flag will
347a6d42e7dSPeter Dunlap 	 * always be set if we call login_sm_event from within the
348a6d42e7dSPeter Dunlap 	 * state machine code.
349a6d42e7dSPeter Dunlap 	 */
350a6d42e7dSPeter Dunlap 	if (!lsm->icl_busy) {
351a6d42e7dSPeter Dunlap 		lsm->icl_busy = B_TRUE;
352a6d42e7dSPeter Dunlap 		while (!list_is_empty(&lsm->icl_login_events)) {
353a6d42e7dSPeter Dunlap 			ctx = list_head(&lsm->icl_login_events);
354a6d42e7dSPeter Dunlap 			list_remove(&lsm->icl_login_events, ctx);
355a6d42e7dSPeter Dunlap 			idm_sm_audit_event(&lsm->icl_state_audit,
356a6d42e7dSPeter Dunlap 			    SAS_ISCSIT_LOGIN, (int)lsm->icl_login_state,
357a6d42e7dSPeter Dunlap 			    (int)ctx->le_ctx_event, (uintptr_t)pdu);
358a6d42e7dSPeter Dunlap 
35930e7468fSPeter Dunlap 			/*
36030e7468fSPeter Dunlap 			 * If the lsm is in a terminal state, just drain
36130e7468fSPeter Dunlap 			 * any remaining events.
36230e7468fSPeter Dunlap 			 */
36330e7468fSPeter Dunlap 			if ((lsm->icl_login_state == ILS_LOGIN_ERROR) ||
36430e7468fSPeter Dunlap 			    (lsm->icl_login_state == ILS_LOGIN_DONE)) {
36530e7468fSPeter Dunlap 				kmem_free(ctx, sizeof (*ctx));
36630e7468fSPeter Dunlap 				continue;
36730e7468fSPeter Dunlap 			}
368a6d42e7dSPeter Dunlap 			mutex_exit(&lsm->icl_mutex);
369a6d42e7dSPeter Dunlap 			login_sm_event_dispatch(lsm, ict, ctx);
370a6d42e7dSPeter Dunlap 			mutex_enter(&lsm->icl_mutex);
371a6d42e7dSPeter Dunlap 		}
372a6d42e7dSPeter Dunlap 		lsm->icl_busy = B_FALSE;
373a6d42e7dSPeter Dunlap 
374a6d42e7dSPeter Dunlap 		/*
375a6d42e7dSPeter Dunlap 		 * When the state machine reaches ILS_LOGIN_DONE or
376a6d42e7dSPeter Dunlap 		 * ILS_LOGIN_ERROR state the login process has completed
377a6d42e7dSPeter Dunlap 		 * and it's time to cleanup.  The state machine code will
378a6d42e7dSPeter Dunlap 		 * mark itself "complete" when this happens.
379a6d42e7dSPeter Dunlap 		 *
380a6d42e7dSPeter Dunlap 		 * To protect against spurious events (which shouldn't
381a6d42e7dSPeter Dunlap 		 * happen) set icl_busy again.
382a6d42e7dSPeter Dunlap 		 */
383a6d42e7dSPeter Dunlap 		if (lsm->icl_login_complete) {
384a6d42e7dSPeter Dunlap 			lsm->icl_busy = B_TRUE;
385a6d42e7dSPeter Dunlap 			if (taskq_dispatch(iscsit_global.global_dispatch_taskq,
386fc8ae2ecSToomas Soome 			    login_sm_complete, ict, DDI_SLEEP) ==
387fc8ae2ecSToomas Soome 			    TASKQID_INVALID) {
388a6d42e7dSPeter Dunlap 				cmn_err(CE_WARN, "iscsit_login_sm_event_locked:"
389a6d42e7dSPeter Dunlap 				    " Failed to dispatch task");
390a6d42e7dSPeter Dunlap 			}
391a6d42e7dSPeter Dunlap 		}
392a6d42e7dSPeter Dunlap 	}
393a6d42e7dSPeter Dunlap }
394a6d42e7dSPeter Dunlap 
395a6d42e7dSPeter Dunlap static void
login_sm_complete(void * ict_void)396a6d42e7dSPeter Dunlap login_sm_complete(void *ict_void)
397a6d42e7dSPeter Dunlap {
398a6d42e7dSPeter Dunlap 	iscsit_conn_t *ict = ict_void;
399a6d42e7dSPeter Dunlap 
400a6d42e7dSPeter Dunlap 	/*
4014142b486SJames Moore 	 * State machine has run to completion, resources
4024142b486SJames Moore 	 * will be cleaned up when connection is destroyed.
403a6d42e7dSPeter Dunlap 	 */
4044142b486SJames Moore 	iscsit_conn_rele(ict);
405a6d42e7dSPeter Dunlap }
406a6d42e7dSPeter Dunlap 
407a6d42e7dSPeter Dunlap static void
login_sm_event_dispatch(iscsit_conn_login_t * lsm,iscsit_conn_t * ict,login_event_ctx_t * ctx)408a6d42e7dSPeter Dunlap login_sm_event_dispatch(iscsit_conn_login_t *lsm, iscsit_conn_t *ict,
409a6d42e7dSPeter Dunlap     login_event_ctx_t *ctx)
410a6d42e7dSPeter Dunlap {
411a6d42e7dSPeter Dunlap 	idm_pdu_t *pdu = ctx->le_pdu; /* Only valid for some events */
412a6d42e7dSPeter Dunlap 
413a6d42e7dSPeter Dunlap 	DTRACE_PROBE2(login__event, iscsit_conn_t *, ict,
414a6d42e7dSPeter Dunlap 	    login_event_ctx_t *, ctx);
415a6d42e7dSPeter Dunlap 
416a6d42e7dSPeter Dunlap 	IDM_SM_LOG(CE_NOTE, "login_sm_event_dispatch: ict %p event %s(%d)",
417a6d42e7dSPeter Dunlap 	    (void *)ict,
418a6d42e7dSPeter Dunlap 	    iscsit_ile_name[ctx->le_ctx_event], ctx->le_ctx_event);
419a6d42e7dSPeter Dunlap 
420a6d42e7dSPeter Dunlap 	/* State independent actions */
421a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
422a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
423a6d42e7dSPeter Dunlap 		/* Perform basic sanity checks on the header */
424a6d42e7dSPeter Dunlap 		if (login_sm_req_pdu_check(ict, pdu) != IDM_STATUS_SUCCESS) {
4254142b486SJames Moore 			idm_pdu_t *rpdu;
4264142b486SJames Moore 
427a6d42e7dSPeter Dunlap 			SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
428a6d42e7dSPeter Dunlap 			    ISCSI_LOGIN_STATUS_INVALID_REQUEST);
429a6d42e7dSPeter Dunlap 			/*
430a6d42e7dSPeter Dunlap 			 * If we haven't processed any PDU's yet then use
431a6d42e7dSPeter Dunlap 			 * this one as a template for the response
432a6d42e7dSPeter Dunlap 			 */
433a6d42e7dSPeter Dunlap 			if (ict->ict_login_sm.icl_login_resp_tmpl->opcode == 0)
434a6d42e7dSPeter Dunlap 				login_sm_handle_initial_login(ict, pdu);
4354142b486SJames Moore 			rpdu = login_sm_build_login_response(ict);
4364142b486SJames Moore 			login_sm_send_next_response(ict, rpdu);
437a6d42e7dSPeter Dunlap 			idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
43830e7468fSPeter Dunlap 			kmem_free(ctx, sizeof (*ctx));
439a6d42e7dSPeter Dunlap 			return;
440a6d42e7dSPeter Dunlap 		}
441a6d42e7dSPeter Dunlap 		break;
442a6d42e7dSPeter Dunlap 	default:
443a6d42e7dSPeter Dunlap 		break;
444a6d42e7dSPeter Dunlap 	}
445a6d42e7dSPeter Dunlap 
446a6d42e7dSPeter Dunlap 	/* State dependent actions */
447a6d42e7dSPeter Dunlap 	switch (lsm->icl_login_state) {
448a6d42e7dSPeter Dunlap 	case ILS_LOGIN_INIT:
449a6d42e7dSPeter Dunlap 		login_sm_init(ict, ctx);
450a6d42e7dSPeter Dunlap 		break;
451a6d42e7dSPeter Dunlap 	case ILS_LOGIN_WAITING:
452a6d42e7dSPeter Dunlap 		login_sm_waiting(ict, ctx);
453a6d42e7dSPeter Dunlap 		break;
454a6d42e7dSPeter Dunlap 	case ILS_LOGIN_PROCESSING:
455a6d42e7dSPeter Dunlap 		login_sm_processing(ict, ctx);
456a6d42e7dSPeter Dunlap 		break;
457a6d42e7dSPeter Dunlap 	case ILS_LOGIN_RESPONDING:
458a6d42e7dSPeter Dunlap 		login_sm_responding(ict, ctx);
459a6d42e7dSPeter Dunlap 		break;
460a6d42e7dSPeter Dunlap 	case ILS_LOGIN_RESPONDED:
461a6d42e7dSPeter Dunlap 		login_sm_responded(ict, ctx);
462a6d42e7dSPeter Dunlap 		break;
463a6d42e7dSPeter Dunlap 	case ILS_LOGIN_FFP:
464a6d42e7dSPeter Dunlap 		login_sm_ffp(ict, ctx);
465a6d42e7dSPeter Dunlap 		break;
466a6d42e7dSPeter Dunlap 	case ILS_LOGIN_DONE:
467a6d42e7dSPeter Dunlap 		login_sm_done(ict, ctx);
468a6d42e7dSPeter Dunlap 		break;
469a6d42e7dSPeter Dunlap 	case ILS_LOGIN_ERROR:
470a6d42e7dSPeter Dunlap 		login_sm_error(ict, ctx);
471a6d42e7dSPeter Dunlap 		break;
472a6d42e7dSPeter Dunlap 	}
473a6d42e7dSPeter Dunlap 
474a6d42e7dSPeter Dunlap 	kmem_free(ctx, sizeof (*ctx));
475a6d42e7dSPeter Dunlap }
476a6d42e7dSPeter Dunlap 
477a6d42e7dSPeter Dunlap static void
login_sm_init(iscsit_conn_t * ict,login_event_ctx_t * ctx)478a6d42e7dSPeter Dunlap login_sm_init(iscsit_conn_t *ict, login_event_ctx_t *ctx)
479a6d42e7dSPeter Dunlap {
480a6d42e7dSPeter Dunlap 	idm_pdu_t *pdu;
481a6d42e7dSPeter Dunlap 
482a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
483a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
484a6d42e7dSPeter Dunlap 		pdu = ctx->le_pdu;
485a6d42e7dSPeter Dunlap 
486a6d42e7dSPeter Dunlap 		/*
487a6d42e7dSPeter Dunlap 		 * This is the first login PDU we've received so use
488a6d42e7dSPeter Dunlap 		 * it to build the login response template and set our CSG.
489a6d42e7dSPeter Dunlap 		 */
490a6d42e7dSPeter Dunlap 		login_sm_handle_initial_login(ict, pdu);
491a6d42e7dSPeter Dunlap 
492a6d42e7dSPeter Dunlap 		/*
493a6d42e7dSPeter Dunlap 		 * Accumulate all the login PDU's that make up this
494a6d42e7dSPeter Dunlap 		 * request on a queue.
495a6d42e7dSPeter Dunlap 		 */
496a6d42e7dSPeter Dunlap 		mutex_enter(&ict->ict_login_sm.icl_mutex);
497a6d42e7dSPeter Dunlap 		list_insert_tail(&ict->ict_login_sm.icl_pdu_list, pdu);
498a6d42e7dSPeter Dunlap 		mutex_exit(&ict->ict_login_sm.icl_mutex);
499a6d42e7dSPeter Dunlap 
500a6d42e7dSPeter Dunlap 		if (pdu->isp_hdr->flags & ISCSI_FLAG_LOGIN_CONTINUE) {
501a6d42e7dSPeter Dunlap 			login_sm_send_ack(ict, pdu);
502a6d42e7dSPeter Dunlap 			login_sm_new_state(ict, ctx, ILS_LOGIN_WAITING);
503a6d42e7dSPeter Dunlap 		} else {
504a6d42e7dSPeter Dunlap 			login_sm_new_state(ict, ctx, ILS_LOGIN_PROCESSING);
505a6d42e7dSPeter Dunlap 		}
506a6d42e7dSPeter Dunlap 		break;
507a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
508a6d42e7dSPeter Dunlap 	case ILE_LOGIN_ERROR:
509a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
510a6d42e7dSPeter Dunlap 		break;
511a6d42e7dSPeter Dunlap 	default:
512a6d42e7dSPeter Dunlap 		ASSERT(0);
513a6d42e7dSPeter Dunlap 	}
514a6d42e7dSPeter Dunlap }
515a6d42e7dSPeter Dunlap 
516a6d42e7dSPeter Dunlap static void
login_sm_waiting(iscsit_conn_t * ict,login_event_ctx_t * ctx)517a6d42e7dSPeter Dunlap login_sm_waiting(iscsit_conn_t *ict, login_event_ctx_t *ctx)
518a6d42e7dSPeter Dunlap {
519a6d42e7dSPeter Dunlap 	idm_pdu_t *pdu;
520a6d42e7dSPeter Dunlap 
521a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
522a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
523a6d42e7dSPeter Dunlap 		pdu = ctx->le_pdu;
524a6d42e7dSPeter Dunlap 		mutex_enter(&ict->ict_login_sm.icl_mutex);
525a6d42e7dSPeter Dunlap 		list_insert_tail(&ict->ict_login_sm.icl_pdu_list, pdu);
526a6d42e7dSPeter Dunlap 		mutex_exit(&ict->ict_login_sm.icl_mutex);
527a6d42e7dSPeter Dunlap 		if (!(pdu->isp_hdr->flags & ISCSI_FLAG_LOGIN_CONTINUE)) {
528a6d42e7dSPeter Dunlap 			login_sm_new_state(ict, ctx, ILS_LOGIN_PROCESSING);
529a6d42e7dSPeter Dunlap 		} else {
530a6d42e7dSPeter Dunlap 			login_sm_send_ack(ict, pdu);
531a6d42e7dSPeter Dunlap 		}
532a6d42e7dSPeter Dunlap 		break;
533a6d42e7dSPeter Dunlap 	case ILE_LOGIN_ERROR:
534a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
535a6d42e7dSPeter Dunlap 		break;
536a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RESP_COMPLETE:
537a6d42e7dSPeter Dunlap 		break;
538a6d42e7dSPeter Dunlap 	default:
539a6d42e7dSPeter Dunlap 		ASSERT(0);
540a6d42e7dSPeter Dunlap 	}
541a6d42e7dSPeter Dunlap }
542a6d42e7dSPeter Dunlap 
543a6d42e7dSPeter Dunlap static void
login_sm_processing(iscsit_conn_t * ict,login_event_ctx_t * ctx)544a6d42e7dSPeter Dunlap login_sm_processing(iscsit_conn_t *ict, login_event_ctx_t *ctx)
545a6d42e7dSPeter Dunlap {
546a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
547a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RESP_READY:
548a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_RESPONDING);
549a6d42e7dSPeter Dunlap 		break;
550a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
551a6d42e7dSPeter Dunlap 		idm_pdu_complete(ctx->le_pdu, IDM_STATUS_SUCCESS);
552a6d42e7dSPeter Dunlap 		/*FALLTHROUGH*/
553a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
554a6d42e7dSPeter Dunlap 	case ILE_LOGIN_ERROR:
555a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
556a6d42e7dSPeter Dunlap 		break;
557a6d42e7dSPeter Dunlap 	default:
558a6d42e7dSPeter Dunlap 		ASSERT(0);
559a6d42e7dSPeter Dunlap 	}
560a6d42e7dSPeter Dunlap }
561a6d42e7dSPeter Dunlap 
562a6d42e7dSPeter Dunlap static void
login_sm_responding(iscsit_conn_t * ict,login_event_ctx_t * ctx)563a6d42e7dSPeter Dunlap login_sm_responding(iscsit_conn_t *ict, login_event_ctx_t *ctx)
564a6d42e7dSPeter Dunlap {
5654142b486SJames Moore 	idm_pdu_t *pdu, *rpdu;
566a6d42e7dSPeter Dunlap 
567a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
568a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
569a6d42e7dSPeter Dunlap 		pdu = ctx->le_pdu;
570a6d42e7dSPeter Dunlap 		/*
571a6d42e7dSPeter Dunlap 		 * We should only be in "responding" state if we have not
572a6d42e7dSPeter Dunlap 		 * sent the last PDU of a multi-PDU login response sequence.
573a6d42e7dSPeter Dunlap 		 * In that case we expect this received PDU to be an
574a6d42e7dSPeter Dunlap 		 * acknowledgement from the initiator (login PDU with C
575a6d42e7dSPeter Dunlap 		 * bit cleared and no data).  If it's the acknowledgement
576a6d42e7dSPeter Dunlap 		 * we are expecting then we send the next PDU in the login
577a6d42e7dSPeter Dunlap 		 * response sequence.  Otherwise it's a protocol error and
578a6d42e7dSPeter Dunlap 		 * the login fails.
579a6d42e7dSPeter Dunlap 		 */
580a6d42e7dSPeter Dunlap 		if (login_sm_validate_ack(ict, pdu) == IDM_STATUS_SUCCESS) {
5814142b486SJames Moore 			rpdu = login_sm_build_login_response(ict);
5824142b486SJames Moore 			login_sm_send_next_response(ict, rpdu);
583a6d42e7dSPeter Dunlap 		} else {
584a6d42e7dSPeter Dunlap 			login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
585a6d42e7dSPeter Dunlap 		}
586a6d42e7dSPeter Dunlap 		idm_pdu_complete(pdu, IDM_STATUS_SUCCESS);
587a6d42e7dSPeter Dunlap 		break;
588a6d42e7dSPeter Dunlap 	case ILE_LOGIN_FFP:
589a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_FFP);
590a6d42e7dSPeter Dunlap 		break;
591a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RESP_COMPLETE:
592a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_RESPONDED);
593a6d42e7dSPeter Dunlap 		break;
594a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
595a6d42e7dSPeter Dunlap 	case ILE_LOGIN_ERROR:
596a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
597a6d42e7dSPeter Dunlap 		break;
598a6d42e7dSPeter Dunlap 	default:
599a6d42e7dSPeter Dunlap 		ASSERT(0);
600a6d42e7dSPeter Dunlap 	}
601a6d42e7dSPeter Dunlap }
602a6d42e7dSPeter Dunlap 
603a6d42e7dSPeter Dunlap static void
login_sm_responded(iscsit_conn_t * ict,login_event_ctx_t * ctx)604a6d42e7dSPeter Dunlap login_sm_responded(iscsit_conn_t *ict, login_event_ctx_t *ctx)
605a6d42e7dSPeter Dunlap {
606a6d42e7dSPeter Dunlap 	idm_pdu_t		*pdu;
607a6d42e7dSPeter Dunlap 	iscsi_login_hdr_t	*lh;
608a6d42e7dSPeter Dunlap 
609a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
610a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
611a6d42e7dSPeter Dunlap 		pdu = ctx->le_pdu;
612a6d42e7dSPeter Dunlap 		lh = (iscsi_login_hdr_t *)pdu->isp_hdr;
613a6d42e7dSPeter Dunlap 		/*
614a6d42e7dSPeter Dunlap 		 * Set the CSG, NSG and Transit bits based on the this PDU.
615a6d42e7dSPeter Dunlap 		 * The CSG already validated in login_sm_req_pdu_check().
616a6d42e7dSPeter Dunlap 		 * We'll clear the transit bit if we encounter any login
617a6d42e7dSPeter Dunlap 		 * parameters in the request that required an additional
618a6d42e7dSPeter Dunlap 		 * login transfer (i.e. no acceptable
619a6d42e7dSPeter Dunlap 		 * choices in range or we needed to change a boolean
620a6d42e7dSPeter Dunlap 		 * value from "Yes" to "No").
621a6d42e7dSPeter Dunlap 		 */
622a6d42e7dSPeter Dunlap 		ict->ict_login_sm.icl_login_csg =
623a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_CURRENT_STAGE(lh->flags);
624a6d42e7dSPeter Dunlap 		ict->ict_login_sm.icl_login_nsg =
625a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_NEXT_STAGE(lh->flags);
626a6d42e7dSPeter Dunlap 		ict->ict_login_sm.icl_login_transit =
627a6d42e7dSPeter Dunlap 		    lh->flags & ISCSI_FLAG_LOGIN_TRANSIT;
628a6d42e7dSPeter Dunlap 		mutex_enter(&ict->ict_login_sm.icl_mutex);
629a6d42e7dSPeter Dunlap 		list_insert_tail(&ict->ict_login_sm.icl_pdu_list, pdu);
630a6d42e7dSPeter Dunlap 		mutex_exit(&ict->ict_login_sm.icl_mutex);
631a6d42e7dSPeter Dunlap 		if (pdu->isp_hdr->flags & ISCSI_FLAG_LOGIN_CONTINUE) {
632a6d42e7dSPeter Dunlap 			login_sm_send_ack(ict, pdu);
633a6d42e7dSPeter Dunlap 			login_sm_new_state(ict, ctx, ILS_LOGIN_WAITING);
634a6d42e7dSPeter Dunlap 		} else {
635a6d42e7dSPeter Dunlap 			login_sm_new_state(ict, ctx, ILS_LOGIN_PROCESSING);
636a6d42e7dSPeter Dunlap 		}
637a6d42e7dSPeter Dunlap 		break;
638a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
639a6d42e7dSPeter Dunlap 	case ILE_LOGIN_ERROR:
640a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
641a6d42e7dSPeter Dunlap 		break;
642a6d42e7dSPeter Dunlap 	default:
643a6d42e7dSPeter Dunlap 		ASSERT(0);
644a6d42e7dSPeter Dunlap 	}
645a6d42e7dSPeter Dunlap }
646a6d42e7dSPeter Dunlap 
647a6d42e7dSPeter Dunlap static void
login_sm_ffp(iscsit_conn_t * ict,login_event_ctx_t * ctx)648a6d42e7dSPeter Dunlap login_sm_ffp(iscsit_conn_t *ict, login_event_ctx_t *ctx)
649a6d42e7dSPeter Dunlap {
650a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
651a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RESP_COMPLETE:
652a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_DONE);
653a6d42e7dSPeter Dunlap 		break;
654a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
655a6d42e7dSPeter Dunlap 	case ILE_LOGIN_ERROR:
656a6d42e7dSPeter Dunlap 		login_sm_new_state(ict, ctx, ILS_LOGIN_ERROR);
657a6d42e7dSPeter Dunlap 		break;
658a6d42e7dSPeter Dunlap 	default:
659a6d42e7dSPeter Dunlap 		ASSERT(0);
660a6d42e7dSPeter Dunlap 	}
661a6d42e7dSPeter Dunlap 
662a6d42e7dSPeter Dunlap }
663a6d42e7dSPeter Dunlap 
664a6d42e7dSPeter Dunlap /*ARGSUSED*/
665a6d42e7dSPeter Dunlap static void
login_sm_done(iscsit_conn_t * ict,login_event_ctx_t * ctx)666a6d42e7dSPeter Dunlap login_sm_done(iscsit_conn_t *ict, login_event_ctx_t *ctx)
667a6d42e7dSPeter Dunlap {
668a6d42e7dSPeter Dunlap 	/* Terminal state, we should get no events */
669a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
670a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
671a6d42e7dSPeter Dunlap 		/*
672a6d42e7dSPeter Dunlap 		 * We've already processed everything we're going to
673a6d42e7dSPeter Dunlap 		 * process.  Drop any additional login PDU's.
674a6d42e7dSPeter Dunlap 		 */
675a6d42e7dSPeter Dunlap 		idm_pdu_complete(ctx->le_pdu, IDM_STATUS_SUCCESS);
676a6d42e7dSPeter Dunlap 		break;
677a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
678a6d42e7dSPeter Dunlap 		/* Don't care */
679a6d42e7dSPeter Dunlap 		break;
680a6d42e7dSPeter Dunlap 	default:
681a6d42e7dSPeter Dunlap 		ASSERT(0);
682a6d42e7dSPeter Dunlap 	}
683a6d42e7dSPeter Dunlap }
684a6d42e7dSPeter Dunlap 
685a6d42e7dSPeter Dunlap /*ARGSUSED*/
686a6d42e7dSPeter Dunlap static void
login_sm_error(iscsit_conn_t * ict,login_event_ctx_t * ctx)687a6d42e7dSPeter Dunlap login_sm_error(iscsit_conn_t *ict, login_event_ctx_t *ctx)
688a6d42e7dSPeter Dunlap {
689a6d42e7dSPeter Dunlap 	switch (ctx->le_ctx_event) {
690a6d42e7dSPeter Dunlap 	case ILE_LOGIN_RCV:
691a6d42e7dSPeter Dunlap 		/*
692a6d42e7dSPeter Dunlap 		 * We've already processed everything we're going to
693a6d42e7dSPeter Dunlap 		 * process.  Drop any additional login PDU's.
694a6d42e7dSPeter Dunlap 		 */
695a6d42e7dSPeter Dunlap 		idm_pdu_complete(ctx->le_pdu, IDM_STATUS_SUCCESS);
696a6d42e7dSPeter Dunlap 		break;
697a6d42e7dSPeter Dunlap 	case ILE_LOGIN_CONN_ERROR:
698a6d42e7dSPeter Dunlap 		/* Don't care */
699a6d42e7dSPeter Dunlap 		break;
700a6d42e7dSPeter Dunlap 	default:
701a6d42e7dSPeter Dunlap 		ASSERT(0);
702a6d42e7dSPeter Dunlap 	}
703a6d42e7dSPeter Dunlap }
704a6d42e7dSPeter Dunlap 
705a6d42e7dSPeter Dunlap static void
login_sm_new_state(iscsit_conn_t * ict,login_event_ctx_t * ctx,iscsit_login_state_t new_state)706a6d42e7dSPeter Dunlap login_sm_new_state(iscsit_conn_t *ict, login_event_ctx_t *ctx,
707a6d42e7dSPeter Dunlap     iscsit_login_state_t new_state)
708a6d42e7dSPeter Dunlap {
709a6d42e7dSPeter Dunlap 	iscsit_conn_login_t *lsm = &ict->ict_login_sm;
7104142b486SJames Moore 	idm_pdu_t *rpdu;
711a6d42e7dSPeter Dunlap 
712a6d42e7dSPeter Dunlap 	/*
713a6d42e7dSPeter Dunlap 	 * Validate new state
714a6d42e7dSPeter Dunlap 	 */
715a6d42e7dSPeter Dunlap 	ASSERT(new_state != ILS_UNDEFINED);
716a6d42e7dSPeter Dunlap 	ASSERT3U(new_state, <, ILS_MAX_STATE);
717a6d42e7dSPeter Dunlap 
718a6d42e7dSPeter Dunlap 	new_state = (new_state < ILS_MAX_STATE) ?
719a6d42e7dSPeter Dunlap 	    new_state : ILS_UNDEFINED;
720a6d42e7dSPeter Dunlap 
721a6d42e7dSPeter Dunlap 	IDM_SM_LOG(CE_NOTE, "login_sm_new_state: conn %p "
722a6d42e7dSPeter Dunlap 	    "%s (%d) --> %s (%d)\n", (void *)ict->ict_ic,
723a6d42e7dSPeter Dunlap 	    iscsit_ils_name[lsm->icl_login_state], lsm->icl_login_state,
724a6d42e7dSPeter Dunlap 	    iscsit_ils_name[new_state], new_state);
725a6d42e7dSPeter Dunlap 
726a6d42e7dSPeter Dunlap 	DTRACE_PROBE3(login__state__change,
727a6d42e7dSPeter Dunlap 	    iscsit_conn_t *, ict, login_event_ctx_t *, ctx,
728a6d42e7dSPeter Dunlap 	    iscsit_login_state_t, new_state);
729a6d42e7dSPeter Dunlap 
730a6d42e7dSPeter Dunlap 	mutex_enter(&lsm->icl_mutex);
731a6d42e7dSPeter Dunlap 	idm_sm_audit_state_change(&lsm->icl_state_audit, SAS_ISCSIT_LOGIN,
732a6d42e7dSPeter Dunlap 	    (int)lsm->icl_login_state, (int)new_state);
733a6d42e7dSPeter Dunlap 	lsm->icl_login_last_state = lsm->icl_login_state;
734a6d42e7dSPeter Dunlap 	lsm->icl_login_state = new_state;
735a6d42e7dSPeter Dunlap 	mutex_exit(&lsm->icl_mutex);
736a6d42e7dSPeter Dunlap 
737*61dfa509SRick McNeal 	/*
738*61dfa509SRick McNeal 	 * Tale of caution here. The use of new_state instead of using
739*61dfa509SRick McNeal 	 * lsm->icl_login_state is deliberate (which had been used originally).
740*61dfa509SRick McNeal 	 * Since the icl_mutex is dropped under the right circumstances
741*61dfa509SRick McNeal 	 * the login state changes between setting the state and examining
742*61dfa509SRick McNeal 	 * the state to proceed. No big surprise since the lock was being
743*61dfa509SRick McNeal 	 * used in the first place to prevent just that type of change.
744*61dfa509SRick McNeal 	 *
745*61dfa509SRick McNeal 	 * There has been a case where network errors occurred while a client
746*61dfa509SRick McNeal 	 * was attempting to reinstate the connection causing multiple
747*61dfa509SRick McNeal 	 * login packets to arrive into the state machine. Those multiple
748*61dfa509SRick McNeal 	 * packets which were processed incorrectly caused the reference
749*61dfa509SRick McNeal 	 * count on the connection to be one higher than it should be and
750*61dfa509SRick McNeal 	 * from then on the connection can't close correctly causing a hang.
751*61dfa509SRick McNeal 	 *
752*61dfa509SRick McNeal 	 * Upon examination of the core it was found that the connection
753*61dfa509SRick McNeal 	 * audit data had calls looking like:
754*61dfa509SRick McNeal 	 *    login_sm_event_dispatch
755*61dfa509SRick McNeal 	 *    login_sm_processing
756*61dfa509SRick McNeal 	 *    login_sm_new_state
757*61dfa509SRick McNeal 	 * That call sequence means the new state was/is ILS_LOGIN_ERROR
758*61dfa509SRick McNeal 	 * yet the audit trail continues with a call to
759*61dfa509SRick McNeal 	 *    login_sm_send_next_response
760*61dfa509SRick McNeal 	 * which could only occur if icl_login_state had changed. Had the
761*61dfa509SRick McNeal 	 * design of COMSTAR taken this into account the code would
762*61dfa509SRick McNeal 	 * originally have held the icl_mutex across the processing of the
763*61dfa509SRick McNeal 	 * state processing. Lock order and calls which sleep prevent that
764*61dfa509SRick McNeal 	 * from being possible. The next best solution is to use the local
765*61dfa509SRick McNeal 	 * variable which holds the state.
766*61dfa509SRick McNeal 	 */
767*61dfa509SRick McNeal 	switch (new_state) {
768a6d42e7dSPeter Dunlap 	case ILS_LOGIN_WAITING:
769a6d42e7dSPeter Dunlap 		/* Do nothing, waiting for more login PDU's */
770a6d42e7dSPeter Dunlap 		break;
771a6d42e7dSPeter Dunlap 	case ILS_LOGIN_PROCESSING:
772a6d42e7dSPeter Dunlap 		/* All login PDU's received, process login request */
773a6d42e7dSPeter Dunlap 		login_sm_process_request(ict);
774a6d42e7dSPeter Dunlap 		break;
775a6d42e7dSPeter Dunlap 	case ILS_LOGIN_RESPONDING:
7764142b486SJames Moore 		rpdu = login_sm_build_login_response(ict);
7774142b486SJames Moore 		login_sm_send_next_response(ict, rpdu);
778a6d42e7dSPeter Dunlap 		break;
779a6d42e7dSPeter Dunlap 	case ILS_LOGIN_RESPONDED:
780a6d42e7dSPeter Dunlap 		/* clean up the login response idm text buffer */
781a6d42e7dSPeter Dunlap 		if (lsm->icl_login_resp_itb != NULL) {
782a6d42e7dSPeter Dunlap 			idm_itextbuf_free(lsm->icl_login_resp_itb);
783a6d42e7dSPeter Dunlap 			lsm->icl_login_resp_itb = NULL;
784a6d42e7dSPeter Dunlap 		}
785a6d42e7dSPeter Dunlap 		break;
786a6d42e7dSPeter Dunlap 	case ILS_LOGIN_FFP:
787a6d42e7dSPeter Dunlap 		login_sm_ffp_actions(ict);
788a6d42e7dSPeter Dunlap 		break;
789a6d42e7dSPeter Dunlap 	case ILS_LOGIN_DONE:
790a6d42e7dSPeter Dunlap 	case ILS_LOGIN_ERROR:
7914142b486SJames Moore 		/*
7924142b486SJames Moore 		 * Flag the terminal state for the dispatcher
7934142b486SJames Moore 		 */
794a6d42e7dSPeter Dunlap 		lsm->icl_login_complete = B_TRUE;
795a6d42e7dSPeter Dunlap 		break;
796a6d42e7dSPeter Dunlap 	case ILS_LOGIN_INIT: /* Initial state, can't return */
797a6d42e7dSPeter Dunlap 	default:
798a6d42e7dSPeter Dunlap 		ASSERT(0);
799a6d42e7dSPeter Dunlap 		/*NOTREACHED*/
800a6d42e7dSPeter Dunlap 	}
801a6d42e7dSPeter Dunlap }
802a6d42e7dSPeter Dunlap 
803a6d42e7dSPeter Dunlap /*ARGSUSED*/
804a6d42e7dSPeter Dunlap static void
login_sm_send_ack(iscsit_conn_t * ict,idm_pdu_t * pdu)805a6d42e7dSPeter Dunlap login_sm_send_ack(iscsit_conn_t *ict, idm_pdu_t *pdu)
806a6d42e7dSPeter Dunlap {
807a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
8084142b486SJames Moore 	idm_pdu_t		*lack;
809a6d42e7dSPeter Dunlap 
8104142b486SJames Moore 	/*
8114142b486SJames Moore 	 * allocate the response pdu
8124142b486SJames Moore 	 */
8134142b486SJames Moore 	lack = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0);
8144142b486SJames Moore 	idm_pdu_init(lack, ict->ict_ic, ict, login_resp_complete_cb);
8154142b486SJames Moore 	lack->isp_flags |= IDM_PDU_LOGIN_TX;
8164142b486SJames Moore 
8174142b486SJames Moore 	/*
8184142b486SJames Moore 	 * copy the response template into the response pdu
8194142b486SJames Moore 	 */
8204142b486SJames Moore 	bcopy(lsm->icl_login_resp_tmpl, lack->isp_hdr, sizeof (iscsi_hdr_t));
8214142b486SJames Moore 
8224142b486SJames Moore 	iscsit_conn_hold(ict);
8234142b486SJames Moore 	idm_pdu_tx(lack);
824a6d42e7dSPeter Dunlap }
825a6d42e7dSPeter Dunlap 
826a6d42e7dSPeter Dunlap /*ARGSUSED*/
827a6d42e7dSPeter Dunlap static idm_status_t
login_sm_validate_ack(iscsit_conn_t * ict,idm_pdu_t * pdu)828a6d42e7dSPeter Dunlap login_sm_validate_ack(iscsit_conn_t *ict, idm_pdu_t *pdu)
829a6d42e7dSPeter Dunlap {
830a6d42e7dSPeter Dunlap 	iscsi_hdr_t *ihp = pdu->isp_hdr;
831a6d42e7dSPeter Dunlap 	if (ihp->flags & ISCSI_FLAG_TEXT_CONTINUE) {
832a6d42e7dSPeter Dunlap 		return (IDM_STATUS_FAIL);
833a6d42e7dSPeter Dunlap 	}
834a6d42e7dSPeter Dunlap 	if (ntoh24(ihp->dlength) != 0) {
835a6d42e7dSPeter Dunlap 		return (IDM_STATUS_FAIL);
836a6d42e7dSPeter Dunlap 	}
837a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
838a6d42e7dSPeter Dunlap }
839a6d42e7dSPeter Dunlap 
840a6d42e7dSPeter Dunlap static boolean_t
login_sm_is_last_response(idm_pdu_t * pdu)8414142b486SJames Moore login_sm_is_last_response(idm_pdu_t *pdu)
842a6d42e7dSPeter Dunlap {
843a6d42e7dSPeter Dunlap 
8444142b486SJames Moore 	if (pdu->isp_hdr->flags & ISCSI_FLAG_LOGIN_CONTINUE) {
845a6d42e7dSPeter Dunlap 		return (B_FALSE);
846a6d42e7dSPeter Dunlap 	}
847a6d42e7dSPeter Dunlap 	return (B_TRUE);
848a6d42e7dSPeter Dunlap }
849a6d42e7dSPeter Dunlap 
850a6d42e7dSPeter Dunlap 
851a6d42e7dSPeter Dunlap static void
login_sm_handle_initial_login(iscsit_conn_t * ict,idm_pdu_t * pdu)852a6d42e7dSPeter Dunlap login_sm_handle_initial_login(iscsit_conn_t *ict, idm_pdu_t *pdu)
853a6d42e7dSPeter Dunlap {
854a6d42e7dSPeter Dunlap 	iscsi_login_hdr_t *lh_req = (iscsi_login_hdr_t *)pdu->isp_hdr;
855a6d42e7dSPeter Dunlap 	iscsi_login_rsp_hdr_t *lh_resp =
856a6d42e7dSPeter Dunlap 	    ict->ict_login_sm.icl_login_resp_tmpl;
857a6d42e7dSPeter Dunlap 
858a6d42e7dSPeter Dunlap 	/*
859a6d42e7dSPeter Dunlap 	 * First login PDU, this connection should not have a sesssion
860a6d42e7dSPeter Dunlap 	 * associated.
861a6d42e7dSPeter Dunlap 	 */
862a6d42e7dSPeter Dunlap 	ASSERT(ict->ict_sess == NULL);
863a6d42e7dSPeter Dunlap 
864a6d42e7dSPeter Dunlap 	/*
865a6d42e7dSPeter Dunlap 	 * Save off TSIH and ISID for later use in finding a session
866a6d42e7dSPeter Dunlap 	 */
867a6d42e7dSPeter Dunlap 	ict->ict_login_sm.icl_cmdsn = ntohl(lh_req->cmdsn);
868a6d42e7dSPeter Dunlap 	ict->ict_login_sm.icl_tsih = ntohs(lh_req->tsid);
869a6d42e7dSPeter Dunlap 	bcopy(lh_req->isid, ict->ict_login_sm.icl_isid, ISCSI_ISID_LEN);
870a6d42e7dSPeter Dunlap 
871a6d42e7dSPeter Dunlap 	/*
872a6d42e7dSPeter Dunlap 	 * We'll need the CID as well
873a6d42e7dSPeter Dunlap 	 */
874a6d42e7dSPeter Dunlap 	ict->ict_cid = ntohs(lh_req->cid);
875a6d42e7dSPeter Dunlap 
876a6d42e7dSPeter Dunlap 	/*
877a6d42e7dSPeter Dunlap 	 * Set the CSG, NSG and Transit bits based on the first PDU
878a6d42e7dSPeter Dunlap 	 * in the login sequence.  The CSG already validated in
879a6d42e7dSPeter Dunlap 	 * login_sm_req_pdu_check(). We'll clear the transit bit if
880a6d42e7dSPeter Dunlap 	 * we encounter any login parameters in the request that
881a6d42e7dSPeter Dunlap 	 * required an additional login transfer (i.e. no acceptable
882a6d42e7dSPeter Dunlap 	 * choices in range or we needed to change a boolean
883a6d42e7dSPeter Dunlap 	 * value from "Yes" to "No").
884a6d42e7dSPeter Dunlap 	 */
885a6d42e7dSPeter Dunlap 	ict->ict_login_sm.icl_login_csg =
886a6d42e7dSPeter Dunlap 	    ISCSI_LOGIN_CURRENT_STAGE(lh_req->flags);
887a6d42e7dSPeter Dunlap 	ict->ict_login_sm.icl_login_nsg =
888a6d42e7dSPeter Dunlap 	    ISCSI_LOGIN_NEXT_STAGE(lh_req->flags);
889a6d42e7dSPeter Dunlap 	ict->ict_login_sm.icl_login_transit =
890a6d42e7dSPeter Dunlap 	    lh_req->flags & ISCSI_FLAG_LOGIN_TRANSIT;
891a6d42e7dSPeter Dunlap 
892a6d42e7dSPeter Dunlap 	/*
893a6d42e7dSPeter Dunlap 	 * Initialize header for login reject response.  This will also
894a6d42e7dSPeter Dunlap 	 * be copied for use as a template for other login responses
895a6d42e7dSPeter Dunlap 	 */
896a6d42e7dSPeter Dunlap 	lh_resp->opcode = ISCSI_OP_LOGIN_RSP;
897a6d42e7dSPeter Dunlap 	lh_resp->max_version = ISCSIT_MAX_VERSION;
898a6d42e7dSPeter Dunlap 
899a6d42e7dSPeter Dunlap 	/*
900a6d42e7dSPeter Dunlap 	 * We already validated that we can support one of the initiator's
901a6d42e7dSPeter Dunlap 	 * versions in login_sm_req_pdu_check().
902a6d42e7dSPeter Dunlap 	 */
903a6d42e7dSPeter Dunlap #if (ISCSIT_MAX_VERSION > 0)
904a6d42e7dSPeter Dunlap 	if (ISCSIT_MAX_VERSION >= lh_req->min_version) {
905a6d42e7dSPeter Dunlap 		lh_resp->active_version =
906a6d42e7dSPeter Dunlap 		    MIN(lh_req->max_version, ISCSIT_MAX_VERSION);
907a6d42e7dSPeter Dunlap 	} else {
908a6d42e7dSPeter Dunlap 		ASSERT(ISCSIT_MAX_VERSION <= lh_req->max_version);
909a6d42e7dSPeter Dunlap 		lh_resp->active_version = ISCSIT_MAX_VERSION;
910a6d42e7dSPeter Dunlap 	}
911a6d42e7dSPeter Dunlap #endif
912a6d42e7dSPeter Dunlap 
913a6d42e7dSPeter Dunlap 	lh_resp->hlength = 0; /* No AHS */
914a6d42e7dSPeter Dunlap 	bcopy(lh_req->isid, lh_resp->isid, ISCSI_ISID_LEN);
915a6d42e7dSPeter Dunlap 	lh_resp->tsid = lh_req->tsid;
916a6d42e7dSPeter Dunlap 	lh_resp->itt = lh_req->itt;
917a6d42e7dSPeter Dunlap 
918a6d42e7dSPeter Dunlap 	/*
919a6d42e7dSPeter Dunlap 	 * StatSn, ExpCmdSn and MaxCmdSn will be set immediately before
920a6d42e7dSPeter Dunlap 	 * transmission
921a6d42e7dSPeter Dunlap 	 */
922a6d42e7dSPeter Dunlap }
923a6d42e7dSPeter Dunlap 
924a6d42e7dSPeter Dunlap static void
login_sm_send_next_response(iscsit_conn_t * ict,idm_pdu_t * pdu)9254142b486SJames Moore login_sm_send_next_response(iscsit_conn_t *ict, idm_pdu_t *pdu)
926a6d42e7dSPeter Dunlap {
927a6d42e7dSPeter Dunlap 	iscsi_login_rsp_hdr_t *lh_resp = (iscsi_login_rsp_hdr_t *)pdu->isp_hdr;
928a6d42e7dSPeter Dunlap 
9294142b486SJames Moore 	/* Make sure this PDU is part of the login phase */
930a6d42e7dSPeter Dunlap 	ASSERT((pdu->isp_flags & IDM_PDU_LOGIN_TX) != 0);
931a6d42e7dSPeter Dunlap 
932a6d42e7dSPeter Dunlap 	/*
933a6d42e7dSPeter Dunlap 	 * Fill in header values
934a6d42e7dSPeter Dunlap 	 */
935a6d42e7dSPeter Dunlap 	hton24(lh_resp->dlength, pdu->isp_datalen);
936a6d42e7dSPeter Dunlap 
937a6d42e7dSPeter Dunlap 	/*
93860220f10SPriya Krishnan 	 * If the login is successful, this login response will contain
93960220f10SPriya Krishnan 	 * the next StatSN and advance the StatSN for the connection.
940a6d42e7dSPeter Dunlap 	 */
941a6d42e7dSPeter Dunlap 	if (lh_resp->status_class == ISCSI_STATUS_CLASS_SUCCESS) {
942a6d42e7dSPeter Dunlap 		ASSERT(ict->ict_sess != NULL);
943a6d42e7dSPeter Dunlap 
944a6d42e7dSPeter Dunlap 		if ((lh_resp->flags & ISCSI_FLAG_LOGIN_TRANSIT) &&
945a6d42e7dSPeter Dunlap 		    (ISCSI_LOGIN_NEXT_STAGE(lh_resp->flags) ==
946a6d42e7dSPeter Dunlap 		    ISCSI_FULL_FEATURE_PHASE) &&
947a6d42e7dSPeter Dunlap 		    !(lh_resp->flags & ISCSI_FLAG_LOGIN_CONTINUE)) {
9484142b486SJames Moore 			iscsit_login_sm_event(ict, ILE_LOGIN_FFP, NULL);
9494142b486SJames Moore 		}
9504142b486SJames Moore 		if (login_sm_is_last_response(pdu) == B_TRUE) {
9514142b486SJames Moore 			/*
9524142b486SJames Moore 			 * The last of a potentially mult-PDU response finished.
9534142b486SJames Moore 			 */
9544142b486SJames Moore 			iscsit_login_sm_event(ict, ILE_LOGIN_RESP_COMPLETE,
9554142b486SJames Moore 			    NULL);
956a6d42e7dSPeter Dunlap 		}
957a6d42e7dSPeter Dunlap 
9584142b486SJames Moore 		iscsit_conn_hold(ict);
95960220f10SPriya Krishnan 		pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN;
960a6d42e7dSPeter Dunlap 		iscsit_pdu_tx(pdu);
961a6d42e7dSPeter Dunlap 	} else {
962a6d42e7dSPeter Dunlap 		/*
963a6d42e7dSPeter Dunlap 		 * If status_class != ISCSI_STATUS_CLASS_SUCCESS then
964a6d42e7dSPeter Dunlap 		 * StatSN is not valid and we can call idm_pdu_tx instead
965a6d42e7dSPeter Dunlap 		 * of iscsit_pdu_tx.  This is very good thing since in
966a6d42e7dSPeter Dunlap 		 * some cases of login failure we may not have a session.
967a6d42e7dSPeter Dunlap 		 * Since iscsit_calc_rspsn grabs the session mutex while
968a6d42e7dSPeter Dunlap 		 * it is retrieving values for expcmdsn and maxcmdsn this
969a6d42e7dSPeter Dunlap 		 * would cause a panic.
970a6d42e7dSPeter Dunlap 		 *
971a6d42e7dSPeter Dunlap 		 * Since we still want a value for expcmdsn, fill in an
972a6d42e7dSPeter Dunlap 		 * appropriate value based on the login request before
9731050fd6dSJames Moore 		 * sending the response. Cmdsn/expcmdsn do not advance during
9741050fd6dSJames Moore 		 * login phase.
975a6d42e7dSPeter Dunlap 		 */
9761050fd6dSJames Moore 		lh_resp->expcmdsn = htonl(ict->ict_login_sm.icl_cmdsn);
9771050fd6dSJames Moore 		lh_resp->maxcmdsn = htonl(ict->ict_login_sm.icl_cmdsn + 1);
978a6d42e7dSPeter Dunlap 
9794142b486SJames Moore 		iscsit_conn_hold(ict);
9804142b486SJames Moore 		idm_pdu_tx(pdu);
981a6d42e7dSPeter Dunlap 	}
982a6d42e7dSPeter Dunlap 
983a6d42e7dSPeter Dunlap }
984a6d42e7dSPeter Dunlap 
985a6d42e7dSPeter Dunlap static void
login_sm_process_request(iscsit_conn_t * ict)986a6d42e7dSPeter Dunlap login_sm_process_request(iscsit_conn_t *ict)
987a6d42e7dSPeter Dunlap {
988a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
989a6d42e7dSPeter Dunlap 	uint8_t			error_class = 0;
990a6d42e7dSPeter Dunlap 	uint8_t			error_detail = 0;
991a6d42e7dSPeter Dunlap 
992a6d42e7dSPeter Dunlap 	/*
993a6d42e7dSPeter Dunlap 	 * First walk all the PDU's that make up this login request
994a6d42e7dSPeter Dunlap 	 * and compile all the iSCSI key-value pairs into nvlist format.
995a6d42e7dSPeter Dunlap 	 */
996a6d42e7dSPeter Dunlap 
997a6d42e7dSPeter Dunlap 	ASSERT(lsm->icl_request_nvlist == NULL);
998a6d42e7dSPeter Dunlap 	/* create an nvlist for request key/value pairs */
999a6d42e7dSPeter Dunlap 	if (idm_pdu_list_to_nvlist(&lsm->icl_pdu_list,
1000a6d42e7dSPeter Dunlap 	    &lsm->icl_request_nvlist, &error_detail) != IDM_STATUS_SUCCESS) {
1001a6d42e7dSPeter Dunlap 		error_class = ISCSI_STATUS_CLASS_TARGET_ERR;
1002a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, error_class, error_detail);
1003a6d42e7dSPeter Dunlap 		goto request_fail;
1004a6d42e7dSPeter Dunlap 	}
1005a6d42e7dSPeter Dunlap 
1006a6d42e7dSPeter Dunlap 	/* Allocate a new nvlist for response key/value pairs */
1007a6d42e7dSPeter Dunlap 	ASSERT(lsm->icl_response_nvlist == NULL);
1008a6d42e7dSPeter Dunlap 	if (nvlist_alloc(&lsm->icl_response_nvlist, NV_UNIQUE_NAME,
1009a6d42e7dSPeter Dunlap 	    KM_NOSLEEP) != 0) {
1010a6d42e7dSPeter Dunlap 		error_class = ISCSI_STATUS_CLASS_TARGET_ERR;
1011a6d42e7dSPeter Dunlap 		error_detail = ISCSI_LOGIN_STATUS_NO_RESOURCES;
1012a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, error_class, error_detail);
1013a6d42e7dSPeter Dunlap 		goto request_fail;
1014a6d42e7dSPeter Dunlap 	}
1015a6d42e7dSPeter Dunlap 
1016a6d42e7dSPeter Dunlap 	/*
1017a6d42e7dSPeter Dunlap 	 * This would be a very good time to make sure we have
1018a6d42e7dSPeter Dunlap 	 * negotiated the required values for the login phase.  For
1019a6d42e7dSPeter Dunlap 	 * example we definitely should have defined InitiatorName,
1020a6d42e7dSPeter Dunlap 	 * and Target name regardless of our current login phase.
1021a6d42e7dSPeter Dunlap 	 */
1022a6d42e7dSPeter Dunlap 	if (!ict->ict_op.op_initial_params_set) {
1023a6d42e7dSPeter Dunlap 		if (login_sm_validate_initial_parameters(ict) !=
1024a6d42e7dSPeter Dunlap 		    IDM_STATUS_SUCCESS) {
1025a6d42e7dSPeter Dunlap 			goto request_fail;
1026a6d42e7dSPeter Dunlap 		}
1027a6d42e7dSPeter Dunlap 
1028a6d42e7dSPeter Dunlap 		/*
1029a6d42e7dSPeter Dunlap 		 * Now setup our session association.  This includes
1030a6d42e7dSPeter Dunlap 		 * create a new session or looking up an existing session,
1031a6d42e7dSPeter Dunlap 		 * and if this is not a discovery session then we will
1032a6d42e7dSPeter Dunlap 		 * also register this session with STMF.
1033a6d42e7dSPeter Dunlap 		 */
1034a6d42e7dSPeter Dunlap 		if (login_sm_session_bind(ict) != IDM_STATUS_SUCCESS) {
1035a6d42e7dSPeter Dunlap 			goto request_fail;
1036a6d42e7dSPeter Dunlap 		}
1037a6d42e7dSPeter Dunlap 
1038a6d42e7dSPeter Dunlap 		if (login_sm_set_auth(ict) != IDM_STATUS_SUCCESS) {
1039a6d42e7dSPeter Dunlap 			goto request_fail;
1040a6d42e7dSPeter Dunlap 		}
1041a6d42e7dSPeter Dunlap 
1042a6d42e7dSPeter Dunlap 		/*
1043a6d42e7dSPeter Dunlap 		 * Prepend TargetAlias and PortalGroupTag
1044a6d42e7dSPeter Dunlap 		 */
1045a6d42e7dSPeter Dunlap 		if (ict->ict_op.op_discovery_session == B_FALSE) {
1046a6d42e7dSPeter Dunlap 			if ((lsm->icl_auth.ca_tgt_alias[0]) != '\0') {
1047a6d42e7dSPeter Dunlap 				(void) iscsit_reply_string(ict,
1048a6d42e7dSPeter Dunlap 				    "TargetAlias",
1049a6d42e7dSPeter Dunlap 				    &lsm->icl_auth.ca_tgt_alias[0]);
1050a6d42e7dSPeter Dunlap 			}
1051a6d42e7dSPeter Dunlap 			(void) iscsit_reply_numerical(ict,
1052a6d42e7dSPeter Dunlap 			    "TargetPortalGroupTag",
1053a6d42e7dSPeter Dunlap 			    (uint64_t)lsm->icl_tpgt_tag);
1054a6d42e7dSPeter Dunlap 		}
1055a6d42e7dSPeter Dunlap 
1056a6d42e7dSPeter Dunlap 		ict->ict_op.op_initial_params_set = B_TRUE;
1057a6d42e7dSPeter Dunlap 	}
1058a6d42e7dSPeter Dunlap 
1059a6d42e7dSPeter Dunlap 	if (login_sm_process_nvlist(ict) != IDM_STATUS_SUCCESS) {
1060a6d42e7dSPeter Dunlap 		goto request_fail;
1061a6d42e7dSPeter Dunlap 	}
1062a6d42e7dSPeter Dunlap 
1063a6d42e7dSPeter Dunlap 	if (login_sm_check_security(ict) != IDM_STATUS_SUCCESS) {
1064a6d42e7dSPeter Dunlap 		goto request_fail;
1065a6d42e7dSPeter Dunlap 	}
1066a6d42e7dSPeter Dunlap 
10674142b486SJames Moore 	/* clean up request_nvlist */
10684142b486SJames Moore 	if (lsm->icl_request_nvlist != NULL) {
10694142b486SJames Moore 		nvlist_free(lsm->icl_request_nvlist);
10704142b486SJames Moore 		lsm->icl_request_nvlist = NULL;
10714142b486SJames Moore 	}
10724142b486SJames Moore 
10734142b486SJames Moore 	/* convert any responses to textbuf form */
10744142b486SJames Moore 	ASSERT(lsm->icl_login_resp_itb == NULL);
10754142b486SJames Moore 	if (lsm->icl_response_nvlist) {
10764142b486SJames Moore 		lsm->icl_login_resp_itb = idm_nvlist_to_itextbuf(
10774142b486SJames Moore 		    lsm->icl_response_nvlist);
10784142b486SJames Moore 		if (lsm->icl_login_resp_itb == NULL) {
10794142b486SJames Moore 			/* Still need to send the resp so continue */
10804142b486SJames Moore 			SET_LOGIN_ERROR(ict,
10814142b486SJames Moore 			    ISCSI_STATUS_CLASS_TARGET_ERR,
10824142b486SJames Moore 			    ISCSI_LOGIN_STATUS_NO_RESOURCES);
10834142b486SJames Moore 		}
10844142b486SJames Moore 		/* clean up response_nvlist */
10854142b486SJames Moore 		nvlist_free(lsm->icl_response_nvlist);
10864142b486SJames Moore 		lsm->icl_response_nvlist = NULL;
10874142b486SJames Moore 	}
10884142b486SJames Moore 
10894142b486SJames Moore 	/* tell the state machine to send the textbuf */
1090a6d42e7dSPeter Dunlap 	iscsit_login_sm_event(ict, ILE_LOGIN_RESP_READY, NULL);
10914142b486SJames Moore 	return;
10924142b486SJames Moore 
10934142b486SJames Moore request_fail:
1094a6d42e7dSPeter Dunlap 
1095a6d42e7dSPeter Dunlap 	/* clean up request_nvlist and response_nvlist */
1096a6d42e7dSPeter Dunlap 	if (lsm->icl_request_nvlist != NULL) {
1097a6d42e7dSPeter Dunlap 		nvlist_free(lsm->icl_request_nvlist);
1098a6d42e7dSPeter Dunlap 		lsm->icl_request_nvlist = NULL;
1099a6d42e7dSPeter Dunlap 	}
1100a6d42e7dSPeter Dunlap 	if (lsm->icl_response_nvlist != NULL) {
1101a6d42e7dSPeter Dunlap 		nvlist_free(lsm->icl_response_nvlist);
1102a6d42e7dSPeter Dunlap 		lsm->icl_response_nvlist = NULL;
1103a6d42e7dSPeter Dunlap 	}
1104e2073a1dSCharles Ting 	/* Make sure we already set the login error */
1105e2073a1dSCharles Ting 	if (ict->ict_login_sm.icl_login_resp_err_class ==
1106e2073a1dSCharles Ting 	    ISCSI_STATUS_CLASS_SUCCESS) {
1107e2073a1dSCharles Ting 		SET_LOGIN_ERROR(ict,
1108e2073a1dSCharles Ting 		    ISCSI_STATUS_CLASS_TARGET_ERR,
1109e2073a1dSCharles Ting 		    ISCSI_LOGIN_STATUS_TARGET_ERROR);
1110e2073a1dSCharles Ting 	}
1111e2073a1dSCharles Ting 	iscsit_login_sm_event(ict, ILE_LOGIN_RESP_READY, NULL);
1112a6d42e7dSPeter Dunlap }
1113a6d42e7dSPeter Dunlap 
1114a6d42e7dSPeter Dunlap 
1115a6d42e7dSPeter Dunlap static void
login_sm_ffp_actions(iscsit_conn_t * ict)1116a6d42e7dSPeter Dunlap login_sm_ffp_actions(iscsit_conn_t *ict)
1117a6d42e7dSPeter Dunlap {
1118a6d42e7dSPeter Dunlap 	iscsit_process_negotiated_values(ict);
1119a6d42e7dSPeter Dunlap }
1120a6d42e7dSPeter Dunlap 
1121a6d42e7dSPeter Dunlap static idm_status_t
login_sm_validate_initial_parameters(iscsit_conn_t * ict)1122a6d42e7dSPeter Dunlap login_sm_validate_initial_parameters(iscsit_conn_t *ict)
1123a6d42e7dSPeter Dunlap {
1124a6d42e7dSPeter Dunlap 	int		nvrc;
1125a6d42e7dSPeter Dunlap 	char		*string_val;
11261ef61828SYuri Pankov 	char		*u8_iscsi_name;
11271ef61828SYuri Pankov 	size_t		u8_iscsi_name_len;
1128a6d42e7dSPeter Dunlap 	uint8_t		error_class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
1129a6d42e7dSPeter Dunlap 	uint8_t		error_detail = ISCSI_LOGIN_STATUS_MISSING_FIELDS;
1130a6d42e7dSPeter Dunlap 	idm_status_t	status = IDM_STATUS_FAIL;
1131a6d42e7dSPeter Dunlap 	iscsit_conn_login_t *lsm = &ict->ict_login_sm;
1132a6d42e7dSPeter Dunlap 
1133a6d42e7dSPeter Dunlap 	/*
1134a6d42e7dSPeter Dunlap 	 * Make sure we received the required information from the initial
1135a6d42e7dSPeter Dunlap 	 * login. Add these declaratives to the negotiated list and
1136a6d42e7dSPeter Dunlap 	 * remove them from the request list as we go. If anything fails,
1137a6d42e7dSPeter Dunlap 	 * the caller will clean-up the nvlists.
1138a6d42e7dSPeter Dunlap 	 */
1139a6d42e7dSPeter Dunlap 
1140a6d42e7dSPeter Dunlap 	/*
1141a6d42e7dSPeter Dunlap 	 * Initiator name
1142a6d42e7dSPeter Dunlap 	 */
1143a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_string(lsm->icl_request_nvlist,
1144a6d42e7dSPeter Dunlap 	    "InitiatorName", &string_val)) != 0) {
1145a6d42e7dSPeter Dunlap 		goto initial_params_done;
1146a6d42e7dSPeter Dunlap 	}
11471ef61828SYuri Pankov 
11481ef61828SYuri Pankov 	u8_iscsi_name = iscsit_fold_name(string_val, &u8_iscsi_name_len);
11491ef61828SYuri Pankov 	if (u8_iscsi_name == NULL)
1150a6d42e7dSPeter Dunlap 		goto initial_params_done;
11511ef61828SYuri Pankov 	nvrc = nvlist_add_string(lsm->icl_negotiated_values, "InitiatorName",
11521ef61828SYuri Pankov 	    u8_iscsi_name);
11531ef61828SYuri Pankov 	kmem_free(u8_iscsi_name, u8_iscsi_name_len);
11541ef61828SYuri Pankov 	if (nvrc != 0)
11551ef61828SYuri Pankov 		goto initial_params_done;
11561ef61828SYuri Pankov 
1157a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_string(lsm->icl_negotiated_values,
1158a6d42e7dSPeter Dunlap 	    "InitiatorName", &string_val)) != 0) {
1159a6d42e7dSPeter Dunlap 		goto initial_params_done;
1160a6d42e7dSPeter Dunlap 	}
1161a6d42e7dSPeter Dunlap 	lsm->icl_initiator_name = string_val;
1162a668b114SPriya Krishnan 	idm_conn_set_initiator_name(ict->ict_ic, lsm->icl_initiator_name);
1163a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_remove(lsm->icl_request_nvlist,
1164a6d42e7dSPeter Dunlap 	    "InitiatorName", DATA_TYPE_STRING)) != 0) {
1165a6d42e7dSPeter Dunlap 		goto initial_params_done;
1166a6d42e7dSPeter Dunlap 	}
1167a6d42e7dSPeter Dunlap 
1168a6d42e7dSPeter Dunlap 	/*
1169a6d42e7dSPeter Dunlap 	 * Session type
1170a6d42e7dSPeter Dunlap 	 */
1171a6d42e7dSPeter Dunlap 	ict->ict_op.op_discovery_session = B_FALSE;
1172a6d42e7dSPeter Dunlap 	nvrc = nvlist_lookup_string(lsm->icl_request_nvlist,
1173a6d42e7dSPeter Dunlap 	    "SessionType", &string_val);
1174a6d42e7dSPeter Dunlap 	if (nvrc != ENOENT && nvrc != 0) {
1175a6d42e7dSPeter Dunlap 		goto initial_params_done;
1176a6d42e7dSPeter Dunlap 	}
1177a6d42e7dSPeter Dunlap 	if (nvrc == 0) {
1178a6d42e7dSPeter Dunlap 		if (strcmp(string_val, "Discovery") == 0) {
1179a6d42e7dSPeter Dunlap 			ict->ict_op.op_discovery_session = B_TRUE;
1180a6d42e7dSPeter Dunlap 		} else if (strcmp(string_val, "Normal") != 0) {
1181a6d42e7dSPeter Dunlap 			goto initial_params_done;
1182a6d42e7dSPeter Dunlap 		}
1183a6d42e7dSPeter Dunlap 		if ((nvrc = nvlist_add_string(lsm->icl_negotiated_values,
1184a6d42e7dSPeter Dunlap 		    "SessionType", string_val)) != 0) {
1185a6d42e7dSPeter Dunlap 			goto initial_params_done;
1186a6d42e7dSPeter Dunlap 		}
1187a6d42e7dSPeter Dunlap 		if ((nvrc = nvlist_remove(lsm->icl_request_nvlist,
1188a6d42e7dSPeter Dunlap 		    "SessionType", DATA_TYPE_STRING)) != 0) {
1189a6d42e7dSPeter Dunlap 			goto initial_params_done;
1190a6d42e7dSPeter Dunlap 		}
1191a6d42e7dSPeter Dunlap 	}
1192a6d42e7dSPeter Dunlap 
1193a6d42e7dSPeter Dunlap 	/*
1194a6d42e7dSPeter Dunlap 	 * Must have either TargetName or SessionType==Discovery
1195a6d42e7dSPeter Dunlap 	 */
1196a6d42e7dSPeter Dunlap 	lsm->icl_target_name = NULL;
1197a6d42e7dSPeter Dunlap 	nvrc = nvlist_lookup_string(lsm->icl_request_nvlist,
1198a6d42e7dSPeter Dunlap 	    "TargetName", &string_val);
1199a6d42e7dSPeter Dunlap 	if (nvrc != ENOENT && nvrc != 0) {
1200a6d42e7dSPeter Dunlap 		goto initial_params_done;
1201a6d42e7dSPeter Dunlap 	}
1202a6d42e7dSPeter Dunlap 	if (nvrc == 0) {
12031ef61828SYuri Pankov 		u8_iscsi_name = iscsit_fold_name(string_val,
12041ef61828SYuri Pankov 		    &u8_iscsi_name_len);
12051ef61828SYuri Pankov 		if (u8_iscsi_name == NULL)
12061ef61828SYuri Pankov 			goto initial_params_done;
12071ef61828SYuri Pankov 		nvrc = nvlist_add_string(lsm->icl_negotiated_values,
12081ef61828SYuri Pankov 		    "TargetName", u8_iscsi_name);
12091ef61828SYuri Pankov 		kmem_free(u8_iscsi_name, u8_iscsi_name_len);
12101ef61828SYuri Pankov 		if (nvrc != 0)
1211a6d42e7dSPeter Dunlap 			goto initial_params_done;
1212a6d42e7dSPeter Dunlap 		if ((nvrc = nvlist_lookup_string(lsm->icl_negotiated_values,
1213a6d42e7dSPeter Dunlap 		    "TargetName", &string_val)) != 0) {
1214a6d42e7dSPeter Dunlap 			goto initial_params_done;
1215a6d42e7dSPeter Dunlap 		}
1216a6d42e7dSPeter Dunlap 		lsm->icl_target_name = string_val;
1217a668b114SPriya Krishnan 		idm_conn_set_target_name(ict->ict_ic, lsm->icl_target_name);
1218a6d42e7dSPeter Dunlap 		if ((nvrc = nvlist_remove(lsm->icl_request_nvlist,
1219a6d42e7dSPeter Dunlap 		    "TargetName", DATA_TYPE_STRING)) != 0) {
1220a6d42e7dSPeter Dunlap 			goto initial_params_done;
1221a6d42e7dSPeter Dunlap 		}
1222a6d42e7dSPeter Dunlap 	} else if (ict->ict_op.op_discovery_session == B_FALSE) {
1223a6d42e7dSPeter Dunlap 		/*
1224a6d42e7dSPeter Dunlap 		 * Missing target name
1225a6d42e7dSPeter Dunlap 		 */
1226a6d42e7dSPeter Dunlap 		goto initial_params_done;
1227a6d42e7dSPeter Dunlap 	}
1228a6d42e7dSPeter Dunlap 
1229a668b114SPriya Krishnan 	idm_conn_set_isid(ict->ict_ic, lsm->icl_isid);
1230a668b114SPriya Krishnan 	(void) snprintf(ict->ict_ic->ic_tsih, ISCSI_MAX_TSIH_LEN + 1, "0x%04x",
1231a668b114SPriya Krishnan 	    lsm->icl_tsih);
1232a668b114SPriya Krishnan 
1233a6d42e7dSPeter Dunlap 	IDM_SM_LOG(CE_NOTE, "conn %p: initiator=%s", (void *)ict->ict_ic,
1234a6d42e7dSPeter Dunlap 	    (lsm->icl_initiator_name == NULL) ? "N/A" :
1235a6d42e7dSPeter Dunlap 	    lsm->icl_initiator_name);
1236a6d42e7dSPeter Dunlap 	IDM_SM_LOG(CE_NOTE, "conn %p: target=%s", (void *)ict->ict_ic,
1237a6d42e7dSPeter Dunlap 	    (lsm->icl_target_name == NULL) ? "N/A" :
1238a6d42e7dSPeter Dunlap 	    lsm->icl_target_name);
1239a6d42e7dSPeter Dunlap 	IDM_SM_LOG(CE_NOTE, "conn %p: sessiontype=%s", (void *)ict->ict_ic,
1240a6d42e7dSPeter Dunlap 	    ict->ict_op.op_discovery_session ? "Discovery" : "Normal");
1241a6d42e7dSPeter Dunlap 
1242a6d42e7dSPeter Dunlap 	/* Sucess */
1243a6d42e7dSPeter Dunlap 	status = IDM_STATUS_SUCCESS;
1244a6d42e7dSPeter Dunlap 	error_class = ISCSI_STATUS_CLASS_SUCCESS;
1245a6d42e7dSPeter Dunlap 	error_detail = ISCSI_LOGIN_STATUS_ACCEPT;
1246a6d42e7dSPeter Dunlap 
1247a6d42e7dSPeter Dunlap initial_params_done:
1248a6d42e7dSPeter Dunlap 	SET_LOGIN_ERROR(ict, error_class, error_detail);
1249a6d42e7dSPeter Dunlap 	return (status);
1250a6d42e7dSPeter Dunlap }
1251a6d42e7dSPeter Dunlap 
1252a6d42e7dSPeter Dunlap 
1253a6d42e7dSPeter Dunlap /*
1254a6d42e7dSPeter Dunlap  * login_sm_session_bind
1255a6d42e7dSPeter Dunlap  *
1256a6d42e7dSPeter Dunlap  * This function looks at the data from the initial login request
1257a6d42e7dSPeter Dunlap  * of a new connection and either looks up and existing session,
1258a6d42e7dSPeter Dunlap  * creates a new session, or returns an error.  RFC3720 section 5.3.1
1259a6d42e7dSPeter Dunlap  * defines these rules:
1260a6d42e7dSPeter Dunlap  *
1261a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1262a6d42e7dSPeter Dunlap  * |ISID      | TSIH        | CID    |     Target action              |
1263a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1264a6d42e7dSPeter Dunlap  * |new       | non-zero    | any    |     fail the login             |
1265a6d42e7dSPeter Dunlap  * |          |             |        |     ("session does not exist") |
1266a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1267a6d42e7dSPeter Dunlap  * |new       | zero        | any    |     instantiate a new session  |
1268a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1269a6d42e7dSPeter Dunlap  * |existing  | zero        | any    |     do session reinstatement   |
1270a6d42e7dSPeter Dunlap  * |          |             |        |     (see section 5.3.5)        |
1271a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1272a6d42e7dSPeter Dunlap  * |existing  | non-zero    | new    |     add a new connection to    |
1273a6d42e7dSPeter Dunlap  * |          | existing    |        |     the session                |
1274a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1275a6d42e7dSPeter Dunlap  * |existing  | non-zero    |existing|     do connection reinstatement|
1276a6d42e7dSPeter Dunlap  * |          | existing    |        |    (see section 5.3.4)         |
1277a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1278a6d42e7dSPeter Dunlap  * |existing  | non-zero    | any    |         fail the login         |
1279a6d42e7dSPeter Dunlap  * |          | new         |        |     ("session does not exist") |
1280a6d42e7dSPeter Dunlap  * +------------------------------------------------------------------+
1281a6d42e7dSPeter Dunlap  *
1282a6d42e7dSPeter Dunlap  */
1283a6d42e7dSPeter Dunlap 
1284a6d42e7dSPeter Dunlap /*
1285a6d42e7dSPeter Dunlap  * Map an <ipv6,port> address to an <ipv4,port> address if possible.
1286a6d42e7dSPeter Dunlap  * Returns:
1287a6d42e7dSPeter Dunlap  *    1 - success
1288a6d42e7dSPeter Dunlap  *    0 - address not mapable
1289a6d42e7dSPeter Dunlap  */
1290a6d42e7dSPeter Dunlap 
1291483b029bSYuri Pankov int
iscsit_is_v4_mapped(struct sockaddr_storage * sa,struct sockaddr_storage * v4sa)1292a6d42e7dSPeter Dunlap iscsit_is_v4_mapped(struct sockaddr_storage *sa, struct sockaddr_storage *v4sa)
1293a6d42e7dSPeter Dunlap {
1294a6d42e7dSPeter Dunlap 	struct sockaddr_in *sin;
1295a6d42e7dSPeter Dunlap 	struct in_addr *in;
1296a6d42e7dSPeter Dunlap 	struct sockaddr_in6 *sin6;
1297a6d42e7dSPeter Dunlap 	struct in6_addr *in6;
1298a6d42e7dSPeter Dunlap 	int ret = 0;
1299a6d42e7dSPeter Dunlap 
1300a6d42e7dSPeter Dunlap 	sin6 = (struct sockaddr_in6 *)sa;
1301a6d42e7dSPeter Dunlap 	in6 = &sin6->sin6_addr;
1302a6d42e7dSPeter Dunlap 	if ((sa->ss_family == AF_INET6) &&
1303a6d42e7dSPeter Dunlap 	    (IN6_IS_ADDR_V4MAPPED(in6) || IN6_IS_ADDR_V4COMPAT(in6))) {
1304a6d42e7dSPeter Dunlap 		sin = (struct sockaddr_in *)v4sa;
1305a6d42e7dSPeter Dunlap 		in = &sin->sin_addr;
1306a6d42e7dSPeter Dunlap 		v4sa->ss_family = AF_INET;
1307a6d42e7dSPeter Dunlap 		sin->sin_port = sin6->sin6_port;
1308a6d42e7dSPeter Dunlap 		IN6_V4MAPPED_TO_INADDR(in6, in);
1309a6d42e7dSPeter Dunlap 		ret = 1;
1310a6d42e7dSPeter Dunlap 	}
1311a6d42e7dSPeter Dunlap 	return (ret);
1312a6d42e7dSPeter Dunlap }
1313a6d42e7dSPeter Dunlap 
1314a6d42e7dSPeter Dunlap static idm_status_t
login_sm_session_bind(iscsit_conn_t * ict)1315a6d42e7dSPeter Dunlap login_sm_session_bind(iscsit_conn_t *ict)
1316a6d42e7dSPeter Dunlap {
1317a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
1318a6d42e7dSPeter Dunlap 	iscsit_tgt_t		*tgt = NULL;
1319a6d42e7dSPeter Dunlap 	iscsit_tpgt_t		*tpgt = NULL;
1320a6d42e7dSPeter Dunlap 	iscsit_portal_t		*portal = NULL;
1321a6d42e7dSPeter Dunlap 	iscsit_sess_t		*existing_sess = NULL;
1322a6d42e7dSPeter Dunlap 	iscsit_sess_t		*new_sess = NULL;
1323a6d42e7dSPeter Dunlap 	iscsit_conn_t		*existing_ict = NULL;
1324a6d42e7dSPeter Dunlap 	uint8_t			error_class;
1325a6d42e7dSPeter Dunlap 	uint8_t			error_detail;
1326a6d42e7dSPeter Dunlap 
13273fc1e17eSPriya Krishnan 	/*
13283fc1e17eSPriya Krishnan 	 * The multi-threaded execution of binding login sessions to target
13293fc1e17eSPriya Krishnan 	 * introduced race conditions in the session creation/binding and
13303fc1e17eSPriya Krishnan 	 * allowed duplicate sessions to tbe created. The addition of the
13313fc1e17eSPriya Krishnan 	 * global mutex login_sm_session_mutex makes this function single
13323fc1e17eSPriya Krishnan 	 * threaded to avoid such race conditions. Although this causes
13333fc1e17eSPriya Krishnan 	 * a small portion of the login to be serialized, it is unlikely
13343fc1e17eSPriya Krishnan 	 * that there would be numerous simultaneous logins to become a
13353fc1e17eSPriya Krishnan 	 * performance issue.
13363fc1e17eSPriya Krishnan 	 */
13373fc1e17eSPriya Krishnan 	mutex_enter(&login_sm_session_mutex);
13383fc1e17eSPriya Krishnan 
1339a6d42e7dSPeter Dunlap 	/*
1340a6d42e7dSPeter Dunlap 	 * Look up target and then check if there are sessions or connections
1341a6d42e7dSPeter Dunlap 	 * that match this request (see below).  Any holds taken on objects
1342a6d42e7dSPeter Dunlap 	 * must be released at the end of the function (let's keep things
1343a6d42e7dSPeter Dunlap 	 * simple).
1344a6d42e7dSPeter Dunlap 	 *
1345a6d42e7dSPeter Dunlap 	 * If target name is set then we should have a corresponding target
1346a6d42e7dSPeter Dunlap 	 * context configured.
1347a6d42e7dSPeter Dunlap 	 */
1348a6d42e7dSPeter Dunlap 	if (lsm->icl_target_name != NULL) {
1349a6d42e7dSPeter Dunlap 		/*
1350a6d42e7dSPeter Dunlap 		 * iscsit_tgt_lookup implicitly takes a ref on the target
1351a6d42e7dSPeter Dunlap 		 */
1352a6d42e7dSPeter Dunlap 		ISCSIT_GLOBAL_LOCK(RW_READER);
1353a6d42e7dSPeter Dunlap 		tgt = iscsit_tgt_lookup_locked(lsm->icl_target_name);
1354a6d42e7dSPeter Dunlap 		if (tgt == NULL) {
1355a6d42e7dSPeter Dunlap 			ISCSIT_GLOBAL_UNLOCK();
1356a6d42e7dSPeter Dunlap 			SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
1357a6d42e7dSPeter Dunlap 			    ISCSI_LOGIN_STATUS_TGT_NOT_FOUND);
1358a6d42e7dSPeter Dunlap 			goto session_bind_error;
1359a6d42e7dSPeter Dunlap 		} else {
1360a6d42e7dSPeter Dunlap 			mutex_enter(&tgt->target_mutex);
1361a6d42e7dSPeter Dunlap 			tpgt = avl_first(&tgt->target_tpgt_list);
1362a6d42e7dSPeter Dunlap 
1363a6d42e7dSPeter Dunlap 			if (IS_DEFAULT_TPGT(tpgt)) {
1364a6d42e7dSPeter Dunlap 				lsm->icl_tpgt_tag = ISCSIT_DEFAULT_TPGT;
1365a6d42e7dSPeter Dunlap 			} else {
1366a6d42e7dSPeter Dunlap 				/*
1367a6d42e7dSPeter Dunlap 				 * Find the portal group tag for the
1368a6d42e7dSPeter Dunlap 				 * login response.
1369a6d42e7dSPeter Dunlap 				 */
1370a6d42e7dSPeter Dunlap 				struct sockaddr_storage v4sa, *sa;
1371a6d42e7dSPeter Dunlap 
1372a6d42e7dSPeter Dunlap 				sa = &ict->ict_ic->ic_laddr;
1373a6d42e7dSPeter Dunlap 				portal = iscsit_tgt_lookup_portal(tgt,
1374a6d42e7dSPeter Dunlap 				    sa, &tpgt);
1375a6d42e7dSPeter Dunlap 				if (portal == NULL &&
1376a6d42e7dSPeter Dunlap 				    iscsit_is_v4_mapped(sa, &v4sa)) {
1377a6d42e7dSPeter Dunlap 					/*
1378a6d42e7dSPeter Dunlap 					 * Try again if the local address
1379a6d42e7dSPeter Dunlap 					 * was v6 mappable to v4.
1380a6d42e7dSPeter Dunlap 					 */
1381a6d42e7dSPeter Dunlap 					portal = iscsit_tgt_lookup_portal(tgt,
1382a6d42e7dSPeter Dunlap 					    &v4sa, &tpgt);
1383a6d42e7dSPeter Dunlap 
1384a6d42e7dSPeter Dunlap 				}
1385a6d42e7dSPeter Dunlap 				if (portal == NULL) {
1386a6d42e7dSPeter Dunlap 					/*
1387a6d42e7dSPeter Dunlap 					 * Initiator came in on wrong address
1388a6d42e7dSPeter Dunlap 					 */
1389a6d42e7dSPeter Dunlap 					SET_LOGIN_ERROR(ict,
1390a6d42e7dSPeter Dunlap 					    ISCSI_STATUS_CLASS_INITIATOR_ERR,
1391a6d42e7dSPeter Dunlap 					    ISCSI_LOGIN_STATUS_TGT_NOT_FOUND);
1392a6d42e7dSPeter Dunlap 					mutex_exit(&tgt->target_mutex);
1393a6d42e7dSPeter Dunlap 					ISCSIT_GLOBAL_UNLOCK();
1394a6d42e7dSPeter Dunlap 					goto session_bind_error;
1395a6d42e7dSPeter Dunlap 				}
1396a6d42e7dSPeter Dunlap 
1397a6d42e7dSPeter Dunlap 				/*
1398a6d42e7dSPeter Dunlap 				 * Need to release holds on the portal and
1399a6d42e7dSPeter Dunlap 				 * tpgt after processing is complete.
1400a6d42e7dSPeter Dunlap 				 */
1401a6d42e7dSPeter Dunlap 				lsm->icl_tpgt_tag = tpgt->tpgt_tag;
1402a6d42e7dSPeter Dunlap 				iscsit_portal_rele(portal);
1403a6d42e7dSPeter Dunlap 				iscsit_tpgt_rele(tpgt);
1404a6d42e7dSPeter Dunlap 			}
1405a6d42e7dSPeter Dunlap 
14068c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_enter(&iscsit_global.global_state_mutex);
1407a6d42e7dSPeter Dunlap 			if ((tgt->target_state != TS_STMF_ONLINE) ||
1408a6d42e7dSPeter Dunlap 			    ((iscsit_global.global_svc_state != ISE_ENABLED) &&
1409a6d42e7dSPeter Dunlap 			    ((iscsit_global.global_svc_state != ISE_BUSY)))) {
14108c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 				mutex_exit(&iscsit_global.global_state_mutex);
1411a6d42e7dSPeter Dunlap 				SET_LOGIN_ERROR(ict,
141272cf3143Speter dunlap 				    ISCSI_STATUS_CLASS_TARGET_ERR,
141372cf3143Speter dunlap 				    ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
1414a6d42e7dSPeter Dunlap 				mutex_exit(&tgt->target_mutex);
1415a6d42e7dSPeter Dunlap 				ISCSIT_GLOBAL_UNLOCK();
1416a6d42e7dSPeter Dunlap 				goto session_bind_error;
1417a6d42e7dSPeter Dunlap 			}
14188c629652SPeter Cudhea - Sun Microsystems - Burlington, MA United States 			mutex_exit(&iscsit_global.global_state_mutex);
1419a6d42e7dSPeter Dunlap 			mutex_exit(&tgt->target_mutex);
1420a6d42e7dSPeter Dunlap 			ISCSIT_GLOBAL_UNLOCK();
1421a6d42e7dSPeter Dunlap 		}
1422a6d42e7dSPeter Dunlap 	}
1423a6d42e7dSPeter Dunlap 
1424a6d42e7dSPeter Dunlap 	ASSERT((tgt != NULL) || (ict->ict_op.op_discovery_session == B_TRUE));
1425a6d42e7dSPeter Dunlap 
1426a6d42e7dSPeter Dunlap 	/*
1427a6d42e7dSPeter Dunlap 	 * Check if there is an existing session matching this ISID.  If
1428a6d42e7dSPeter Dunlap 	 * tgt == NULL then we'll look for the session on the global list
1429a6d42e7dSPeter Dunlap 	 * of discovery session.  If we find a session then the ISID
1430a6d42e7dSPeter Dunlap 	 * exists.
1431a6d42e7dSPeter Dunlap 	 */
1432a6d42e7dSPeter Dunlap 	existing_sess = iscsit_tgt_lookup_sess(tgt, lsm->icl_initiator_name,
1433a6d42e7dSPeter Dunlap 	    lsm->icl_isid, lsm->icl_tsih, lsm->icl_tpgt_tag);
1434a6d42e7dSPeter Dunlap 	if (existing_sess != NULL) {
1435a6d42e7dSPeter Dunlap 		existing_ict = iscsit_sess_lookup_conn(existing_sess,
1436a6d42e7dSPeter Dunlap 		    ict->ict_cid);
1437a6d42e7dSPeter Dunlap 	}
1438a6d42e7dSPeter Dunlap 
1439a6d42e7dSPeter Dunlap 	/*
1440a6d42e7dSPeter Dunlap 	 * If this is a discovery session, make sure it has appropriate
1441a6d42e7dSPeter Dunlap 	 * parameters.
1442a6d42e7dSPeter Dunlap 	 */
1443a6d42e7dSPeter Dunlap 	if ((ict->ict_op.op_discovery_session == B_TRUE) &&
1444a6d42e7dSPeter Dunlap 	    ((lsm->icl_tsih != ISCSI_UNSPEC_TSIH) || (existing_sess != NULL))) {
1445a6d42e7dSPeter Dunlap 		/* XXX Do we need to check for existing ISID (sess != NULL)? */
1446a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
1447a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_INVALID_REQUEST);
1448a6d42e7dSPeter Dunlap 		goto session_bind_error;
1449a6d42e7dSPeter Dunlap 	}
1450a6d42e7dSPeter Dunlap 
1451a6d42e7dSPeter Dunlap 	/*
1452a6d42e7dSPeter Dunlap 	 * Check the two error conditions from the table.
1453a6d42e7dSPeter Dunlap 	 *
1454a6d42e7dSPeter Dunlap 	 * ISID=new, TSIH=non-zero
1455a6d42e7dSPeter Dunlap 	 */
1456a6d42e7dSPeter Dunlap 	if ((existing_sess == NULL) && (lsm->icl_tsih != ISCSI_UNSPEC_TSIH)) {
1457a6d42e7dSPeter Dunlap 		/* fail the login */
1458a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
1459a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_NO_SESSION);
1460a6d42e7dSPeter Dunlap 		goto session_bind_error;
1461a6d42e7dSPeter Dunlap 	}
1462a6d42e7dSPeter Dunlap 
1463a6d42e7dSPeter Dunlap 	/* ISID=existing, TSIH=non-zero new */
1464a6d42e7dSPeter Dunlap 	if ((existing_sess != NULL) && (lsm->icl_tsih != 0) &&
1465a6d42e7dSPeter Dunlap 	    (existing_sess->ist_tsih != lsm->icl_tsih)) {
1466a6d42e7dSPeter Dunlap 		/* fail the login */
1467a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
1468a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_NO_SESSION);
1469a6d42e7dSPeter Dunlap 		goto session_bind_error;
1470a6d42e7dSPeter Dunlap 	}
1471a6d42e7dSPeter Dunlap 
1472a6d42e7dSPeter Dunlap 	/*
1473a6d42e7dSPeter Dunlap 	 * Handle the remaining table cases in order
1474a6d42e7dSPeter Dunlap 	 */
1475a6d42e7dSPeter Dunlap 	if (existing_sess == NULL) {
1476a6d42e7dSPeter Dunlap 		/* Should have caught this above */
1477a6d42e7dSPeter Dunlap 		ASSERT(lsm->icl_tsih == ISCSI_UNSPEC_TSIH);
1478a6d42e7dSPeter Dunlap 		/*
1479a6d42e7dSPeter Dunlap 		 * ISID=new, TSIH=zero --> instantiate a new session
1480a6d42e7dSPeter Dunlap 		 */
1481a6d42e7dSPeter Dunlap 		new_sess = iscsit_sess_create(tgt, ict, lsm->icl_cmdsn,
1482a6d42e7dSPeter Dunlap 		    lsm->icl_isid, lsm->icl_tpgt_tag, lsm->icl_initiator_name,
1483a6d42e7dSPeter Dunlap 		    lsm->icl_target_name, &error_class, &error_detail);
1484a6d42e7dSPeter Dunlap 		ASSERT(new_sess != NULL);
1485a6d42e7dSPeter Dunlap 
1486a6d42e7dSPeter Dunlap 		/* Session create may have failed even if it returned a value */
1487a6d42e7dSPeter Dunlap 		if (error_class != ISCSI_STATUS_CLASS_SUCCESS) {
1488a6d42e7dSPeter Dunlap 			SET_LOGIN_ERROR(ict, error_class, error_detail);
1489a6d42e7dSPeter Dunlap 			goto session_bind_error;
1490a6d42e7dSPeter Dunlap 		}
1491a6d42e7dSPeter Dunlap 
1492a6d42e7dSPeter Dunlap 		/*
1493a6d42e7dSPeter Dunlap 		 * If we don't already have an STMF session and this is not
1494a6d42e7dSPeter Dunlap 		 * a discovery session then we need to allocate and register
1495a6d42e7dSPeter Dunlap 		 * one.
1496a6d42e7dSPeter Dunlap 		 */
1497a6d42e7dSPeter Dunlap 		if (!ict->ict_op.op_discovery_session) {
1498a6d42e7dSPeter Dunlap 			if (login_sm_session_register(ict) !=
1499a6d42e7dSPeter Dunlap 			    IDM_STATUS_SUCCESS) {
1500a6d42e7dSPeter Dunlap 				/* login_sm_session_register sets error codes */
1501a6d42e7dSPeter Dunlap 				goto session_bind_error;
1502a6d42e7dSPeter Dunlap 			}
1503a6d42e7dSPeter Dunlap 		}
1504a6d42e7dSPeter Dunlap 
1505a6d42e7dSPeter Dunlap 	} else {
1506a6d42e7dSPeter Dunlap 		if (lsm->icl_tsih == ISCSI_UNSPEC_TSIH) {
1507a6d42e7dSPeter Dunlap 			/*
1508a6d42e7dSPeter Dunlap 			 * ISID=existing, TSIH=zero --> Session reinstatement
1509a6d42e7dSPeter Dunlap 			 */
1510a6d42e7dSPeter Dunlap 			new_sess = iscsit_sess_reinstate(tgt, existing_sess,
1511a6d42e7dSPeter Dunlap 			    ict, &error_class, &error_detail);
1512a6d42e7dSPeter Dunlap 			ASSERT(new_sess != NULL);
1513a6d42e7dSPeter Dunlap 
1514a6d42e7dSPeter Dunlap 			if (error_class != ISCSI_STATUS_CLASS_SUCCESS) {
1515a6d42e7dSPeter Dunlap 				SET_LOGIN_ERROR(ict, error_class, error_detail);
1516a6d42e7dSPeter Dunlap 				goto session_bind_error;
1517a6d42e7dSPeter Dunlap 			}
1518a6d42e7dSPeter Dunlap 
1519a6d42e7dSPeter Dunlap 			/*
1520a6d42e7dSPeter Dunlap 			 * If we don't already have an STMF session and this is
1521a6d42e7dSPeter Dunlap 			 * not a discovery session then we need to allocate and
1522a6d42e7dSPeter Dunlap 			 * register one.
1523a6d42e7dSPeter Dunlap 			 */
1524a6d42e7dSPeter Dunlap 			if (!ict->ict_op.op_discovery_session) {
1525a6d42e7dSPeter Dunlap 				if (login_sm_session_register(ict) !=
1526a6d42e7dSPeter Dunlap 				    IDM_STATUS_SUCCESS) {
1527a6d42e7dSPeter Dunlap 					/*
1528a6d42e7dSPeter Dunlap 					 * login_sm_session_register sets
1529a6d42e7dSPeter Dunlap 					 * error codes
1530a6d42e7dSPeter Dunlap 					 */
1531a6d42e7dSPeter Dunlap 					goto session_bind_error;
1532a6d42e7dSPeter Dunlap 				}
1533a6d42e7dSPeter Dunlap 			}
1534a6d42e7dSPeter Dunlap 		} else {
1535a6d42e7dSPeter Dunlap 			/*
1536a6d42e7dSPeter Dunlap 			 * The following code covers these two cases:
1537a6d42e7dSPeter Dunlap 			 * ISID=existing, TSIH=non-zero existing, CID=new
1538a6d42e7dSPeter Dunlap 			 * --> add new connection to MC/S session
1539a6d42e7dSPeter Dunlap 			 * ISID=existing, TSIH=non-zero existing, CID=existing
1540a6d42e7dSPeter Dunlap 			 * --> do connection reinstatement
1541a6d42e7dSPeter Dunlap 			 *
1542a6d42e7dSPeter Dunlap 			 * Session continuation uses this path as well
1543a6d42e7dSPeter Dunlap 			 */
1544a6d42e7dSPeter Dunlap 			cmn_err(CE_NOTE, "login_sm_session_bind: add new "
1545a6d42e7dSPeter Dunlap 			    "conn/sess continue");
1546a6d42e7dSPeter Dunlap 			if (existing_ict != NULL) {
1547a6d42e7dSPeter Dunlap 				/*
1548a6d42e7dSPeter Dunlap 				 * ISID=existing, TSIH=non-zero existing,
1549a6d42e7dSPeter Dunlap 				 * CID=existing --> do connection reinstatement
1550a6d42e7dSPeter Dunlap 				 */
1551a6d42e7dSPeter Dunlap 				if (iscsit_conn_reinstate(existing_ict, ict) !=
1552a6d42e7dSPeter Dunlap 				    IDM_STATUS_SUCCESS) {
1553a6d42e7dSPeter Dunlap 					/*
1554a6d42e7dSPeter Dunlap 					 * Most likely this means the connection
1555a6d42e7dSPeter Dunlap 					 * the initiator is trying to reinstate
1556a6d42e7dSPeter Dunlap 					 * is not in an acceptable state.
1557a6d42e7dSPeter Dunlap 					 */
1558a6d42e7dSPeter Dunlap 					SET_LOGIN_ERROR(ict,
1559a6d42e7dSPeter Dunlap 					    ISCSI_STATUS_CLASS_INITIATOR_ERR,
1560a6d42e7dSPeter Dunlap 					    ISCSI_LOGIN_STATUS_INIT_ERR);
1561a6d42e7dSPeter Dunlap 					goto session_bind_error;
1562a6d42e7dSPeter Dunlap 				}
1563a6d42e7dSPeter Dunlap 			}
1564a6d42e7dSPeter Dunlap 
1565a6d42e7dSPeter Dunlap 			iscsit_sess_sm_event(existing_sess, SE_CONN_IN_LOGIN,
1566a6d42e7dSPeter Dunlap 			    ict);
1567a6d42e7dSPeter Dunlap 		}
1568a6d42e7dSPeter Dunlap 	}
1569a6d42e7dSPeter Dunlap 
1570a6d42e7dSPeter Dunlap 	if (tgt != NULL)
1571a6d42e7dSPeter Dunlap 		iscsit_tgt_rele(tgt);
1572a6d42e7dSPeter Dunlap 	if (existing_sess != NULL)
1573a6d42e7dSPeter Dunlap 		iscsit_sess_rele(existing_sess);
1574a6d42e7dSPeter Dunlap 	if (existing_ict != NULL)
1575a6d42e7dSPeter Dunlap 		iscsit_conn_rele(existing_ict);
1576a6d42e7dSPeter Dunlap 
15773fc1e17eSPriya Krishnan 	mutex_exit(&login_sm_session_mutex);
1578a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1579a6d42e7dSPeter Dunlap 
1580a6d42e7dSPeter Dunlap session_bind_error:
1581a6d42e7dSPeter Dunlap 	if (tgt != NULL)
1582a6d42e7dSPeter Dunlap 		iscsit_tgt_rele(tgt);
1583a6d42e7dSPeter Dunlap 	if (existing_sess != NULL)
1584a6d42e7dSPeter Dunlap 		iscsit_sess_rele(existing_sess);
1585a6d42e7dSPeter Dunlap 	if (existing_ict != NULL)
1586a6d42e7dSPeter Dunlap 		iscsit_conn_rele(existing_ict);
1587a6d42e7dSPeter Dunlap 
1588a6d42e7dSPeter Dunlap 	/*
1589a6d42e7dSPeter Dunlap 	 * If session bind fails we will fail the login but don't destroy
1590a6d42e7dSPeter Dunlap 	 * the session until later.
1591a6d42e7dSPeter Dunlap 	 */
15923fc1e17eSPriya Krishnan 	mutex_exit(&login_sm_session_mutex);
1593a6d42e7dSPeter Dunlap 	return (IDM_STATUS_FAIL);
1594a6d42e7dSPeter Dunlap }
1595a6d42e7dSPeter Dunlap 
1596a6d42e7dSPeter Dunlap 
1597a6d42e7dSPeter Dunlap static idm_status_t
login_sm_set_auth(iscsit_conn_t * ict)1598a6d42e7dSPeter Dunlap login_sm_set_auth(iscsit_conn_t *ict)
1599a6d42e7dSPeter Dunlap {
1600a6d42e7dSPeter Dunlap 	idm_status_t		idmrc = IDM_STATUS_SUCCESS;
1601a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
1602a6d42e7dSPeter Dunlap 	iscsit_ini_t		*ini;
1603a6d42e7dSPeter Dunlap 	iscsit_tgt_t		*tgt;
1604a6d42e7dSPeter Dunlap 	char			*auth = "";
1605a6d42e7dSPeter Dunlap 	char			*radiusserver = "";
1606a6d42e7dSPeter Dunlap 	char			*radiussecret = "";
1607a6d42e7dSPeter Dunlap 	char			*chapuser = "";
1608a6d42e7dSPeter Dunlap 	char			*chapsecret = "";
1609a6d42e7dSPeter Dunlap 	char			*targetchapuser = "";
1610a6d42e7dSPeter Dunlap 	char			*targetchapsecret = "";
1611a6d42e7dSPeter Dunlap 	char			*targetalias = "";
1612a6d42e7dSPeter Dunlap 	int			i;
1613a6d42e7dSPeter Dunlap 
1614a6d42e7dSPeter Dunlap 	ISCSIT_GLOBAL_LOCK(RW_READER);
1615a6d42e7dSPeter Dunlap 
1616a6d42e7dSPeter Dunlap 	/*
1617a6d42e7dSPeter Dunlap 	 * Set authentication method to none for discovery session.
1618a6d42e7dSPeter Dunlap 	 */
1619a6d42e7dSPeter Dunlap 	if (ict->ict_op.op_discovery_session == B_TRUE) {
1620a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_method_valid_list[0] = AM_NONE;
1621a6d42e7dSPeter Dunlap 		ISCSIT_GLOBAL_UNLOCK();
1622a6d42e7dSPeter Dunlap 		return (idmrc);
1623a6d42e7dSPeter Dunlap 	}
1624a6d42e7dSPeter Dunlap 
1625a6d42e7dSPeter Dunlap 	/*
1626a6d42e7dSPeter Dunlap 	 * Get all the authentication parameters we need -- since we hold
1627a6d42e7dSPeter Dunlap 	 * the global config lock we guarantee that the parameters will
1628a6d42e7dSPeter Dunlap 	 * be consistent with each other.
1629a6d42e7dSPeter Dunlap 	 */
1630a6d42e7dSPeter Dunlap 	(void) nvlist_lookup_string(iscsit_global.global_props,
1631a6d42e7dSPeter Dunlap 	    PROP_AUTH, &auth);
1632a6d42e7dSPeter Dunlap 	(void) nvlist_lookup_string(iscsit_global.global_props,
1633a6d42e7dSPeter Dunlap 	    PROP_RADIUS_SERVER, &radiusserver);
1634a6d42e7dSPeter Dunlap 	(void) nvlist_lookup_string(iscsit_global.global_props,
1635a6d42e7dSPeter Dunlap 	    PROP_RADIUS_SECRET, &radiussecret);
1636a6d42e7dSPeter Dunlap 
1637a6d42e7dSPeter Dunlap 	ini = iscsit_ini_lookup_locked(lsm->icl_initiator_name);
1638a6d42e7dSPeter Dunlap 	if (ini != NULL) {
1639a6d42e7dSPeter Dunlap 		/* Get Initiator CHAP parameters */
1640a6d42e7dSPeter Dunlap 		(void) nvlist_lookup_string(ini->ini_props, PROP_CHAP_USER,
1641a6d42e7dSPeter Dunlap 		    &chapuser);
1642a6d42e7dSPeter Dunlap 		(void) nvlist_lookup_string(ini->ini_props, PROP_CHAP_SECRET,
1643a6d42e7dSPeter Dunlap 		    &chapsecret);
1644a6d42e7dSPeter Dunlap 	}
1645a6d42e7dSPeter Dunlap 
1646a6d42e7dSPeter Dunlap 	tgt = ict->ict_sess->ist_tgt;
1647a6d42e7dSPeter Dunlap 	if (tgt != NULL) {
1648a6d42e7dSPeter Dunlap 		/* See if we have a target-specific authentication setting */
1649a6d42e7dSPeter Dunlap 		(void) nvlist_lookup_string(tgt->target_props, PROP_AUTH,
1650a6d42e7dSPeter Dunlap 		    &auth);
1651a6d42e7dSPeter Dunlap 		/* Get target CHAP parameters */
1652a6d42e7dSPeter Dunlap 		(void) nvlist_lookup_string(tgt->target_props,
1653a6d42e7dSPeter Dunlap 		    PROP_TARGET_CHAP_USER, &targetchapuser);
1654a6d42e7dSPeter Dunlap 		(void) nvlist_lookup_string(tgt->target_props,
1655a6d42e7dSPeter Dunlap 		    PROP_TARGET_CHAP_SECRET, &targetchapsecret);
1656a6d42e7dSPeter Dunlap 		/* Get alias */
1657a6d42e7dSPeter Dunlap 		(void) nvlist_lookup_string(tgt->target_props,
1658a6d42e7dSPeter Dunlap 		    PROP_ALIAS, &targetalias);
1659a6d42e7dSPeter Dunlap 	}
1660a6d42e7dSPeter Dunlap 
1661a6d42e7dSPeter Dunlap 	/* Set authentication method */
1662a6d42e7dSPeter Dunlap 	i = 0;
1663a6d42e7dSPeter Dunlap 	if (strcmp(auth, PA_AUTH_RADIUS) == 0) {
1664a6d42e7dSPeter Dunlap 		/* CHAP authentication using RADIUS server */
1665a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_method_valid_list[i++] = AM_CHAP;
1666a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_use_radius = B_TRUE;
1667a6d42e7dSPeter Dunlap 	} else if (strcmp(auth, PA_AUTH_CHAP) == 0) {
1668a6d42e7dSPeter Dunlap 		/* Local CHAP authentication */
1669a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_method_valid_list[i++] = AM_CHAP;
1670a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_use_radius = B_FALSE;
1671a6d42e7dSPeter Dunlap 	} else if ((strcmp(auth, PA_AUTH_NONE) == 0) ||
1672a6d42e7dSPeter Dunlap 	    (strcmp(auth, "") == 0)) {
1673a6d42e7dSPeter Dunlap 		/* No authentication */
1674a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_method_valid_list[i++] = AM_NONE;
1675a6d42e7dSPeter Dunlap 	}
1676a6d42e7dSPeter Dunlap 
1677a6d42e7dSPeter Dunlap 	/*
1678a6d42e7dSPeter Dunlap 	 * If initiator/target CHAP username is not set then use the
1679a6d42e7dSPeter Dunlap 	 * node name.  If lsm->icl_target_name == NULL then this is
1680a6d42e7dSPeter Dunlap 	 * a discovery session so we don't need to work about the target.
1681a6d42e7dSPeter Dunlap 	 */
1682a6d42e7dSPeter Dunlap 	if (strcmp(chapuser, "") == 0) {
1683a6d42e7dSPeter Dunlap 		(void) strlcpy(lsm->icl_auth.ca_ini_chapuser,
1684a6d42e7dSPeter Dunlap 		    lsm->icl_initiator_name,
168530e7468fSPeter Dunlap 		    min(iscsitAuthStringMaxLength, MAX_ISCSI_NODENAMELEN));
1686a6d42e7dSPeter Dunlap 	} else {
1687a6d42e7dSPeter Dunlap 		(void) strlcpy(lsm->icl_auth.ca_ini_chapuser, chapuser,
168830e7468fSPeter Dunlap 		    iscsitAuthStringMaxLength);
1689a6d42e7dSPeter Dunlap 	}
1690a6d42e7dSPeter Dunlap 	if ((lsm->icl_target_name != NULL) &&
1691a6d42e7dSPeter Dunlap 	    (strcmp(targetchapuser, "") == 0)) {
1692a6d42e7dSPeter Dunlap 		(void) strlcpy(lsm->icl_auth.ca_tgt_chapuser,
1693a6d42e7dSPeter Dunlap 		    lsm->icl_target_name,
169430e7468fSPeter Dunlap 		    min(iscsitAuthStringMaxLength, MAX_ISCSI_NODENAMELEN));
1695a6d42e7dSPeter Dunlap 	} else {
1696a6d42e7dSPeter Dunlap 		(void) strlcpy(lsm->icl_auth.ca_tgt_chapuser,
169730e7468fSPeter Dunlap 		    targetchapuser, iscsitAuthStringMaxLength);
1698a6d42e7dSPeter Dunlap 	}
1699a6d42e7dSPeter Dunlap 
1700a6d42e7dSPeter Dunlap 	/*
1701a6d42e7dSPeter Dunlap 	 * Secrets are stored in base64-encoded format so we need to
1702a6d42e7dSPeter Dunlap 	 * decode them into binary form
1703a6d42e7dSPeter Dunlap 	 */
1704a6d42e7dSPeter Dunlap 	if (strcmp(chapsecret, "") == 0) {
1705a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_ini_chapsecretlen = 0;
1706a6d42e7dSPeter Dunlap 	} else {
1707a6d42e7dSPeter Dunlap 		if (iscsi_base64_str_to_binary(chapsecret,
170830e7468fSPeter Dunlap 		    strnlen(chapsecret, iscsitAuthStringMaxLength),
170930e7468fSPeter Dunlap 		    lsm->icl_auth.ca_ini_chapsecret, iscsitAuthStringMaxLength,
1710a6d42e7dSPeter Dunlap 		    &lsm->icl_auth.ca_ini_chapsecretlen) != 0) {
1711a6d42e7dSPeter Dunlap 			cmn_err(CE_WARN, "Corrupted CHAP secret"
1712a6d42e7dSPeter Dunlap 			    " for initiator %s", lsm->icl_initiator_name);
1713a6d42e7dSPeter Dunlap 			lsm->icl_auth.ca_ini_chapsecretlen = 0;
1714a6d42e7dSPeter Dunlap 		}
1715a6d42e7dSPeter Dunlap 	}
1716a6d42e7dSPeter Dunlap 	if (strcmp(targetchapsecret, "") == 0) {
1717a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_tgt_chapsecretlen = 0;
1718a6d42e7dSPeter Dunlap 	} else {
1719a6d42e7dSPeter Dunlap 		if (iscsi_base64_str_to_binary(targetchapsecret,
172030e7468fSPeter Dunlap 		    strnlen(targetchapsecret, iscsitAuthStringMaxLength),
172130e7468fSPeter Dunlap 		    lsm->icl_auth.ca_tgt_chapsecret, iscsitAuthStringMaxLength,
1722a6d42e7dSPeter Dunlap 		    &lsm->icl_auth.ca_tgt_chapsecretlen) != 0) {
1723a6d42e7dSPeter Dunlap 			cmn_err(CE_WARN, "Corrupted CHAP secret"
1724a6d42e7dSPeter Dunlap 			    " for target %s", lsm->icl_target_name);
1725a6d42e7dSPeter Dunlap 			lsm->icl_auth.ca_tgt_chapsecretlen = 0;
1726a6d42e7dSPeter Dunlap 		}
1727a6d42e7dSPeter Dunlap 	}
1728a6d42e7dSPeter Dunlap 	if (strcmp(radiussecret, "") == 0) {
1729a6d42e7dSPeter Dunlap 		lsm->icl_auth.ca_radius_secretlen = 0;
1730a6d42e7dSPeter Dunlap 	} else {
1731a6d42e7dSPeter Dunlap 		if (iscsi_base64_str_to_binary(radiussecret,
173230e7468fSPeter Dunlap 		    strnlen(radiussecret, iscsitAuthStringMaxLength),
173330e7468fSPeter Dunlap 		    lsm->icl_auth.ca_radius_secret, iscsitAuthStringMaxLength,
1734a6d42e7dSPeter Dunlap 		    &lsm->icl_auth.ca_radius_secretlen) != 0) {
1735a6d42e7dSPeter Dunlap 			cmn_err(CE_WARN, "Corrupted RADIUS secret");
1736a6d42e7dSPeter Dunlap 			lsm->icl_auth.ca_radius_secretlen = 0;
1737a6d42e7dSPeter Dunlap 		}
1738a6d42e7dSPeter Dunlap 	}
1739a6d42e7dSPeter Dunlap 
1740a6d42e7dSPeter Dunlap 	/*
1741a6d42e7dSPeter Dunlap 	 * Set alias
1742a6d42e7dSPeter Dunlap 	 */
1743a6d42e7dSPeter Dunlap 	(void) strlcpy(lsm->icl_auth.ca_tgt_alias, targetalias,
1744a6d42e7dSPeter Dunlap 	    MAX_ISCSI_NODENAMELEN);
1745a6d42e7dSPeter Dunlap 
1746a6d42e7dSPeter Dunlap 	/*
1747a6d42e7dSPeter Dunlap 	 * Now that authentication parameters are setup, validate the parameters
1748a6d42e7dSPeter Dunlap 	 * against the authentication mode
1749a6d42e7dSPeter Dunlap 	 * Decode RADIUS server value int lsm->icl_auth.ca_radius_server
1750a6d42e7dSPeter Dunlap 	 */
1751a6d42e7dSPeter Dunlap 	if ((strcmp(auth, PA_AUTH_RADIUS) == 0) &&
1752a6d42e7dSPeter Dunlap 	    ((lsm->icl_auth.ca_radius_secretlen == 0) ||
1753a6d42e7dSPeter Dunlap 	    (strcmp(radiusserver, "") == 0) ||
1754a6d42e7dSPeter Dunlap 	    it_common_convert_sa(radiusserver,
1755a6d42e7dSPeter Dunlap 	    &lsm->icl_auth.ca_radius_server,
1756a6d42e7dSPeter Dunlap 	    DEFAULT_RADIUS_PORT) == NULL)) {
1757a6d42e7dSPeter Dunlap 		cmn_err(CE_WARN, "RADIUS authentication selected "
1758a6d42e7dSPeter Dunlap 		    "for target %s but RADIUS parameters are not "
1759a6d42e7dSPeter Dunlap 		    "configured.", lsm->icl_target_name);
1760a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_TARGET_ERR,
1761a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_TARGET_ERROR);
1762a6d42e7dSPeter Dunlap 		idmrc = IDM_STATUS_FAIL;
1763a6d42e7dSPeter Dunlap 	} else if ((strcmp(auth, PA_AUTH_CHAP) == 0) &&
1764a6d42e7dSPeter Dunlap 	    (lsm->icl_auth.ca_ini_chapsecretlen == 0)) {
1765a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
1766a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_AUTH_FAILED);
1767a6d42e7dSPeter Dunlap 		idmrc = IDM_STATUS_FAIL;
1768a6d42e7dSPeter Dunlap 	}
1769a6d42e7dSPeter Dunlap 
1770a6d42e7dSPeter Dunlap 	ISCSIT_GLOBAL_UNLOCK();
1771a6d42e7dSPeter Dunlap 
1772a6d42e7dSPeter Dunlap 	return (idmrc);
1773a6d42e7dSPeter Dunlap }
1774a6d42e7dSPeter Dunlap 
1775a6d42e7dSPeter Dunlap 
1776a6d42e7dSPeter Dunlap static idm_status_t
login_sm_session_register(iscsit_conn_t * ict)1777a6d42e7dSPeter Dunlap login_sm_session_register(iscsit_conn_t *ict)
1778a6d42e7dSPeter Dunlap {
1779a6d42e7dSPeter Dunlap 	iscsit_sess_t		*ist = ict->ict_sess;
1780a6d42e7dSPeter Dunlap 	stmf_scsi_session_t	*ss;
1781716c1805SNattuvetty Bhavyan 	iscsi_transport_id_t	*iscsi_tptid;
1782716c1805SNattuvetty Bhavyan 	uint16_t		ident_len, adn_len, tptid_sz;
1783*61dfa509SRick McNeal 	char			prop_buf[KSTAT_STRLEN + 1];
1784*61dfa509SRick McNeal 	char			peer_buf[IDM_SA_NTOP_BUFSIZ];
1785a6d42e7dSPeter Dunlap 
1786a6d42e7dSPeter Dunlap 	/*
1787a6d42e7dSPeter Dunlap 	 * Hold target mutex until we have finished registering with STMF
1788a6d42e7dSPeter Dunlap 	 */
1789a6d42e7dSPeter Dunlap 	mutex_enter(&ist->ist_tgt->target_mutex);
1790a6d42e7dSPeter Dunlap 	if (ist->ist_tgt->target_state != TS_STMF_ONLINE) {
1791a6d42e7dSPeter Dunlap 		mutex_exit(&ist->ist_tgt->target_mutex);
1792a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_INITIATOR_ERR,
1793a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_TGT_REMOVED);
1794a6d42e7dSPeter Dunlap 		return (IDM_STATUS_FAIL);
1795a6d42e7dSPeter Dunlap 	}
1796a6d42e7dSPeter Dunlap 
1797a6d42e7dSPeter Dunlap 	ss = stmf_alloc(STMF_STRUCT_SCSI_SESSION, 0,
1798a6d42e7dSPeter Dunlap 	    0);
1799a6d42e7dSPeter Dunlap 	if (ss == NULL) {
1800a6d42e7dSPeter Dunlap 		mutex_exit(&ist->ist_tgt->target_mutex);
1801a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_TARGET_ERR,
1802a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_NO_RESOURCES);
1803a6d42e7dSPeter Dunlap 		return (IDM_STATUS_FAIL);
1804a6d42e7dSPeter Dunlap 	}
1805a6d42e7dSPeter Dunlap 
1806716c1805SNattuvetty Bhavyan 	ident_len = strlen(ist->ist_initiator_name) + 1;
1807a6d42e7dSPeter Dunlap 	ss->ss_rport_id = kmem_zalloc(sizeof (scsi_devid_desc_t) +
1808716c1805SNattuvetty Bhavyan 	    ident_len, KM_SLEEP);
1809a6d42e7dSPeter Dunlap 	(void) strcpy((char *)ss->ss_rport_id->ident, ist->ist_initiator_name);
1810716c1805SNattuvetty Bhavyan 	ss->ss_rport_id->ident_length = ident_len - 1;
1811a6d42e7dSPeter Dunlap 	ss->ss_rport_id->protocol_id = PROTOCOL_iSCSI;
1812a6d42e7dSPeter Dunlap 	ss->ss_rport_id->piv = 1;
1813a6d42e7dSPeter Dunlap 	ss->ss_rport_id->code_set = CODE_SET_ASCII;
1814a6d42e7dSPeter Dunlap 	ss->ss_rport_id->association = ID_IS_TARGET_PORT;
1815a6d42e7dSPeter Dunlap 
1816716c1805SNattuvetty Bhavyan 	/* adn_len should be 4 byte aligned, SPC3 rev 23, section 7.54.6 */
1817716c1805SNattuvetty Bhavyan 	adn_len = (ident_len + 3) & ~ 3;
1818716c1805SNattuvetty Bhavyan 	tptid_sz = sizeof (iscsi_transport_id_t) - 1 + adn_len;
1819716c1805SNattuvetty Bhavyan 	ss->ss_rport = stmf_remote_port_alloc(tptid_sz);
1820716c1805SNattuvetty Bhavyan 	ss->ss_rport->rport_tptid->protocol_id = PROTOCOL_iSCSI;
1821716c1805SNattuvetty Bhavyan 	ss->ss_rport->rport_tptid->format_code = 0;
1822716c1805SNattuvetty Bhavyan 	iscsi_tptid = (iscsi_transport_id_t *)ss->ss_rport->rport_tptid;
1823716c1805SNattuvetty Bhavyan 	SCSI_WRITE16(&iscsi_tptid->add_len, adn_len);
1824716c1805SNattuvetty Bhavyan 	(void) strlcpy((char *)iscsi_tptid->iscsi_name,
1825716c1805SNattuvetty Bhavyan 	    ist->ist_initiator_name, ident_len);
1826716c1805SNattuvetty Bhavyan 
1827a6d42e7dSPeter Dunlap 	ss->ss_lport = ist->ist_lport;
1828a6d42e7dSPeter Dunlap 
1829a6d42e7dSPeter Dunlap 	if (stmf_register_scsi_session(ict->ict_sess->ist_lport, ss) !=
1830a6d42e7dSPeter Dunlap 	    STMF_SUCCESS) {
1831a6d42e7dSPeter Dunlap 		mutex_exit(&ist->ist_tgt->target_mutex);
1832a6d42e7dSPeter Dunlap 		kmem_free(ss->ss_rport_id,
1833a6d42e7dSPeter Dunlap 		    sizeof (scsi_devid_desc_t) +
1834a6d42e7dSPeter Dunlap 		    strlen(ist->ist_initiator_name) + 1);
1835716c1805SNattuvetty Bhavyan 		stmf_remote_port_free(ss->ss_rport);
1836a6d42e7dSPeter Dunlap 		stmf_free(ss);
1837a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, ISCSI_STATUS_CLASS_TARGET_ERR,
1838a6d42e7dSPeter Dunlap 		    ISCSI_LOGIN_STATUS_TARGET_ERROR);
1839a6d42e7dSPeter Dunlap 		return (IDM_STATUS_FAIL);
1840a6d42e7dSPeter Dunlap 	}
1841a6d42e7dSPeter Dunlap 
1842a6d42e7dSPeter Dunlap 	ss->ss_port_private = ict->ict_sess;
1843a6d42e7dSPeter Dunlap 	ict->ict_sess->ist_stmf_sess = ss;
1844a6d42e7dSPeter Dunlap 	mutex_exit(&ist->ist_tgt->target_mutex);
1845*61dfa509SRick McNeal 	(void) snprintf(prop_buf, sizeof (prop_buf), "peername_%"PRIxPTR"",
1846*61dfa509SRick McNeal 	    (uintptr_t)ict->ict_sess);
1847*61dfa509SRick McNeal 	(void) idm_sa_ntop(&ict->ict_ic->ic_raddr, peer_buf,
1848*61dfa509SRick McNeal 	    sizeof (peer_buf));
1849*61dfa509SRick McNeal 	(void) stmf_add_rport_info(ss, prop_buf, peer_buf);
1850a6d42e7dSPeter Dunlap 
1851a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1852a6d42e7dSPeter Dunlap }
1853a6d42e7dSPeter Dunlap 
1854a6d42e7dSPeter Dunlap 
1855a6d42e7dSPeter Dunlap static idm_status_t
login_sm_req_pdu_check(iscsit_conn_t * ict,idm_pdu_t * pdu)1856a6d42e7dSPeter Dunlap login_sm_req_pdu_check(iscsit_conn_t *ict, idm_pdu_t *pdu)
1857a6d42e7dSPeter Dunlap {
1858a6d42e7dSPeter Dunlap 	uint8_t			csg_req;
1859a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
1860a6d42e7dSPeter Dunlap 	iscsi_login_hdr_t	*lh = (iscsi_login_hdr_t *)pdu->isp_hdr;
1861a6d42e7dSPeter Dunlap 	iscsi_login_rsp_hdr_t *lh_resp = lsm->icl_login_resp_tmpl;
1862a6d42e7dSPeter Dunlap 
1863a6d42e7dSPeter Dunlap 	/*
1864a6d42e7dSPeter Dunlap 	 * Check CSG
1865a6d42e7dSPeter Dunlap 	 */
1866a6d42e7dSPeter Dunlap 	csg_req = ISCSI_LOGIN_CURRENT_STAGE(lh->flags);
1867a6d42e7dSPeter Dunlap 	switch (csg_req) {
1868a6d42e7dSPeter Dunlap 	case ISCSI_SECURITY_NEGOTIATION_STAGE:
1869a6d42e7dSPeter Dunlap 	case ISCSI_OP_PARMS_NEGOTIATION_STAGE:
1870a6d42e7dSPeter Dunlap 		if ((csg_req != lsm->icl_login_csg) &&
1871a6d42e7dSPeter Dunlap 		    (lsm->icl_login_state != ILS_LOGIN_INIT)) {
1872a6d42e7dSPeter Dunlap 			/*
1873a6d42e7dSPeter Dunlap 			 * Inappropriate CSG change.  Initiator can only
1874a6d42e7dSPeter Dunlap 			 * change CSG after we've responded with the
1875a6d42e7dSPeter Dunlap 			 * transit bit set.  If we had responded with
1876a6d42e7dSPeter Dunlap 			 * a CSG change previous we would have updated
1877a6d42e7dSPeter Dunlap 			 * our copy of CSG.
1878a6d42e7dSPeter Dunlap 			 *
1879a6d42e7dSPeter Dunlap 			 * The exception is when we are in ILS_LOGIN_INIT
1880a6d42e7dSPeter Dunlap 			 * state since we haven't determined our initial
1881a6d42e7dSPeter Dunlap 			 * CSG value yet.
1882a6d42e7dSPeter Dunlap 			 */
1883a6d42e7dSPeter Dunlap 			goto pdu_check_fail;
1884a6d42e7dSPeter Dunlap 		}
1885a6d42e7dSPeter Dunlap 		break;
1886a6d42e7dSPeter Dunlap 	case ISCSI_FULL_FEATURE_PHASE:
1887a6d42e7dSPeter Dunlap 	default:
1888a6d42e7dSPeter Dunlap 		goto pdu_check_fail;
1889a6d42e7dSPeter Dunlap 	}
1890a6d42e7dSPeter Dunlap 
1891a6d42e7dSPeter Dunlap 	/*
1892a6d42e7dSPeter Dunlap 	 * If this is the first login PDU for a new connection then
1893a6d42e7dSPeter Dunlap 	 * the session will be NULL.
1894a6d42e7dSPeter Dunlap 	 */
1895a6d42e7dSPeter Dunlap 	if (ict->ict_sess != NULL) {
1896a6d42e7dSPeter Dunlap 		/*
1897a6d42e7dSPeter Dunlap 		 * We've already created a session on a previous PDU.  Make
1898a6d42e7dSPeter Dunlap 		 * sure this PDU is consistent with what we've already seen
1899a6d42e7dSPeter Dunlap 		 */
1900a6d42e7dSPeter Dunlap 		if ((ict->ict_cid != ntohs(lh->cid)) ||
1901a6d42e7dSPeter Dunlap 		    (bcmp(ict->ict_sess->ist_isid, lh->isid,
1902a6d42e7dSPeter Dunlap 		    ISCSI_ISID_LEN) != 0)) {
1903a6d42e7dSPeter Dunlap 			goto pdu_check_fail;
1904a6d42e7dSPeter Dunlap 		}
1905a6d42e7dSPeter Dunlap 	}
1906a6d42e7dSPeter Dunlap 
1907a6d42e7dSPeter Dunlap 	/*
1908a6d42e7dSPeter Dunlap 	 * Make sure we are compatible with the version range
1909a6d42e7dSPeter Dunlap 	 */
1910a6d42e7dSPeter Dunlap #if (ISCSIT_MAX_VERSION > 0)
1911a6d42e7dSPeter Dunlap 	if ((lh->min_version > ISCSIT_MAX_VERSION) ||
1912a6d42e7dSPeter Dunlap 	    (lh->max_version < ISCSIT_MIN_VERSION)) {
1913a6d42e7dSPeter Dunlap 		goto pdu_check_fail;
1914a6d42e7dSPeter Dunlap 	}
1915a6d42e7dSPeter Dunlap #endif
1916a6d42e7dSPeter Dunlap 
1917a6d42e7dSPeter Dunlap 	/*
1918a6d42e7dSPeter Dunlap 	 * Just in case the initiator changes things up on us along the way
1919a6d42e7dSPeter Dunlap 	 * check against our active_version -- we can't change the active
1920a6d42e7dSPeter Dunlap 	 * version and the initiator is not *supposed* to change its
1921a6d42e7dSPeter Dunlap 	 * min_version and max_version values so this should never happen.
1922a6d42e7dSPeter Dunlap 	 * Of course we only do this if the response header template has
1923a6d42e7dSPeter Dunlap 	 * been built.
1924a6d42e7dSPeter Dunlap 	 */
1925a6d42e7dSPeter Dunlap 	if ((lh_resp->opcode == ISCSI_OP_LOGIN_RSP) && /* header valid */
1926a6d42e7dSPeter Dunlap 	    ((lh->min_version > lh_resp->active_version) ||
1927a6d42e7dSPeter Dunlap 	    (lh->max_version < lh_resp->active_version))) {
1928a6d42e7dSPeter Dunlap 		goto pdu_check_fail;
1929a6d42e7dSPeter Dunlap 	}
1930a6d42e7dSPeter Dunlap 
1931a6d42e7dSPeter Dunlap 	return (IDM_STATUS_SUCCESS);
1932a6d42e7dSPeter Dunlap 
1933a6d42e7dSPeter Dunlap pdu_check_fail:
1934a6d42e7dSPeter Dunlap 	return (IDM_STATUS_FAIL);
1935a6d42e7dSPeter Dunlap }
1936a6d42e7dSPeter Dunlap 
1937a6d42e7dSPeter Dunlap static idm_status_t
login_sm_process_nvlist(iscsit_conn_t * ict)1938a6d42e7dSPeter Dunlap login_sm_process_nvlist(iscsit_conn_t *ict)
1939a6d42e7dSPeter Dunlap {
1940a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
1941a6d42e7dSPeter Dunlap 	char			*nvp_name;
1942a6d42e7dSPeter Dunlap 	nvpair_t		*nvp;
1943a6d42e7dSPeter Dunlap 	nvpair_t		*next_nvp;
1944a6d42e7dSPeter Dunlap 	nvpair_t		*negotiated_nvp;
1945a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
1946a6d42e7dSPeter Dunlap 	uint8_t			error_class;
1947a6d42e7dSPeter Dunlap 	uint8_t			error_detail;
1948a6d42e7dSPeter Dunlap 	idm_status_t		idm_status;
1949a6d42e7dSPeter Dunlap 
1950a6d42e7dSPeter Dunlap 	error_class = ISCSI_STATUS_CLASS_SUCCESS;
1951a6d42e7dSPeter Dunlap 	error_detail = ISCSI_LOGIN_STATUS_ACCEPT;
1952a6d42e7dSPeter Dunlap 
1953a6d42e7dSPeter Dunlap 	/* First, request that the transport process the list */
1954a6d42e7dSPeter Dunlap 	kvrc = idm_negotiate_key_values(ict->ict_ic, lsm->icl_request_nvlist,
1955a6d42e7dSPeter Dunlap 	    lsm->icl_response_nvlist, lsm->icl_negotiated_values);
1956a6d42e7dSPeter Dunlap 	idm_kvstat_to_error(kvrc, &error_class, &error_detail);
1957a6d42e7dSPeter Dunlap 	if (error_class != ISCSI_STATUS_CLASS_SUCCESS) {
1958a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, error_class, error_detail);
1959a6d42e7dSPeter Dunlap 		idm_status = IDM_STATUS_FAIL;
1960a6d42e7dSPeter Dunlap 		return (idm_status);
1961a6d42e7dSPeter Dunlap 	}
1962a6d42e7dSPeter Dunlap 
1963a6d42e7dSPeter Dunlap 	/* Ensure we clear transit bit if the transport layer has countered */
1964a6d42e7dSPeter Dunlap 	if (kvrc == KV_HANDLED_NO_TRANSIT) {
1965a6d42e7dSPeter Dunlap 		lsm->icl_login_transit = B_FALSE;
1966a6d42e7dSPeter Dunlap 	}
1967a6d42e7dSPeter Dunlap 
196878264421SCharles Ting 	/* Prepend the declarative params */
196978264421SCharles Ting 	if (!ict->ict_op.op_declarative_params_set &&
197078264421SCharles Ting 	    lsm->icl_login_csg == ISCSI_OP_PARMS_NEGOTIATION_STAGE) {
197178264421SCharles Ting 		if (iscsit_add_declarative_keys(ict) != IDM_STATUS_SUCCESS) {
197278264421SCharles Ting 			idm_status = IDM_STATUS_FAIL;
197378264421SCharles Ting 			return (idm_status);
197478264421SCharles Ting 		}
197578264421SCharles Ting 		ict->ict_op.op_declarative_params_set = B_TRUE;
197678264421SCharles Ting 	}
197778264421SCharles Ting 
1978a6d42e7dSPeter Dunlap 	/* Now, move on and process the rest of the pairs */
1979a6d42e7dSPeter Dunlap 	nvp = nvlist_next_nvpair(lsm->icl_request_nvlist, NULL);
1980a6d42e7dSPeter Dunlap 	while (nvp != NULL) {
1981a6d42e7dSPeter Dunlap 		next_nvp = nvlist_next_nvpair(lsm->icl_request_nvlist, nvp);
1982a6d42e7dSPeter Dunlap 		nvp_name = nvpair_name(nvp);
1983a6d42e7dSPeter Dunlap 		/*
1984a6d42e7dSPeter Dunlap 		 * If we've already agreed upon a value then make sure this
1985a6d42e7dSPeter Dunlap 		 * is not attempting to change that value.  From RFC3270
1986a6d42e7dSPeter Dunlap 		 * section 5.3:
1987a6d42e7dSPeter Dunlap 		 *
1988a6d42e7dSPeter Dunlap 		 * "Neither the initiator nor the target should attempt to
1989a6d42e7dSPeter Dunlap 		 * declare or negotiate a parameter more than once during
1990a6d42e7dSPeter Dunlap 		 * login except for responses to specific keys that
1991a6d42e7dSPeter Dunlap 		 * explicitly allow repeated key declarations (e.g.,
1992a6d42e7dSPeter Dunlap 		 * TargetAddress).  An attempt to renegotiate/redeclare
1993a6d42e7dSPeter Dunlap 		 * parameters not specifically allowed MUST be detected
1994a6d42e7dSPeter Dunlap 		 * by the initiator and target.  If such an attempt is
1995a6d42e7dSPeter Dunlap 		 * detected by the target, the target MUST respond
1996a6d42e7dSPeter Dunlap 		 * with Login reject (initiator error); ..."
1997a6d42e7dSPeter Dunlap 		 */
1998a6d42e7dSPeter Dunlap 		if (nvlist_lookup_nvpair(lsm->icl_negotiated_values,
1999a6d42e7dSPeter Dunlap 		    nvp_name, &negotiated_nvp) == 0) {
2000a6d42e7dSPeter Dunlap 			kvrc = KV_HANDLED;
2001a6d42e7dSPeter Dunlap 		} else {
2002a6d42e7dSPeter Dunlap 			kvrc = iscsit_handle_key(ict, nvp, nvp_name);
2003a6d42e7dSPeter Dunlap 		}
2004a6d42e7dSPeter Dunlap 
2005a6d42e7dSPeter Dunlap 		idm_kvstat_to_error(kvrc, &error_class, &error_detail);
2006a6d42e7dSPeter Dunlap 		if (error_class != ISCSI_STATUS_CLASS_SUCCESS) {
2007a6d42e7dSPeter Dunlap 			break;
2008a6d42e7dSPeter Dunlap 		}
2009a6d42e7dSPeter Dunlap 
2010a6d42e7dSPeter Dunlap 		nvp = next_nvp;
2011a6d42e7dSPeter Dunlap 	}
2012a6d42e7dSPeter Dunlap 
2013a6d42e7dSPeter Dunlap 	if (error_class == ISCSI_STATUS_CLASS_SUCCESS) {
2014a6d42e7dSPeter Dunlap 		idm_status = IDM_STATUS_SUCCESS;
2015a6d42e7dSPeter Dunlap 	} else {
2016a6d42e7dSPeter Dunlap 		/* supply login class/detail for login errors */
2017a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, error_class, error_detail);
2018a6d42e7dSPeter Dunlap 		idm_status = IDM_STATUS_FAIL;
2019a6d42e7dSPeter Dunlap 	}
2020a6d42e7dSPeter Dunlap 
2021a6d42e7dSPeter Dunlap 	return (idm_status);
2022a6d42e7dSPeter Dunlap }
2023a6d42e7dSPeter Dunlap 
2024a6d42e7dSPeter Dunlap static idm_status_t
login_sm_check_security(iscsit_conn_t * ict)2025a6d42e7dSPeter Dunlap login_sm_check_security(iscsit_conn_t *ict)
2026a6d42e7dSPeter Dunlap {
2027a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2028a6d42e7dSPeter Dunlap 	conn_auth_t		*auth = &lsm->icl_auth;
2029a6d42e7dSPeter Dunlap 	iscsit_auth_method_t	*am_list = &auth->ca_method_valid_list[0];
2030a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2031a6d42e7dSPeter Dunlap 	uint8_t			error_class;
2032a6d42e7dSPeter Dunlap 	uint8_t			error_detail;
2033a6d42e7dSPeter Dunlap 	idm_status_t		idm_status;
2034a6d42e7dSPeter Dunlap 
2035a6d42e7dSPeter Dunlap 	error_class = ISCSI_STATUS_CLASS_SUCCESS;
2036a6d42e7dSPeter Dunlap 	error_detail = ISCSI_LOGIN_STATUS_ACCEPT;
2037a6d42e7dSPeter Dunlap 
2038a6d42e7dSPeter Dunlap 	/* Check authentication status. */
2039a6d42e7dSPeter Dunlap 	if (lsm->icl_login_csg == ISCSI_SECURITY_NEGOTIATION_STAGE) {
2040a6d42e7dSPeter Dunlap 		/*
2041a6d42e7dSPeter Dunlap 		 * We should have some authentication key/value pair(s)
2042a6d42e7dSPeter Dunlap 		 * received from initiator and the authentication phase
2043a6d42e7dSPeter Dunlap 		 * has been shifted when the key/value pair(s) are being
2044a6d42e7dSPeter Dunlap 		 * handled in the previous call iscsit_handle_security_key.
2045a6d42e7dSPeter Dunlap 		 * Now it turns to target to check the authentication phase
2046a6d42e7dSPeter Dunlap 		 * and shift it after taking some authentication action.
2047a6d42e7dSPeter Dunlap 		 */
2048a6d42e7dSPeter Dunlap 		kvrc = iscsit_reply_security_key(ict);
2049a6d42e7dSPeter Dunlap 		idm_kvstat_to_error(kvrc, &error_class, &error_detail);
2050a6d42e7dSPeter Dunlap 	} else if (!ict->ict_login_sm.icl_auth_pass) {
2051a6d42e7dSPeter Dunlap 		/*
2052a6d42e7dSPeter Dunlap 		 * Check to see if the target allows initiators to bypass the
2053a6d42e7dSPeter Dunlap 		 * security check.  If the target is configured to require
2054a6d42e7dSPeter Dunlap 		 * authentication, we reject the connection.
2055a6d42e7dSPeter Dunlap 		 */
2056a6d42e7dSPeter Dunlap 		if (am_list[0] == AM_NONE || am_list[0] == 0) {
2057a6d42e7dSPeter Dunlap 			ict->ict_login_sm.icl_auth_pass = 1;
2058a6d42e7dSPeter Dunlap 		} else {
2059a6d42e7dSPeter Dunlap 			error_class = ISCSI_STATUS_CLASS_INITIATOR_ERR;
2060a6d42e7dSPeter Dunlap 			error_detail = ISCSI_LOGIN_STATUS_AUTH_FAILED;
2061a6d42e7dSPeter Dunlap 		}
2062a6d42e7dSPeter Dunlap 	}
2063a6d42e7dSPeter Dunlap 
2064a6d42e7dSPeter Dunlap 	if (error_class == ISCSI_STATUS_CLASS_SUCCESS) {
2065a6d42e7dSPeter Dunlap 		idm_status = IDM_STATUS_SUCCESS;
2066a6d42e7dSPeter Dunlap 	} else {
2067a6d42e7dSPeter Dunlap 		/* supply login class/detail for login errors */
2068a6d42e7dSPeter Dunlap 		SET_LOGIN_ERROR(ict, error_class, error_detail);
2069a6d42e7dSPeter Dunlap 		idm_status = IDM_STATUS_FAIL;
2070a6d42e7dSPeter Dunlap 	}
2071a6d42e7dSPeter Dunlap 
2072a6d42e7dSPeter Dunlap 	return (idm_status);
2073a6d42e7dSPeter Dunlap }
2074a6d42e7dSPeter Dunlap 
20754142b486SJames Moore static idm_pdu_t *
login_sm_build_login_response(iscsit_conn_t * ict)2076a6d42e7dSPeter Dunlap login_sm_build_login_response(iscsit_conn_t *ict)
2077a6d42e7dSPeter Dunlap {
2078a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2079a6d42e7dSPeter Dunlap 	iscsi_login_rsp_hdr_t	*lh;
2080a6d42e7dSPeter Dunlap 	int			transit, text_transit = 1;
20814142b486SJames Moore 	idm_pdu_t		*login_resp;
2082a6d42e7dSPeter Dunlap 
2083a6d42e7dSPeter Dunlap 	/*
20844142b486SJames Moore 	 * Create a response PDU and fill it with as much of
20854142b486SJames Moore 	 * the response text that will fit.
2086a6d42e7dSPeter Dunlap 	 */
2087a6d42e7dSPeter Dunlap 
20884142b486SJames Moore 	if (lsm->icl_login_resp_itb) {
20894142b486SJames Moore 		/* allocate a pdu with space for text */
20904142b486SJames Moore 		login_resp = idm_pdu_alloc(sizeof (iscsi_hdr_t),
20914142b486SJames Moore 		    ISCSI_DEFAULT_MAX_RECV_SEG_LEN);
20924142b486SJames Moore 		/* copy a chunk of text into the pdu */
20934142b486SJames Moore 		lsm->icl_login_resp_buf = idm_pdu_init_text_data(
20944142b486SJames Moore 		    login_resp, lsm->icl_login_resp_itb,
20954142b486SJames Moore 		    ISCSI_DEFAULT_MAX_RECV_SEG_LEN,
20964142b486SJames Moore 		    lsm->icl_login_resp_buf, &text_transit);
20974142b486SJames Moore 		if (text_transit) {
20984142b486SJames Moore 			/* text buf has been consumed */
20994142b486SJames Moore 			idm_itextbuf_free(lsm->icl_login_resp_itb);
21004142b486SJames Moore 			lsm->icl_login_resp_itb = NULL;
21014142b486SJames Moore 			lsm->icl_login_resp_buf = NULL;
2102a6d42e7dSPeter Dunlap 		}
2103a6d42e7dSPeter Dunlap 	} else {
21044142b486SJames Moore 		/* allocate a pdu for just a header */
21054142b486SJames Moore 		login_resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0);
2106a6d42e7dSPeter Dunlap 	}
21074142b486SJames Moore 	/* finish initializing the pdu */
21084142b486SJames Moore 	idm_pdu_init(login_resp,
21094142b486SJames Moore 	    ict->ict_ic, ict, login_resp_complete_cb);
21104142b486SJames Moore 	login_resp->isp_flags |= IDM_PDU_LOGIN_TX;
2111a6d42e7dSPeter Dunlap 
2112a6d42e7dSPeter Dunlap 	/*
2113a6d42e7dSPeter Dunlap 	 * Use the BHS header values from the response template
2114a6d42e7dSPeter Dunlap 	 */
2115a6d42e7dSPeter Dunlap 	bcopy(lsm->icl_login_resp_tmpl,
21164142b486SJames Moore 	    login_resp->isp_hdr, sizeof (iscsi_login_rsp_hdr_t));
2117a6d42e7dSPeter Dunlap 
21184142b486SJames Moore 	lh = (iscsi_login_rsp_hdr_t *)login_resp->isp_hdr;
2119a6d42e7dSPeter Dunlap 
2120a6d42e7dSPeter Dunlap 	/* Set error class/detail */
2121a6d42e7dSPeter Dunlap 	lh->status_class = lsm->icl_login_resp_err_class;
2122a6d42e7dSPeter Dunlap 	lh->status_detail = lsm->icl_login_resp_err_detail;
2123a6d42e7dSPeter Dunlap 	/* Set CSG, NSG and Transit */
2124a6d42e7dSPeter Dunlap 	lh->flags = 0;
2125a6d42e7dSPeter Dunlap 	lh->flags |= lsm->icl_login_csg << 2;
2126a6d42e7dSPeter Dunlap 
2127a6d42e7dSPeter Dunlap 
2128a6d42e7dSPeter Dunlap 	if (lh->status_class == ISCSI_STATUS_CLASS_SUCCESS) {
2129a6d42e7dSPeter Dunlap 		if (lsm->icl_login_transit &&
2130a6d42e7dSPeter Dunlap 		    lsm->icl_auth_pass != 0) {
2131a6d42e7dSPeter Dunlap 			transit = 1;
2132a6d42e7dSPeter Dunlap 		} else {
2133a6d42e7dSPeter Dunlap 			transit = 0;
2134a6d42e7dSPeter Dunlap 		}
2135a6d42e7dSPeter Dunlap 		/*
2136a6d42e7dSPeter Dunlap 		 * inititalize the text data
2137a6d42e7dSPeter Dunlap 		 */
2138a6d42e7dSPeter Dunlap 		if (transit == 1 && text_transit == 1) {
2139a6d42e7dSPeter Dunlap 			lh->flags |= lsm->icl_login_nsg;
2140a6d42e7dSPeter Dunlap 			lsm->icl_login_csg = lsm->icl_login_nsg;
2141a6d42e7dSPeter Dunlap 			lh->flags |= ISCSI_FLAG_LOGIN_TRANSIT;
2142a6d42e7dSPeter Dunlap 		} else {
2143a6d42e7dSPeter Dunlap 			lh->flags &= ~ISCSI_FLAG_LOGIN_TRANSIT;
2144a6d42e7dSPeter Dunlap 		}
2145a6d42e7dSPeter Dunlap 
2146a6d42e7dSPeter Dunlap 		/* If we are transitioning to FFP then set TSIH */
2147a6d42e7dSPeter Dunlap 		if (transit && (lh->flags & ISCSI_FLAG_LOGIN_TRANSIT) &&
2148a6d42e7dSPeter Dunlap 		    lsm->icl_login_csg == ISCSI_FULL_FEATURE_PHASE) {
2149a6d42e7dSPeter Dunlap 			lh->tsid = htons(ict->ict_sess->ist_tsih);
2150a6d42e7dSPeter Dunlap 		}
2151a6d42e7dSPeter Dunlap 	} else {
21524142b486SJames Moore 		login_resp->isp_data = 0;
21534142b486SJames Moore 		login_resp->isp_datalen = 0;
2154a6d42e7dSPeter Dunlap 	}
21554142b486SJames Moore 	return (login_resp);
2156a6d42e7dSPeter Dunlap }
2157a6d42e7dSPeter Dunlap 
2158a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_key(iscsit_conn_t * ict,nvpair_t * nvp,char * nvp_name)2159a6d42e7dSPeter Dunlap iscsit_handle_key(iscsit_conn_t *ict, nvpair_t *nvp, char *nvp_name)
2160a6d42e7dSPeter Dunlap {
2161a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2162a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2163a6d42e7dSPeter Dunlap 	const idm_kv_xlate_t	*ikvx;
2164a6d42e7dSPeter Dunlap 
2165a6d42e7dSPeter Dunlap 	ikvx = idm_lookup_kv_xlate(nvp_name, strlen(nvp_name));
2166a6d42e7dSPeter Dunlap 	if (ikvx->ik_key_id == KI_MAX_KEY) {
2167a6d42e7dSPeter Dunlap 		/*
2168a6d42e7dSPeter Dunlap 		 * Any key not understood by the acceptor may be igonred
2169a6d42e7dSPeter Dunlap 		 * by the acceptor without affecting the basic function.
2170a6d42e7dSPeter Dunlap 		 * However, the answer for a key not understood MUST be
2171a6d42e7dSPeter Dunlap 		 * key=NotUnderstood.
2172a6d42e7dSPeter Dunlap 		 */
2173a6d42e7dSPeter Dunlap 		kvrc = iscsit_reply_string(ict, nvp_name,
2174a6d42e7dSPeter Dunlap 		    ISCSI_TEXT_NOTUNDERSTOOD);
2175a6d42e7dSPeter Dunlap 	} else {
2176a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_common_key(ict, nvp, ikvx);
2177a6d42e7dSPeter Dunlap 		if (kvrc == KV_UNHANDLED) {
2178a6d42e7dSPeter Dunlap 			switch (lsm->icl_login_csg) {
2179a6d42e7dSPeter Dunlap 			case ISCSI_SECURITY_NEGOTIATION_STAGE:
2180a6d42e7dSPeter Dunlap 				kvrc = iscsit_handle_security_key(
2181a6d42e7dSPeter Dunlap 				    ict, nvp, ikvx);
2182a6d42e7dSPeter Dunlap 				break;
2183a6d42e7dSPeter Dunlap 			case ISCSI_OP_PARMS_NEGOTIATION_STAGE:
2184a6d42e7dSPeter Dunlap 				kvrc = iscsit_handle_operational_key(
2185a6d42e7dSPeter Dunlap 				    ict, nvp, ikvx);
2186a6d42e7dSPeter Dunlap 				break;
2187a6d42e7dSPeter Dunlap 			case ISCSI_FULL_FEATURE_PHASE:
2188a6d42e7dSPeter Dunlap 			default:
2189a6d42e7dSPeter Dunlap 				/* What are we doing here? */
2190a6d42e7dSPeter Dunlap 				ASSERT(0);
2191a6d42e7dSPeter Dunlap 				kvrc = KV_UNHANDLED;
2192a6d42e7dSPeter Dunlap 			}
2193a6d42e7dSPeter Dunlap 		}
2194a6d42e7dSPeter Dunlap 	}
2195a6d42e7dSPeter Dunlap 
2196a6d42e7dSPeter Dunlap 	return (kvrc);
2197a6d42e7dSPeter Dunlap }
2198a6d42e7dSPeter Dunlap 
2199a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_common_key(iscsit_conn_t * ict,nvpair_t * nvp,const idm_kv_xlate_t * ikvx)2200a6d42e7dSPeter Dunlap iscsit_handle_common_key(iscsit_conn_t *ict, nvpair_t *nvp,
2201a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx)
2202a6d42e7dSPeter Dunlap {
2203a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2204a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2205a6d42e7dSPeter Dunlap 	char			*string_val;
2206a6d42e7dSPeter Dunlap 	int			nvrc;
2207a6d42e7dSPeter Dunlap 
2208a6d42e7dSPeter Dunlap 	switch (ikvx->ik_key_id) {
2209a6d42e7dSPeter Dunlap 	case KI_INITIATOR_NAME:
2210a6d42e7dSPeter Dunlap 	case KI_INITIATOR_ALIAS:
2211a6d42e7dSPeter Dunlap 		nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values, nvp);
2212a6d42e7dSPeter Dunlap 		kvrc = idm_nvstat_to_kvstat(nvrc);
2213a6d42e7dSPeter Dunlap 		break;
2214a6d42e7dSPeter Dunlap 	case KI_TARGET_NAME:
2215a6d42e7dSPeter Dunlap 		/* We'll validate the target during login_sm_session_bind() */
2216a6d42e7dSPeter Dunlap 		nvrc = nvpair_value_string(nvp, &string_val);
2217a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0); /* We built this nvlist */
2218a6d42e7dSPeter Dunlap 
2219a6d42e7dSPeter Dunlap 		nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values, nvp);
2220a6d42e7dSPeter Dunlap 		kvrc = idm_nvstat_to_kvstat(nvrc);
2221a6d42e7dSPeter Dunlap 		break;
2222a6d42e7dSPeter Dunlap 	case KI_TARGET_ALIAS:
2223a6d42e7dSPeter Dunlap 	case KI_TARGET_ADDRESS:
2224a6d42e7dSPeter Dunlap 	case KI_TARGET_PORTAL_GROUP_TAG:
2225a6d42e7dSPeter Dunlap 		kvrc = KV_TARGET_ONLY; /* Only the target can declare this */
2226a6d42e7dSPeter Dunlap 		break;
2227a6d42e7dSPeter Dunlap 	case KI_SESSION_TYPE:
2228a6d42e7dSPeter Dunlap 		/*
2229a6d42e7dSPeter Dunlap 		 * If we don't receive this key on the initial login
2230a6d42e7dSPeter Dunlap 		 * we assume this is a normal session.
2231a6d42e7dSPeter Dunlap 		 */
2232a6d42e7dSPeter Dunlap 		nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values, nvp);
2233a6d42e7dSPeter Dunlap 		kvrc = idm_nvstat_to_kvstat(nvrc);
2234a6d42e7dSPeter Dunlap 		nvrc = nvpair_value_string(nvp, &string_val);
2235a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0); /* We built this nvlist */
2236a6d42e7dSPeter Dunlap 		ict->ict_op.op_discovery_session =
2237a6d42e7dSPeter Dunlap 		    strcmp(string_val, "Discovery") == 0 ? B_TRUE : B_FALSE;
2238a6d42e7dSPeter Dunlap 		break;
2239a6d42e7dSPeter Dunlap 	default:
2240a6d42e7dSPeter Dunlap 		/*
2241a6d42e7dSPeter Dunlap 		 * This is not really an error but we should
2242a6d42e7dSPeter Dunlap 		 * leave this nvpair on the list since we
2243a6d42e7dSPeter Dunlap 		 * didn't do anything with it.  Either
2244a6d42e7dSPeter Dunlap 		 * the security or operational phase
2245a6d42e7dSPeter Dunlap 		 * handling functions should process it.
2246a6d42e7dSPeter Dunlap 		 */
2247a6d42e7dSPeter Dunlap 		kvrc = KV_UNHANDLED;
2248a6d42e7dSPeter Dunlap 		break;
2249a6d42e7dSPeter Dunlap 	}
2250a6d42e7dSPeter Dunlap 
2251a6d42e7dSPeter Dunlap 	return (kvrc);
2252a6d42e7dSPeter Dunlap }
2253a6d42e7dSPeter Dunlap 
2254a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_security_key(iscsit_conn_t * ict,nvpair_t * nvp,const idm_kv_xlate_t * ikvx)2255a6d42e7dSPeter Dunlap iscsit_handle_security_key(iscsit_conn_t *ict, nvpair_t *nvp,
2256a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx)
2257a6d42e7dSPeter Dunlap {
2258a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2259a6d42e7dSPeter Dunlap 	iscsit_auth_client_t	*client = &lsm->icl_auth_client;
2260a6d42e7dSPeter Dunlap 	iscsikey_id_t		kv_id;
2261a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2262a6d42e7dSPeter Dunlap 	iscsit_auth_handler_t	handler;
2263a6d42e7dSPeter Dunlap 
2264a6d42e7dSPeter Dunlap 	/*
2265a6d42e7dSPeter Dunlap 	 * After all of security keys are handled, this function will
2266a6d42e7dSPeter Dunlap 	 * be called again to verify current authentication status
2267a6d42e7dSPeter Dunlap 	 * and perform some actual authentication work. At this time,
2268a6d42e7dSPeter Dunlap 	 * the nvp and ikvx will be passed in as NULLs.
2269a6d42e7dSPeter Dunlap 	 */
2270a6d42e7dSPeter Dunlap 	if (ikvx != NULL) {
2271a6d42e7dSPeter Dunlap 		kv_id = ikvx->ik_key_id;
2272a6d42e7dSPeter Dunlap 	} else {
2273a6d42e7dSPeter Dunlap 		kv_id = 0;
2274a6d42e7dSPeter Dunlap 	}
2275a6d42e7dSPeter Dunlap 
2276a6d42e7dSPeter Dunlap 	handler = iscsit_auth_get_handler(client, kv_id);
2277a6d42e7dSPeter Dunlap 	if (handler) {
2278a6d42e7dSPeter Dunlap 		kvrc = handler(ict, nvp, ikvx);
2279a6d42e7dSPeter Dunlap 	} else {
2280a6d42e7dSPeter Dunlap 		kvrc = KV_UNHANDLED; /* invalid request */
2281a6d42e7dSPeter Dunlap 	}
2282a6d42e7dSPeter Dunlap 
2283a6d42e7dSPeter Dunlap 	return (kvrc);
2284a6d42e7dSPeter Dunlap }
2285a6d42e7dSPeter Dunlap 
2286a6d42e7dSPeter Dunlap static kv_status_t
iscsit_reply_security_key(iscsit_conn_t * ict)2287a6d42e7dSPeter Dunlap iscsit_reply_security_key(iscsit_conn_t *ict)
2288a6d42e7dSPeter Dunlap {
2289a6d42e7dSPeter Dunlap 	return (iscsit_handle_security_key(ict, NULL, NULL));
2290a6d42e7dSPeter Dunlap }
2291a6d42e7dSPeter Dunlap 
2292a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_operational_key(iscsit_conn_t * ict,nvpair_t * nvp,const idm_kv_xlate_t * ikvx)2293a6d42e7dSPeter Dunlap iscsit_handle_operational_key(iscsit_conn_t *ict, nvpair_t *nvp,
2294a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx)
2295a6d42e7dSPeter Dunlap {
2296a6d42e7dSPeter Dunlap 	kv_status_t		kvrc = KV_UNHANDLED;
2297a6d42e7dSPeter Dunlap 	boolean_t		bool_val;
2298a6d42e7dSPeter Dunlap 	uint64_t		num_val;
2299a6d42e7dSPeter Dunlap 	int			nvrc;
2300a6d42e7dSPeter Dunlap 
2301a6d42e7dSPeter Dunlap 	/*
2302a6d42e7dSPeter Dunlap 	 * Retrieve values.  All value lookups are expected to succeed
2303a6d42e7dSPeter Dunlap 	 * since we build the nvlist while decoding the text buffer.  This
2304a6d42e7dSPeter Dunlap 	 * step is intended to eliminate some duplication of code (for example
2305a6d42e7dSPeter Dunlap 	 * we only need to code the numerical value lookup once).  We will
2306a6d42e7dSPeter Dunlap 	 * handle the values (if necessary) below.
2307a6d42e7dSPeter Dunlap 	 */
2308a6d42e7dSPeter Dunlap 	switch (ikvx->ik_key_id) {
2309a6d42e7dSPeter Dunlap 		/* Lists */
2310a6d42e7dSPeter Dunlap 	case KI_HEADER_DIGEST:
2311a6d42e7dSPeter Dunlap 	case KI_DATA_DIGEST:
2312a6d42e7dSPeter Dunlap 		break;
2313a6d42e7dSPeter Dunlap 		/* Booleans */
2314a6d42e7dSPeter Dunlap 	case KI_INITIAL_R2T:
2315a6d42e7dSPeter Dunlap 	case KI_IMMEDIATE_DATA:
2316a6d42e7dSPeter Dunlap 	case KI_DATA_PDU_IN_ORDER:
2317a6d42e7dSPeter Dunlap 	case KI_DATA_SEQUENCE_IN_ORDER:
2318a6d42e7dSPeter Dunlap 	case KI_IFMARKER:
2319a6d42e7dSPeter Dunlap 	case KI_OFMARKER:
2320a6d42e7dSPeter Dunlap 		nvrc = nvpair_value_boolean_value(nvp, &bool_val);
2321a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0); /* We built this nvlist */
2322a6d42e7dSPeter Dunlap 		break;
2323a6d42e7dSPeter Dunlap 		/* Numericals */
2324a6d42e7dSPeter Dunlap 	case KI_MAX_CONNECTIONS:
2325a6d42e7dSPeter Dunlap 	case KI_MAX_RECV_DATA_SEGMENT_LENGTH:
2326a6d42e7dSPeter Dunlap 	case KI_MAX_BURST_LENGTH:
2327a6d42e7dSPeter Dunlap 	case KI_FIRST_BURST_LENGTH:
2328a6d42e7dSPeter Dunlap 	case KI_DEFAULT_TIME_2_WAIT:
2329a6d42e7dSPeter Dunlap 	case KI_DEFAULT_TIME_2_RETAIN:
2330a6d42e7dSPeter Dunlap 	case KI_MAX_OUTSTANDING_R2T:
2331a6d42e7dSPeter Dunlap 	case KI_ERROR_RECOVERY_LEVEL:
2332a6d42e7dSPeter Dunlap 		nvrc = nvpair_value_uint64(nvp, &num_val);
2333a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2334a6d42e7dSPeter Dunlap 		break;
2335a6d42e7dSPeter Dunlap 		/* Ranges */
2336a6d42e7dSPeter Dunlap 	case KI_OFMARKERINT:
2337a6d42e7dSPeter Dunlap 	case KI_IFMARKERINT:
2338a6d42e7dSPeter Dunlap 		break;
2339a6d42e7dSPeter Dunlap 	default:
2340a6d42e7dSPeter Dunlap 		break;
2341a6d42e7dSPeter Dunlap 	}
2342a6d42e7dSPeter Dunlap 
2343a6d42e7dSPeter Dunlap 	/*
2344a6d42e7dSPeter Dunlap 	 * Now handle the values according to the key name.  Sometimes we
2345a6d42e7dSPeter Dunlap 	 * don't care what the value is -- in that case we just add the nvpair
2346a6d42e7dSPeter Dunlap 	 * to the negotiated values list.
2347a6d42e7dSPeter Dunlap 	 */
2348a6d42e7dSPeter Dunlap 	switch (ikvx->ik_key_id) {
2349a6d42e7dSPeter Dunlap 	case KI_HEADER_DIGEST:
2350a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_digest(ict, nvp, ikvx);
2351a6d42e7dSPeter Dunlap 		break;
2352a6d42e7dSPeter Dunlap 	case KI_DATA_DIGEST:
2353a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_digest(ict, nvp, ikvx);
2354a6d42e7dSPeter Dunlap 		break;
2355a6d42e7dSPeter Dunlap 	case KI_INITIAL_R2T:
2356a6d42e7dSPeter Dunlap 		/* We *require* INITIAL_R2T=yes */
2357a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_boolean(ict, nvp, bool_val, ikvx,
2358a6d42e7dSPeter Dunlap 		    B_TRUE);
2359a6d42e7dSPeter Dunlap 		break;
2360a6d42e7dSPeter Dunlap 	case KI_IMMEDIATE_DATA:
2361a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_boolean(ict, nvp, bool_val, ikvx,
2362263f58aaSPriya Krishnan 		    bool_val);
2363a6d42e7dSPeter Dunlap 		break;
2364a6d42e7dSPeter Dunlap 	case KI_DATA_PDU_IN_ORDER:
2365a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_boolean(ict, nvp, bool_val, ikvx,
2366a6d42e7dSPeter Dunlap 		    B_TRUE);
2367a6d42e7dSPeter Dunlap 		break;
2368a6d42e7dSPeter Dunlap 	case KI_DATA_SEQUENCE_IN_ORDER:
2369a6d42e7dSPeter Dunlap 		/* We allow any value for DATA_SEQUENCE_IN_ORDER */
2370a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_boolean(ict, nvp, bool_val, ikvx,
2371a6d42e7dSPeter Dunlap 		    bool_val);
2372a6d42e7dSPeter Dunlap 		break;
2373a6d42e7dSPeter Dunlap 	case KI_OFMARKER:
2374a6d42e7dSPeter Dunlap 	case KI_IFMARKER:
2375a6d42e7dSPeter Dunlap 		/* We don't support markers */
2376a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_boolean(ict, nvp, bool_val, ikvx,
2377a6d42e7dSPeter Dunlap 		    B_FALSE);
2378a6d42e7dSPeter Dunlap 		break;
2379a6d42e7dSPeter Dunlap 	case KI_MAX_CONNECTIONS:
2380a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2381a6d42e7dSPeter Dunlap 		    ISCSI_MIN_CONNECTIONS,
2382a6d42e7dSPeter Dunlap 		    ISCSI_MAX_CONNECTIONS,
2383a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_CONNECTIONS);
2384a6d42e7dSPeter Dunlap 		break;
238556261083SCharles Ting 		/* this is a declartive param */
2386a6d42e7dSPeter Dunlap 	case KI_MAX_RECV_DATA_SEGMENT_LENGTH:
2387a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2388a6d42e7dSPeter Dunlap 		    ISCSI_MIN_RECV_DATA_SEGMENT_LENGTH,
2389a6d42e7dSPeter Dunlap 		    ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH,
239056261083SCharles Ting 		    ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH);
2391a6d42e7dSPeter Dunlap 		break;
2392a6d42e7dSPeter Dunlap 	case KI_MAX_BURST_LENGTH:
2393a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2394a6d42e7dSPeter Dunlap 		    ISCSI_MIN_MAX_BURST_LENGTH,
2395a6d42e7dSPeter Dunlap 		    ISCSI_MAX_BURST_LENGTH,
2396a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_BURST_LENGTH);
2397a6d42e7dSPeter Dunlap 		break;
2398a6d42e7dSPeter Dunlap 	case KI_FIRST_BURST_LENGTH:
2399a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2400a6d42e7dSPeter Dunlap 		    ISCSI_MIN_FIRST_BURST_LENGTH,
2401a6d42e7dSPeter Dunlap 		    ISCSI_MAX_FIRST_BURST_LENGTH,
2402a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_FIRST_BURST_LENGTH);
2403a6d42e7dSPeter Dunlap 		break;
2404a6d42e7dSPeter Dunlap 	case KI_DEFAULT_TIME_2_WAIT:
2405a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2406a6d42e7dSPeter Dunlap 		    ISCSI_MIN_TIME2WAIT,
2407a6d42e7dSPeter Dunlap 		    ISCSI_MAX_TIME2WAIT,
2408a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_TIME2WAIT);
2409a6d42e7dSPeter Dunlap 		break;
2410a6d42e7dSPeter Dunlap 	case KI_DEFAULT_TIME_2_RETAIN:
2411a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2412a6d42e7dSPeter Dunlap 		    ISCSI_MIN_TIME2RETAIN,
2413a6d42e7dSPeter Dunlap 		    ISCSI_MAX_TIME2RETAIN,
2414a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_TIME2RETAIN);
2415a6d42e7dSPeter Dunlap 		break;
2416a6d42e7dSPeter Dunlap 	case KI_MAX_OUTSTANDING_R2T:
2417a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2418a6d42e7dSPeter Dunlap 		    ISCSI_MIN_MAX_OUTSTANDING_R2T,
2419a6d42e7dSPeter Dunlap 		    ISCSI_MAX_OUTSTANDING_R2T,
2420a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_OUTSTANDING_R2T);
2421a6d42e7dSPeter Dunlap 		break;
2422a6d42e7dSPeter Dunlap 	case KI_ERROR_RECOVERY_LEVEL:
2423a6d42e7dSPeter Dunlap 		kvrc = iscsit_handle_numerical(ict, nvp, num_val, ikvx,
2424a6d42e7dSPeter Dunlap 		    ISCSI_MIN_ERROR_RECOVERY_LEVEL,
2425a6d42e7dSPeter Dunlap 		    ISCSI_MAX_ERROR_RECOVERY_LEVEL,
2426a6d42e7dSPeter Dunlap 		    ISCSIT_MAX_ERROR_RECOVERY_LEVEL);
2427a6d42e7dSPeter Dunlap 		break;
2428a6d42e7dSPeter Dunlap 	case KI_OFMARKERINT:
2429a6d42e7dSPeter Dunlap 	case KI_IFMARKERINT:
2430a6d42e7dSPeter Dunlap 		kvrc = iscsit_reply_string(ict, ikvx->ik_key_name,
2431a6d42e7dSPeter Dunlap 		    ISCSI_TEXT_IRRELEVANT);
2432a6d42e7dSPeter Dunlap 		break;
2433a6d42e7dSPeter Dunlap 	default:
2434a6d42e7dSPeter Dunlap 		kvrc = KV_UNHANDLED; /* invalid request */
2435a6d42e7dSPeter Dunlap 		break;
2436a6d42e7dSPeter Dunlap 	}
2437a6d42e7dSPeter Dunlap 
2438a6d42e7dSPeter Dunlap 	return (kvrc);
2439a6d42e7dSPeter Dunlap }
2440a6d42e7dSPeter Dunlap 
2441a6d42e7dSPeter Dunlap static kv_status_t
iscsit_reply_numerical(iscsit_conn_t * ict,const char * nvp_name,const uint64_t value)2442a6d42e7dSPeter Dunlap iscsit_reply_numerical(iscsit_conn_t *ict,
2443a6d42e7dSPeter Dunlap     const char *nvp_name, const uint64_t value)
2444a6d42e7dSPeter Dunlap {
2445a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2446a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2447a6d42e7dSPeter Dunlap 	int			nvrc;
2448a6d42e7dSPeter Dunlap 
2449a6d42e7dSPeter Dunlap 	nvrc = nvlist_add_uint64(lsm->icl_response_nvlist,
2450a6d42e7dSPeter Dunlap 	    nvp_name, value);
2451a6d42e7dSPeter Dunlap 	kvrc = idm_nvstat_to_kvstat(nvrc);
2452a6d42e7dSPeter Dunlap 
2453a6d42e7dSPeter Dunlap 	return (kvrc);
2454a6d42e7dSPeter Dunlap }
2455a6d42e7dSPeter Dunlap 
2456a6d42e7dSPeter Dunlap static kv_status_t
iscsit_reply_string(iscsit_conn_t * ict,const char * nvp_name,const char * text)2457a6d42e7dSPeter Dunlap iscsit_reply_string(iscsit_conn_t *ict,
2458a6d42e7dSPeter Dunlap     const char *nvp_name, const char *text)
2459a6d42e7dSPeter Dunlap {
2460a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2461a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2462a6d42e7dSPeter Dunlap 	int			nvrc;
2463a6d42e7dSPeter Dunlap 
2464a6d42e7dSPeter Dunlap 	nvrc = nvlist_add_string(lsm->icl_response_nvlist,
2465a6d42e7dSPeter Dunlap 	    nvp_name, text);
2466a6d42e7dSPeter Dunlap 	kvrc = idm_nvstat_to_kvstat(nvrc);
2467a6d42e7dSPeter Dunlap 
2468a6d42e7dSPeter Dunlap 	return (kvrc);
2469a6d42e7dSPeter Dunlap }
2470a6d42e7dSPeter Dunlap 
2471a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_digest(iscsit_conn_t * ict,nvpair_t * choices,const idm_kv_xlate_t * ikvx)2472a6d42e7dSPeter Dunlap iscsit_handle_digest(iscsit_conn_t *ict, nvpair_t *choices,
2473a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx)
2474a6d42e7dSPeter Dunlap {
2475a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2476a6d42e7dSPeter Dunlap 	kv_status_t		kvrc = KV_VALUE_ERROR;
2477a6d42e7dSPeter Dunlap 	int			nvrc;
2478a6d42e7dSPeter Dunlap 	nvpair_t		*digest_choice;
2479a6d42e7dSPeter Dunlap 	char			*digest_choice_string;
2480a6d42e7dSPeter Dunlap 
2481a6d42e7dSPeter Dunlap 	/*
2482a6d42e7dSPeter Dunlap 	 * Need to add persistent config here if we want users to allow
2483a6d42e7dSPeter Dunlap 	 * disabling of digests on the target side.  You could argue that
2484a6d42e7dSPeter Dunlap 	 * this makes things too complicated... just let the initiator state
2485a6d42e7dSPeter Dunlap 	 * what it wants and we'll take it.  For now that's exactly what
2486a6d42e7dSPeter Dunlap 	 * we'll do.
2487a6d42e7dSPeter Dunlap 	 *
2488a6d42e7dSPeter Dunlap 	 * Basic digest negotiation happens here at iSCSI level.   IDM
2489a6d42e7dSPeter Dunlap 	 * can override this during negotiate_key_values phase to
2490a6d42e7dSPeter Dunlap 	 * decline to set up any digest processing.
2491a6d42e7dSPeter Dunlap 	 */
2492a6d42e7dSPeter Dunlap 	digest_choice = idm_get_next_listvalue(choices, NULL);
2493a6d42e7dSPeter Dunlap 
2494a6d42e7dSPeter Dunlap 	/*
2495a6d42e7dSPeter Dunlap 	 * Loop through all choices.  As soon as we find a choice
2496a6d42e7dSPeter Dunlap 	 * that we support add the value to our negotiated values list
2497a6d42e7dSPeter Dunlap 	 * and respond with that value in the login response.
2498a6d42e7dSPeter Dunlap 	 */
2499a6d42e7dSPeter Dunlap 	while (digest_choice != NULL) {
2500a6d42e7dSPeter Dunlap 		nvrc = nvpair_value_string(digest_choice,
2501a6d42e7dSPeter Dunlap 		    &digest_choice_string);
2502a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2503a6d42e7dSPeter Dunlap 
2504a6d42e7dSPeter Dunlap 		if ((strcasecmp(digest_choice_string, "crc32c") == 0) ||
2505a6d42e7dSPeter Dunlap 		    (strcasecmp(digest_choice_string, "none") == 0)) {
2506a6d42e7dSPeter Dunlap 			/* Add to negotiated values list */
2507a6d42e7dSPeter Dunlap 			nvrc = nvlist_add_string(lsm->icl_negotiated_values,
2508a6d42e7dSPeter Dunlap 			    ikvx->ik_key_name, digest_choice_string);
2509a6d42e7dSPeter Dunlap 			kvrc = idm_nvstat_to_kvstat(nvrc);
2510a6d42e7dSPeter Dunlap 			if (nvrc == 0) {
2511a6d42e7dSPeter Dunlap 				/* Add to login response list */
2512a6d42e7dSPeter Dunlap 				nvrc = nvlist_add_string(
2513a6d42e7dSPeter Dunlap 				    lsm->icl_response_nvlist,
2514a6d42e7dSPeter Dunlap 				    ikvx->ik_key_name, digest_choice_string);
2515a6d42e7dSPeter Dunlap 				kvrc = idm_nvstat_to_kvstat(nvrc);
2516a6d42e7dSPeter Dunlap 			}
2517a6d42e7dSPeter Dunlap 			break;
2518a6d42e7dSPeter Dunlap 		}
2519a6d42e7dSPeter Dunlap 		digest_choice = idm_get_next_listvalue(choices,
2520a6d42e7dSPeter Dunlap 		    digest_choice);
2521a6d42e7dSPeter Dunlap 	}
2522a6d42e7dSPeter Dunlap 
2523a6d42e7dSPeter Dunlap 	if (digest_choice == NULL)
2524a6d42e7dSPeter Dunlap 		kvrc = KV_VALUE_ERROR;
2525a6d42e7dSPeter Dunlap 
2526a6d42e7dSPeter Dunlap 	return (kvrc);
2527a6d42e7dSPeter Dunlap }
2528a6d42e7dSPeter Dunlap 
2529a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_boolean(iscsit_conn_t * ict,nvpair_t * nvp,boolean_t value,const idm_kv_xlate_t * ikvx,boolean_t iscsit_value)2530a6d42e7dSPeter Dunlap iscsit_handle_boolean(iscsit_conn_t *ict, nvpair_t *nvp, boolean_t value,
2531a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx, boolean_t iscsit_value)
2532a6d42e7dSPeter Dunlap {
2533a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2534a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2535a6d42e7dSPeter Dunlap 	int			nvrc;
2536a6d42e7dSPeter Dunlap 
253756261083SCharles Ting 	if (ikvx->ik_declarative) {
253856261083SCharles Ting 		nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values, nvp);
2539a6d42e7dSPeter Dunlap 	} else {
254056261083SCharles Ting 		if (value != iscsit_value) {
254156261083SCharles Ting 			/* Respond back to initiator with our value */
254256261083SCharles Ting 			value = iscsit_value;
2543c050a449SPeter Gill 			nvrc = nvlist_add_boolean_value(
2544c050a449SPeter Gill 			    lsm->icl_negotiated_values,
2545c050a449SPeter Gill 			    ikvx->ik_key_name, value);
254656261083SCharles Ting 			lsm->icl_login_transit = B_FALSE;
254756261083SCharles Ting 		} else {
254856261083SCharles Ting 			/* Add this to our negotiated values */
254956261083SCharles Ting 			nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values,
255056261083SCharles Ting 			    nvp);
255156261083SCharles Ting 		}
2552a6d42e7dSPeter Dunlap 
255356261083SCharles Ting 		/* Response of Simple-value Negotiation */
255456261083SCharles Ting 		if (nvrc == 0) {
255556261083SCharles Ting 			nvrc = nvlist_add_boolean_value(
255656261083SCharles Ting 			    lsm->icl_response_nvlist, ikvx->ik_key_name, value);
255756261083SCharles Ting 		}
2558a6d42e7dSPeter Dunlap 	}
255956261083SCharles Ting 
2560a6d42e7dSPeter Dunlap 	kvrc = idm_nvstat_to_kvstat(nvrc);
2561a6d42e7dSPeter Dunlap 
2562a6d42e7dSPeter Dunlap 	return (kvrc);
2563a6d42e7dSPeter Dunlap }
2564a6d42e7dSPeter Dunlap 
2565a6d42e7dSPeter Dunlap static kv_status_t
iscsit_handle_numerical(iscsit_conn_t * ict,nvpair_t * nvp,uint64_t value,const idm_kv_xlate_t * ikvx,uint64_t iscsi_min_value,uint64_t iscsi_max_value,uint64_t iscsit_max_value)2566a6d42e7dSPeter Dunlap iscsit_handle_numerical(iscsit_conn_t *ict, nvpair_t *nvp, uint64_t value,
2567a6d42e7dSPeter Dunlap     const idm_kv_xlate_t *ikvx,
2568a6d42e7dSPeter Dunlap     uint64_t iscsi_min_value, uint64_t iscsi_max_value,
2569a6d42e7dSPeter Dunlap     uint64_t iscsit_max_value)
2570a6d42e7dSPeter Dunlap {
2571a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2572a6d42e7dSPeter Dunlap 	kv_status_t		kvrc;
2573a6d42e7dSPeter Dunlap 	int			nvrc;
2574a6d42e7dSPeter Dunlap 
2575a6d42e7dSPeter Dunlap 	/* Validate against standard */
2576a6d42e7dSPeter Dunlap 	if ((value < iscsi_min_value) || (value > iscsi_max_value)) {
2577a6d42e7dSPeter Dunlap 		kvrc = KV_VALUE_ERROR;
257856261083SCharles Ting 	} else if (ikvx->ik_declarative) {
257956261083SCharles Ting 		nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values, nvp);
258056261083SCharles Ting 		kvrc = idm_nvstat_to_kvstat(nvrc);
2581a6d42e7dSPeter Dunlap 	} else {
2582a6d42e7dSPeter Dunlap 		if (value > iscsit_max_value) {
2583a6d42e7dSPeter Dunlap 			/* Respond back to initiator with our value */
2584a6d42e7dSPeter Dunlap 			value = iscsit_max_value;
2585c050a449SPeter Gill 			nvrc = nvlist_add_uint64(lsm->icl_negotiated_values,
2586c050a449SPeter Gill 			    ikvx->ik_key_name, value);
2587a6d42e7dSPeter Dunlap 			lsm->icl_login_transit = B_FALSE;
2588a6d42e7dSPeter Dunlap 		} else {
2589a6d42e7dSPeter Dunlap 			/* Add this to our negotiated values */
2590a6d42e7dSPeter Dunlap 			nvrc = nvlist_add_nvpair(lsm->icl_negotiated_values,
2591a6d42e7dSPeter Dunlap 			    nvp);
2592a6d42e7dSPeter Dunlap 		}
2593a6d42e7dSPeter Dunlap 
2594a6d42e7dSPeter Dunlap 		/* Response of Simple-value Negotiation */
259556261083SCharles Ting 		if (nvrc == 0) {
2596a6d42e7dSPeter Dunlap 			nvrc = nvlist_add_uint64(lsm->icl_response_nvlist,
2597a6d42e7dSPeter Dunlap 			    ikvx->ik_key_name, value);
2598a6d42e7dSPeter Dunlap 		}
2599a6d42e7dSPeter Dunlap 		kvrc = idm_nvstat_to_kvstat(nvrc);
2600a6d42e7dSPeter Dunlap 	}
2601a6d42e7dSPeter Dunlap 
2602a6d42e7dSPeter Dunlap 	return (kvrc);
2603a6d42e7dSPeter Dunlap }
2604a6d42e7dSPeter Dunlap 
2605a6d42e7dSPeter Dunlap 
2606a6d42e7dSPeter Dunlap static void
iscsit_process_negotiated_values(iscsit_conn_t * ict)2607a6d42e7dSPeter Dunlap iscsit_process_negotiated_values(iscsit_conn_t *ict)
2608a6d42e7dSPeter Dunlap {
2609a6d42e7dSPeter Dunlap 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
2610a6d42e7dSPeter Dunlap 	char			*string_val;
2611a6d42e7dSPeter Dunlap 	boolean_t		boolean_val;
2612a6d42e7dSPeter Dunlap 	uint64_t		uint64_val;
2613a6d42e7dSPeter Dunlap 	int			nvrc;
2614a6d42e7dSPeter Dunlap 
2615a6d42e7dSPeter Dunlap 	/* Let the IDM level activate its parameters first */
261630e7468fSPeter Dunlap 	idm_notice_key_values(ict->ict_ic, lsm->icl_negotiated_values);
2617a6d42e7dSPeter Dunlap 
2618a6d42e7dSPeter Dunlap 	/*
2619a6d42e7dSPeter Dunlap 	 * Initiator alias and target alias
2620a6d42e7dSPeter Dunlap 	 */
2621a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_string(lsm->icl_negotiated_values,
2622a6d42e7dSPeter Dunlap 	    "InitiatorAlias", &string_val)) != ENOENT) {
2623a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2624a6d42e7dSPeter Dunlap 		ict->ict_sess->ist_initiator_alias =
2625a6d42e7dSPeter Dunlap 		    kmem_alloc(strlen(string_val) + 1, KM_SLEEP);
2626a6d42e7dSPeter Dunlap 		(void) strcpy(ict->ict_sess->ist_initiator_alias, string_val);
2627ca3b8945SYuri Pankov 		if (ict->ict_sess->ist_stmf_sess)
2628ca3b8945SYuri Pankov 			ict->ict_sess->ist_stmf_sess->ss_rport_alias =
2629ca3b8945SYuri Pankov 			    strdup(string_val);
2630a6d42e7dSPeter Dunlap 	}
2631a6d42e7dSPeter Dunlap 
2632a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_string(lsm->icl_negotiated_values,
2633a6d42e7dSPeter Dunlap 	    "TargetAlias", &string_val)) != ENOENT) {
2634a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2635a6d42e7dSPeter Dunlap 		ict->ict_sess->ist_target_alias =
2636a6d42e7dSPeter Dunlap 		    kmem_alloc(strlen(string_val) + 1, KM_SLEEP);
2637a6d42e7dSPeter Dunlap 		(void) strcpy(ict->ict_sess->ist_target_alias, string_val);
2638a6d42e7dSPeter Dunlap 	}
2639a6d42e7dSPeter Dunlap 
2640a6d42e7dSPeter Dunlap 	/*
2641a6d42e7dSPeter Dunlap 	 * Operational parameters.  We process SessionType when it is
2642a6d42e7dSPeter Dunlap 	 * initially received since it is required on the initial login.
2643a6d42e7dSPeter Dunlap 	 */
2644a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_boolean_value(lsm->icl_negotiated_values,
2645a6d42e7dSPeter Dunlap 	    "InitialR2T", &boolean_val)) != ENOENT) {
2646a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2647a6d42e7dSPeter Dunlap 		ict->ict_op.op_initial_r2t = boolean_val;
2648a6d42e7dSPeter Dunlap 	}
2649a6d42e7dSPeter Dunlap 
2650a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_boolean_value(lsm->icl_negotiated_values,
2651a6d42e7dSPeter Dunlap 	    "ImmediateData", &boolean_val)) != ENOENT) {
2652a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2653a6d42e7dSPeter Dunlap 		ict->ict_op.op_immed_data = boolean_val;
2654a6d42e7dSPeter Dunlap 	}
2655a6d42e7dSPeter Dunlap 
2656a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_boolean_value(lsm->icl_negotiated_values,
2657a6d42e7dSPeter Dunlap 	    "DataPDUInOrder", &boolean_val)) != ENOENT) {
2658a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2659a6d42e7dSPeter Dunlap 		ict->ict_op.op_data_pdu_in_order = boolean_val;
2660a6d42e7dSPeter Dunlap 	}
2661a6d42e7dSPeter Dunlap 
2662a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_boolean_value(lsm->icl_negotiated_values,
2663a6d42e7dSPeter Dunlap 	    "DataSequenceInOrder", &boolean_val)) != ENOENT) {
2664a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2665a6d42e7dSPeter Dunlap 		ict->ict_op.op_data_sequence_in_order = boolean_val;
2666a6d42e7dSPeter Dunlap 	}
2667a6d42e7dSPeter Dunlap 
2668a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2669a6d42e7dSPeter Dunlap 	    "MaxConnections", &uint64_val)) != ENOENT) {
2670a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2671a6d42e7dSPeter Dunlap 		ict->ict_op.op_max_connections = uint64_val;
2672a6d42e7dSPeter Dunlap 	}
2673a6d42e7dSPeter Dunlap 
2674a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2675a6d42e7dSPeter Dunlap 	    "MaxRecvDataSegmentLength", &uint64_val)) != ENOENT) {
2676a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2677a6d42e7dSPeter Dunlap 		ict->ict_op.op_max_recv_data_segment_length = uint64_val;
2678a6d42e7dSPeter Dunlap 	}
2679a6d42e7dSPeter Dunlap 
2680a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2681a6d42e7dSPeter Dunlap 	    "MaxBurstLength", &uint64_val)) != ENOENT) {
2682a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2683a6d42e7dSPeter Dunlap 		ict->ict_op.op_max_burst_length = uint64_val;
2684a6d42e7dSPeter Dunlap 	}
2685a6d42e7dSPeter Dunlap 
2686a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2687a6d42e7dSPeter Dunlap 	    "FirstBurstLength", &uint64_val)) != ENOENT) {
2688a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2689a6d42e7dSPeter Dunlap 		ict->ict_op.op_first_burst_length = uint64_val;
2690a6d42e7dSPeter Dunlap 	}
2691a6d42e7dSPeter Dunlap 
2692a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2693a6d42e7dSPeter Dunlap 	    "DefaultTime2Wait", &uint64_val)) != ENOENT) {
2694a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2695a6d42e7dSPeter Dunlap 		ict->ict_op.op_default_time_2_wait = uint64_val;
2696a6d42e7dSPeter Dunlap 	}
2697a6d42e7dSPeter Dunlap 
2698a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2699a6d42e7dSPeter Dunlap 	    "DefaultTime2Retain", &uint64_val)) != ENOENT) {
2700a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2701a6d42e7dSPeter Dunlap 		ict->ict_op.op_default_time_2_retain = uint64_val;
2702a6d42e7dSPeter Dunlap 	}
2703a6d42e7dSPeter Dunlap 
2704a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2705a6d42e7dSPeter Dunlap 	    "MaxOutstandingR2T", &uint64_val)) != ENOENT) {
2706a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2707a6d42e7dSPeter Dunlap 		ict->ict_op.op_max_outstanding_r2t = uint64_val;
2708a6d42e7dSPeter Dunlap 	}
2709a6d42e7dSPeter Dunlap 
2710a6d42e7dSPeter Dunlap 	if ((nvrc = nvlist_lookup_uint64(lsm->icl_negotiated_values,
2711a6d42e7dSPeter Dunlap 	    "ErrorRecoveryLevel", &uint64_val)) != ENOENT) {
2712a6d42e7dSPeter Dunlap 		ASSERT(nvrc == 0);
2713a6d42e7dSPeter Dunlap 		ict->ict_op.op_error_recovery_level = uint64_val;
2714a6d42e7dSPeter Dunlap 	}
2715a6d42e7dSPeter Dunlap }
271656261083SCharles Ting 
271756261083SCharles Ting static idm_status_t
iscsit_add_declarative_keys(iscsit_conn_t * ict)271856261083SCharles Ting iscsit_add_declarative_keys(iscsit_conn_t *ict)
271956261083SCharles Ting {
272056261083SCharles Ting 	nvlist_t		*cfg_nv = NULL;
272156261083SCharles Ting 	kv_status_t		kvrc;
272256261083SCharles Ting 	int			nvrc;
272356261083SCharles Ting 	iscsit_conn_login_t	*lsm = &ict->ict_login_sm;
272456261083SCharles Ting 	uint8_t			error_class;
272556261083SCharles Ting 	uint8_t			error_detail;
272656261083SCharles Ting 	idm_status_t		idm_status;
272756261083SCharles Ting 
272856261083SCharles Ting 	if ((nvrc = nvlist_alloc(&cfg_nv, NV_UNIQUE_NAME, KM_NOSLEEP)) != 0) {
272956261083SCharles Ting 		kvrc = idm_nvstat_to_kvstat(nvrc);
273056261083SCharles Ting 		goto alloc_fail;
273156261083SCharles Ting 	}
273256261083SCharles Ting 	if ((nvrc = nvlist_add_uint64(cfg_nv, "MaxRecvDataSegmentLength",
273356261083SCharles Ting 	    max_dataseglen_target)) != 0) {
273456261083SCharles Ting 		kvrc = idm_nvstat_to_kvstat(nvrc);
273556261083SCharles Ting 		goto done;
273656261083SCharles Ting 	}
273756261083SCharles Ting 
273856261083SCharles Ting 	kvrc = idm_declare_key_values(ict->ict_ic, cfg_nv,
273956261083SCharles Ting 	    lsm->icl_response_nvlist);
274056261083SCharles Ting done:
274156261083SCharles Ting 	nvlist_free(cfg_nv);
274256261083SCharles Ting alloc_fail:
274356261083SCharles Ting 	idm_kvstat_to_error(kvrc, &error_class, &error_detail);
274456261083SCharles Ting 	if (error_class == ISCSI_STATUS_CLASS_SUCCESS) {
274556261083SCharles Ting 		idm_status = IDM_STATUS_SUCCESS;
274656261083SCharles Ting 	} else {
274756261083SCharles Ting 		SET_LOGIN_ERROR(ict, error_class, error_detail);
274856261083SCharles Ting 		idm_status = IDM_STATUS_FAIL;
274956261083SCharles Ting 	}
275056261083SCharles Ting 	return (idm_status);
275156261083SCharles Ting }
27521ef61828SYuri Pankov 
27531ef61828SYuri Pankov static char *
iscsit_fold_name(char * name,size_t * buflen)27541ef61828SYuri Pankov iscsit_fold_name(char *name, size_t *buflen)
27551ef61828SYuri Pankov {
27561ef61828SYuri Pankov 	char		*ret;
27571ef61828SYuri Pankov 	const char	*sns;
27581ef61828SYuri Pankov 	int		errnum;
27591ef61828SYuri Pankov 	int		flag = U8_TEXTPREP_NFKC;
27601ef61828SYuri Pankov 	size_t		inlen, outlen, coff;
27611ef61828SYuri Pankov 
27621ef61828SYuri Pankov 	if (name == NULL)
27631ef61828SYuri Pankov 		return (NULL);
27641ef61828SYuri Pankov 
27651ef61828SYuri Pankov 	/* Check for one of the supported name types */
27661ef61828SYuri Pankov 	if (strncasecmp(name, SNS_EUI ".", strlen(SNS_EUI) + 1) == 0) {
27671ef61828SYuri Pankov 		sns = SNS_EUI;
2768*61dfa509SRick McNeal 		*buflen = SNS_EUI_LEN_MAX + 1;
27691ef61828SYuri Pankov 		flag |= U8_TEXTPREP_TOUPPER;
27701ef61828SYuri Pankov 	} else if (strncasecmp(name, SNS_IQN ".", strlen(SNS_IQN) + 1) == 0) {
27711ef61828SYuri Pankov 		sns = SNS_IQN;
2772*61dfa509SRick McNeal 		*buflen = SNS_IQN_LEN_MAX + 1;
27731ef61828SYuri Pankov 		flag |= U8_TEXTPREP_TOLOWER;
27741ef61828SYuri Pankov 	} else if (strncasecmp(name, SNS_NAA ".", strlen(SNS_NAA) + 1) == 0) {
27751ef61828SYuri Pankov 		sns = SNS_NAA;
2776*61dfa509SRick McNeal 		*buflen = SNS_NAA_LEN_MAX + 1;
27771ef61828SYuri Pankov 		flag |= U8_TEXTPREP_TOUPPER;
27781ef61828SYuri Pankov 	} else {
27791ef61828SYuri Pankov 		return (NULL);
27801ef61828SYuri Pankov 	}
27811ef61828SYuri Pankov 
27821ef61828SYuri Pankov 	ret = kmem_zalloc(*buflen, KM_SLEEP);
27831ef61828SYuri Pankov 	coff = strlen(sns);
27841ef61828SYuri Pankov 	inlen = strlen(name) - coff;
2785*61dfa509SRick McNeal 	outlen = *buflen - coff - 1;
27861ef61828SYuri Pankov 
27871ef61828SYuri Pankov 	/* Fold the case and normalize string */
27881ef61828SYuri Pankov 	if (u8_textprep_str(name + coff, &inlen, ret + coff, &outlen, flag,
27891ef61828SYuri Pankov 	    U8_UNICODE_320, &errnum) == (size_t)-1) {
27901ef61828SYuri Pankov 		kmem_free(ret, *buflen);
27911ef61828SYuri Pankov 		return (NULL);
27921ef61828SYuri Pankov 	}
27931ef61828SYuri Pankov 
27941ef61828SYuri Pankov 	/* Copy the name type prefix */
27951ef61828SYuri Pankov 	bcopy(sns, ret, coff);
27961ef61828SYuri Pankov 
27971ef61828SYuri Pankov 	return (ret);
27981ef61828SYuri Pankov }
2799