1 /*******************************************************************************
2 * This file contains main functions related to iSCSI Parameter negotiation.
4 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
6 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
8 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 ******************************************************************************/
21 #include <linux/slab.h>
23 #include "iscsi_target_core.h"
24 #include "iscsi_target_util.h"
25 #include "iscsi_target_parameters.h"
27 int iscsi_login_rx_data(
28 struct iscsi_conn
*conn
,
35 memset(&iov
, 0, sizeof(struct kvec
));
40 * Initial Marker-less Interval.
41 * Add the values regardless of IFMarker/OFMarker, considering
42 * it may not be negoitated yet.
44 conn
->of_marker
+= length
;
46 rx_got
= rx_data(conn
, &iov
, 1, length
);
47 if (rx_got
!= length
) {
48 pr_err("rx_data returned %d, expecting %d.\n",
56 int iscsi_login_tx_data(
57 struct iscsi_conn
*conn
,
65 length
= (ISCSI_HDR_LEN
+ text_length
);
67 memset(&iov
[0], 0, 2 * sizeof(struct kvec
));
68 iov
[0].iov_len
= ISCSI_HDR_LEN
;
69 iov
[0].iov_base
= pdu_buf
;
70 iov
[1].iov_len
= text_length
;
71 iov
[1].iov_base
= text_buf
;
74 * Initial Marker-less Interval.
75 * Add the values regardless of IFMarker/OFMarker, considering
76 * it may not be negoitated yet.
78 conn
->if_marker
+= length
;
80 tx_sent
= tx_data(conn
, &iov
[0], 2, length
);
81 if (tx_sent
!= length
) {
82 pr_err("tx_data returned %d, expecting %d.\n",
90 void iscsi_dump_conn_ops(struct iscsi_conn_ops
*conn_ops
)
92 pr_debug("HeaderDigest: %s\n", (conn_ops
->HeaderDigest
) ?
94 pr_debug("DataDigest: %s\n", (conn_ops
->DataDigest
) ?
96 pr_debug("MaxRecvDataSegmentLength: %u\n",
97 conn_ops
->MaxRecvDataSegmentLength
);
98 pr_debug("OFMarker: %s\n", (conn_ops
->OFMarker
) ? "Yes" : "No");
99 pr_debug("IFMarker: %s\n", (conn_ops
->IFMarker
) ? "Yes" : "No");
100 if (conn_ops
->OFMarker
)
101 pr_debug("OFMarkInt: %u\n", conn_ops
->OFMarkInt
);
102 if (conn_ops
->IFMarker
)
103 pr_debug("IFMarkInt: %u\n", conn_ops
->IFMarkInt
);
106 void iscsi_dump_sess_ops(struct iscsi_sess_ops
*sess_ops
)
108 pr_debug("InitiatorName: %s\n", sess_ops
->InitiatorName
);
109 pr_debug("InitiatorAlias: %s\n", sess_ops
->InitiatorAlias
);
110 pr_debug("TargetName: %s\n", sess_ops
->TargetName
);
111 pr_debug("TargetAlias: %s\n", sess_ops
->TargetAlias
);
112 pr_debug("TargetPortalGroupTag: %hu\n",
113 sess_ops
->TargetPortalGroupTag
);
114 pr_debug("MaxConnections: %hu\n", sess_ops
->MaxConnections
);
115 pr_debug("InitialR2T: %s\n",
116 (sess_ops
->InitialR2T
) ? "Yes" : "No");
117 pr_debug("ImmediateData: %s\n", (sess_ops
->ImmediateData
) ?
119 pr_debug("MaxBurstLength: %u\n", sess_ops
->MaxBurstLength
);
120 pr_debug("FirstBurstLength: %u\n", sess_ops
->FirstBurstLength
);
121 pr_debug("DefaultTime2Wait: %hu\n", sess_ops
->DefaultTime2Wait
);
122 pr_debug("DefaultTime2Retain: %hu\n",
123 sess_ops
->DefaultTime2Retain
);
124 pr_debug("MaxOutstandingR2T: %hu\n",
125 sess_ops
->MaxOutstandingR2T
);
126 pr_debug("DataPDUInOrder: %s\n",
127 (sess_ops
->DataPDUInOrder
) ? "Yes" : "No");
128 pr_debug("DataSequenceInOrder: %s\n",
129 (sess_ops
->DataSequenceInOrder
) ? "Yes" : "No");
130 pr_debug("ErrorRecoveryLevel: %hu\n",
131 sess_ops
->ErrorRecoveryLevel
);
132 pr_debug("SessionType: %s\n", (sess_ops
->SessionType
) ?
133 "Discovery" : "Normal");
136 void iscsi_print_params(struct iscsi_param_list
*param_list
)
138 struct iscsi_param
*param
;
140 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
)
141 pr_debug("%s: %s\n", param
->name
, param
->value
);
144 static struct iscsi_param
*iscsi_set_default_param(struct iscsi_param_list
*param_list
,
145 char *name
, char *value
, u8 phase
, u8 scope
, u8 sender
,
146 u16 type_range
, u8 use
)
148 struct iscsi_param
*param
= NULL
;
150 param
= kzalloc(sizeof(struct iscsi_param
), GFP_KERNEL
);
152 pr_err("Unable to allocate memory for parameter.\n");
155 INIT_LIST_HEAD(¶m
->p_list
);
157 param
->name
= kzalloc(strlen(name
) + 1, GFP_KERNEL
);
159 pr_err("Unable to allocate memory for parameter name.\n");
163 param
->value
= kzalloc(strlen(value
) + 1, GFP_KERNEL
);
165 pr_err("Unable to allocate memory for parameter value.\n");
169 memcpy(param
->name
, name
, strlen(name
));
170 param
->name
[strlen(name
)] = '\0';
171 memcpy(param
->value
, value
, strlen(value
));
172 param
->value
[strlen(value
)] = '\0';
173 param
->phase
= phase
;
174 param
->scope
= scope
;
175 param
->sender
= sender
;
177 param
->type_range
= type_range
;
179 switch (param
->type_range
) {
180 case TYPERANGE_BOOL_AND
:
181 param
->type
= TYPE_BOOL_AND
;
183 case TYPERANGE_BOOL_OR
:
184 param
->type
= TYPE_BOOL_OR
;
186 case TYPERANGE_0_TO_2
:
187 case TYPERANGE_0_TO_3600
:
188 case TYPERANGE_0_TO_32767
:
189 case TYPERANGE_0_TO_65535
:
190 case TYPERANGE_1_TO_65535
:
191 case TYPERANGE_2_TO_3600
:
192 case TYPERANGE_512_TO_16777215
:
193 param
->type
= TYPE_NUMBER
;
196 case TYPERANGE_DIGEST
:
197 param
->type
= TYPE_VALUE_LIST
| TYPE_STRING
;
199 case TYPERANGE_MARKINT
:
200 param
->type
= TYPE_NUMBER_RANGE
;
201 param
->type_range
|= TYPERANGE_1_TO_65535
;
203 case TYPERANGE_ISCSINAME
:
204 case TYPERANGE_SESSIONTYPE
:
205 case TYPERANGE_TARGETADDRESS
:
207 param
->type
= TYPE_STRING
;
210 pr_err("Unknown type_range 0x%02x\n",
214 list_add_tail(¶m
->p_list
, ¶m_list
->param_list
);
227 /* #warning Add extension keys */
228 int iscsi_create_default_params(struct iscsi_param_list
**param_list_ptr
)
230 struct iscsi_param
*param
= NULL
;
231 struct iscsi_param_list
*pl
;
233 pl
= kzalloc(sizeof(struct iscsi_param_list
), GFP_KERNEL
);
235 pr_err("Unable to allocate memory for"
236 " struct iscsi_param_list.\n");
239 INIT_LIST_HEAD(&pl
->param_list
);
240 INIT_LIST_HEAD(&pl
->extra_response_list
);
243 * The format for setting the initial parameter definitions are:
253 param
= iscsi_set_default_param(pl
, AUTHMETHOD
, INITIAL_AUTHMETHOD
,
254 PHASE_SECURITY
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
255 TYPERANGE_AUTH
, USE_INITIAL_ONLY
);
259 param
= iscsi_set_default_param(pl
, HEADERDIGEST
, INITIAL_HEADERDIGEST
,
260 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
261 TYPERANGE_DIGEST
, USE_INITIAL_ONLY
);
265 param
= iscsi_set_default_param(pl
, DATADIGEST
, INITIAL_DATADIGEST
,
266 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
267 TYPERANGE_DIGEST
, USE_INITIAL_ONLY
);
271 param
= iscsi_set_default_param(pl
, MAXCONNECTIONS
,
272 INITIAL_MAXCONNECTIONS
, PHASE_OPERATIONAL
,
273 SCOPE_SESSION_WIDE
, SENDER_BOTH
,
274 TYPERANGE_1_TO_65535
, USE_LEADING_ONLY
);
278 param
= iscsi_set_default_param(pl
, SENDTARGETS
, INITIAL_SENDTARGETS
,
279 PHASE_FFP0
, SCOPE_SESSION_WIDE
, SENDER_INITIATOR
,
284 param
= iscsi_set_default_param(pl
, TARGETNAME
, INITIAL_TARGETNAME
,
285 PHASE_DECLARATIVE
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
286 TYPERANGE_ISCSINAME
, USE_ALL
);
290 param
= iscsi_set_default_param(pl
, INITIATORNAME
,
291 INITIAL_INITIATORNAME
, PHASE_DECLARATIVE
,
292 SCOPE_SESSION_WIDE
, SENDER_INITIATOR
,
293 TYPERANGE_ISCSINAME
, USE_INITIAL_ONLY
);
297 param
= iscsi_set_default_param(pl
, TARGETALIAS
, INITIAL_TARGETALIAS
,
298 PHASE_DECLARATIVE
, SCOPE_SESSION_WIDE
, SENDER_TARGET
,
299 TYPERANGE_UTF8
, USE_ALL
);
303 param
= iscsi_set_default_param(pl
, INITIATORALIAS
,
304 INITIAL_INITIATORALIAS
, PHASE_DECLARATIVE
,
305 SCOPE_SESSION_WIDE
, SENDER_INITIATOR
, TYPERANGE_UTF8
,
310 param
= iscsi_set_default_param(pl
, TARGETADDRESS
,
311 INITIAL_TARGETADDRESS
, PHASE_DECLARATIVE
,
312 SCOPE_SESSION_WIDE
, SENDER_TARGET
,
313 TYPERANGE_TARGETADDRESS
, USE_ALL
);
317 param
= iscsi_set_default_param(pl
, TARGETPORTALGROUPTAG
,
318 INITIAL_TARGETPORTALGROUPTAG
,
319 PHASE_DECLARATIVE
, SCOPE_SESSION_WIDE
, SENDER_TARGET
,
320 TYPERANGE_0_TO_65535
, USE_INITIAL_ONLY
);
324 param
= iscsi_set_default_param(pl
, INITIALR2T
, INITIAL_INITIALR2T
,
325 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
326 TYPERANGE_BOOL_OR
, USE_LEADING_ONLY
);
330 param
= iscsi_set_default_param(pl
, IMMEDIATEDATA
,
331 INITIAL_IMMEDIATEDATA
, PHASE_OPERATIONAL
,
332 SCOPE_SESSION_WIDE
, SENDER_BOTH
, TYPERANGE_BOOL_AND
,
337 param
= iscsi_set_default_param(pl
, MAXXMITDATASEGMENTLENGTH
,
338 INITIAL_MAXXMITDATASEGMENTLENGTH
,
339 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
340 TYPERANGE_512_TO_16777215
, USE_ALL
);
344 param
= iscsi_set_default_param(pl
, MAXRECVDATASEGMENTLENGTH
,
345 INITIAL_MAXRECVDATASEGMENTLENGTH
,
346 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
347 TYPERANGE_512_TO_16777215
, USE_ALL
);
351 param
= iscsi_set_default_param(pl
, MAXBURSTLENGTH
,
352 INITIAL_MAXBURSTLENGTH
, PHASE_OPERATIONAL
,
353 SCOPE_SESSION_WIDE
, SENDER_BOTH
,
354 TYPERANGE_512_TO_16777215
, USE_LEADING_ONLY
);
358 param
= iscsi_set_default_param(pl
, FIRSTBURSTLENGTH
,
359 INITIAL_FIRSTBURSTLENGTH
,
360 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
361 TYPERANGE_512_TO_16777215
, USE_LEADING_ONLY
);
365 param
= iscsi_set_default_param(pl
, DEFAULTTIME2WAIT
,
366 INITIAL_DEFAULTTIME2WAIT
,
367 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
368 TYPERANGE_0_TO_3600
, USE_LEADING_ONLY
);
372 param
= iscsi_set_default_param(pl
, DEFAULTTIME2RETAIN
,
373 INITIAL_DEFAULTTIME2RETAIN
,
374 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
375 TYPERANGE_0_TO_3600
, USE_LEADING_ONLY
);
379 param
= iscsi_set_default_param(pl
, MAXOUTSTANDINGR2T
,
380 INITIAL_MAXOUTSTANDINGR2T
,
381 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
382 TYPERANGE_1_TO_65535
, USE_LEADING_ONLY
);
386 param
= iscsi_set_default_param(pl
, DATAPDUINORDER
,
387 INITIAL_DATAPDUINORDER
, PHASE_OPERATIONAL
,
388 SCOPE_SESSION_WIDE
, SENDER_BOTH
, TYPERANGE_BOOL_OR
,
393 param
= iscsi_set_default_param(pl
, DATASEQUENCEINORDER
,
394 INITIAL_DATASEQUENCEINORDER
,
395 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
396 TYPERANGE_BOOL_OR
, USE_LEADING_ONLY
);
400 param
= iscsi_set_default_param(pl
, ERRORRECOVERYLEVEL
,
401 INITIAL_ERRORRECOVERYLEVEL
,
402 PHASE_OPERATIONAL
, SCOPE_SESSION_WIDE
, SENDER_BOTH
,
403 TYPERANGE_0_TO_2
, USE_LEADING_ONLY
);
407 param
= iscsi_set_default_param(pl
, SESSIONTYPE
, INITIAL_SESSIONTYPE
,
408 PHASE_DECLARATIVE
, SCOPE_SESSION_WIDE
, SENDER_INITIATOR
,
409 TYPERANGE_SESSIONTYPE
, USE_LEADING_ONLY
);
413 param
= iscsi_set_default_param(pl
, IFMARKER
, INITIAL_IFMARKER
,
414 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
415 TYPERANGE_BOOL_AND
, USE_INITIAL_ONLY
);
419 param
= iscsi_set_default_param(pl
, OFMARKER
, INITIAL_OFMARKER
,
420 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
421 TYPERANGE_BOOL_AND
, USE_INITIAL_ONLY
);
425 param
= iscsi_set_default_param(pl
, IFMARKINT
, INITIAL_IFMARKINT
,
426 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
427 TYPERANGE_MARKINT
, USE_INITIAL_ONLY
);
431 param
= iscsi_set_default_param(pl
, OFMARKINT
, INITIAL_OFMARKINT
,
432 PHASE_OPERATIONAL
, SCOPE_CONNECTION_ONLY
, SENDER_BOTH
,
433 TYPERANGE_MARKINT
, USE_INITIAL_ONLY
);
437 *param_list_ptr
= pl
;
440 iscsi_release_param_list(pl
);
444 int iscsi_set_keys_to_negotiate(
446 struct iscsi_param_list
*param_list
)
448 struct iscsi_param
*param
;
450 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
452 if (!strcmp(param
->name
, AUTHMETHOD
)) {
453 SET_PSTATE_NEGOTIATE(param
);
454 } else if (!strcmp(param
->name
, HEADERDIGEST
)) {
455 SET_PSTATE_NEGOTIATE(param
);
456 } else if (!strcmp(param
->name
, DATADIGEST
)) {
457 SET_PSTATE_NEGOTIATE(param
);
458 } else if (!strcmp(param
->name
, MAXCONNECTIONS
)) {
459 SET_PSTATE_NEGOTIATE(param
);
460 } else if (!strcmp(param
->name
, TARGETNAME
)) {
462 } else if (!strcmp(param
->name
, INITIATORNAME
)) {
464 } else if (!strcmp(param
->name
, TARGETALIAS
)) {
466 SET_PSTATE_NEGOTIATE(param
);
467 } else if (!strcmp(param
->name
, INITIATORALIAS
)) {
469 } else if (!strcmp(param
->name
, TARGETPORTALGROUPTAG
)) {
470 SET_PSTATE_NEGOTIATE(param
);
471 } else if (!strcmp(param
->name
, INITIALR2T
)) {
472 SET_PSTATE_NEGOTIATE(param
);
473 } else if (!strcmp(param
->name
, IMMEDIATEDATA
)) {
474 SET_PSTATE_NEGOTIATE(param
);
475 } else if (!strcmp(param
->name
, MAXRECVDATASEGMENTLENGTH
)) {
476 SET_PSTATE_NEGOTIATE(param
);
477 } else if (!strcmp(param
->name
, MAXXMITDATASEGMENTLENGTH
)) {
479 } else if (!strcmp(param
->name
, MAXBURSTLENGTH
)) {
480 SET_PSTATE_NEGOTIATE(param
);
481 } else if (!strcmp(param
->name
, FIRSTBURSTLENGTH
)) {
482 SET_PSTATE_NEGOTIATE(param
);
483 } else if (!strcmp(param
->name
, DEFAULTTIME2WAIT
)) {
484 SET_PSTATE_NEGOTIATE(param
);
485 } else if (!strcmp(param
->name
, DEFAULTTIME2RETAIN
)) {
486 SET_PSTATE_NEGOTIATE(param
);
487 } else if (!strcmp(param
->name
, MAXOUTSTANDINGR2T
)) {
488 SET_PSTATE_NEGOTIATE(param
);
489 } else if (!strcmp(param
->name
, DATAPDUINORDER
)) {
490 SET_PSTATE_NEGOTIATE(param
);
491 } else if (!strcmp(param
->name
, DATASEQUENCEINORDER
)) {
492 SET_PSTATE_NEGOTIATE(param
);
493 } else if (!strcmp(param
->name
, ERRORRECOVERYLEVEL
)) {
494 SET_PSTATE_NEGOTIATE(param
);
495 } else if (!strcmp(param
->name
, SESSIONTYPE
)) {
496 SET_PSTATE_NEGOTIATE(param
);
497 } else if (!strcmp(param
->name
, IFMARKER
)) {
498 SET_PSTATE_NEGOTIATE(param
);
499 } else if (!strcmp(param
->name
, OFMARKER
)) {
500 SET_PSTATE_NEGOTIATE(param
);
501 } else if (!strcmp(param
->name
, IFMARKINT
)) {
502 SET_PSTATE_NEGOTIATE(param
);
503 } else if (!strcmp(param
->name
, OFMARKINT
)) {
504 SET_PSTATE_NEGOTIATE(param
);
511 int iscsi_set_keys_irrelevant_for_discovery(
512 struct iscsi_param_list
*param_list
)
514 struct iscsi_param
*param
;
516 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
517 if (!strcmp(param
->name
, MAXCONNECTIONS
))
518 param
->state
&= ~PSTATE_NEGOTIATE
;
519 else if (!strcmp(param
->name
, INITIALR2T
))
520 param
->state
&= ~PSTATE_NEGOTIATE
;
521 else if (!strcmp(param
->name
, IMMEDIATEDATA
))
522 param
->state
&= ~PSTATE_NEGOTIATE
;
523 else if (!strcmp(param
->name
, MAXBURSTLENGTH
))
524 param
->state
&= ~PSTATE_NEGOTIATE
;
525 else if (!strcmp(param
->name
, FIRSTBURSTLENGTH
))
526 param
->state
&= ~PSTATE_NEGOTIATE
;
527 else if (!strcmp(param
->name
, MAXOUTSTANDINGR2T
))
528 param
->state
&= ~PSTATE_NEGOTIATE
;
529 else if (!strcmp(param
->name
, DATAPDUINORDER
))
530 param
->state
&= ~PSTATE_NEGOTIATE
;
531 else if (!strcmp(param
->name
, DATASEQUENCEINORDER
))
532 param
->state
&= ~PSTATE_NEGOTIATE
;
533 else if (!strcmp(param
->name
, ERRORRECOVERYLEVEL
))
534 param
->state
&= ~PSTATE_NEGOTIATE
;
535 else if (!strcmp(param
->name
, DEFAULTTIME2WAIT
))
536 param
->state
&= ~PSTATE_NEGOTIATE
;
537 else if (!strcmp(param
->name
, DEFAULTTIME2RETAIN
))
538 param
->state
&= ~PSTATE_NEGOTIATE
;
539 else if (!strcmp(param
->name
, IFMARKER
))
540 param
->state
&= ~PSTATE_NEGOTIATE
;
541 else if (!strcmp(param
->name
, OFMARKER
))
542 param
->state
&= ~PSTATE_NEGOTIATE
;
543 else if (!strcmp(param
->name
, IFMARKINT
))
544 param
->state
&= ~PSTATE_NEGOTIATE
;
545 else if (!strcmp(param
->name
, OFMARKINT
))
546 param
->state
&= ~PSTATE_NEGOTIATE
;
552 int iscsi_copy_param_list(
553 struct iscsi_param_list
**dst_param_list
,
554 struct iscsi_param_list
*src_param_list
,
557 struct iscsi_param
*param
= NULL
;
558 struct iscsi_param
*new_param
= NULL
;
559 struct iscsi_param_list
*param_list
= NULL
;
561 param_list
= kzalloc(sizeof(struct iscsi_param_list
), GFP_KERNEL
);
563 pr_err("Unable to allocate memory for struct iscsi_param_list.\n");
566 INIT_LIST_HEAD(¶m_list
->param_list
);
567 INIT_LIST_HEAD(¶m_list
->extra_response_list
);
569 list_for_each_entry(param
, &src_param_list
->param_list
, p_list
) {
570 if (!leading
&& (param
->scope
& SCOPE_SESSION_WIDE
)) {
571 if ((strcmp(param
->name
, "TargetName") != 0) &&
572 (strcmp(param
->name
, "InitiatorName") != 0) &&
573 (strcmp(param
->name
, "TargetPortalGroupTag") != 0))
577 new_param
= kzalloc(sizeof(struct iscsi_param
), GFP_KERNEL
);
579 pr_err("Unable to allocate memory for struct iscsi_param.\n");
583 new_param
->name
= kstrdup(param
->name
, GFP_KERNEL
);
584 new_param
->value
= kstrdup(param
->value
, GFP_KERNEL
);
585 if (!new_param
->value
|| !new_param
->name
) {
586 kfree(new_param
->value
);
587 kfree(new_param
->name
);
589 pr_err("Unable to allocate memory for parameter name/value.\n");
593 new_param
->set_param
= param
->set_param
;
594 new_param
->phase
= param
->phase
;
595 new_param
->scope
= param
->scope
;
596 new_param
->sender
= param
->sender
;
597 new_param
->type
= param
->type
;
598 new_param
->use
= param
->use
;
599 new_param
->type_range
= param
->type_range
;
601 list_add_tail(&new_param
->p_list
, ¶m_list
->param_list
);
604 if (!list_empty(¶m_list
->param_list
)) {
605 *dst_param_list
= param_list
;
607 pr_err("No parameters allocated.\n");
614 iscsi_release_param_list(param_list
);
618 static void iscsi_release_extra_responses(struct iscsi_param_list
*param_list
)
620 struct iscsi_extra_response
*er
, *er_tmp
;
622 list_for_each_entry_safe(er
, er_tmp
, ¶m_list
->extra_response_list
,
624 list_del(&er
->er_list
);
629 void iscsi_release_param_list(struct iscsi_param_list
*param_list
)
631 struct iscsi_param
*param
, *param_tmp
;
633 list_for_each_entry_safe(param
, param_tmp
, ¶m_list
->param_list
,
635 list_del(¶m
->p_list
);
645 iscsi_release_extra_responses(param_list
);
650 struct iscsi_param
*iscsi_find_param_from_key(
652 struct iscsi_param_list
*param_list
)
654 struct iscsi_param
*param
;
656 if (!key
|| !param_list
) {
657 pr_err("Key or parameter list pointer is NULL.\n");
661 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
662 if (!strcmp(key
, param
->name
))
666 pr_err("Unable to locate key \"%s\".\n", key
);
670 int iscsi_extract_key_value(char *textbuf
, char **key
, char **value
)
672 *value
= strchr(textbuf
, '=');
674 pr_err("Unable to locate \"=\" separator for key,"
675 " ignoring request.\n");
686 int iscsi_update_param_value(struct iscsi_param
*param
, char *value
)
690 param
->value
= kzalloc(strlen(value
) + 1, GFP_KERNEL
);
692 pr_err("Unable to allocate memory for value.\n");
696 memcpy(param
->value
, value
, strlen(value
));
697 param
->value
[strlen(value
)] = '\0';
699 pr_debug("iSCSI Parameter updated to %s=%s\n",
700 param
->name
, param
->value
);
704 static int iscsi_add_notunderstood_response(
707 struct iscsi_param_list
*param_list
)
709 struct iscsi_extra_response
*extra_response
;
711 if (strlen(value
) > VALUE_MAXLEN
) {
712 pr_err("Value for notunderstood key \"%s\" exceeds %d,"
713 " protocol error.\n", key
, VALUE_MAXLEN
);
717 extra_response
= kzalloc(sizeof(struct iscsi_extra_response
), GFP_KERNEL
);
718 if (!extra_response
) {
719 pr_err("Unable to allocate memory for"
720 " struct iscsi_extra_response.\n");
723 INIT_LIST_HEAD(&extra_response
->er_list
);
725 strncpy(extra_response
->key
, key
, strlen(key
) + 1);
726 strncpy(extra_response
->value
, NOTUNDERSTOOD
,
727 strlen(NOTUNDERSTOOD
) + 1);
729 list_add_tail(&extra_response
->er_list
,
730 ¶m_list
->extra_response_list
);
734 static int iscsi_check_for_auth_key(char *key
)
739 if (!strcmp(key
, "CHAP_A") || !strcmp(key
, "CHAP_I") ||
740 !strcmp(key
, "CHAP_C") || !strcmp(key
, "CHAP_N") ||
741 !strcmp(key
, "CHAP_R"))
747 if (!strcmp(key
, "SRP_U") || !strcmp(key
, "SRP_N") ||
748 !strcmp(key
, "SRP_g") || !strcmp(key
, "SRP_s") ||
749 !strcmp(key
, "SRP_A") || !strcmp(key
, "SRP_B") ||
750 !strcmp(key
, "SRP_M") || !strcmp(key
, "SRP_HM"))
756 static void iscsi_check_proposer_for_optional_reply(struct iscsi_param
*param
)
758 if (IS_TYPE_BOOL_AND(param
)) {
759 if (!strcmp(param
->value
, NO
))
760 SET_PSTATE_REPLY_OPTIONAL(param
);
761 } else if (IS_TYPE_BOOL_OR(param
)) {
762 if (!strcmp(param
->value
, YES
))
763 SET_PSTATE_REPLY_OPTIONAL(param
);
765 * Required for gPXE iSCSI boot client
767 if (!strcmp(param
->name
, IMMEDIATEDATA
))
768 SET_PSTATE_REPLY_OPTIONAL(param
);
769 } else if (IS_TYPE_NUMBER(param
)) {
770 if (!strcmp(param
->name
, MAXRECVDATASEGMENTLENGTH
))
771 SET_PSTATE_REPLY_OPTIONAL(param
);
773 * The GlobalSAN iSCSI Initiator for MacOSX does
774 * not respond to MaxBurstLength, FirstBurstLength,
775 * DefaultTime2Wait or DefaultTime2Retain parameter keys.
776 * So, we set them to 'reply optional' here, and assume the
777 * the defaults from iscsi_parameters.h if the initiator
778 * is not RFC compliant and the keys are not negotiated.
780 if (!strcmp(param
->name
, MAXBURSTLENGTH
))
781 SET_PSTATE_REPLY_OPTIONAL(param
);
782 if (!strcmp(param
->name
, FIRSTBURSTLENGTH
))
783 SET_PSTATE_REPLY_OPTIONAL(param
);
784 if (!strcmp(param
->name
, DEFAULTTIME2WAIT
))
785 SET_PSTATE_REPLY_OPTIONAL(param
);
786 if (!strcmp(param
->name
, DEFAULTTIME2RETAIN
))
787 SET_PSTATE_REPLY_OPTIONAL(param
);
789 * Required for gPXE iSCSI boot client
791 if (!strcmp(param
->name
, MAXCONNECTIONS
))
792 SET_PSTATE_REPLY_OPTIONAL(param
);
793 } else if (IS_PHASE_DECLARATIVE(param
))
794 SET_PSTATE_REPLY_OPTIONAL(param
);
797 static int iscsi_check_boolean_value(struct iscsi_param
*param
, char *value
)
799 if (strcmp(value
, YES
) && strcmp(value
, NO
)) {
800 pr_err("Illegal value for \"%s\", must be either"
801 " \"%s\" or \"%s\".\n", param
->name
, YES
, NO
);
808 static int iscsi_check_numerical_value(struct iscsi_param
*param
, char *value_ptr
)
813 value
= simple_strtoul(value_ptr
, &tmpptr
, 0);
815 if (IS_TYPERANGE_0_TO_2(param
)) {
816 if ((value
< 0) || (value
> 2)) {
817 pr_err("Illegal value for \"%s\", must be"
818 " between 0 and 2.\n", param
->name
);
823 if (IS_TYPERANGE_0_TO_3600(param
)) {
824 if ((value
< 0) || (value
> 3600)) {
825 pr_err("Illegal value for \"%s\", must be"
826 " between 0 and 3600.\n", param
->name
);
831 if (IS_TYPERANGE_0_TO_32767(param
)) {
832 if ((value
< 0) || (value
> 32767)) {
833 pr_err("Illegal value for \"%s\", must be"
834 " between 0 and 32767.\n", param
->name
);
839 if (IS_TYPERANGE_0_TO_65535(param
)) {
840 if ((value
< 0) || (value
> 65535)) {
841 pr_err("Illegal value for \"%s\", must be"
842 " between 0 and 65535.\n", param
->name
);
847 if (IS_TYPERANGE_1_TO_65535(param
)) {
848 if ((value
< 1) || (value
> 65535)) {
849 pr_err("Illegal value for \"%s\", must be"
850 " between 1 and 65535.\n", param
->name
);
855 if (IS_TYPERANGE_2_TO_3600(param
)) {
856 if ((value
< 2) || (value
> 3600)) {
857 pr_err("Illegal value for \"%s\", must be"
858 " between 2 and 3600.\n", param
->name
);
863 if (IS_TYPERANGE_512_TO_16777215(param
)) {
864 if ((value
< 512) || (value
> 16777215)) {
865 pr_err("Illegal value for \"%s\", must be"
866 " between 512 and 16777215.\n", param
->name
);
875 static int iscsi_check_numerical_range_value(struct iscsi_param
*param
, char *value
)
877 char *left_val_ptr
= NULL
, *right_val_ptr
= NULL
;
878 char *tilde_ptr
= NULL
;
879 u32 left_val
, right_val
, local_left_val
;
881 if (strcmp(param
->name
, IFMARKINT
) &&
882 strcmp(param
->name
, OFMARKINT
)) {
883 pr_err("Only parameters \"%s\" or \"%s\" may contain a"
884 " numerical range value.\n", IFMARKINT
, OFMARKINT
);
888 if (IS_PSTATE_PROPOSER(param
))
891 tilde_ptr
= strchr(value
, '~');
893 pr_err("Unable to locate numerical range indicator"
894 " \"~\" for \"%s\".\n", param
->name
);
899 left_val_ptr
= value
;
900 right_val_ptr
= value
+ strlen(left_val_ptr
) + 1;
902 if (iscsi_check_numerical_value(param
, left_val_ptr
) < 0)
904 if (iscsi_check_numerical_value(param
, right_val_ptr
) < 0)
907 left_val
= simple_strtoul(left_val_ptr
, NULL
, 0);
908 right_val
= simple_strtoul(right_val_ptr
, NULL
, 0);
911 if (right_val
< left_val
) {
912 pr_err("Numerical range for parameter \"%s\" contains"
913 " a right value which is less than the left.\n",
919 * For now, enforce reasonable defaults for [I,O]FMarkInt.
921 tilde_ptr
= strchr(param
->value
, '~');
923 pr_err("Unable to locate numerical range indicator"
924 " \"~\" for \"%s\".\n", param
->name
);
929 left_val_ptr
= param
->value
;
930 right_val_ptr
= param
->value
+ strlen(left_val_ptr
) + 1;
932 local_left_val
= simple_strtoul(left_val_ptr
, NULL
, 0);
935 if (param
->set_param
) {
936 if ((left_val
< local_left_val
) ||
937 (right_val
< local_left_val
)) {
938 pr_err("Passed value range \"%u~%u\" is below"
939 " minimum left value \"%u\" for key \"%s\","
940 " rejecting.\n", left_val
, right_val
,
941 local_left_val
, param
->name
);
945 if ((left_val
< local_left_val
) &&
946 (right_val
< local_left_val
)) {
947 pr_err("Received value range \"%u~%u\" is"
948 " below minimum left value \"%u\" for key"
949 " \"%s\", rejecting.\n", left_val
, right_val
,
950 local_left_val
, param
->name
);
951 SET_PSTATE_REJECT(param
);
952 if (iscsi_update_param_value(param
, REJECT
) < 0)
960 static int iscsi_check_string_or_list_value(struct iscsi_param
*param
, char *value
)
962 if (IS_PSTATE_PROPOSER(param
))
965 if (IS_TYPERANGE_AUTH_PARAM(param
)) {
966 if (strcmp(value
, KRB5
) && strcmp(value
, SPKM1
) &&
967 strcmp(value
, SPKM2
) && strcmp(value
, SRP
) &&
968 strcmp(value
, CHAP
) && strcmp(value
, NONE
)) {
969 pr_err("Illegal value for \"%s\", must be"
970 " \"%s\", \"%s\", \"%s\", \"%s\", \"%s\""
971 " or \"%s\".\n", param
->name
, KRB5
,
972 SPKM1
, SPKM2
, SRP
, CHAP
, NONE
);
976 if (IS_TYPERANGE_DIGEST_PARAM(param
)) {
977 if (strcmp(value
, CRC32C
) && strcmp(value
, NONE
)) {
978 pr_err("Illegal value for \"%s\", must be"
979 " \"%s\" or \"%s\".\n", param
->name
,
984 if (IS_TYPERANGE_SESSIONTYPE(param
)) {
985 if (strcmp(value
, DISCOVERY
) && strcmp(value
, NORMAL
)) {
986 pr_err("Illegal value for \"%s\", must be"
987 " \"%s\" or \"%s\".\n", param
->name
,
997 * This function is used to pick a value range number, currently just
998 * returns the lesser of both right values.
1000 static char *iscsi_get_value_from_number_range(
1001 struct iscsi_param
*param
,
1004 char *end_ptr
, *tilde_ptr1
= NULL
, *tilde_ptr2
= NULL
;
1005 u32 acceptor_right_value
, proposer_right_value
;
1007 tilde_ptr1
= strchr(value
, '~');
1010 *tilde_ptr1
++ = '\0';
1011 proposer_right_value
= simple_strtoul(tilde_ptr1
, &end_ptr
, 0);
1013 tilde_ptr2
= strchr(param
->value
, '~');
1016 *tilde_ptr2
++ = '\0';
1017 acceptor_right_value
= simple_strtoul(tilde_ptr2
, &end_ptr
, 0);
1019 return (acceptor_right_value
>= proposer_right_value
) ?
1020 tilde_ptr1
: tilde_ptr2
;
1023 static char *iscsi_check_valuelist_for_support(
1024 struct iscsi_param
*param
,
1027 char *tmp1
= NULL
, *tmp2
= NULL
;
1028 char *acceptor_values
= NULL
, *proposer_values
= NULL
;
1030 acceptor_values
= param
->value
;
1031 proposer_values
= value
;
1034 if (!proposer_values
)
1036 tmp1
= strchr(proposer_values
, ',');
1039 acceptor_values
= param
->value
;
1041 if (!acceptor_values
) {
1046 tmp2
= strchr(acceptor_values
, ',');
1049 if (!strcmp(acceptor_values
, proposer_values
)) {
1057 acceptor_values
= tmp2
;
1058 } while (acceptor_values
);
1061 proposer_values
= tmp1
;
1062 } while (proposer_values
);
1065 return proposer_values
;
1068 static int iscsi_check_acceptor_state(struct iscsi_param
*param
, char *value
,
1069 struct iscsi_conn
*conn
)
1071 u8 acceptor_boolean_value
= 0, proposer_boolean_value
= 0;
1072 char *negoitated_value
= NULL
;
1074 if (IS_PSTATE_ACCEPTOR(param
)) {
1075 pr_err("Received key \"%s\" twice, protocol error.\n",
1080 if (IS_PSTATE_REJECT(param
))
1083 if (IS_TYPE_BOOL_AND(param
)) {
1084 if (!strcmp(value
, YES
))
1085 proposer_boolean_value
= 1;
1086 if (!strcmp(param
->value
, YES
))
1087 acceptor_boolean_value
= 1;
1088 if (acceptor_boolean_value
&& proposer_boolean_value
)
1091 if (iscsi_update_param_value(param
, NO
) < 0)
1093 if (!proposer_boolean_value
)
1094 SET_PSTATE_REPLY_OPTIONAL(param
);
1096 } else if (IS_TYPE_BOOL_OR(param
)) {
1097 if (!strcmp(value
, YES
))
1098 proposer_boolean_value
= 1;
1099 if (!strcmp(param
->value
, YES
))
1100 acceptor_boolean_value
= 1;
1101 if (acceptor_boolean_value
|| proposer_boolean_value
) {
1102 if (iscsi_update_param_value(param
, YES
) < 0)
1104 if (proposer_boolean_value
)
1105 SET_PSTATE_REPLY_OPTIONAL(param
);
1107 } else if (IS_TYPE_NUMBER(param
)) {
1108 char *tmpptr
, buf
[10];
1109 u32 acceptor_value
= simple_strtoul(param
->value
, &tmpptr
, 0);
1110 u32 proposer_value
= simple_strtoul(value
, &tmpptr
, 0);
1114 if (!strcmp(param
->name
, MAXCONNECTIONS
) ||
1115 !strcmp(param
->name
, MAXBURSTLENGTH
) ||
1116 !strcmp(param
->name
, FIRSTBURSTLENGTH
) ||
1117 !strcmp(param
->name
, MAXOUTSTANDINGR2T
) ||
1118 !strcmp(param
->name
, DEFAULTTIME2RETAIN
) ||
1119 !strcmp(param
->name
, ERRORRECOVERYLEVEL
)) {
1120 if (proposer_value
> acceptor_value
) {
1121 sprintf(buf
, "%u", acceptor_value
);
1122 if (iscsi_update_param_value(param
,
1126 if (iscsi_update_param_value(param
, value
) < 0)
1129 } else if (!strcmp(param
->name
, DEFAULTTIME2WAIT
)) {
1130 if (acceptor_value
> proposer_value
) {
1131 sprintf(buf
, "%u", acceptor_value
);
1132 if (iscsi_update_param_value(param
,
1136 if (iscsi_update_param_value(param
, value
) < 0)
1140 if (iscsi_update_param_value(param
, value
) < 0)
1144 if (!strcmp(param
->name
, MAXRECVDATASEGMENTLENGTH
)) {
1145 struct iscsi_param
*param_mxdsl
;
1146 unsigned long long tmp
;
1149 rc
= strict_strtoull(param
->value
, 0, &tmp
);
1153 conn
->conn_ops
->MaxRecvDataSegmentLength
= tmp
;
1154 pr_debug("Saving op->MaxRecvDataSegmentLength from"
1155 " original initiator received value: %u\n",
1156 conn
->conn_ops
->MaxRecvDataSegmentLength
);
1158 param_mxdsl
= iscsi_find_param_from_key(
1159 MAXXMITDATASEGMENTLENGTH
,
1164 rc
= iscsi_update_param_value(param
,
1165 param_mxdsl
->value
);
1169 pr_debug("Updated %s to target MXDSL value: %s\n",
1170 param
->name
, param
->value
);
1173 } else if (IS_TYPE_NUMBER_RANGE(param
)) {
1174 negoitated_value
= iscsi_get_value_from_number_range(
1176 if (!negoitated_value
)
1178 if (iscsi_update_param_value(param
, negoitated_value
) < 0)
1180 } else if (IS_TYPE_VALUE_LIST(param
)) {
1181 negoitated_value
= iscsi_check_valuelist_for_support(
1183 if (!negoitated_value
) {
1184 pr_err("Proposer's value list \"%s\" contains"
1185 " no valid values from Acceptor's value list"
1186 " \"%s\".\n", value
, param
->value
);
1189 if (iscsi_update_param_value(param
, negoitated_value
) < 0)
1191 } else if (IS_PHASE_DECLARATIVE(param
)) {
1192 if (iscsi_update_param_value(param
, value
) < 0)
1194 SET_PSTATE_REPLY_OPTIONAL(param
);
1200 static int iscsi_check_proposer_state(struct iscsi_param
*param
, char *value
)
1202 if (IS_PSTATE_RESPONSE_GOT(param
)) {
1203 pr_err("Received key \"%s\" twice, protocol error.\n",
1208 if (IS_TYPE_NUMBER_RANGE(param
)) {
1209 u32 left_val
= 0, right_val
= 0, recieved_value
= 0;
1210 char *left_val_ptr
= NULL
, *right_val_ptr
= NULL
;
1211 char *tilde_ptr
= NULL
;
1213 if (!strcmp(value
, IRRELEVANT
) || !strcmp(value
, REJECT
)) {
1214 if (iscsi_update_param_value(param
, value
) < 0)
1219 tilde_ptr
= strchr(value
, '~');
1221 pr_err("Illegal \"~\" in response for \"%s\".\n",
1225 tilde_ptr
= strchr(param
->value
, '~');
1227 pr_err("Unable to locate numerical range"
1228 " indicator \"~\" for \"%s\".\n", param
->name
);
1233 left_val_ptr
= param
->value
;
1234 right_val_ptr
= param
->value
+ strlen(left_val_ptr
) + 1;
1235 left_val
= simple_strtoul(left_val_ptr
, NULL
, 0);
1236 right_val
= simple_strtoul(right_val_ptr
, NULL
, 0);
1237 recieved_value
= simple_strtoul(value
, NULL
, 0);
1241 if ((recieved_value
< left_val
) ||
1242 (recieved_value
> right_val
)) {
1243 pr_err("Illegal response \"%s=%u\", value must"
1244 " be between %u and %u.\n", param
->name
,
1245 recieved_value
, left_val
, right_val
);
1248 } else if (IS_TYPE_VALUE_LIST(param
)) {
1249 char *comma_ptr
= NULL
, *tmp_ptr
= NULL
;
1251 comma_ptr
= strchr(value
, ',');
1253 pr_err("Illegal \",\" in response for \"%s\".\n",
1258 tmp_ptr
= iscsi_check_valuelist_for_support(param
, value
);
1263 if (iscsi_update_param_value(param
, value
) < 0)
1269 static int iscsi_check_value(struct iscsi_param
*param
, char *value
)
1271 char *comma_ptr
= NULL
;
1273 if (!strcmp(value
, REJECT
)) {
1274 if (!strcmp(param
->name
, IFMARKINT
) ||
1275 !strcmp(param
->name
, OFMARKINT
)) {
1277 * Reject is not fatal for [I,O]FMarkInt, and causes
1278 * [I,O]FMarker to be reset to No. (See iSCSI v20 A.3.2)
1280 SET_PSTATE_REJECT(param
);
1283 pr_err("Received %s=%s\n", param
->name
, value
);
1286 if (!strcmp(value
, IRRELEVANT
)) {
1287 pr_debug("Received %s=%s\n", param
->name
, value
);
1288 SET_PSTATE_IRRELEVANT(param
);
1291 if (!strcmp(value
, NOTUNDERSTOOD
)) {
1292 if (!IS_PSTATE_PROPOSER(param
)) {
1293 pr_err("Received illegal offer %s=%s\n",
1294 param
->name
, value
);
1298 /* #warning FIXME: Add check for X-ExtensionKey here */
1299 pr_err("Standard iSCSI key \"%s\" cannot be answered"
1300 " with \"%s\", protocol error.\n", param
->name
, value
);
1306 comma_ptr
= strchr(value
, ',');
1308 if (comma_ptr
&& !IS_TYPE_VALUE_LIST(param
)) {
1309 pr_err("Detected value separator \",\", but"
1310 " key \"%s\" does not allow a value list,"
1311 " protocol error.\n", param
->name
);
1317 if (strlen(value
) > VALUE_MAXLEN
) {
1318 pr_err("Value for key \"%s\" exceeds %d,"
1319 " protocol error.\n", param
->name
,
1324 if (IS_TYPE_BOOL_AND(param
) || IS_TYPE_BOOL_OR(param
)) {
1325 if (iscsi_check_boolean_value(param
, value
) < 0)
1327 } else if (IS_TYPE_NUMBER(param
)) {
1328 if (iscsi_check_numerical_value(param
, value
) < 0)
1330 } else if (IS_TYPE_NUMBER_RANGE(param
)) {
1331 if (iscsi_check_numerical_range_value(param
, value
) < 0)
1333 } else if (IS_TYPE_STRING(param
) || IS_TYPE_VALUE_LIST(param
)) {
1334 if (iscsi_check_string_or_list_value(param
, value
) < 0)
1337 pr_err("Huh? 0x%02x\n", param
->type
);
1350 static struct iscsi_param
*__iscsi_check_key(
1353 struct iscsi_param_list
*param_list
)
1355 struct iscsi_param
*param
;
1357 if (strlen(key
) > KEY_MAXLEN
) {
1358 pr_err("Length of key name \"%s\" exceeds %d.\n",
1363 param
= iscsi_find_param_from_key(key
, param_list
);
1367 if ((sender
& SENDER_INITIATOR
) && !IS_SENDER_INITIATOR(param
)) {
1368 pr_err("Key \"%s\" may not be sent to %s,"
1369 " protocol error.\n", param
->name
,
1370 (sender
& SENDER_RECEIVER
) ? "target" : "initiator");
1374 if ((sender
& SENDER_TARGET
) && !IS_SENDER_TARGET(param
)) {
1375 pr_err("Key \"%s\" may not be sent to %s,"
1376 " protocol error.\n", param
->name
,
1377 (sender
& SENDER_RECEIVER
) ? "initiator" : "target");
1384 static struct iscsi_param
*iscsi_check_key(
1388 struct iscsi_param_list
*param_list
)
1390 struct iscsi_param
*param
;
1392 * Key name length must not exceed 63 bytes. (See iSCSI v20 5.1)
1394 if (strlen(key
) > KEY_MAXLEN
) {
1395 pr_err("Length of key name \"%s\" exceeds %d.\n",
1400 param
= iscsi_find_param_from_key(key
, param_list
);
1404 if ((sender
& SENDER_INITIATOR
) && !IS_SENDER_INITIATOR(param
)) {
1405 pr_err("Key \"%s\" may not be sent to %s,"
1406 " protocol error.\n", param
->name
,
1407 (sender
& SENDER_RECEIVER
) ? "target" : "initiator");
1410 if ((sender
& SENDER_TARGET
) && !IS_SENDER_TARGET(param
)) {
1411 pr_err("Key \"%s\" may not be sent to %s,"
1412 " protocol error.\n", param
->name
,
1413 (sender
& SENDER_RECEIVER
) ? "initiator" : "target");
1417 if (IS_PSTATE_ACCEPTOR(param
)) {
1418 pr_err("Key \"%s\" received twice, protocol error.\n",
1426 if (!(param
->phase
& phase
)) {
1427 pr_err("Key \"%s\" may not be negotiated during ",
1430 case PHASE_SECURITY
:
1431 pr_debug("Security phase.\n");
1433 case PHASE_OPERATIONAL
:
1434 pr_debug("Operational phase.\n");
1437 pr_debug("Unknown phase.\n");
1445 static int iscsi_enforce_integrity_rules(
1447 struct iscsi_param_list
*param_list
)
1450 u8 DataSequenceInOrder
= 0;
1451 u8 ErrorRecoveryLevel
= 0, SessionType
= 0;
1452 u8 IFMarker
= 0, OFMarker
= 0;
1453 u8 IFMarkInt_Reject
= 1, OFMarkInt_Reject
= 1;
1454 u32 FirstBurstLength
= 0, MaxBurstLength
= 0;
1455 struct iscsi_param
*param
= NULL
;
1457 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
1458 if (!(param
->phase
& phase
))
1460 if (!strcmp(param
->name
, SESSIONTYPE
))
1461 if (!strcmp(param
->value
, NORMAL
))
1463 if (!strcmp(param
->name
, ERRORRECOVERYLEVEL
))
1464 ErrorRecoveryLevel
= simple_strtoul(param
->value
,
1466 if (!strcmp(param
->name
, DATASEQUENCEINORDER
))
1467 if (!strcmp(param
->value
, YES
))
1468 DataSequenceInOrder
= 1;
1469 if (!strcmp(param
->name
, MAXBURSTLENGTH
))
1470 MaxBurstLength
= simple_strtoul(param
->value
,
1472 if (!strcmp(param
->name
, IFMARKER
))
1473 if (!strcmp(param
->value
, YES
))
1475 if (!strcmp(param
->name
, OFMARKER
))
1476 if (!strcmp(param
->value
, YES
))
1478 if (!strcmp(param
->name
, IFMARKINT
))
1479 if (!strcmp(param
->value
, REJECT
))
1480 IFMarkInt_Reject
= 1;
1481 if (!strcmp(param
->name
, OFMARKINT
))
1482 if (!strcmp(param
->value
, REJECT
))
1483 OFMarkInt_Reject
= 1;
1486 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
1487 if (!(param
->phase
& phase
))
1489 if (!SessionType
&& (!IS_PSTATE_ACCEPTOR(param
) &&
1490 (strcmp(param
->name
, IFMARKER
) &&
1491 strcmp(param
->name
, OFMARKER
) &&
1492 strcmp(param
->name
, IFMARKINT
) &&
1493 strcmp(param
->name
, OFMARKINT
))))
1495 if (!strcmp(param
->name
, MAXOUTSTANDINGR2T
) &&
1496 DataSequenceInOrder
&& (ErrorRecoveryLevel
> 0)) {
1497 if (strcmp(param
->value
, "1")) {
1498 if (iscsi_update_param_value(param
, "1") < 0)
1500 pr_debug("Reset \"%s\" to \"%s\".\n",
1501 param
->name
, param
->value
);
1504 if (!strcmp(param
->name
, MAXCONNECTIONS
) && !SessionType
) {
1505 if (strcmp(param
->value
, "1")) {
1506 if (iscsi_update_param_value(param
, "1") < 0)
1508 pr_debug("Reset \"%s\" to \"%s\".\n",
1509 param
->name
, param
->value
);
1512 if (!strcmp(param
->name
, FIRSTBURSTLENGTH
)) {
1513 FirstBurstLength
= simple_strtoul(param
->value
,
1515 if (FirstBurstLength
> MaxBurstLength
) {
1517 memset(tmpbuf
, 0, 10);
1518 sprintf(tmpbuf
, "%u", MaxBurstLength
);
1519 if (iscsi_update_param_value(param
, tmpbuf
))
1521 pr_debug("Reset \"%s\" to \"%s\".\n",
1522 param
->name
, param
->value
);
1525 if (!strcmp(param
->name
, IFMARKER
) && IFMarkInt_Reject
) {
1526 if (iscsi_update_param_value(param
, NO
) < 0)
1529 pr_debug("Reset \"%s\" to \"%s\".\n",
1530 param
->name
, param
->value
);
1532 if (!strcmp(param
->name
, OFMARKER
) && OFMarkInt_Reject
) {
1533 if (iscsi_update_param_value(param
, NO
) < 0)
1536 pr_debug("Reset \"%s\" to \"%s\".\n",
1537 param
->name
, param
->value
);
1539 if (!strcmp(param
->name
, IFMARKINT
) && !IFMarker
) {
1540 if (!strcmp(param
->value
, REJECT
))
1542 param
->state
&= ~PSTATE_NEGOTIATE
;
1543 if (iscsi_update_param_value(param
, IRRELEVANT
) < 0)
1545 pr_debug("Reset \"%s\" to \"%s\".\n",
1546 param
->name
, param
->value
);
1548 if (!strcmp(param
->name
, OFMARKINT
) && !OFMarker
) {
1549 if (!strcmp(param
->value
, REJECT
))
1551 param
->state
&= ~PSTATE_NEGOTIATE
;
1552 if (iscsi_update_param_value(param
, IRRELEVANT
) < 0)
1554 pr_debug("Reset \"%s\" to \"%s\".\n",
1555 param
->name
, param
->value
);
1562 int iscsi_decode_text_input(
1567 struct iscsi_conn
*conn
)
1569 struct iscsi_param_list
*param_list
= conn
->param_list
;
1570 char *tmpbuf
, *start
= NULL
, *end
= NULL
;
1572 tmpbuf
= kzalloc(length
+ 1, GFP_KERNEL
);
1574 pr_err("Unable to allocate memory for tmpbuf.\n");
1578 memcpy(tmpbuf
, textbuf
, length
);
1579 tmpbuf
[length
] = '\0';
1581 end
= (start
+ length
);
1583 while (start
< end
) {
1585 struct iscsi_param
*param
;
1587 if (iscsi_extract_key_value(start
, &key
, &value
) < 0) {
1592 pr_debug("Got key: %s=%s\n", key
, value
);
1594 if (phase
& PHASE_SECURITY
) {
1595 if (iscsi_check_for_auth_key(key
) > 0) {
1596 char *tmpptr
= key
+ strlen(key
);
1603 param
= iscsi_check_key(key
, phase
, sender
, param_list
);
1605 if (iscsi_add_notunderstood_response(key
,
1606 value
, param_list
) < 0) {
1610 start
+= strlen(key
) + strlen(value
) + 2;
1613 if (iscsi_check_value(param
, value
) < 0) {
1618 start
+= strlen(key
) + strlen(value
) + 2;
1620 if (IS_PSTATE_PROPOSER(param
)) {
1621 if (iscsi_check_proposer_state(param
, value
) < 0) {
1625 SET_PSTATE_RESPONSE_GOT(param
);
1627 if (iscsi_check_acceptor_state(param
, value
, conn
) < 0) {
1631 SET_PSTATE_ACCEPTOR(param
);
1639 int iscsi_encode_text_output(
1644 struct iscsi_param_list
*param_list
)
1646 char *output_buf
= NULL
;
1647 struct iscsi_extra_response
*er
;
1648 struct iscsi_param
*param
;
1650 output_buf
= textbuf
+ *length
;
1652 if (iscsi_enforce_integrity_rules(phase
, param_list
) < 0)
1655 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
1656 if (!(param
->sender
& sender
))
1658 if (IS_PSTATE_ACCEPTOR(param
) &&
1659 !IS_PSTATE_RESPONSE_SENT(param
) &&
1660 !IS_PSTATE_REPLY_OPTIONAL(param
) &&
1661 (param
->phase
& phase
)) {
1662 *length
+= sprintf(output_buf
, "%s=%s",
1663 param
->name
, param
->value
);
1665 output_buf
= textbuf
+ *length
;
1666 SET_PSTATE_RESPONSE_SENT(param
);
1667 pr_debug("Sending key: %s=%s\n",
1668 param
->name
, param
->value
);
1671 if (IS_PSTATE_NEGOTIATE(param
) &&
1672 !IS_PSTATE_ACCEPTOR(param
) &&
1673 !IS_PSTATE_PROPOSER(param
) &&
1674 (param
->phase
& phase
)) {
1675 *length
+= sprintf(output_buf
, "%s=%s",
1676 param
->name
, param
->value
);
1678 output_buf
= textbuf
+ *length
;
1679 SET_PSTATE_PROPOSER(param
);
1680 iscsi_check_proposer_for_optional_reply(param
);
1681 pr_debug("Sending key: %s=%s\n",
1682 param
->name
, param
->value
);
1686 list_for_each_entry(er
, ¶m_list
->extra_response_list
, er_list
) {
1687 *length
+= sprintf(output_buf
, "%s=%s", er
->key
, er
->value
);
1689 output_buf
= textbuf
+ *length
;
1690 pr_debug("Sending key: %s=%s\n", er
->key
, er
->value
);
1692 iscsi_release_extra_responses(param_list
);
1697 int iscsi_check_negotiated_keys(struct iscsi_param_list
*param_list
)
1700 struct iscsi_param
*param
;
1702 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
1703 if (IS_PSTATE_NEGOTIATE(param
) &&
1704 IS_PSTATE_PROPOSER(param
) &&
1705 !IS_PSTATE_RESPONSE_GOT(param
) &&
1706 !IS_PSTATE_REPLY_OPTIONAL(param
) &&
1707 !IS_PHASE_DECLARATIVE(param
)) {
1708 pr_err("No response for proposed key \"%s\".\n",
1717 int iscsi_change_param_value(
1719 struct iscsi_param_list
*param_list
,
1722 char *key
= NULL
, *value
= NULL
;
1723 struct iscsi_param
*param
;
1726 if (iscsi_extract_key_value(keyvalue
, &key
, &value
) < 0)
1730 param
= __iscsi_check_key(keyvalue
, sender
, param_list
);
1734 param
= iscsi_check_key(keyvalue
, 0, sender
, param_list
);
1738 param
->set_param
= 1;
1739 if (iscsi_check_value(param
, value
) < 0) {
1740 param
->set_param
= 0;
1743 param
->set_param
= 0;
1746 if (iscsi_update_param_value(param
, value
) < 0)
1752 void iscsi_set_connection_parameters(
1753 struct iscsi_conn_ops
*ops
,
1754 struct iscsi_param_list
*param_list
)
1757 struct iscsi_param
*param
;
1759 pr_debug("---------------------------------------------------"
1760 "---------------\n");
1761 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
1763 * Special case to set MAXXMITDATASEGMENTLENGTH from the
1764 * target requested MaxRecvDataSegmentLength, even though
1765 * this key is not sent over the wire.
1767 if (!strcmp(param
->name
, MAXXMITDATASEGMENTLENGTH
)) {
1768 ops
->MaxXmitDataSegmentLength
=
1769 simple_strtoul(param
->value
, &tmpptr
, 0);
1770 pr_debug("MaxXmitDataSegmentLength: %s\n",
1774 if (!IS_PSTATE_ACCEPTOR(param
) && !IS_PSTATE_PROPOSER(param
))
1776 if (!strcmp(param
->name
, AUTHMETHOD
)) {
1777 pr_debug("AuthMethod: %s\n",
1779 } else if (!strcmp(param
->name
, HEADERDIGEST
)) {
1780 ops
->HeaderDigest
= !strcmp(param
->value
, CRC32C
);
1781 pr_debug("HeaderDigest: %s\n",
1783 } else if (!strcmp(param
->name
, DATADIGEST
)) {
1784 ops
->DataDigest
= !strcmp(param
->value
, CRC32C
);
1785 pr_debug("DataDigest: %s\n",
1787 } else if (!strcmp(param
->name
, MAXRECVDATASEGMENTLENGTH
)) {
1789 * At this point iscsi_check_acceptor_state() will have
1790 * set ops->MaxRecvDataSegmentLength from the original
1791 * initiator provided value.
1793 pr_debug("MaxRecvDataSegmentLength: %u\n",
1794 ops
->MaxRecvDataSegmentLength
);
1795 } else if (!strcmp(param
->name
, OFMARKER
)) {
1796 ops
->OFMarker
= !strcmp(param
->value
, YES
);
1797 pr_debug("OFMarker: %s\n",
1799 } else if (!strcmp(param
->name
, IFMARKER
)) {
1800 ops
->IFMarker
= !strcmp(param
->value
, YES
);
1801 pr_debug("IFMarker: %s\n",
1803 } else if (!strcmp(param
->name
, OFMARKINT
)) {
1805 simple_strtoul(param
->value
, &tmpptr
, 0);
1806 pr_debug("OFMarkInt: %s\n",
1808 } else if (!strcmp(param
->name
, IFMARKINT
)) {
1810 simple_strtoul(param
->value
, &tmpptr
, 0);
1811 pr_debug("IFMarkInt: %s\n",
1815 pr_debug("----------------------------------------------------"
1816 "--------------\n");
1819 void iscsi_set_session_parameters(
1820 struct iscsi_sess_ops
*ops
,
1821 struct iscsi_param_list
*param_list
,
1825 struct iscsi_param
*param
;
1827 pr_debug("----------------------------------------------------"
1828 "--------------\n");
1829 list_for_each_entry(param
, ¶m_list
->param_list
, p_list
) {
1830 if (!IS_PSTATE_ACCEPTOR(param
) && !IS_PSTATE_PROPOSER(param
))
1832 if (!strcmp(param
->name
, INITIATORNAME
)) {
1836 snprintf(ops
->InitiatorName
,
1837 sizeof(ops
->InitiatorName
),
1838 "%s", param
->value
);
1839 pr_debug("InitiatorName: %s\n",
1841 } else if (!strcmp(param
->name
, INITIATORALIAS
)) {
1844 snprintf(ops
->InitiatorAlias
,
1845 sizeof(ops
->InitiatorAlias
),
1846 "%s", param
->value
);
1847 pr_debug("InitiatorAlias: %s\n",
1849 } else if (!strcmp(param
->name
, TARGETNAME
)) {
1853 snprintf(ops
->TargetName
,
1854 sizeof(ops
->TargetName
),
1855 "%s", param
->value
);
1856 pr_debug("TargetName: %s\n",
1858 } else if (!strcmp(param
->name
, TARGETALIAS
)) {
1861 snprintf(ops
->TargetAlias
, sizeof(ops
->TargetAlias
),
1862 "%s", param
->value
);
1863 pr_debug("TargetAlias: %s\n",
1865 } else if (!strcmp(param
->name
, TARGETPORTALGROUPTAG
)) {
1866 ops
->TargetPortalGroupTag
=
1867 simple_strtoul(param
->value
, &tmpptr
, 0);
1868 pr_debug("TargetPortalGroupTag: %s\n",
1870 } else if (!strcmp(param
->name
, MAXCONNECTIONS
)) {
1871 ops
->MaxConnections
=
1872 simple_strtoul(param
->value
, &tmpptr
, 0);
1873 pr_debug("MaxConnections: %s\n",
1875 } else if (!strcmp(param
->name
, INITIALR2T
)) {
1876 ops
->InitialR2T
= !strcmp(param
->value
, YES
);
1877 pr_debug("InitialR2T: %s\n",
1879 } else if (!strcmp(param
->name
, IMMEDIATEDATA
)) {
1880 ops
->ImmediateData
= !strcmp(param
->value
, YES
);
1881 pr_debug("ImmediateData: %s\n",
1883 } else if (!strcmp(param
->name
, MAXBURSTLENGTH
)) {
1884 ops
->MaxBurstLength
=
1885 simple_strtoul(param
->value
, &tmpptr
, 0);
1886 pr_debug("MaxBurstLength: %s\n",
1888 } else if (!strcmp(param
->name
, FIRSTBURSTLENGTH
)) {
1889 ops
->FirstBurstLength
=
1890 simple_strtoul(param
->value
, &tmpptr
, 0);
1891 pr_debug("FirstBurstLength: %s\n",
1893 } else if (!strcmp(param
->name
, DEFAULTTIME2WAIT
)) {
1894 ops
->DefaultTime2Wait
=
1895 simple_strtoul(param
->value
, &tmpptr
, 0);
1896 pr_debug("DefaultTime2Wait: %s\n",
1898 } else if (!strcmp(param
->name
, DEFAULTTIME2RETAIN
)) {
1899 ops
->DefaultTime2Retain
=
1900 simple_strtoul(param
->value
, &tmpptr
, 0);
1901 pr_debug("DefaultTime2Retain: %s\n",
1903 } else if (!strcmp(param
->name
, MAXOUTSTANDINGR2T
)) {
1904 ops
->MaxOutstandingR2T
=
1905 simple_strtoul(param
->value
, &tmpptr
, 0);
1906 pr_debug("MaxOutstandingR2T: %s\n",
1908 } else if (!strcmp(param
->name
, DATAPDUINORDER
)) {
1909 ops
->DataPDUInOrder
= !strcmp(param
->value
, YES
);
1910 pr_debug("DataPDUInOrder: %s\n",
1912 } else if (!strcmp(param
->name
, DATASEQUENCEINORDER
)) {
1913 ops
->DataSequenceInOrder
= !strcmp(param
->value
, YES
);
1914 pr_debug("DataSequenceInOrder: %s\n",
1916 } else if (!strcmp(param
->name
, ERRORRECOVERYLEVEL
)) {
1917 ops
->ErrorRecoveryLevel
=
1918 simple_strtoul(param
->value
, &tmpptr
, 0);
1919 pr_debug("ErrorRecoveryLevel: %s\n",
1921 } else if (!strcmp(param
->name
, SESSIONTYPE
)) {
1922 ops
->SessionType
= !strcmp(param
->value
, DISCOVERY
);
1923 pr_debug("SessionType: %s\n",
1927 pr_debug("----------------------------------------------------"
1928 "--------------\n");