1 /******************************************************************************* 2 * This file contains main functions related to iSCSI Parameter negotiation. 3 * 4 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC. 5 * 6 * Licensed to the Linux Foundation under the General Public License (GPL) version 2. 7 * 8 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org> 9 * 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. 14 * 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 ******************************************************************************/ 20 21 #include <linux/slab.h> 22 23 #include "iscsi_target_core.h" 24 #include "iscsi_target_util.h" 25 #include "iscsi_target_parameters.h" 26 27 int iscsi_login_rx_data( 28 struct iscsi_conn *conn, 29 char *buf, 30 int length) 31 { 32 int rx_got; 33 struct kvec iov; 34 35 memset(&iov, 0, sizeof(struct kvec)); 36 iov.iov_len = length; 37 iov.iov_base = buf; 38 39 /* 40 * Initial Marker-less Interval. 41 * Add the values regardless of IFMarker/OFMarker, considering 42 * it may not be negoitated yet. 43 */ 44 conn->of_marker += length; 45 46 rx_got = rx_data(conn, &iov, 1, length); 47 if (rx_got != length) { 48 pr_err("rx_data returned %d, expecting %d.\n", 49 rx_got, length); 50 return -1; 51 } 52 53 return 0 ; 54 } 55 56 int iscsi_login_tx_data( 57 struct iscsi_conn *conn, 58 char *pdu_buf, 59 char *text_buf, 60 int text_length) 61 { 62 int length, tx_sent; 63 struct kvec iov[2]; 64 65 length = (ISCSI_HDR_LEN + text_length); 66 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; 72 73 /* 74 * Initial Marker-less Interval. 75 * Add the values regardless of IFMarker/OFMarker, considering 76 * it may not be negoitated yet. 77 */ 78 conn->if_marker += length; 79 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", 83 tx_sent, length); 84 return -1; 85 } 86 87 return 0; 88 } 89 90 void iscsi_dump_conn_ops(struct iscsi_conn_ops *conn_ops) 91 { 92 pr_debug("HeaderDigest: %s\n", (conn_ops->HeaderDigest) ? 93 "CRC32C" : "None"); 94 pr_debug("DataDigest: %s\n", (conn_ops->DataDigest) ? 95 "CRC32C" : "None"); 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); 104 } 105 106 void iscsi_dump_sess_ops(struct iscsi_sess_ops *sess_ops) 107 { 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) ? 118 "Yes" : "No"); 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"); 134 } 135 136 void iscsi_print_params(struct iscsi_param_list *param_list) 137 { 138 struct iscsi_param *param; 139 140 list_for_each_entry(param, ¶m_list->param_list, p_list) 141 pr_debug("%s: %s\n", param->name, param->value); 142 } 143 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) 147 { 148 struct iscsi_param *param = NULL; 149 150 param = kzalloc(sizeof(struct iscsi_param), GFP_KERNEL); 151 if (!param) { 152 pr_err("Unable to allocate memory for parameter.\n"); 153 goto out; 154 } 155 INIT_LIST_HEAD(¶m->p_list); 156 157 param->name = kzalloc(strlen(name) + 1, GFP_KERNEL); 158 if (!param->name) { 159 pr_err("Unable to allocate memory for parameter name.\n"); 160 goto out; 161 } 162 163 param->value = kzalloc(strlen(value) + 1, GFP_KERNEL); 164 if (!param->value) { 165 pr_err("Unable to allocate memory for parameter value.\n"); 166 goto out; 167 } 168 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; 176 param->use = use; 177 param->type_range = type_range; 178 179 switch (param->type_range) { 180 case TYPERANGE_BOOL_AND: 181 param->type = TYPE_BOOL_AND; 182 break; 183 case TYPERANGE_BOOL_OR: 184 param->type = TYPE_BOOL_OR; 185 break; 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; 194 break; 195 case TYPERANGE_AUTH: 196 case TYPERANGE_DIGEST: 197 param->type = TYPE_VALUE_LIST | TYPE_STRING; 198 break; 199 case TYPERANGE_MARKINT: 200 param->type = TYPE_NUMBER_RANGE; 201 param->type_range |= TYPERANGE_1_TO_65535; 202 break; 203 case TYPERANGE_ISCSINAME: 204 case TYPERANGE_SESSIONTYPE: 205 case TYPERANGE_TARGETADDRESS: 206 case TYPERANGE_UTF8: 207 param->type = TYPE_STRING; 208 break; 209 default: 210 pr_err("Unknown type_range 0x%02x\n", 211 param->type_range); 212 goto out; 213 } 214 list_add_tail(¶m->p_list, ¶m_list->param_list); 215 216 return param; 217 out: 218 if (param) { 219 kfree(param->value); 220 kfree(param->name); 221 kfree(param); 222 } 223 224 return NULL; 225 } 226 227 /* #warning Add extension keys */ 228 int iscsi_create_default_params(struct iscsi_param_list **param_list_ptr) 229 { 230 struct iscsi_param *param = NULL; 231 struct iscsi_param_list *pl; 232 233 pl = kzalloc(sizeof(struct iscsi_param_list), GFP_KERNEL); 234 if (!pl) { 235 pr_err("Unable to allocate memory for" 236 " struct iscsi_param_list.\n"); 237 return -1 ; 238 } 239 INIT_LIST_HEAD(&pl->param_list); 240 INIT_LIST_HEAD(&pl->extra_response_list); 241 242 /* 243 * The format for setting the initial parameter definitions are: 244 * 245 * Parameter name: 246 * Initial value: 247 * Allowable phase: 248 * Scope: 249 * Allowable senders: 250 * Typerange: 251 * Use: 252 */ 253 param = iscsi_set_default_param(pl, AUTHMETHOD, INITIAL_AUTHMETHOD, 254 PHASE_SECURITY, SCOPE_CONNECTION_ONLY, SENDER_BOTH, 255 TYPERANGE_AUTH, USE_INITIAL_ONLY); 256 if (!param) 257 goto out; 258 259 param = iscsi_set_default_param(pl, HEADERDIGEST, INITIAL_HEADERDIGEST, 260 PHASE_OPERATIONAL, SCOPE_CONNECTION_ONLY, SENDER_BOTH, 261 TYPERANGE_DIGEST, USE_INITIAL_ONLY); 262 if (!param) 263 goto out; 264 265 param = iscsi_set_default_param(pl, DATADIGEST, INITIAL_DATADIGEST, 266 PHASE_OPERATIONAL, SCOPE_CONNECTION_ONLY, SENDER_BOTH, 267 TYPERANGE_DIGEST, USE_INITIAL_ONLY); 268 if (!param) 269 goto out; 270 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); 275 if (!param) 276 goto out; 277 278 param = iscsi_set_default_param(pl, SENDTARGETS, INITIAL_SENDTARGETS, 279 PHASE_FFP0, SCOPE_SESSION_WIDE, SENDER_INITIATOR, 280 TYPERANGE_UTF8, 0); 281 if (!param) 282 goto out; 283 284 param = iscsi_set_default_param(pl, TARGETNAME, INITIAL_TARGETNAME, 285 PHASE_DECLARATIVE, SCOPE_SESSION_WIDE, SENDER_BOTH, 286 TYPERANGE_ISCSINAME, USE_ALL); 287 if (!param) 288 goto out; 289 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); 294 if (!param) 295 goto out; 296 297 param = iscsi_set_default_param(pl, TARGETALIAS, INITIAL_TARGETALIAS, 298 PHASE_DECLARATIVE, SCOPE_SESSION_WIDE, SENDER_TARGET, 299 TYPERANGE_UTF8, USE_ALL); 300 if (!param) 301 goto out; 302 303 param = iscsi_set_default_param(pl, INITIATORALIAS, 304 INITIAL_INITIATORALIAS, PHASE_DECLARATIVE, 305 SCOPE_SESSION_WIDE, SENDER_INITIATOR, TYPERANGE_UTF8, 306 USE_ALL); 307 if (!param) 308 goto out; 309 310 param = iscsi_set_default_param(pl, TARGETADDRESS, 311 INITIAL_TARGETADDRESS, PHASE_DECLARATIVE, 312 SCOPE_SESSION_WIDE, SENDER_TARGET, 313 TYPERANGE_TARGETADDRESS, USE_ALL); 314 if (!param) 315 goto out; 316 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); 321 if (!param) 322 goto out; 323 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); 327 if (!param) 328 goto out; 329 330 param = iscsi_set_default_param(pl, IMMEDIATEDATA, 331 INITIAL_IMMEDIATEDATA, PHASE_OPERATIONAL, 332 SCOPE_SESSION_WIDE, SENDER_BOTH, TYPERANGE_BOOL_AND, 333 USE_LEADING_ONLY); 334 if (!param) 335 goto out; 336 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); 341 if (!param) 342 goto out; 343 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); 348 if (!param) 349 goto out; 350 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); 355 if (!param) 356 goto out; 357 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); 362 if (!param) 363 goto out; 364 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); 369 if (!param) 370 goto out; 371 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); 376 if (!param) 377 goto out; 378 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); 383 if (!param) 384 goto out; 385 386 param = iscsi_set_default_param(pl, DATAPDUINORDER, 387 INITIAL_DATAPDUINORDER, PHASE_OPERATIONAL, 388 SCOPE_SESSION_WIDE, SENDER_BOTH, TYPERANGE_BOOL_OR, 389 USE_LEADING_ONLY); 390 if (!param) 391 goto out; 392 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); 397 if (!param) 398 goto out; 399 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); 404 if (!param) 405 goto out; 406 407 param = iscsi_set_default_param(pl, SESSIONTYPE, INITIAL_SESSIONTYPE, 408 PHASE_DECLARATIVE, SCOPE_SESSION_WIDE, SENDER_INITIATOR, 409 TYPERANGE_SESSIONTYPE, USE_LEADING_ONLY); 410 if (!param) 411 goto out; 412 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); 416 if (!param) 417 goto out; 418 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); 422 if (!param) 423 goto out; 424 425 param = iscsi_set_default_param(pl, IFMARKINT, INITIAL_IFMARKINT, 426 PHASE_OPERATIONAL, SCOPE_CONNECTION_ONLY, SENDER_BOTH, 427 TYPERANGE_MARKINT, USE_INITIAL_ONLY); 428 if (!param) 429 goto out; 430 431 param = iscsi_set_default_param(pl, OFMARKINT, INITIAL_OFMARKINT, 432 PHASE_OPERATIONAL, SCOPE_CONNECTION_ONLY, SENDER_BOTH, 433 TYPERANGE_MARKINT, USE_INITIAL_ONLY); 434 if (!param) 435 goto out; 436 437 *param_list_ptr = pl; 438 return 0; 439 out: 440 iscsi_release_param_list(pl); 441 return -1; 442 } 443 444 int iscsi_set_keys_to_negotiate( 445 int sessiontype, 446 struct iscsi_param_list *param_list) 447 { 448 struct iscsi_param *param; 449 450 list_for_each_entry(param, ¶m_list->param_list, p_list) { 451 param->state = 0; 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)) { 461 continue; 462 } else if (!strcmp(param->name, INITIATORNAME)) { 463 continue; 464 } else if (!strcmp(param->name, TARGETALIAS)) { 465 if (param->value) 466 SET_PSTATE_NEGOTIATE(param); 467 } else if (!strcmp(param->name, INITIATORALIAS)) { 468 continue; 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)) { 478 continue; 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); 505 } 506 } 507 508 return 0; 509 } 510 511 int iscsi_set_keys_irrelevant_for_discovery( 512 struct iscsi_param_list *param_list) 513 { 514 struct iscsi_param *param; 515 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; 547 } 548 549 return 0; 550 } 551 552 int iscsi_copy_param_list( 553 struct iscsi_param_list **dst_param_list, 554 struct iscsi_param_list *src_param_list, 555 int leading) 556 { 557 struct iscsi_param *param = NULL; 558 struct iscsi_param *new_param = NULL; 559 struct iscsi_param_list *param_list = NULL; 560 561 param_list = kzalloc(sizeof(struct iscsi_param_list), GFP_KERNEL); 562 if (!param_list) { 563 pr_err("Unable to allocate memory for struct iscsi_param_list.\n"); 564 goto err_out; 565 } 566 INIT_LIST_HEAD(¶m_list->param_list); 567 INIT_LIST_HEAD(¶m_list->extra_response_list); 568 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)) 574 continue; 575 } 576 577 new_param = kzalloc(sizeof(struct iscsi_param), GFP_KERNEL); 578 if (!new_param) { 579 pr_err("Unable to allocate memory for struct iscsi_param.\n"); 580 goto err_out; 581 } 582 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); 588 kfree(new_param); 589 pr_err("Unable to allocate memory for parameter name/value.\n"); 590 goto err_out; 591 } 592 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; 600 601 list_add_tail(&new_param->p_list, ¶m_list->param_list); 602 } 603 604 if (!list_empty(¶m_list->param_list)) { 605 *dst_param_list = param_list; 606 } else { 607 pr_err("No parameters allocated.\n"); 608 goto err_out; 609 } 610 611 return 0; 612 613 err_out: 614 iscsi_release_param_list(param_list); 615 return -1; 616 } 617 618 static void iscsi_release_extra_responses(struct iscsi_param_list *param_list) 619 { 620 struct iscsi_extra_response *er, *er_tmp; 621 622 list_for_each_entry_safe(er, er_tmp, ¶m_list->extra_response_list, 623 er_list) { 624 list_del(&er->er_list); 625 kfree(er); 626 } 627 } 628 629 void iscsi_release_param_list(struct iscsi_param_list *param_list) 630 { 631 struct iscsi_param *param, *param_tmp; 632 633 list_for_each_entry_safe(param, param_tmp, ¶m_list->param_list, 634 p_list) { 635 list_del(¶m->p_list); 636 637 kfree(param->name); 638 param->name = NULL; 639 kfree(param->value); 640 param->value = NULL; 641 kfree(param); 642 param = NULL; 643 } 644 645 iscsi_release_extra_responses(param_list); 646 647 kfree(param_list); 648 } 649 650 struct iscsi_param *iscsi_find_param_from_key( 651 char *key, 652 struct iscsi_param_list *param_list) 653 { 654 struct iscsi_param *param; 655 656 if (!key || !param_list) { 657 pr_err("Key or parameter list pointer is NULL.\n"); 658 return NULL; 659 } 660 661 list_for_each_entry(param, ¶m_list->param_list, p_list) { 662 if (!strcmp(key, param->name)) 663 return param; 664 } 665 666 pr_err("Unable to locate key \"%s\".\n", key); 667 return NULL; 668 } 669 670 int iscsi_extract_key_value(char *textbuf, char **key, char **value) 671 { 672 *value = strchr(textbuf, '='); 673 if (!*value) { 674 pr_err("Unable to locate \"=\" separator for key," 675 " ignoring request.\n"); 676 return -1; 677 } 678 679 *key = textbuf; 680 **value = '\0'; 681 *value = *value + 1; 682 683 return 0; 684 } 685 686 int iscsi_update_param_value(struct iscsi_param *param, char *value) 687 { 688 kfree(param->value); 689 690 param->value = kzalloc(strlen(value) + 1, GFP_KERNEL); 691 if (!param->value) { 692 pr_err("Unable to allocate memory for value.\n"); 693 return -ENOMEM; 694 } 695 696 memcpy(param->value, value, strlen(value)); 697 param->value[strlen(value)] = '\0'; 698 699 pr_debug("iSCSI Parameter updated to %s=%s\n", 700 param->name, param->value); 701 return 0; 702 } 703 704 static int iscsi_add_notunderstood_response( 705 char *key, 706 char *value, 707 struct iscsi_param_list *param_list) 708 { 709 struct iscsi_extra_response *extra_response; 710 711 if (strlen(value) > VALUE_MAXLEN) { 712 pr_err("Value for notunderstood key \"%s\" exceeds %d," 713 " protocol error.\n", key, VALUE_MAXLEN); 714 return -1; 715 } 716 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"); 721 return -1; 722 } 723 INIT_LIST_HEAD(&extra_response->er_list); 724 725 strncpy(extra_response->key, key, strlen(key) + 1); 726 strncpy(extra_response->value, NOTUNDERSTOOD, 727 strlen(NOTUNDERSTOOD) + 1); 728 729 list_add_tail(&extra_response->er_list, 730 ¶m_list->extra_response_list); 731 return 0; 732 } 733 734 static int iscsi_check_for_auth_key(char *key) 735 { 736 /* 737 * RFC 1994 738 */ 739 if (!strcmp(key, "CHAP_A") || !strcmp(key, "CHAP_I") || 740 !strcmp(key, "CHAP_C") || !strcmp(key, "CHAP_N") || 741 !strcmp(key, "CHAP_R")) 742 return 1; 743 744 /* 745 * RFC 2945 746 */ 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")) 751 return 1; 752 753 return 0; 754 } 755 756 static void iscsi_check_proposer_for_optional_reply(struct iscsi_param *param) 757 { 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); 764 /* 765 * Required for gPXE iSCSI boot client 766 */ 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); 772 /* 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. 779 */ 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); 788 /* 789 * Required for gPXE iSCSI boot client 790 */ 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); 795 } 796 797 static int iscsi_check_boolean_value(struct iscsi_param *param, char *value) 798 { 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); 802 return -1; 803 } 804 805 return 0; 806 } 807 808 static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_ptr) 809 { 810 char *tmpptr; 811 int value = 0; 812 813 value = simple_strtoul(value_ptr, &tmpptr, 0); 814 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); 819 return -1; 820 } 821 return 0; 822 } 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); 827 return -1; 828 } 829 return 0; 830 } 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); 835 return -1; 836 } 837 return 0; 838 } 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); 843 return -1; 844 } 845 return 0; 846 } 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); 851 return -1; 852 } 853 return 0; 854 } 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); 859 return -1; 860 } 861 return 0; 862 } 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); 867 return -1; 868 } 869 return 0; 870 } 871 872 return 0; 873 } 874 875 static int iscsi_check_numerical_range_value(struct iscsi_param *param, char *value) 876 { 877 char *left_val_ptr = NULL, *right_val_ptr = NULL; 878 char *tilde_ptr = NULL; 879 u32 left_val, right_val, local_left_val; 880 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); 885 return -1; 886 } 887 888 if (IS_PSTATE_PROPOSER(param)) 889 return 0; 890 891 tilde_ptr = strchr(value, '~'); 892 if (!tilde_ptr) { 893 pr_err("Unable to locate numerical range indicator" 894 " \"~\" for \"%s\".\n", param->name); 895 return -1; 896 } 897 *tilde_ptr = '\0'; 898 899 left_val_ptr = value; 900 right_val_ptr = value + strlen(left_val_ptr) + 1; 901 902 if (iscsi_check_numerical_value(param, left_val_ptr) < 0) 903 return -1; 904 if (iscsi_check_numerical_value(param, right_val_ptr) < 0) 905 return -1; 906 907 left_val = simple_strtoul(left_val_ptr, NULL, 0); 908 right_val = simple_strtoul(right_val_ptr, NULL, 0); 909 *tilde_ptr = '~'; 910 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", 914 param->name); 915 return -1; 916 } 917 918 /* 919 * For now, enforce reasonable defaults for [I,O]FMarkInt. 920 */ 921 tilde_ptr = strchr(param->value, '~'); 922 if (!tilde_ptr) { 923 pr_err("Unable to locate numerical range indicator" 924 " \"~\" for \"%s\".\n", param->name); 925 return -1; 926 } 927 *tilde_ptr = '\0'; 928 929 left_val_ptr = param->value; 930 right_val_ptr = param->value + strlen(left_val_ptr) + 1; 931 932 local_left_val = simple_strtoul(left_val_ptr, NULL, 0); 933 *tilde_ptr = '~'; 934 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); 942 return -1; 943 } 944 } else { 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) 953 return -1; 954 } 955 } 956 957 return 0; 958 } 959 960 static int iscsi_check_string_or_list_value(struct iscsi_param *param, char *value) 961 { 962 if (IS_PSTATE_PROPOSER(param)) 963 return 0; 964 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); 973 return -1; 974 } 975 } 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, 980 CRC32C, NONE); 981 return -1; 982 } 983 } 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, 988 DISCOVERY, NORMAL); 989 return -1; 990 } 991 } 992 993 return 0; 994 } 995 996 /* 997 * This function is used to pick a value range number, currently just 998 * returns the lesser of both right values. 999 */ 1000 static char *iscsi_get_value_from_number_range( 1001 struct iscsi_param *param, 1002 char *value) 1003 { 1004 char *end_ptr, *tilde_ptr1 = NULL, *tilde_ptr2 = NULL; 1005 u32 acceptor_right_value, proposer_right_value; 1006 1007 tilde_ptr1 = strchr(value, '~'); 1008 if (!tilde_ptr1) 1009 return NULL; 1010 *tilde_ptr1++ = '\0'; 1011 proposer_right_value = simple_strtoul(tilde_ptr1, &end_ptr, 0); 1012 1013 tilde_ptr2 = strchr(param->value, '~'); 1014 if (!tilde_ptr2) 1015 return NULL; 1016 *tilde_ptr2++ = '\0'; 1017 acceptor_right_value = simple_strtoul(tilde_ptr2, &end_ptr, 0); 1018 1019 return (acceptor_right_value >= proposer_right_value) ? 1020 tilde_ptr1 : tilde_ptr2; 1021 } 1022 1023 static char *iscsi_check_valuelist_for_support( 1024 struct iscsi_param *param, 1025 char *value) 1026 { 1027 char *tmp1 = NULL, *tmp2 = NULL; 1028 char *acceptor_values = NULL, *proposer_values = NULL; 1029 1030 acceptor_values = param->value; 1031 proposer_values = value; 1032 1033 do { 1034 if (!proposer_values) 1035 return NULL; 1036 tmp1 = strchr(proposer_values, ','); 1037 if (tmp1) 1038 *tmp1 = '\0'; 1039 acceptor_values = param->value; 1040 do { 1041 if (!acceptor_values) { 1042 if (tmp1) 1043 *tmp1 = ','; 1044 return NULL; 1045 } 1046 tmp2 = strchr(acceptor_values, ','); 1047 if (tmp2) 1048 *tmp2 = '\0'; 1049 if (!strcmp(acceptor_values, proposer_values)) { 1050 if (tmp2) 1051 *tmp2 = ','; 1052 goto out; 1053 } 1054 if (tmp2) 1055 *tmp2++ = ','; 1056 1057 acceptor_values = tmp2; 1058 } while (acceptor_values); 1059 if (tmp1) 1060 *tmp1++ = ','; 1061 proposer_values = tmp1; 1062 } while (proposer_values); 1063 1064 out: 1065 return proposer_values; 1066 } 1067 1068 static int iscsi_check_acceptor_state(struct iscsi_param *param, char *value, 1069 struct iscsi_conn *conn) 1070 { 1071 u8 acceptor_boolean_value = 0, proposer_boolean_value = 0; 1072 char *negoitated_value = NULL; 1073 1074 if (IS_PSTATE_ACCEPTOR(param)) { 1075 pr_err("Received key \"%s\" twice, protocol error.\n", 1076 param->name); 1077 return -1; 1078 } 1079 1080 if (IS_PSTATE_REJECT(param)) 1081 return 0; 1082 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) 1089 do {} while (0); 1090 else { 1091 if (iscsi_update_param_value(param, NO) < 0) 1092 return -1; 1093 if (!proposer_boolean_value) 1094 SET_PSTATE_REPLY_OPTIONAL(param); 1095 } 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) 1103 return -1; 1104 if (proposer_boolean_value) 1105 SET_PSTATE_REPLY_OPTIONAL(param); 1106 } 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); 1111 1112 memset(buf, 0, 10); 1113 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, 1123 &buf[0]) < 0) 1124 return -1; 1125 } else { 1126 if (iscsi_update_param_value(param, value) < 0) 1127 return -1; 1128 } 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, 1133 &buf[0]) < 0) 1134 return -1; 1135 } else { 1136 if (iscsi_update_param_value(param, value) < 0) 1137 return -1; 1138 } 1139 } else { 1140 if (iscsi_update_param_value(param, value) < 0) 1141 return -1; 1142 } 1143 1144 if (!strcmp(param->name, MAXRECVDATASEGMENTLENGTH)) { 1145 struct iscsi_param *param_mxdsl; 1146 unsigned long long tmp; 1147 int rc; 1148 1149 rc = strict_strtoull(param->value, 0, &tmp); 1150 if (rc < 0) 1151 return -1; 1152 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); 1157 1158 param_mxdsl = iscsi_find_param_from_key( 1159 MAXXMITDATASEGMENTLENGTH, 1160 conn->param_list); 1161 if (!param_mxdsl) 1162 return -1; 1163 1164 rc = iscsi_update_param_value(param, 1165 param_mxdsl->value); 1166 if (rc < 0) 1167 return -1; 1168 1169 pr_debug("Updated %s to target MXDSL value: %s\n", 1170 param->name, param->value); 1171 } 1172 1173 } else if (IS_TYPE_NUMBER_RANGE(param)) { 1174 negoitated_value = iscsi_get_value_from_number_range( 1175 param, value); 1176 if (!negoitated_value) 1177 return -1; 1178 if (iscsi_update_param_value(param, negoitated_value) < 0) 1179 return -1; 1180 } else if (IS_TYPE_VALUE_LIST(param)) { 1181 negoitated_value = iscsi_check_valuelist_for_support( 1182 param, value); 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); 1187 return -1; 1188 } 1189 if (iscsi_update_param_value(param, negoitated_value) < 0) 1190 return -1; 1191 } else if (IS_PHASE_DECLARATIVE(param)) { 1192 if (iscsi_update_param_value(param, value) < 0) 1193 return -1; 1194 SET_PSTATE_REPLY_OPTIONAL(param); 1195 } 1196 1197 return 0; 1198 } 1199 1200 static int iscsi_check_proposer_state(struct iscsi_param *param, char *value) 1201 { 1202 if (IS_PSTATE_RESPONSE_GOT(param)) { 1203 pr_err("Received key \"%s\" twice, protocol error.\n", 1204 param->name); 1205 return -1; 1206 } 1207 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; 1212 1213 if (!strcmp(value, IRRELEVANT) || !strcmp(value, REJECT)) { 1214 if (iscsi_update_param_value(param, value) < 0) 1215 return -1; 1216 return 0; 1217 } 1218 1219 tilde_ptr = strchr(value, '~'); 1220 if (tilde_ptr) { 1221 pr_err("Illegal \"~\" in response for \"%s\".\n", 1222 param->name); 1223 return -1; 1224 } 1225 tilde_ptr = strchr(param->value, '~'); 1226 if (!tilde_ptr) { 1227 pr_err("Unable to locate numerical range" 1228 " indicator \"~\" for \"%s\".\n", param->name); 1229 return -1; 1230 } 1231 *tilde_ptr = '\0'; 1232 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); 1238 1239 *tilde_ptr = '~'; 1240 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); 1246 return -1; 1247 } 1248 } else if (IS_TYPE_VALUE_LIST(param)) { 1249 char *comma_ptr = NULL, *tmp_ptr = NULL; 1250 1251 comma_ptr = strchr(value, ','); 1252 if (comma_ptr) { 1253 pr_err("Illegal \",\" in response for \"%s\".\n", 1254 param->name); 1255 return -1; 1256 } 1257 1258 tmp_ptr = iscsi_check_valuelist_for_support(param, value); 1259 if (!tmp_ptr) 1260 return -1; 1261 } 1262 1263 if (iscsi_update_param_value(param, value) < 0) 1264 return -1; 1265 1266 return 0; 1267 } 1268 1269 static int iscsi_check_value(struct iscsi_param *param, char *value) 1270 { 1271 char *comma_ptr = NULL; 1272 1273 if (!strcmp(value, REJECT)) { 1274 if (!strcmp(param->name, IFMARKINT) || 1275 !strcmp(param->name, OFMARKINT)) { 1276 /* 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) 1279 */ 1280 SET_PSTATE_REJECT(param); 1281 return 0; 1282 } 1283 pr_err("Received %s=%s\n", param->name, value); 1284 return -1; 1285 } 1286 if (!strcmp(value, IRRELEVANT)) { 1287 pr_debug("Received %s=%s\n", param->name, value); 1288 SET_PSTATE_IRRELEVANT(param); 1289 return 0; 1290 } 1291 if (!strcmp(value, NOTUNDERSTOOD)) { 1292 if (!IS_PSTATE_PROPOSER(param)) { 1293 pr_err("Received illegal offer %s=%s\n", 1294 param->name, value); 1295 return -1; 1296 } 1297 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); 1301 return -1; 1302 } 1303 1304 do { 1305 comma_ptr = NULL; 1306 comma_ptr = strchr(value, ','); 1307 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); 1312 return -1; 1313 } 1314 if (comma_ptr) 1315 *comma_ptr = '\0'; 1316 1317 if (strlen(value) > VALUE_MAXLEN) { 1318 pr_err("Value for key \"%s\" exceeds %d," 1319 " protocol error.\n", param->name, 1320 VALUE_MAXLEN); 1321 return -1; 1322 } 1323 1324 if (IS_TYPE_BOOL_AND(param) || IS_TYPE_BOOL_OR(param)) { 1325 if (iscsi_check_boolean_value(param, value) < 0) 1326 return -1; 1327 } else if (IS_TYPE_NUMBER(param)) { 1328 if (iscsi_check_numerical_value(param, value) < 0) 1329 return -1; 1330 } else if (IS_TYPE_NUMBER_RANGE(param)) { 1331 if (iscsi_check_numerical_range_value(param, value) < 0) 1332 return -1; 1333 } else if (IS_TYPE_STRING(param) || IS_TYPE_VALUE_LIST(param)) { 1334 if (iscsi_check_string_or_list_value(param, value) < 0) 1335 return -1; 1336 } else { 1337 pr_err("Huh? 0x%02x\n", param->type); 1338 return -1; 1339 } 1340 1341 if (comma_ptr) 1342 *comma_ptr++ = ','; 1343 1344 value = comma_ptr; 1345 } while (value); 1346 1347 return 0; 1348 } 1349 1350 static struct iscsi_param *__iscsi_check_key( 1351 char *key, 1352 int sender, 1353 struct iscsi_param_list *param_list) 1354 { 1355 struct iscsi_param *param; 1356 1357 if (strlen(key) > KEY_MAXLEN) { 1358 pr_err("Length of key name \"%s\" exceeds %d.\n", 1359 key, KEY_MAXLEN); 1360 return NULL; 1361 } 1362 1363 param = iscsi_find_param_from_key(key, param_list); 1364 if (!param) 1365 return NULL; 1366 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"); 1371 return NULL; 1372 } 1373 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"); 1378 return NULL; 1379 } 1380 1381 return param; 1382 } 1383 1384 static struct iscsi_param *iscsi_check_key( 1385 char *key, 1386 int phase, 1387 int sender, 1388 struct iscsi_param_list *param_list) 1389 { 1390 struct iscsi_param *param; 1391 /* 1392 * Key name length must not exceed 63 bytes. (See iSCSI v20 5.1) 1393 */ 1394 if (strlen(key) > KEY_MAXLEN) { 1395 pr_err("Length of key name \"%s\" exceeds %d.\n", 1396 key, KEY_MAXLEN); 1397 return NULL; 1398 } 1399 1400 param = iscsi_find_param_from_key(key, param_list); 1401 if (!param) 1402 return NULL; 1403 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"); 1408 return NULL; 1409 } 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"); 1414 return NULL; 1415 } 1416 1417 if (IS_PSTATE_ACCEPTOR(param)) { 1418 pr_err("Key \"%s\" received twice, protocol error.\n", 1419 key); 1420 return NULL; 1421 } 1422 1423 if (!phase) 1424 return param; 1425 1426 if (!(param->phase & phase)) { 1427 pr_err("Key \"%s\" may not be negotiated during ", 1428 param->name); 1429 switch (phase) { 1430 case PHASE_SECURITY: 1431 pr_debug("Security phase.\n"); 1432 break; 1433 case PHASE_OPERATIONAL: 1434 pr_debug("Operational phase.\n"); 1435 default: 1436 pr_debug("Unknown phase.\n"); 1437 } 1438 return NULL; 1439 } 1440 1441 return param; 1442 } 1443 1444 static int iscsi_enforce_integrity_rules( 1445 u8 phase, 1446 struct iscsi_param_list *param_list) 1447 { 1448 char *tmpptr; 1449 u8 DataSequenceInOrder = 0; 1450 u8 ErrorRecoveryLevel = 0, SessionType = 0; 1451 u8 IFMarker = 0, OFMarker = 0; 1452 u8 IFMarkInt_Reject = 1, OFMarkInt_Reject = 1; 1453 u32 FirstBurstLength = 0, MaxBurstLength = 0; 1454 struct iscsi_param *param = NULL; 1455 1456 list_for_each_entry(param, ¶m_list->param_list, p_list) { 1457 if (!(param->phase & phase)) 1458 continue; 1459 if (!strcmp(param->name, SESSIONTYPE)) 1460 if (!strcmp(param->value, NORMAL)) 1461 SessionType = 1; 1462 if (!strcmp(param->name, ERRORRECOVERYLEVEL)) 1463 ErrorRecoveryLevel = simple_strtoul(param->value, 1464 &tmpptr, 0); 1465 if (!strcmp(param->name, DATASEQUENCEINORDER)) 1466 if (!strcmp(param->value, YES)) 1467 DataSequenceInOrder = 1; 1468 if (!strcmp(param->name, MAXBURSTLENGTH)) 1469 MaxBurstLength = simple_strtoul(param->value, 1470 &tmpptr, 0); 1471 if (!strcmp(param->name, IFMARKER)) 1472 if (!strcmp(param->value, YES)) 1473 IFMarker = 1; 1474 if (!strcmp(param->name, OFMARKER)) 1475 if (!strcmp(param->value, YES)) 1476 OFMarker = 1; 1477 if (!strcmp(param->name, IFMARKINT)) 1478 if (!strcmp(param->value, REJECT)) 1479 IFMarkInt_Reject = 1; 1480 if (!strcmp(param->name, OFMARKINT)) 1481 if (!strcmp(param->value, REJECT)) 1482 OFMarkInt_Reject = 1; 1483 } 1484 1485 list_for_each_entry(param, ¶m_list->param_list, p_list) { 1486 if (!(param->phase & phase)) 1487 continue; 1488 if (!SessionType && (!IS_PSTATE_ACCEPTOR(param) && 1489 (strcmp(param->name, IFMARKER) && 1490 strcmp(param->name, OFMARKER) && 1491 strcmp(param->name, IFMARKINT) && 1492 strcmp(param->name, OFMARKINT)))) 1493 continue; 1494 if (!strcmp(param->name, MAXOUTSTANDINGR2T) && 1495 DataSequenceInOrder && (ErrorRecoveryLevel > 0)) { 1496 if (strcmp(param->value, "1")) { 1497 if (iscsi_update_param_value(param, "1") < 0) 1498 return -1; 1499 pr_debug("Reset \"%s\" to \"%s\".\n", 1500 param->name, param->value); 1501 } 1502 } 1503 if (!strcmp(param->name, MAXCONNECTIONS) && !SessionType) { 1504 if (strcmp(param->value, "1")) { 1505 if (iscsi_update_param_value(param, "1") < 0) 1506 return -1; 1507 pr_debug("Reset \"%s\" to \"%s\".\n", 1508 param->name, param->value); 1509 } 1510 } 1511 if (!strcmp(param->name, FIRSTBURSTLENGTH)) { 1512 FirstBurstLength = simple_strtoul(param->value, 1513 &tmpptr, 0); 1514 if (FirstBurstLength > MaxBurstLength) { 1515 char tmpbuf[10]; 1516 memset(tmpbuf, 0, 10); 1517 sprintf(tmpbuf, "%u", MaxBurstLength); 1518 if (iscsi_update_param_value(param, tmpbuf)) 1519 return -1; 1520 pr_debug("Reset \"%s\" to \"%s\".\n", 1521 param->name, param->value); 1522 } 1523 } 1524 if (!strcmp(param->name, IFMARKER) && IFMarkInt_Reject) { 1525 if (iscsi_update_param_value(param, NO) < 0) 1526 return -1; 1527 IFMarker = 0; 1528 pr_debug("Reset \"%s\" to \"%s\".\n", 1529 param->name, param->value); 1530 } 1531 if (!strcmp(param->name, OFMARKER) && OFMarkInt_Reject) { 1532 if (iscsi_update_param_value(param, NO) < 0) 1533 return -1; 1534 OFMarker = 0; 1535 pr_debug("Reset \"%s\" to \"%s\".\n", 1536 param->name, param->value); 1537 } 1538 if (!strcmp(param->name, IFMARKINT) && !IFMarker) { 1539 if (!strcmp(param->value, REJECT)) 1540 continue; 1541 param->state &= ~PSTATE_NEGOTIATE; 1542 if (iscsi_update_param_value(param, IRRELEVANT) < 0) 1543 return -1; 1544 pr_debug("Reset \"%s\" to \"%s\".\n", 1545 param->name, param->value); 1546 } 1547 if (!strcmp(param->name, OFMARKINT) && !OFMarker) { 1548 if (!strcmp(param->value, REJECT)) 1549 continue; 1550 param->state &= ~PSTATE_NEGOTIATE; 1551 if (iscsi_update_param_value(param, IRRELEVANT) < 0) 1552 return -1; 1553 pr_debug("Reset \"%s\" to \"%s\".\n", 1554 param->name, param->value); 1555 } 1556 } 1557 1558 return 0; 1559 } 1560 1561 int iscsi_decode_text_input( 1562 u8 phase, 1563 u8 sender, 1564 char *textbuf, 1565 u32 length, 1566 struct iscsi_conn *conn) 1567 { 1568 struct iscsi_param_list *param_list = conn->param_list; 1569 char *tmpbuf, *start = NULL, *end = NULL; 1570 1571 tmpbuf = kzalloc(length + 1, GFP_KERNEL); 1572 if (!tmpbuf) { 1573 pr_err("Unable to allocate memory for tmpbuf.\n"); 1574 return -1; 1575 } 1576 1577 memcpy(tmpbuf, textbuf, length); 1578 tmpbuf[length] = '\0'; 1579 start = tmpbuf; 1580 end = (start + length); 1581 1582 while (start < end) { 1583 char *key, *value; 1584 struct iscsi_param *param; 1585 1586 if (iscsi_extract_key_value(start, &key, &value) < 0) { 1587 kfree(tmpbuf); 1588 return -1; 1589 } 1590 1591 pr_debug("Got key: %s=%s\n", key, value); 1592 1593 if (phase & PHASE_SECURITY) { 1594 if (iscsi_check_for_auth_key(key) > 0) { 1595 char *tmpptr = key + strlen(key); 1596 *tmpptr = '='; 1597 kfree(tmpbuf); 1598 return 1; 1599 } 1600 } 1601 1602 param = iscsi_check_key(key, phase, sender, param_list); 1603 if (!param) { 1604 if (iscsi_add_notunderstood_response(key, 1605 value, param_list) < 0) { 1606 kfree(tmpbuf); 1607 return -1; 1608 } 1609 start += strlen(key) + strlen(value) + 2; 1610 continue; 1611 } 1612 if (iscsi_check_value(param, value) < 0) { 1613 kfree(tmpbuf); 1614 return -1; 1615 } 1616 1617 start += strlen(key) + strlen(value) + 2; 1618 1619 if (IS_PSTATE_PROPOSER(param)) { 1620 if (iscsi_check_proposer_state(param, value) < 0) { 1621 kfree(tmpbuf); 1622 return -1; 1623 } 1624 SET_PSTATE_RESPONSE_GOT(param); 1625 } else { 1626 if (iscsi_check_acceptor_state(param, value, conn) < 0) { 1627 kfree(tmpbuf); 1628 return -1; 1629 } 1630 SET_PSTATE_ACCEPTOR(param); 1631 } 1632 } 1633 1634 kfree(tmpbuf); 1635 return 0; 1636 } 1637 1638 int iscsi_encode_text_output( 1639 u8 phase, 1640 u8 sender, 1641 char *textbuf, 1642 u32 *length, 1643 struct iscsi_param_list *param_list) 1644 { 1645 char *output_buf = NULL; 1646 struct iscsi_extra_response *er; 1647 struct iscsi_param *param; 1648 1649 output_buf = textbuf + *length; 1650 1651 if (iscsi_enforce_integrity_rules(phase, param_list) < 0) 1652 return -1; 1653 1654 list_for_each_entry(param, ¶m_list->param_list, p_list) { 1655 if (!(param->sender & sender)) 1656 continue; 1657 if (IS_PSTATE_ACCEPTOR(param) && 1658 !IS_PSTATE_RESPONSE_SENT(param) && 1659 !IS_PSTATE_REPLY_OPTIONAL(param) && 1660 (param->phase & phase)) { 1661 *length += sprintf(output_buf, "%s=%s", 1662 param->name, param->value); 1663 *length += 1; 1664 output_buf = textbuf + *length; 1665 SET_PSTATE_RESPONSE_SENT(param); 1666 pr_debug("Sending key: %s=%s\n", 1667 param->name, param->value); 1668 continue; 1669 } 1670 if (IS_PSTATE_NEGOTIATE(param) && 1671 !IS_PSTATE_ACCEPTOR(param) && 1672 !IS_PSTATE_PROPOSER(param) && 1673 (param->phase & phase)) { 1674 *length += sprintf(output_buf, "%s=%s", 1675 param->name, param->value); 1676 *length += 1; 1677 output_buf = textbuf + *length; 1678 SET_PSTATE_PROPOSER(param); 1679 iscsi_check_proposer_for_optional_reply(param); 1680 pr_debug("Sending key: %s=%s\n", 1681 param->name, param->value); 1682 } 1683 } 1684 1685 list_for_each_entry(er, ¶m_list->extra_response_list, er_list) { 1686 *length += sprintf(output_buf, "%s=%s", er->key, er->value); 1687 *length += 1; 1688 output_buf = textbuf + *length; 1689 pr_debug("Sending key: %s=%s\n", er->key, er->value); 1690 } 1691 iscsi_release_extra_responses(param_list); 1692 1693 return 0; 1694 } 1695 1696 int iscsi_check_negotiated_keys(struct iscsi_param_list *param_list) 1697 { 1698 int ret = 0; 1699 struct iscsi_param *param; 1700 1701 list_for_each_entry(param, ¶m_list->param_list, p_list) { 1702 if (IS_PSTATE_NEGOTIATE(param) && 1703 IS_PSTATE_PROPOSER(param) && 1704 !IS_PSTATE_RESPONSE_GOT(param) && 1705 !IS_PSTATE_REPLY_OPTIONAL(param) && 1706 !IS_PHASE_DECLARATIVE(param)) { 1707 pr_err("No response for proposed key \"%s\".\n", 1708 param->name); 1709 ret = -1; 1710 } 1711 } 1712 1713 return ret; 1714 } 1715 1716 int iscsi_change_param_value( 1717 char *keyvalue, 1718 struct iscsi_param_list *param_list, 1719 int check_key) 1720 { 1721 char *key = NULL, *value = NULL; 1722 struct iscsi_param *param; 1723 int sender = 0; 1724 1725 if (iscsi_extract_key_value(keyvalue, &key, &value) < 0) 1726 return -1; 1727 1728 if (!check_key) { 1729 param = __iscsi_check_key(keyvalue, sender, param_list); 1730 if (!param) 1731 return -1; 1732 } else { 1733 param = iscsi_check_key(keyvalue, 0, sender, param_list); 1734 if (!param) 1735 return -1; 1736 1737 param->set_param = 1; 1738 if (iscsi_check_value(param, value) < 0) { 1739 param->set_param = 0; 1740 return -1; 1741 } 1742 param->set_param = 0; 1743 } 1744 1745 if (iscsi_update_param_value(param, value) < 0) 1746 return -1; 1747 1748 return 0; 1749 } 1750 1751 void iscsi_set_connection_parameters( 1752 struct iscsi_conn_ops *ops, 1753 struct iscsi_param_list *param_list) 1754 { 1755 char *tmpptr; 1756 struct iscsi_param *param; 1757 1758 pr_debug("---------------------------------------------------" 1759 "---------------\n"); 1760 list_for_each_entry(param, ¶m_list->param_list, p_list) { 1761 /* 1762 * Special case to set MAXXMITDATASEGMENTLENGTH from the 1763 * target requested MaxRecvDataSegmentLength, even though 1764 * this key is not sent over the wire. 1765 */ 1766 if (!strcmp(param->name, MAXXMITDATASEGMENTLENGTH)) { 1767 ops->MaxXmitDataSegmentLength = 1768 simple_strtoul(param->value, &tmpptr, 0); 1769 pr_debug("MaxXmitDataSegmentLength: %s\n", 1770 param->value); 1771 } 1772 1773 if (!IS_PSTATE_ACCEPTOR(param) && !IS_PSTATE_PROPOSER(param)) 1774 continue; 1775 if (!strcmp(param->name, AUTHMETHOD)) { 1776 pr_debug("AuthMethod: %s\n", 1777 param->value); 1778 } else if (!strcmp(param->name, HEADERDIGEST)) { 1779 ops->HeaderDigest = !strcmp(param->value, CRC32C); 1780 pr_debug("HeaderDigest: %s\n", 1781 param->value); 1782 } else if (!strcmp(param->name, DATADIGEST)) { 1783 ops->DataDigest = !strcmp(param->value, CRC32C); 1784 pr_debug("DataDigest: %s\n", 1785 param->value); 1786 } else if (!strcmp(param->name, MAXRECVDATASEGMENTLENGTH)) { 1787 /* 1788 * At this point iscsi_check_acceptor_state() will have 1789 * set ops->MaxRecvDataSegmentLength from the original 1790 * initiator provided value. 1791 */ 1792 pr_debug("MaxRecvDataSegmentLength: %u\n", 1793 ops->MaxRecvDataSegmentLength); 1794 } else if (!strcmp(param->name, OFMARKER)) { 1795 ops->OFMarker = !strcmp(param->value, YES); 1796 pr_debug("OFMarker: %s\n", 1797 param->value); 1798 } else if (!strcmp(param->name, IFMARKER)) { 1799 ops->IFMarker = !strcmp(param->value, YES); 1800 pr_debug("IFMarker: %s\n", 1801 param->value); 1802 } else if (!strcmp(param->name, OFMARKINT)) { 1803 ops->OFMarkInt = 1804 simple_strtoul(param->value, &tmpptr, 0); 1805 pr_debug("OFMarkInt: %s\n", 1806 param->value); 1807 } else if (!strcmp(param->name, IFMARKINT)) { 1808 ops->IFMarkInt = 1809 simple_strtoul(param->value, &tmpptr, 0); 1810 pr_debug("IFMarkInt: %s\n", 1811 param->value); 1812 } 1813 } 1814 pr_debug("----------------------------------------------------" 1815 "--------------\n"); 1816 } 1817 1818 void iscsi_set_session_parameters( 1819 struct iscsi_sess_ops *ops, 1820 struct iscsi_param_list *param_list, 1821 int leading) 1822 { 1823 char *tmpptr; 1824 struct iscsi_param *param; 1825 1826 pr_debug("----------------------------------------------------" 1827 "--------------\n"); 1828 list_for_each_entry(param, ¶m_list->param_list, p_list) { 1829 if (!IS_PSTATE_ACCEPTOR(param) && !IS_PSTATE_PROPOSER(param)) 1830 continue; 1831 if (!strcmp(param->name, INITIATORNAME)) { 1832 if (!param->value) 1833 continue; 1834 if (leading) 1835 snprintf(ops->InitiatorName, 1836 sizeof(ops->InitiatorName), 1837 "%s", param->value); 1838 pr_debug("InitiatorName: %s\n", 1839 param->value); 1840 } else if (!strcmp(param->name, INITIATORALIAS)) { 1841 if (!param->value) 1842 continue; 1843 snprintf(ops->InitiatorAlias, 1844 sizeof(ops->InitiatorAlias), 1845 "%s", param->value); 1846 pr_debug("InitiatorAlias: %s\n", 1847 param->value); 1848 } else if (!strcmp(param->name, TARGETNAME)) { 1849 if (!param->value) 1850 continue; 1851 if (leading) 1852 snprintf(ops->TargetName, 1853 sizeof(ops->TargetName), 1854 "%s", param->value); 1855 pr_debug("TargetName: %s\n", 1856 param->value); 1857 } else if (!strcmp(param->name, TARGETALIAS)) { 1858 if (!param->value) 1859 continue; 1860 snprintf(ops->TargetAlias, sizeof(ops->TargetAlias), 1861 "%s", param->value); 1862 pr_debug("TargetAlias: %s\n", 1863 param->value); 1864 } else if (!strcmp(param->name, TARGETPORTALGROUPTAG)) { 1865 ops->TargetPortalGroupTag = 1866 simple_strtoul(param->value, &tmpptr, 0); 1867 pr_debug("TargetPortalGroupTag: %s\n", 1868 param->value); 1869 } else if (!strcmp(param->name, MAXCONNECTIONS)) { 1870 ops->MaxConnections = 1871 simple_strtoul(param->value, &tmpptr, 0); 1872 pr_debug("MaxConnections: %s\n", 1873 param->value); 1874 } else if (!strcmp(param->name, INITIALR2T)) { 1875 ops->InitialR2T = !strcmp(param->value, YES); 1876 pr_debug("InitialR2T: %s\n", 1877 param->value); 1878 } else if (!strcmp(param->name, IMMEDIATEDATA)) { 1879 ops->ImmediateData = !strcmp(param->value, YES); 1880 pr_debug("ImmediateData: %s\n", 1881 param->value); 1882 } else if (!strcmp(param->name, MAXBURSTLENGTH)) { 1883 ops->MaxBurstLength = 1884 simple_strtoul(param->value, &tmpptr, 0); 1885 pr_debug("MaxBurstLength: %s\n", 1886 param->value); 1887 } else if (!strcmp(param->name, FIRSTBURSTLENGTH)) { 1888 ops->FirstBurstLength = 1889 simple_strtoul(param->value, &tmpptr, 0); 1890 pr_debug("FirstBurstLength: %s\n", 1891 param->value); 1892 } else if (!strcmp(param->name, DEFAULTTIME2WAIT)) { 1893 ops->DefaultTime2Wait = 1894 simple_strtoul(param->value, &tmpptr, 0); 1895 pr_debug("DefaultTime2Wait: %s\n", 1896 param->value); 1897 } else if (!strcmp(param->name, DEFAULTTIME2RETAIN)) { 1898 ops->DefaultTime2Retain = 1899 simple_strtoul(param->value, &tmpptr, 0); 1900 pr_debug("DefaultTime2Retain: %s\n", 1901 param->value); 1902 } else if (!strcmp(param->name, MAXOUTSTANDINGR2T)) { 1903 ops->MaxOutstandingR2T = 1904 simple_strtoul(param->value, &tmpptr, 0); 1905 pr_debug("MaxOutstandingR2T: %s\n", 1906 param->value); 1907 } else if (!strcmp(param->name, DATAPDUINORDER)) { 1908 ops->DataPDUInOrder = !strcmp(param->value, YES); 1909 pr_debug("DataPDUInOrder: %s\n", 1910 param->value); 1911 } else if (!strcmp(param->name, DATASEQUENCEINORDER)) { 1912 ops->DataSequenceInOrder = !strcmp(param->value, YES); 1913 pr_debug("DataSequenceInOrder: %s\n", 1914 param->value); 1915 } else if (!strcmp(param->name, ERRORRECOVERYLEVEL)) { 1916 ops->ErrorRecoveryLevel = 1917 simple_strtoul(param->value, &tmpptr, 0); 1918 pr_debug("ErrorRecoveryLevel: %s\n", 1919 param->value); 1920 } else if (!strcmp(param->name, SESSIONTYPE)) { 1921 ops->SessionType = !strcmp(param->value, DISCOVERY); 1922 pr_debug("SessionType: %s\n", 1923 param->value); 1924 } 1925 } 1926 pr_debug("----------------------------------------------------" 1927 "--------------\n"); 1928 1929 } 1930