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/ctype.h> 22 #include <scsi/iscsi_proto.h> 23 #include <target/target_core_base.h> 24 #include <target/target_core_fabric.h> 25 #include <target/iscsi/iscsi_transport.h> 26 27 #include "iscsi_target_core.h" 28 #include "iscsi_target_parameters.h" 29 #include "iscsi_target_login.h" 30 #include "iscsi_target_nego.h" 31 #include "iscsi_target_tpg.h" 32 #include "iscsi_target_util.h" 33 #include "iscsi_target.h" 34 #include "iscsi_target_auth.h" 35 36 #define MAX_LOGIN_PDUS 7 37 #define TEXT_LEN 4096 38 39 void convert_null_to_semi(char *buf, int len) 40 { 41 int i; 42 43 for (i = 0; i < len; i++) 44 if (buf[i] == '\0') 45 buf[i] = ';'; 46 } 47 48 static int strlen_semi(char *buf) 49 { 50 int i = 0; 51 52 while (buf[i] != '\0') { 53 if (buf[i] == ';') 54 return i; 55 i++; 56 } 57 58 return -1; 59 } 60 61 int extract_param( 62 const char *in_buf, 63 const char *pattern, 64 unsigned int max_length, 65 char *out_buf, 66 unsigned char *type) 67 { 68 char *ptr; 69 int len; 70 71 if (!in_buf || !pattern || !out_buf || !type) 72 return -1; 73 74 ptr = strstr(in_buf, pattern); 75 if (!ptr) 76 return -1; 77 78 ptr = strstr(ptr, "="); 79 if (!ptr) 80 return -1; 81 82 ptr += 1; 83 if (*ptr == '0' && (*(ptr+1) == 'x' || *(ptr+1) == 'X')) { 84 ptr += 2; /* skip 0x */ 85 *type = HEX; 86 } else 87 *type = DECIMAL; 88 89 len = strlen_semi(ptr); 90 if (len < 0) 91 return -1; 92 93 if (len > max_length) { 94 pr_err("Length of input: %d exceeds max_length:" 95 " %d\n", len, max_length); 96 return -1; 97 } 98 memcpy(out_buf, ptr, len); 99 out_buf[len] = '\0'; 100 101 return 0; 102 } 103 104 static u32 iscsi_handle_authentication( 105 struct iscsi_conn *conn, 106 char *in_buf, 107 char *out_buf, 108 int in_length, 109 int *out_length, 110 unsigned char *authtype) 111 { 112 struct iscsi_session *sess = conn->sess; 113 struct iscsi_node_auth *auth; 114 struct iscsi_node_acl *iscsi_nacl; 115 struct iscsi_portal_group *iscsi_tpg; 116 struct se_node_acl *se_nacl; 117 118 if (!sess->sess_ops->SessionType) { 119 /* 120 * For SessionType=Normal 121 */ 122 se_nacl = conn->sess->se_sess->se_node_acl; 123 if (!se_nacl) { 124 pr_err("Unable to locate struct se_node_acl for" 125 " CHAP auth\n"); 126 return -1; 127 } 128 iscsi_nacl = container_of(se_nacl, struct iscsi_node_acl, 129 se_node_acl); 130 if (!iscsi_nacl) { 131 pr_err("Unable to locate struct iscsi_node_acl for" 132 " CHAP auth\n"); 133 return -1; 134 } 135 136 if (se_nacl->dynamic_node_acl) { 137 iscsi_tpg = container_of(se_nacl->se_tpg, 138 struct iscsi_portal_group, tpg_se_tpg); 139 140 auth = &iscsi_tpg->tpg_demo_auth; 141 } else { 142 iscsi_nacl = container_of(se_nacl, struct iscsi_node_acl, 143 se_node_acl); 144 145 auth = ISCSI_NODE_AUTH(iscsi_nacl); 146 } 147 } else { 148 /* 149 * For SessionType=Discovery 150 */ 151 auth = &iscsit_global->discovery_acl.node_auth; 152 } 153 154 if (strstr("CHAP", authtype)) 155 strcpy(conn->sess->auth_type, "CHAP"); 156 else 157 strcpy(conn->sess->auth_type, NONE); 158 159 if (strstr("None", authtype)) 160 return 1; 161 #ifdef CANSRP 162 else if (strstr("SRP", authtype)) 163 return srp_main_loop(conn, auth, in_buf, out_buf, 164 &in_length, out_length); 165 #endif 166 else if (strstr("CHAP", authtype)) 167 return chap_main_loop(conn, auth, in_buf, out_buf, 168 &in_length, out_length); 169 else if (strstr("SPKM1", authtype)) 170 return 2; 171 else if (strstr("SPKM2", authtype)) 172 return 2; 173 else if (strstr("KRB5", authtype)) 174 return 2; 175 else 176 return 2; 177 } 178 179 static void iscsi_remove_failed_auth_entry(struct iscsi_conn *conn) 180 { 181 kfree(conn->auth_protocol); 182 } 183 184 int iscsi_target_check_login_request( 185 struct iscsi_conn *conn, 186 struct iscsi_login *login) 187 { 188 int req_csg, req_nsg; 189 u32 payload_length; 190 struct iscsi_login_req *login_req; 191 192 login_req = (struct iscsi_login_req *) login->req; 193 payload_length = ntoh24(login_req->dlength); 194 195 switch (login_req->opcode & ISCSI_OPCODE_MASK) { 196 case ISCSI_OP_LOGIN: 197 break; 198 default: 199 pr_err("Received unknown opcode 0x%02x.\n", 200 login_req->opcode & ISCSI_OPCODE_MASK); 201 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 202 ISCSI_LOGIN_STATUS_INIT_ERR); 203 return -1; 204 } 205 206 if ((login_req->flags & ISCSI_FLAG_LOGIN_CONTINUE) && 207 (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) { 208 pr_err("Login request has both ISCSI_FLAG_LOGIN_CONTINUE" 209 " and ISCSI_FLAG_LOGIN_TRANSIT set, protocol error.\n"); 210 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 211 ISCSI_LOGIN_STATUS_INIT_ERR); 212 return -1; 213 } 214 215 req_csg = ISCSI_LOGIN_CURRENT_STAGE(login_req->flags); 216 req_nsg = ISCSI_LOGIN_NEXT_STAGE(login_req->flags); 217 218 if (req_csg != login->current_stage) { 219 pr_err("Initiator unexpectedly changed login stage" 220 " from %d to %d, login failed.\n", login->current_stage, 221 req_csg); 222 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 223 ISCSI_LOGIN_STATUS_INIT_ERR); 224 return -1; 225 } 226 227 if ((req_nsg == 2) || (req_csg >= 2) || 228 ((login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT) && 229 (req_nsg <= req_csg))) { 230 pr_err("Illegal login_req->flags Combination, CSG: %d," 231 " NSG: %d, ISCSI_FLAG_LOGIN_TRANSIT: %d.\n", req_csg, 232 req_nsg, (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)); 233 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 234 ISCSI_LOGIN_STATUS_INIT_ERR); 235 return -1; 236 } 237 238 if ((login_req->max_version != login->version_max) || 239 (login_req->min_version != login->version_min)) { 240 pr_err("Login request changed Version Max/Nin" 241 " unexpectedly to 0x%02x/0x%02x, protocol error\n", 242 login_req->max_version, login_req->min_version); 243 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 244 ISCSI_LOGIN_STATUS_INIT_ERR); 245 return -1; 246 } 247 248 if (memcmp(login_req->isid, login->isid, 6) != 0) { 249 pr_err("Login request changed ISID unexpectedly," 250 " protocol error.\n"); 251 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 252 ISCSI_LOGIN_STATUS_INIT_ERR); 253 return -1; 254 } 255 256 if (login_req->itt != login->init_task_tag) { 257 pr_err("Login request changed ITT unexpectedly to" 258 " 0x%08x, protocol error.\n", login_req->itt); 259 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 260 ISCSI_LOGIN_STATUS_INIT_ERR); 261 return -1; 262 } 263 264 if (payload_length > MAX_KEY_VALUE_PAIRS) { 265 pr_err("Login request payload exceeds default" 266 " MaxRecvDataSegmentLength: %u, protocol error.\n", 267 MAX_KEY_VALUE_PAIRS); 268 return -1; 269 } 270 271 return 0; 272 } 273 274 static int iscsi_target_check_first_request( 275 struct iscsi_conn *conn, 276 struct iscsi_login *login) 277 { 278 struct iscsi_param *param = NULL; 279 struct se_node_acl *se_nacl; 280 281 login->first_request = 0; 282 283 list_for_each_entry(param, &conn->param_list->param_list, p_list) { 284 if (!strncmp(param->name, SESSIONTYPE, 11)) { 285 if (!IS_PSTATE_ACCEPTOR(param)) { 286 pr_err("SessionType key not received" 287 " in first login request.\n"); 288 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 289 ISCSI_LOGIN_STATUS_MISSING_FIELDS); 290 return -1; 291 } 292 if (!strncmp(param->value, DISCOVERY, 9)) 293 return 0; 294 } 295 296 if (!strncmp(param->name, INITIATORNAME, 13)) { 297 if (!IS_PSTATE_ACCEPTOR(param)) { 298 if (!login->leading_connection) 299 continue; 300 301 pr_err("InitiatorName key not received" 302 " in first login request.\n"); 303 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 304 ISCSI_LOGIN_STATUS_MISSING_FIELDS); 305 return -1; 306 } 307 308 /* 309 * For non-leading connections, double check that the 310 * received InitiatorName matches the existing session's 311 * struct iscsi_node_acl. 312 */ 313 if (!login->leading_connection) { 314 se_nacl = conn->sess->se_sess->se_node_acl; 315 if (!se_nacl) { 316 pr_err("Unable to locate" 317 " struct se_node_acl\n"); 318 iscsit_tx_login_rsp(conn, 319 ISCSI_STATUS_CLS_INITIATOR_ERR, 320 ISCSI_LOGIN_STATUS_TGT_NOT_FOUND); 321 return -1; 322 } 323 324 if (strcmp(param->value, 325 se_nacl->initiatorname)) { 326 pr_err("Incorrect" 327 " InitiatorName: %s for this" 328 " iSCSI Initiator Node.\n", 329 param->value); 330 iscsit_tx_login_rsp(conn, 331 ISCSI_STATUS_CLS_INITIATOR_ERR, 332 ISCSI_LOGIN_STATUS_TGT_NOT_FOUND); 333 return -1; 334 } 335 } 336 } 337 } 338 339 return 0; 340 } 341 342 static int iscsi_target_do_tx_login_io(struct iscsi_conn *conn, struct iscsi_login *login) 343 { 344 u32 padding = 0; 345 struct iscsi_session *sess = conn->sess; 346 struct iscsi_login_rsp *login_rsp; 347 348 login_rsp = (struct iscsi_login_rsp *) login->rsp; 349 350 login_rsp->opcode = ISCSI_OP_LOGIN_RSP; 351 hton24(login_rsp->dlength, login->rsp_length); 352 memcpy(login_rsp->isid, login->isid, 6); 353 login_rsp->tsih = cpu_to_be16(login->tsih); 354 login_rsp->itt = login->init_task_tag; 355 login_rsp->statsn = cpu_to_be32(conn->stat_sn++); 356 login_rsp->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 357 login_rsp->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 358 359 pr_debug("Sending Login Response, Flags: 0x%02x, ITT: 0x%08x," 360 " ExpCmdSN; 0x%08x, MaxCmdSN: 0x%08x, StatSN: 0x%08x, Length:" 361 " %u\n", login_rsp->flags, (__force u32)login_rsp->itt, 362 ntohl(login_rsp->exp_cmdsn), ntohl(login_rsp->max_cmdsn), 363 ntohl(login_rsp->statsn), login->rsp_length); 364 365 padding = ((-login->rsp_length) & 3); 366 367 if (conn->conn_transport->iscsit_put_login_tx(conn, login, 368 login->rsp_length + padding) < 0) 369 return -1; 370 371 login->rsp_length = 0; 372 mutex_lock(&sess->cmdsn_mutex); 373 login_rsp->exp_cmdsn = cpu_to_be32(sess->exp_cmd_sn); 374 login_rsp->max_cmdsn = cpu_to_be32(sess->max_cmd_sn); 375 mutex_unlock(&sess->cmdsn_mutex); 376 377 return 0; 378 } 379 380 static int iscsi_target_do_login_io(struct iscsi_conn *conn, struct iscsi_login *login) 381 { 382 if (iscsi_target_do_tx_login_io(conn, login) < 0) 383 return -1; 384 385 if (conn->conn_transport->iscsit_get_login_rx(conn, login) < 0) 386 return -1; 387 388 return 0; 389 } 390 391 /* 392 * NOTE: We check for existing sessions or connections AFTER the initiator 393 * has been successfully authenticated in order to protect against faked 394 * ISID/TSIH combinations. 395 */ 396 static int iscsi_target_check_for_existing_instances( 397 struct iscsi_conn *conn, 398 struct iscsi_login *login) 399 { 400 if (login->checked_for_existing) 401 return 0; 402 403 login->checked_for_existing = 1; 404 405 if (!login->tsih) 406 return iscsi_check_for_session_reinstatement(conn); 407 else 408 return iscsi_login_post_auth_non_zero_tsih(conn, login->cid, 409 login->initial_exp_statsn); 410 } 411 412 static int iscsi_target_do_authentication( 413 struct iscsi_conn *conn, 414 struct iscsi_login *login) 415 { 416 int authret; 417 u32 payload_length; 418 struct iscsi_param *param; 419 struct iscsi_login_req *login_req; 420 struct iscsi_login_rsp *login_rsp; 421 422 login_req = (struct iscsi_login_req *) login->req; 423 login_rsp = (struct iscsi_login_rsp *) login->rsp; 424 payload_length = ntoh24(login_req->dlength); 425 426 param = iscsi_find_param_from_key(AUTHMETHOD, conn->param_list); 427 if (!param) 428 return -1; 429 430 authret = iscsi_handle_authentication( 431 conn, 432 login->req_buf, 433 login->rsp_buf, 434 payload_length, 435 &login->rsp_length, 436 param->value); 437 switch (authret) { 438 case 0: 439 pr_debug("Received OK response" 440 " from LIO Authentication, continuing.\n"); 441 break; 442 case 1: 443 pr_debug("iSCSI security negotiation" 444 " completed successfully.\n"); 445 login->auth_complete = 1; 446 if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE1) && 447 (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) { 448 login_rsp->flags |= (ISCSI_FLAG_LOGIN_NEXT_STAGE1 | 449 ISCSI_FLAG_LOGIN_TRANSIT); 450 login->current_stage = 1; 451 } 452 return iscsi_target_check_for_existing_instances( 453 conn, login); 454 case 2: 455 pr_err("Security negotiation" 456 " failed.\n"); 457 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 458 ISCSI_LOGIN_STATUS_AUTH_FAILED); 459 return -1; 460 default: 461 pr_err("Received unknown error %d from LIO" 462 " Authentication\n", authret); 463 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 464 ISCSI_LOGIN_STATUS_TARGET_ERROR); 465 return -1; 466 } 467 468 return 0; 469 } 470 471 static int iscsi_target_handle_csg_zero( 472 struct iscsi_conn *conn, 473 struct iscsi_login *login) 474 { 475 int ret; 476 u32 payload_length; 477 struct iscsi_param *param; 478 struct iscsi_login_req *login_req; 479 struct iscsi_login_rsp *login_rsp; 480 481 login_req = (struct iscsi_login_req *) login->req; 482 login_rsp = (struct iscsi_login_rsp *) login->rsp; 483 payload_length = ntoh24(login_req->dlength); 484 485 param = iscsi_find_param_from_key(AUTHMETHOD, conn->param_list); 486 if (!param) 487 return -1; 488 489 ret = iscsi_decode_text_input( 490 PHASE_SECURITY|PHASE_DECLARATIVE, 491 SENDER_INITIATOR|SENDER_RECEIVER, 492 login->req_buf, 493 payload_length, 494 conn); 495 if (ret < 0) 496 return -1; 497 498 if (ret > 0) { 499 if (login->auth_complete) { 500 pr_err("Initiator has already been" 501 " successfully authenticated, but is still" 502 " sending %s keys.\n", param->value); 503 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 504 ISCSI_LOGIN_STATUS_INIT_ERR); 505 return -1; 506 } 507 508 goto do_auth; 509 } 510 511 if (login->first_request) 512 if (iscsi_target_check_first_request(conn, login) < 0) 513 return -1; 514 515 ret = iscsi_encode_text_output( 516 PHASE_SECURITY|PHASE_DECLARATIVE, 517 SENDER_TARGET, 518 login->rsp_buf, 519 &login->rsp_length, 520 conn->param_list); 521 if (ret < 0) 522 return -1; 523 524 if (!iscsi_check_negotiated_keys(conn->param_list)) { 525 if (ISCSI_TPG_ATTRIB(ISCSI_TPG_C(conn))->authentication && 526 !strncmp(param->value, NONE, 4)) { 527 pr_err("Initiator sent AuthMethod=None but" 528 " Target is enforcing iSCSI Authentication," 529 " login failed.\n"); 530 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 531 ISCSI_LOGIN_STATUS_AUTH_FAILED); 532 return -1; 533 } 534 535 if (ISCSI_TPG_ATTRIB(ISCSI_TPG_C(conn))->authentication && 536 !login->auth_complete) 537 return 0; 538 539 if (strncmp(param->value, NONE, 4) && !login->auth_complete) 540 return 0; 541 542 if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE1) && 543 (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) { 544 login_rsp->flags |= ISCSI_FLAG_LOGIN_NEXT_STAGE1 | 545 ISCSI_FLAG_LOGIN_TRANSIT; 546 login->current_stage = 1; 547 } 548 } 549 550 return 0; 551 do_auth: 552 return iscsi_target_do_authentication(conn, login); 553 } 554 555 static int iscsi_target_handle_csg_one(struct iscsi_conn *conn, struct iscsi_login *login) 556 { 557 int ret; 558 u32 payload_length; 559 struct iscsi_login_req *login_req; 560 struct iscsi_login_rsp *login_rsp; 561 562 login_req = (struct iscsi_login_req *) login->req; 563 login_rsp = (struct iscsi_login_rsp *) login->rsp; 564 payload_length = ntoh24(login_req->dlength); 565 566 ret = iscsi_decode_text_input( 567 PHASE_OPERATIONAL|PHASE_DECLARATIVE, 568 SENDER_INITIATOR|SENDER_RECEIVER, 569 login->req_buf, 570 payload_length, 571 conn); 572 if (ret < 0) { 573 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 574 ISCSI_LOGIN_STATUS_INIT_ERR); 575 return -1; 576 } 577 578 if (login->first_request) 579 if (iscsi_target_check_first_request(conn, login) < 0) 580 return -1; 581 582 if (iscsi_target_check_for_existing_instances(conn, login) < 0) 583 return -1; 584 585 ret = iscsi_encode_text_output( 586 PHASE_OPERATIONAL|PHASE_DECLARATIVE, 587 SENDER_TARGET, 588 login->rsp_buf, 589 &login->rsp_length, 590 conn->param_list); 591 if (ret < 0) { 592 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 593 ISCSI_LOGIN_STATUS_INIT_ERR); 594 return -1; 595 } 596 597 if (!login->auth_complete && 598 ISCSI_TPG_ATTRIB(ISCSI_TPG_C(conn))->authentication) { 599 pr_err("Initiator is requesting CSG: 1, has not been" 600 " successfully authenticated, and the Target is" 601 " enforcing iSCSI Authentication, login failed.\n"); 602 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 603 ISCSI_LOGIN_STATUS_AUTH_FAILED); 604 return -1; 605 } 606 607 if (!iscsi_check_negotiated_keys(conn->param_list)) 608 if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE3) && 609 (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) 610 login_rsp->flags |= ISCSI_FLAG_LOGIN_NEXT_STAGE3 | 611 ISCSI_FLAG_LOGIN_TRANSIT; 612 613 return 0; 614 } 615 616 static int iscsi_target_do_login(struct iscsi_conn *conn, struct iscsi_login *login) 617 { 618 int pdu_count = 0; 619 struct iscsi_login_req *login_req; 620 struct iscsi_login_rsp *login_rsp; 621 622 login_req = (struct iscsi_login_req *) login->req; 623 login_rsp = (struct iscsi_login_rsp *) login->rsp; 624 625 while (1) { 626 if (++pdu_count > MAX_LOGIN_PDUS) { 627 pr_err("MAX_LOGIN_PDUS count reached.\n"); 628 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 629 ISCSI_LOGIN_STATUS_TARGET_ERROR); 630 return -1; 631 } 632 633 switch (ISCSI_LOGIN_CURRENT_STAGE(login_req->flags)) { 634 case 0: 635 login_rsp->flags &= ~ISCSI_FLAG_LOGIN_CURRENT_STAGE_MASK; 636 if (iscsi_target_handle_csg_zero(conn, login) < 0) 637 return -1; 638 break; 639 case 1: 640 login_rsp->flags |= ISCSI_FLAG_LOGIN_CURRENT_STAGE1; 641 if (iscsi_target_handle_csg_one(conn, login) < 0) 642 return -1; 643 if (login_rsp->flags & ISCSI_FLAG_LOGIN_TRANSIT) { 644 login->tsih = conn->sess->tsih; 645 login->login_complete = 1; 646 if (iscsi_target_do_tx_login_io(conn, 647 login) < 0) 648 return -1; 649 return 0; 650 } 651 break; 652 default: 653 pr_err("Illegal CSG: %d received from" 654 " Initiator, protocol error.\n", 655 ISCSI_LOGIN_CURRENT_STAGE(login_req->flags)); 656 break; 657 } 658 659 if (iscsi_target_do_login_io(conn, login) < 0) 660 return -1; 661 662 if (login_rsp->flags & ISCSI_FLAG_LOGIN_TRANSIT) { 663 login_rsp->flags &= ~ISCSI_FLAG_LOGIN_TRANSIT; 664 login_rsp->flags &= ~ISCSI_FLAG_LOGIN_NEXT_STAGE_MASK; 665 } 666 } 667 668 return 0; 669 } 670 671 static void iscsi_initiatorname_tolower( 672 char *param_buf) 673 { 674 char *c; 675 u32 iqn_size = strlen(param_buf), i; 676 677 for (i = 0; i < iqn_size; i++) { 678 c = ¶m_buf[i]; 679 if (!isupper(*c)) 680 continue; 681 682 *c = tolower(*c); 683 } 684 } 685 686 /* 687 * Processes the first Login Request.. 688 */ 689 int iscsi_target_locate_portal( 690 struct iscsi_np *np, 691 struct iscsi_conn *conn, 692 struct iscsi_login *login) 693 { 694 char *i_buf = NULL, *s_buf = NULL, *t_buf = NULL; 695 char *tmpbuf, *start = NULL, *end = NULL, *key, *value; 696 struct iscsi_session *sess = conn->sess; 697 struct iscsi_tiqn *tiqn; 698 struct iscsi_login_req *login_req; 699 u32 payload_length; 700 int sessiontype = 0, ret = 0; 701 702 login_req = (struct iscsi_login_req *) login->req; 703 payload_length = ntoh24(login_req->dlength); 704 705 tmpbuf = kzalloc(payload_length + 1, GFP_KERNEL); 706 if (!tmpbuf) { 707 pr_err("Unable to allocate memory for tmpbuf.\n"); 708 return -1; 709 } 710 711 memcpy(tmpbuf, login->req_buf, payload_length); 712 tmpbuf[payload_length] = '\0'; 713 start = tmpbuf; 714 end = (start + payload_length); 715 716 /* 717 * Locate the initial keys expected from the Initiator node in 718 * the first login request in order to progress with the login phase. 719 */ 720 while (start < end) { 721 if (iscsi_extract_key_value(start, &key, &value) < 0) { 722 ret = -1; 723 goto out; 724 } 725 726 if (!strncmp(key, "InitiatorName", 13)) 727 i_buf = value; 728 else if (!strncmp(key, "SessionType", 11)) 729 s_buf = value; 730 else if (!strncmp(key, "TargetName", 10)) 731 t_buf = value; 732 733 start += strlen(key) + strlen(value) + 2; 734 } 735 /* 736 * See 5.3. Login Phase. 737 */ 738 if (!i_buf) { 739 pr_err("InitiatorName key not received" 740 " in first login request.\n"); 741 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 742 ISCSI_LOGIN_STATUS_MISSING_FIELDS); 743 ret = -1; 744 goto out; 745 } 746 /* 747 * Convert the incoming InitiatorName to lowercase following 748 * RFC-3720 3.2.6.1. section c) that says that iSCSI IQNs 749 * are NOT case sensitive. 750 */ 751 iscsi_initiatorname_tolower(i_buf); 752 753 if (!s_buf) { 754 if (!login->leading_connection) 755 goto get_target; 756 757 pr_err("SessionType key not received" 758 " in first login request.\n"); 759 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 760 ISCSI_LOGIN_STATUS_MISSING_FIELDS); 761 ret = -1; 762 goto out; 763 } 764 765 /* 766 * Use default portal group for discovery sessions. 767 */ 768 sessiontype = strncmp(s_buf, DISCOVERY, 9); 769 if (!sessiontype) { 770 conn->tpg = iscsit_global->discovery_tpg; 771 if (!login->leading_connection) 772 goto get_target; 773 774 sess->sess_ops->SessionType = 1; 775 /* 776 * Setup crc32c modules from libcrypto 777 */ 778 if (iscsi_login_setup_crypto(conn) < 0) { 779 pr_err("iscsi_login_setup_crypto() failed\n"); 780 ret = -1; 781 goto out; 782 } 783 /* 784 * Serialize access across the discovery struct iscsi_portal_group to 785 * process login attempt. 786 */ 787 if (iscsit_access_np(np, conn->tpg) < 0) { 788 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 789 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE); 790 ret = -1; 791 goto out; 792 } 793 ret = 0; 794 goto out; 795 } 796 797 get_target: 798 if (!t_buf) { 799 pr_err("TargetName key not received" 800 " in first login request while" 801 " SessionType=Normal.\n"); 802 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 803 ISCSI_LOGIN_STATUS_MISSING_FIELDS); 804 ret = -1; 805 goto out; 806 } 807 808 /* 809 * Locate Target IQN from Storage Node. 810 */ 811 tiqn = iscsit_get_tiqn_for_login(t_buf); 812 if (!tiqn) { 813 pr_err("Unable to locate Target IQN: %s in" 814 " Storage Node\n", t_buf); 815 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 816 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE); 817 ret = -1; 818 goto out; 819 } 820 pr_debug("Located Storage Object: %s\n", tiqn->tiqn); 821 822 /* 823 * Locate Target Portal Group from Storage Node. 824 */ 825 conn->tpg = iscsit_get_tpg_from_np(tiqn, np); 826 if (!conn->tpg) { 827 pr_err("Unable to locate Target Portal Group" 828 " on %s\n", tiqn->tiqn); 829 iscsit_put_tiqn_for_login(tiqn); 830 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 831 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE); 832 ret = -1; 833 goto out; 834 } 835 pr_debug("Located Portal Group Object: %hu\n", conn->tpg->tpgt); 836 /* 837 * Setup crc32c modules from libcrypto 838 */ 839 if (iscsi_login_setup_crypto(conn) < 0) { 840 pr_err("iscsi_login_setup_crypto() failed\n"); 841 ret = -1; 842 goto out; 843 } 844 /* 845 * Serialize access across the struct iscsi_portal_group to 846 * process login attempt. 847 */ 848 if (iscsit_access_np(np, conn->tpg) < 0) { 849 iscsit_put_tiqn_for_login(tiqn); 850 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 851 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE); 852 ret = -1; 853 conn->tpg = NULL; 854 goto out; 855 } 856 857 /* 858 * conn->sess->node_acl will be set when the referenced 859 * struct iscsi_session is located from received ISID+TSIH in 860 * iscsi_login_non_zero_tsih_s2(). 861 */ 862 if (!login->leading_connection) { 863 ret = 0; 864 goto out; 865 } 866 867 /* 868 * This value is required in iscsi_login_zero_tsih_s2() 869 */ 870 sess->sess_ops->SessionType = 0; 871 872 /* 873 * Locate incoming Initiator IQN reference from Storage Node. 874 */ 875 sess->se_sess->se_node_acl = core_tpg_check_initiator_node_acl( 876 &conn->tpg->tpg_se_tpg, i_buf); 877 if (!sess->se_sess->se_node_acl) { 878 pr_err("iSCSI Initiator Node: %s is not authorized to" 879 " access iSCSI target portal group: %hu.\n", 880 i_buf, conn->tpg->tpgt); 881 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR, 882 ISCSI_LOGIN_STATUS_TGT_FORBIDDEN); 883 ret = -1; 884 goto out; 885 } 886 887 ret = 0; 888 out: 889 kfree(tmpbuf); 890 return ret; 891 } 892 893 int iscsi_target_start_negotiation( 894 struct iscsi_login *login, 895 struct iscsi_conn *conn) 896 { 897 int ret; 898 899 ret = iscsi_target_do_login(conn, login); 900 if (ret != 0) 901 iscsi_remove_failed_auth_entry(conn); 902 903 iscsi_target_nego_release(conn); 904 return ret; 905 } 906 907 void iscsi_target_nego_release(struct iscsi_conn *conn) 908 { 909 struct iscsi_login *login = conn->conn_login; 910 911 if (!login) 912 return; 913 914 kfree(login->req_buf); 915 kfree(login->rsp_buf); 916 kfree(login); 917 918 conn->conn_login = NULL; 919 } 920