drivers/target/iscsi/iscsi_target_nego.c

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