fs/cifs/sess.c

   1 /*
   2  *   fs/cifs/sess.c
   3  *
   4  *   SMB/CIFS session setup handling routines
   5  *
   6  *   Copyright (c) International Business Machines  Corp., 2006, 2009
   7  *   Author(s): Steve French (sfrench@us.ibm.com)
   8  *
   9  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 #include "cifspdu.h"
  25 #include "cifsglob.h"
  26 #include "cifsproto.h"
  27 #include "cifs_unicode.h"
  28 #include "cifs_debug.h"
  29 #include "ntlmssp.h"
  30 #include "nterr.h"
  31 #include <linux/utsname.h>
  32 #include <linux/slab.h>
  33 #include "cifs_spnego.h"
  34
  35 static __u32 cifs_ssetup_hdr(struct cifs_ses *ses, SESSION_SETUP_ANDX *pSMB)
  36 {
  37         __u32 capabilities = 0;
  38
  39         /* init fields common to all four types of SessSetup */
  40         /* Note that offsets for first seven fields in req struct are same  */
  41         /*      in CIFS Specs so does not matter which of 3 forms of struct */
  42         /*      that we use in next few lines                               */
  43         /* Note that header is initialized to zero in header_assemble */
  44         pSMB->req.AndXCommand = 0xFF;
  45         pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32,
  46                                         CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4,
  47                                         USHRT_MAX));
  48         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
  49         pSMB->req.VcNumber = __constant_cpu_to_le16(1);
  50
  51         /* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
  52
  53         /* BB verify whether signing required on neg or just on auth frame
  54            (and NTLM case) */
  55
  56         capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
  57                         CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
  58
  59         if (ses->server->sign)
  60                 pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
  61
  62         if (ses->capabilities & CAP_UNICODE) {
  63                 pSMB->req.hdr.Flags2 |= SMBFLG2_UNICODE;
  64                 capabilities |= CAP_UNICODE;
  65         }
  66         if (ses->capabilities & CAP_STATUS32) {
  67                 pSMB->req.hdr.Flags2 |= SMBFLG2_ERR_STATUS;
  68                 capabilities |= CAP_STATUS32;
  69         }
  70         if (ses->capabilities & CAP_DFS) {
  71                 pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
  72                 capabilities |= CAP_DFS;
  73         }
  74         if (ses->capabilities & CAP_UNIX)
  75                 capabilities |= CAP_UNIX;
  76
  77         return capabilities;
  78 }
  79
  80 static void
  81 unicode_oslm_strings(char **pbcc_area, const struct nls_table *nls_cp)
  82 {
  83         char *bcc_ptr = *pbcc_area;
  84         int bytes_ret = 0;
  85
  86         /* Copy OS version */
  87         bytes_ret = cifs_strtoUTF16((__le16 *)bcc_ptr, "Linux version ", 32,
  88                                     nls_cp);
  89         bcc_ptr += 2 * bytes_ret;
  90         bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, init_utsname()->release,
  91                                     32, nls_cp);
  92         bcc_ptr += 2 * bytes_ret;
  93         bcc_ptr += 2; /* trailing null */
  94
  95         bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
  96                                     32, nls_cp);
  97         bcc_ptr += 2 * bytes_ret;
  98         bcc_ptr += 2; /* trailing null */
  99
 100         *pbcc_area = bcc_ptr;
 101 }
 102
 103 static void unicode_domain_string(char **pbcc_area, struct cifs_ses *ses,
 104                                    const struct nls_table *nls_cp)
 105 {
 106         char *bcc_ptr = *pbcc_area;
 107         int bytes_ret = 0;
 108
 109         /* copy domain */
 110         if (ses->domainName == NULL) {
 111                 /* Sending null domain better than using a bogus domain name (as
 112                 we did briefly in 2.6.18) since server will use its default */
 113                 *bcc_ptr = 0;
 114                 *(bcc_ptr+1) = 0;
 115                 bytes_ret = 0;
 116         } else
 117                 bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->domainName,
 118                                             CIFS_MAX_DOMAINNAME_LEN, nls_cp);
 119         bcc_ptr += 2 * bytes_ret;
 120         bcc_ptr += 2;  /* account for null terminator */
 121
 122         *pbcc_area = bcc_ptr;
 123 }
 124
 125
 126 static void unicode_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 127                                    const struct nls_table *nls_cp)
 128 {
 129         char *bcc_ptr = *pbcc_area;
 130         int bytes_ret = 0;
 131
 132         /* BB FIXME add check that strings total less
 133         than 335 or will need to send them as arrays */
 134
 135         /* unicode strings, must be word aligned before the call */
 136 /*      if ((long) bcc_ptr % 2) {
 137                 *bcc_ptr = 0;
 138                 bcc_ptr++;
 139         } */
 140         /* copy user */
 141         if (ses->user_name == NULL) {
 142                 /* null user mount */
 143                 *bcc_ptr = 0;
 144                 *(bcc_ptr+1) = 0;
 145         } else {
 146                 bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->user_name,
 147                                             CIFS_MAX_USERNAME_LEN, nls_cp);
 148         }
 149         bcc_ptr += 2 * bytes_ret;
 150         bcc_ptr += 2; /* account for null termination */
 151
 152         unicode_domain_string(&bcc_ptr, ses, nls_cp);
 153         unicode_oslm_strings(&bcc_ptr, nls_cp);
 154
 155         *pbcc_area = bcc_ptr;
 156 }
 157
 158 static void ascii_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 159                                  const struct nls_table *nls_cp)
 160 {
 161         char *bcc_ptr = *pbcc_area;
 162
 163         /* copy user */
 164         /* BB what about null user mounts - check that we do this BB */
 165         /* copy user */
 166         if (ses->user_name != NULL) {
 167                 strncpy(bcc_ptr, ses->user_name, CIFS_MAX_USERNAME_LEN);
 168                 bcc_ptr += strnlen(ses->user_name, CIFS_MAX_USERNAME_LEN);
 169         }
 170         /* else null user mount */
 171         *bcc_ptr = 0;
 172         bcc_ptr++; /* account for null termination */
 173
 174         /* copy domain */
 175         if (ses->domainName != NULL) {
 176                 strncpy(bcc_ptr, ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
 177                 bcc_ptr += strnlen(ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
 178         } /* else we will send a null domain name
 179              so the server will default to its own domain */
 180         *bcc_ptr = 0;
 181         bcc_ptr++;
 182
 183         /* BB check for overflow here */
 184
 185         strcpy(bcc_ptr, "Linux version ");
 186         bcc_ptr += strlen("Linux version ");
 187         strcpy(bcc_ptr, init_utsname()->release);
 188         bcc_ptr += strlen(init_utsname()->release) + 1;
 189
 190         strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
 191         bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
 192
 193         *pbcc_area = bcc_ptr;
 194 }
 195
 196 static void
 197 decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
 198                       const struct nls_table *nls_cp)
 199 {
 200         int len;
 201         char *data = *pbcc_area;
 202
 203         cifs_dbg(FYI, "bleft %d\n", bleft);
 204
 205         kfree(ses->serverOS);
 206         ses->serverOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 207         cifs_dbg(FYI, "serverOS=%s\n", ses->serverOS);
 208         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 209         data += len;
 210         bleft -= len;
 211         if (bleft <= 0)
 212                 return;
 213
 214         kfree(ses->serverNOS);
 215         ses->serverNOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 216         cifs_dbg(FYI, "serverNOS=%s\n", ses->serverNOS);
 217         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 218         data += len;
 219         bleft -= len;
 220         if (bleft <= 0)
 221                 return;
 222
 223         kfree(ses->serverDomain);
 224         ses->serverDomain = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 225         cifs_dbg(FYI, "serverDomain=%s\n", ses->serverDomain);
 226
 227         return;
 228 }
 229
 230 static void decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
 231                                 struct cifs_ses *ses,
 232                                 const struct nls_table *nls_cp)
 233 {
 234         int len;
 235         char *bcc_ptr = *pbcc_area;
 236
 237         cifs_dbg(FYI, "decode sessetup ascii. bleft %d\n", bleft);
 238
 239         len = strnlen(bcc_ptr, bleft);
 240         if (len >= bleft)
 241                 return;
 242
 243         kfree(ses->serverOS);
 244
 245         ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
 246         if (ses->serverOS)
 247                 strncpy(ses->serverOS, bcc_ptr, len);
 248         if (strncmp(ses->serverOS, "OS/2", 4) == 0)
 249                 cifs_dbg(FYI, "OS/2 server\n");
 250
 251         bcc_ptr += len + 1;
 252         bleft -= len + 1;
 253
 254         len = strnlen(bcc_ptr, bleft);
 255         if (len >= bleft)
 256                 return;
 257
 258         kfree(ses->serverNOS);
 259
 260         ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
 261         if (ses->serverNOS)
 262                 strncpy(ses->serverNOS, bcc_ptr, len);
 263
 264         bcc_ptr += len + 1;
 265         bleft -= len + 1;
 266
 267         len = strnlen(bcc_ptr, bleft);
 268         if (len > bleft)
 269                 return;
 270
 271         /* No domain field in LANMAN case. Domain is
 272            returned by old servers in the SMB negprot response */
 273         /* BB For newer servers which do not support Unicode,
 274            but thus do return domain here we could add parsing
 275            for it later, but it is not very important */
 276         cifs_dbg(FYI, "ascii: bytes left %d\n", bleft);
 277 }
 278
 279 int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
 280                                     struct cifs_ses *ses)
 281 {
 282         unsigned int tioffset; /* challenge message target info area */
 283         unsigned int tilen; /* challenge message target info area length  */
 284
 285         CHALLENGE_MESSAGE *pblob = (CHALLENGE_MESSAGE *)bcc_ptr;
 286
 287         if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
 288                 cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);
 289                 return -EINVAL;
 290         }
 291
 292         if (memcmp(pblob->Signature, "NTLMSSP", 8)) {
 293                 cifs_dbg(VFS, "blob signature incorrect %s\n",
 294                          pblob->Signature);
 295                 return -EINVAL;
 296         }
 297         if (pblob->MessageType != NtLmChallenge) {
 298                 cifs_dbg(VFS, "Incorrect message type %d\n",
 299                          pblob->MessageType);
 300                 return -EINVAL;
 301         }
 302
 303         memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);
 304         /* BB we could decode pblob->NegotiateFlags; some may be useful */
 305         /* In particular we can examine sign flags */
 306         /* BB spec says that if AvId field of MsvAvTimestamp is populated then
 307                 we must set the MIC field of the AUTHENTICATE_MESSAGE */
 308         ses->ntlmssp->server_flags = le32_to_cpu(pblob->NegotiateFlags);
 309         tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
 310         tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
 311         if (tioffset > blob_len || tioffset + tilen > blob_len) {
 312                 cifs_dbg(VFS, "tioffset + tilen too high %u + %u",
 313                         tioffset, tilen);
 314                 return -EINVAL;
 315         }
 316         if (tilen) {
 317                 ses->auth_key.response = kmemdup(bcc_ptr + tioffset, tilen,
 318                                                  GFP_KERNEL);
 319                 if (!ses->auth_key.response) {
 320                         cifs_dbg(VFS, "Challenge target info alloc failure");
 321                         return -ENOMEM;
 322                 }
 323                 ses->auth_key.len = tilen;
 324         }
 325
 326         return 0;
 327 }
 328
 329 /* BB Move to ntlmssp.c eventually */
 330
 331 /* We do not malloc the blob, it is passed in pbuffer, because
 332    it is fixed size, and small, making this approach cleaner */
 333 void build_ntlmssp_negotiate_blob(unsigned char *pbuffer,
 334                                          struct cifs_ses *ses)
 335 {
 336         NEGOTIATE_MESSAGE *sec_blob = (NEGOTIATE_MESSAGE *)pbuffer;
 337         __u32 flags;
 338
 339         memset(pbuffer, 0, sizeof(NEGOTIATE_MESSAGE));
 340         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 341         sec_blob->MessageType = NtLmNegotiate;
 342
 343         /* BB is NTLMV2 session security format easier to use here? */
 344         flags = NTLMSSP_NEGOTIATE_56 |  NTLMSSP_REQUEST_TARGET |
 345                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 346                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC;
 347         if (ses->server->sign) {
 348                 flags |= NTLMSSP_NEGOTIATE_SIGN;
 349                 if (!ses->server->session_estab ||
 350                                 ses->ntlmssp->sesskey_per_smbsess)
 351                         flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 352         }
 353
 354         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 355
 356         sec_blob->WorkstationName.BufferOffset = 0;
 357         sec_blob->WorkstationName.Length = 0;
 358         sec_blob->WorkstationName.MaximumLength = 0;
 359
 360         /* Domain name is sent on the Challenge not Negotiate NTLMSSP request */
 361         sec_blob->DomainName.BufferOffset = 0;
 362         sec_blob->DomainName.Length = 0;
 363         sec_blob->DomainName.MaximumLength = 0;
 364 }
 365
 366 /* We do not malloc the blob, it is passed in pbuffer, because its
 367    maximum possible size is fixed and small, making this approach cleaner.
 368    This function returns the length of the data in the blob */
 369 int build_ntlmssp_auth_blob(unsigned char *pbuffer,
 370                                         u16 *buflen,
 371                                    struct cifs_ses *ses,
 372                                    const struct nls_table *nls_cp)
 373 {
 374         int rc;
 375         AUTHENTICATE_MESSAGE *sec_blob = (AUTHENTICATE_MESSAGE *)pbuffer;
 376         __u32 flags;
 377         unsigned char *tmp;
 378
 379         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 380         sec_blob->MessageType = NtLmAuthenticate;
 381
 382         flags = NTLMSSP_NEGOTIATE_56 |
 383                 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_TARGET_INFO |
 384                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 385                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC;
 386         if (ses->server->sign) {
 387                 flags |= NTLMSSP_NEGOTIATE_SIGN;
 388                 if (!ses->server->session_estab ||
 389                                 ses->ntlmssp->sesskey_per_smbsess)
 390                         flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 391         }
 392
 393         tmp = pbuffer + sizeof(AUTHENTICATE_MESSAGE);
 394         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 395
 396         sec_blob->LmChallengeResponse.BufferOffset =
 397                                 cpu_to_le32(sizeof(AUTHENTICATE_MESSAGE));
 398         sec_blob->LmChallengeResponse.Length = 0;
 399         sec_blob->LmChallengeResponse.MaximumLength = 0;
 400
 401         sec_blob->NtChallengeResponse.BufferOffset = cpu_to_le32(tmp - pbuffer);
 402         rc = setup_ntlmv2_rsp(ses, nls_cp);
 403         if (rc) {
 404                 cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc);
 405                 goto setup_ntlmv2_ret;
 406         }
 407         memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 408                         ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 409         tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
 410
 411         sec_blob->NtChallengeResponse.Length =
 412                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 413         sec_blob->NtChallengeResponse.MaximumLength =
 414                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 415
 416         if (ses->domainName == NULL) {
 417                 sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 418                 sec_blob->DomainName.Length = 0;
 419                 sec_blob->DomainName.MaximumLength = 0;
 420                 tmp += 2;
 421         } else {
 422                 int len;
 423                 len = cifs_strtoUTF16((__le16 *)tmp, ses->domainName,
 424                                       CIFS_MAX_USERNAME_LEN, nls_cp);
 425                 len *= 2; /* unicode is 2 bytes each */
 426                 sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 427                 sec_blob->DomainName.Length = cpu_to_le16(len);
 428                 sec_blob->DomainName.MaximumLength = cpu_to_le16(len);
 429                 tmp += len;
 430         }
 431
 432         if (ses->user_name == NULL) {
 433                 sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 434                 sec_blob->UserName.Length = 0;
 435                 sec_blob->UserName.MaximumLength = 0;
 436                 tmp += 2;
 437         } else {
 438                 int len;
 439                 len = cifs_strtoUTF16((__le16 *)tmp, ses->user_name,
 440                                       CIFS_MAX_USERNAME_LEN, nls_cp);
 441                 len *= 2; /* unicode is 2 bytes each */
 442                 sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 443                 sec_blob->UserName.Length = cpu_to_le16(len);
 444                 sec_blob->UserName.MaximumLength = cpu_to_le16(len);
 445                 tmp += len;
 446         }
 447
 448         sec_blob->WorkstationName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 449         sec_blob->WorkstationName.Length = 0;
 450         sec_blob->WorkstationName.MaximumLength = 0;
 451         tmp += 2;
 452
 453         if (((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) ||
 454                 (ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
 455                         && !calc_seckey(ses)) {
 456                 memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
 457                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - pbuffer);
 458                 sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);
 459                 sec_blob->SessionKey.MaximumLength =
 460                                 cpu_to_le16(CIFS_CPHTXT_SIZE);
 461                 tmp += CIFS_CPHTXT_SIZE;
 462         } else {
 463                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - pbuffer);
 464                 sec_blob->SessionKey.Length = 0;
 465                 sec_blob->SessionKey.MaximumLength = 0;
 466         }
 467
 468 setup_ntlmv2_ret:
 469         *buflen = tmp - pbuffer;
 470         return rc;
 471 }
 472
 473 enum securityEnum
 474 select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
 475 {
 476         switch (server->negflavor) {
 477         case CIFS_NEGFLAVOR_EXTENDED:
 478                 switch (requested) {
 479                 case Kerberos:
 480                 case RawNTLMSSP:
 481                         return requested;
 482                 case Unspecified:
 483                         if (server->sec_ntlmssp &&
 484                             (global_secflags & CIFSSEC_MAY_NTLMSSP))
 485                                 return RawNTLMSSP;
 486                         if ((server->sec_kerberos || server->sec_mskerberos) &&
 487                             (global_secflags & CIFSSEC_MAY_KRB5))
 488                                 return Kerberos;
 489                         /* Fallthrough */
 490                 default:
 491                         return Unspecified;
 492                 }
 493         case CIFS_NEGFLAVOR_UNENCAP:
 494                 switch (requested) {
 495                 case NTLM:
 496                 case NTLMv2:
 497                         return requested;
 498                 case Unspecified:
 499                         if (global_secflags & CIFSSEC_MAY_NTLMV2)
 500                                 return NTLMv2;
 501                         if (global_secflags & CIFSSEC_MAY_NTLM)
 502                                 return NTLM;
 503                 default:
 504                         /* Fallthrough to attempt LANMAN authentication next */
 505                         break;
 506                 }
 507         case CIFS_NEGFLAVOR_LANMAN:
 508                 switch (requested) {
 509                 case LANMAN:
 510                         return requested;
 511                 case Unspecified:
 512                         if (global_secflags & CIFSSEC_MAY_LANMAN)
 513                                 return LANMAN;
 514                         /* Fallthrough */
 515                 default:
 516                         return Unspecified;
 517                 }
 518         default:
 519                 return Unspecified;
 520         }
 521 }
 522
 523 struct sess_data {
 524         unsigned int xid;
 525         struct cifs_ses *ses;
 526         struct nls_table *nls_cp;
 527         void (*func)(struct sess_data *);
 528         int result;
 529
 530         /* we will send the SMB in three pieces:
 531          * a fixed length beginning part, an optional
 532          * SPNEGO blob (which can be zero length), and a
 533          * last part which will include the strings
 534          * and rest of bcc area. This allows us to avoid
 535          * a large buffer 17K allocation
 536          */
 537         int buf0_type;
 538         struct kvec iov[3];
 539 };
 540
 541 static int
 542 sess_alloc_buffer(struct sess_data *sess_data, int wct)
 543 {
 544         int rc;
 545         struct cifs_ses *ses = sess_data->ses;
 546         struct smb_hdr *smb_buf;
 547
 548         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
 549                                   (void **)&smb_buf);
 550
 551         if (rc)
 552                 return rc;
 553
 554         sess_data->iov[0].iov_base = (char *)smb_buf;
 555         sess_data->iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
 556         /*
 557          * This variable will be used to clear the buffer
 558          * allocated above in case of any error in the calling function.
 559          */
 560         sess_data->buf0_type = CIFS_SMALL_BUFFER;
 561
 562         /* 2000 big enough to fit max user, domain, NOS name etc. */
 563         sess_data->iov[2].iov_base = kmalloc(2000, GFP_KERNEL);
 564         if (!sess_data->iov[2].iov_base) {
 565                 rc = -ENOMEM;
 566                 goto out_free_smb_buf;
 567         }
 568
 569         return 0;
 570
 571 out_free_smb_buf:
 572         kfree(smb_buf);
 573         sess_data->iov[0].iov_base = NULL;
 574         sess_data->iov[0].iov_len = 0;
 575         sess_data->buf0_type = CIFS_NO_BUFFER;
 576         return rc;
 577 }
 578
 579 static void
 580 sess_free_buffer(struct sess_data *sess_data)
 581 {
 582
 583         free_rsp_buf(sess_data->buf0_type, sess_data->iov[0].iov_base);
 584         sess_data->buf0_type = CIFS_NO_BUFFER;
 585         kfree(sess_data->iov[2].iov_base);
 586 }
 587
 588 static int
 589 sess_establish_session(struct sess_data *sess_data)
 590 {
 591         struct cifs_ses *ses = sess_data->ses;
 592
 593         mutex_lock(&ses->server->srv_mutex);
 594         if (!ses->server->session_estab) {
 595                 if (ses->server->sign) {
 596                         ses->server->session_key.response =
 597                                 kmemdup(ses->auth_key.response,
 598                                 ses->auth_key.len, GFP_KERNEL);
 599                         if (!ses->server->session_key.response) {
 600                                 mutex_unlock(&ses->server->srv_mutex);
 601                                 return -ENOMEM;
 602                         }
 603                         ses->server->session_key.len =
 604                                                 ses->auth_key.len;
 605                 }
 606                 ses->server->sequence_number = 0x2;
 607                 ses->server->session_estab = true;
 608         }
 609         mutex_unlock(&ses->server->srv_mutex);
 610
 611         cifs_dbg(FYI, "CIFS session established successfully\n");
 612         spin_lock(&GlobalMid_Lock);
 613         ses->status = CifsGood;
 614         ses->need_reconnect = false;
 615         spin_unlock(&GlobalMid_Lock);
 616
 617         return 0;
 618 }
 619
 620 static int
 621 sess_sendreceive(struct sess_data *sess_data)
 622 {
 623         int rc;
 624         struct smb_hdr *smb_buf = (struct smb_hdr *) sess_data->iov[0].iov_base;
 625         __u16 count;
 626
 627         count = sess_data->iov[1].iov_len + sess_data->iov[2].iov_len;
 628         smb_buf->smb_buf_length =
 629                 cpu_to_be32(be32_to_cpu(smb_buf->smb_buf_length) + count);
 630         put_bcc(count, smb_buf);
 631
 632         rc = SendReceive2(sess_data->xid, sess_data->ses,
 633                           sess_data->iov, 3 /* num_iovecs */,
 634                           &sess_data->buf0_type,
 635                           CIFS_LOG_ERROR);
 636
 637         return rc;
 638 }
 639
 640 /*
 641  * LANMAN and plaintext are less secure and off by default.
 642  * So we make this explicitly be turned on in kconfig (in the
 643  * build) and turned on at runtime (changed from the default)
 644  * in proc/fs/cifs or via mount parm.  Unfortunately this is
 645  * needed for old Win (e.g. Win95), some obscure NAS and OS/2
 646  */
 647 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 648 static void
 649 sess_auth_lanman(struct sess_data *sess_data)
 650 {
 651         int rc = 0;
 652         struct smb_hdr *smb_buf;
 653         SESSION_SETUP_ANDX *pSMB;
 654         char *bcc_ptr;
 655         struct cifs_ses *ses = sess_data->ses;
 656         char lnm_session_key[CIFS_AUTH_RESP_SIZE];
 657         __u32 capabilities;
 658         __u16 bytes_remaining;
 659
 660         /* lanman 2 style sessionsetup */
 661         /* wct = 10 */
 662         rc = sess_alloc_buffer(sess_data, 10);
 663         if (rc)
 664                 goto out;
 665
 666         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 667         bcc_ptr = sess_data->iov[2].iov_base;
 668         capabilities = cifs_ssetup_hdr(ses, pSMB);
 669
 670         pSMB->req.hdr.Flags2 &= ~SMBFLG2_UNICODE;
 671
 672         /* no capabilities flags in old lanman negotiation */
 673         pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 674
 675         /* Calculate hash with password and copy into bcc_ptr.
 676          * Encryption Key (stored as in cryptkey) gets used if the
 677          * security mode bit in Negottiate Protocol response states
 678          * to use challenge/response method (i.e. Password bit is 1).
 679          */
 680         rc = calc_lanman_hash(ses->password, ses->server->cryptkey,
 681                               ses->server->sec_mode & SECMODE_PW_ENCRYPT ?
 682                               true : false, lnm_session_key);
 683
 684         memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE);
 685         bcc_ptr += CIFS_AUTH_RESP_SIZE;
 686
 687         /*
 688          * can not sign if LANMAN negotiated so no need
 689          * to calculate signing key? but what if server
 690          * changed to do higher than lanman dialect and
 691          * we reconnected would we ever calc signing_key?
 692          */
 693
 694         cifs_dbg(FYI, "Negotiating LANMAN setting up strings\n");
 695         /* Unicode not allowed for LANMAN dialects */
 696         ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
 697
 698         sess_data->iov[2].iov_len = (long) bcc_ptr -
 699                         (long) sess_data->iov[2].iov_base;
 700
 701         rc = sess_sendreceive(sess_data);
 702         if (rc)
 703                 goto out;
 704
 705         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 706         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
 707
 708         /* lanman response has a word count of 3 */
 709         if (smb_buf->WordCount != 3) {
 710                 rc = -EIO;
 711                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
 712                 goto out;
 713         }
 714
 715         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
 716                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
 717
 718         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
 719         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
 720
 721         bytes_remaining = get_bcc(smb_buf);
 722         bcc_ptr = pByteArea(smb_buf);
 723
 724         /* BB check if Unicode and decode strings */
 725         if (bytes_remaining == 0) {
 726                 /* no string area to decode, do nothing */
 727         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
 728                 /* unicode string area must be word-aligned */
 729                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
 730                         ++bcc_ptr;
 731                         --bytes_remaining;
 732                 }
 733                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
 734                                       sess_data->nls_cp);
 735         } else {
 736                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
 737                                     sess_data->nls_cp);
 738         }
 739
 740         rc = sess_establish_session(sess_data);
 741 out:
 742         sess_data->result = rc;
 743         sess_data->func = NULL;
 744         sess_free_buffer(sess_data);
 745 }
 746
 747 #else
 748
 749 static void
 750 sess_auth_lanman(struct sess_data *sess_data)
 751 {
 752         sess_data->result = -EOPNOTSUPP;
 753         sess_data->func = NULL;
 754 }
 755 #endif
 756
 757 static void
 758 sess_auth_ntlm(struct sess_data *sess_data)
 759 {
 760         int rc = 0;
 761         struct smb_hdr *smb_buf;
 762         SESSION_SETUP_ANDX *pSMB;
 763         char *bcc_ptr;
 764         struct cifs_ses *ses = sess_data->ses;
 765         __u32 capabilities;
 766         __u16 bytes_remaining;
 767
 768         /* old style NTLM sessionsetup */
 769         /* wct = 13 */
 770         rc = sess_alloc_buffer(sess_data, 13);
 771         if (rc)
 772                 goto out;
 773
 774         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 775         bcc_ptr = sess_data->iov[2].iov_base;
 776         capabilities = cifs_ssetup_hdr(ses, pSMB);
 777
 778         pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 779         pSMB->req_no_secext.CaseInsensitivePasswordLength =
 780                         cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 781         pSMB->req_no_secext.CaseSensitivePasswordLength =
 782                         cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 783
 784         /* calculate ntlm response and session key */
 785         rc = setup_ntlm_response(ses, sess_data->nls_cp);
 786         if (rc) {
 787                 cifs_dbg(VFS, "Error %d during NTLM authentication\n",
 788                                  rc);
 789                 goto out;
 790         }
 791
 792         /* copy ntlm response */
 793         memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 794                         CIFS_AUTH_RESP_SIZE);
 795         bcc_ptr += CIFS_AUTH_RESP_SIZE;
 796         memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 797                         CIFS_AUTH_RESP_SIZE);
 798         bcc_ptr += CIFS_AUTH_RESP_SIZE;
 799
 800         if (ses->capabilities & CAP_UNICODE) {
 801                 /* unicode strings must be word aligned */
 802                 if (sess_data->iov[0].iov_len % 2) {
 803                         *bcc_ptr = 0;
 804                         bcc_ptr++;
 805                 }
 806                 unicode_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
 807         } else {
 808                 ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
 809         }
 810
 811
 812         sess_data->iov[2].iov_len = (long) bcc_ptr -
 813                         (long) sess_data->iov[2].iov_base;
 814
 815         rc = sess_sendreceive(sess_data);
 816         if (rc)
 817                 goto out;
 818
 819         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 820         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
 821
 822         if (smb_buf->WordCount != 3) {
 823                 rc = -EIO;
 824                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
 825                 goto out;
 826         }
 827
 828         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
 829                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
 830
 831         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
 832         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
 833
 834         bytes_remaining = get_bcc(smb_buf);
 835         bcc_ptr = pByteArea(smb_buf);
 836
 837         /* BB check if Unicode and decode strings */
 838         if (bytes_remaining == 0) {
 839                 /* no string area to decode, do nothing */
 840         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
 841                 /* unicode string area must be word-aligned */
 842                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
 843                         ++bcc_ptr;
 844                         --bytes_remaining;
 845                 }
 846                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
 847                                       sess_data->nls_cp);
 848         } else {
 849                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
 850                                     sess_data->nls_cp);
 851         }
 852
 853         rc = sess_establish_session(sess_data);
 854 out:
 855         sess_data->result = rc;
 856         sess_data->func = NULL;
 857         sess_free_buffer(sess_data);
 858         kfree(ses->auth_key.response);
 859         ses->auth_key.response = NULL;
 860 }
 861
 862 static void
 863 sess_auth_ntlmv2(struct sess_data *sess_data)
 864 {
 865         int rc = 0;
 866         struct smb_hdr *smb_buf;
 867         SESSION_SETUP_ANDX *pSMB;
 868         char *bcc_ptr;
 869         struct cifs_ses *ses = sess_data->ses;
 870         __u32 capabilities;
 871         __u16 bytes_remaining;
 872
 873         /* old style NTLM sessionsetup */
 874         /* wct = 13 */
 875         rc = sess_alloc_buffer(sess_data, 13);
 876         if (rc)
 877                 goto out;
 878
 879         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 880         bcc_ptr = sess_data->iov[2].iov_base;
 881         capabilities = cifs_ssetup_hdr(ses, pSMB);
 882
 883         pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 884
 885         /* LM2 password would be here if we supported it */
 886         pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
 887
 888         /* calculate nlmv2 response and session key */
 889         rc = setup_ntlmv2_rsp(ses, sess_data->nls_cp);
 890         if (rc) {
 891                 cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n", rc);
 892                 goto out;
 893         }
 894
 895         memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 896                         ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 897         bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
 898
 899         /* set case sensitive password length after tilen may get
 900          * assigned, tilen is 0 otherwise.
 901          */
 902         pSMB->req_no_secext.CaseSensitivePasswordLength =
 903                 cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 904
 905         if (ses->capabilities & CAP_UNICODE) {
 906                 if (sess_data->iov[0].iov_len % 2) {
 907                         *bcc_ptr = 0;
 908                         bcc_ptr++;
 909                 }
 910                 unicode_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
 911         } else {
 912                 ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
 913         }
 914
 915
 916         sess_data->iov[2].iov_len = (long) bcc_ptr -
 917                         (long) sess_data->iov[2].iov_base;
 918
 919         rc = sess_sendreceive(sess_data);
 920         if (rc)
 921                 goto out;
 922
 923         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
 924         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
 925
 926         if (smb_buf->WordCount != 3) {
 927                 rc = -EIO;
 928                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
 929                 goto out;
 930         }
 931
 932         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
 933                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
 934
 935         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
 936         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
 937
 938         bytes_remaining = get_bcc(smb_buf);
 939         bcc_ptr = pByteArea(smb_buf);
 940
 941         /* BB check if Unicode and decode strings */
 942         if (bytes_remaining == 0) {
 943                 /* no string area to decode, do nothing */
 944         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
 945                 /* unicode string area must be word-aligned */
 946                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
 947                         ++bcc_ptr;
 948                         --bytes_remaining;
 949                 }
 950                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
 951                                       sess_data->nls_cp);
 952         } else {
 953                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
 954                                     sess_data->nls_cp);
 955         }
 956
 957         rc = sess_establish_session(sess_data);
 958 out:
 959         sess_data->result = rc;
 960         sess_data->func = NULL;
 961         sess_free_buffer(sess_data);
 962         kfree(ses->auth_key.response);
 963         ses->auth_key.response = NULL;
 964 }
 965
 966
 967 int
 968 CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
 969                const struct nls_table *nls_cp)
 970 {
 971         int rc = 0;
 972         int wct;
 973         struct smb_hdr *smb_buf;
 974         char *bcc_ptr;
 975         char *str_area;
 976         SESSION_SETUP_ANDX *pSMB;
 977         __u32 capabilities;
 978         __u16 count;
 979         int resp_buf_type;
 980         struct kvec iov[3];
 981         enum securityEnum type;
 982         __u16 action, bytes_remaining;
 983         struct key *spnego_key = NULL;
 984         __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
 985         u16 blob_len;
 986         char *ntlmsspblob = NULL;
 987         struct sess_data *sess_data;
 988
 989         if (ses == NULL) {
 990                 WARN(1, "%s: ses == NULL!", __func__);
 991                 return -EINVAL;
 992         }
 993
 994         sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
 995         if (!sess_data)
 996                 return -ENOMEM;
 997         sess_data->xid = xid;
 998         sess_data->ses = ses;
 999         sess_data->buf0_type = CIFS_NO_BUFFER;
1000         sess_data->nls_cp = (struct nls_table *) nls_cp;
1001
1002         type = select_sectype(ses->server, ses->sectype);
1003         cifs_dbg(FYI, "sess setup type %d\n", type);
1004         if (type == Unspecified) {
1005                 cifs_dbg(VFS,
1006                         "Unable to select appropriate authentication method!");
1007                 return -EINVAL;
1008         }
1009
1010         switch (type) {
1011         case LANMAN:
1012                 sess_auth_lanman(sess_data);
1013                 goto out;
1014         case NTLM:
1015                 sess_auth_ntlm(sess_data);
1016                 goto out;
1017         case NTLMv2:
1018                 sess_auth_ntlmv2(sess_data);
1019                 goto out;
1020         default:
1021                 cifs_dbg(FYI, "Continuing with CIFS_SessSetup\n");
1022         }
1023
1024         if (type == RawNTLMSSP) {
1025                 /* if memory allocation is successful, caller of this function
1026                  * frees it.
1027                  */
1028                 ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
1029                 if (!ses->ntlmssp)
1030                         return -ENOMEM;
1031                 ses->ntlmssp->sesskey_per_smbsess = false;
1032
1033         }
1034
1035 ssetup_ntlmssp_authenticate:
1036         if (phase == NtLmChallenge)
1037                 phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
1038
1039         /* same size: negotiate or auth, NTLMSSP or extended security */
1040         wct = 12;
1041
1042         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
1043                             (void **)&smb_buf);
1044         if (rc)
1045                 return rc;
1046
1047         pSMB = (SESSION_SETUP_ANDX *)smb_buf;
1048
1049         capabilities = cifs_ssetup_hdr(ses, pSMB);
1050
1051         /* we will send the SMB in three pieces:
1052         a fixed length beginning part, an optional
1053         SPNEGO blob (which can be zero length), and a
1054         last part which will include the strings
1055         and rest of bcc area. This allows us to avoid
1056         a large buffer 17K allocation */
1057         iov[0].iov_base = (char *)pSMB;
1058         iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
1059
1060         /* setting this here allows the code at the end of the function
1061            to free the request buffer if there's an error */
1062         resp_buf_type = CIFS_SMALL_BUFFER;
1063
1064         /* 2000 big enough to fit max user, domain, NOS name etc. */
1065         str_area = kmalloc(2000, GFP_KERNEL);
1066         if (str_area == NULL) {
1067                 rc = -ENOMEM;
1068                 goto ssetup_exit;
1069         }
1070         bcc_ptr = str_area;
1071
1072         iov[1].iov_base = NULL;
1073         iov[1].iov_len = 0;
1074
1075         if (type == Kerberos) {
1076 #ifdef CONFIG_CIFS_UPCALL
1077                 struct cifs_spnego_msg *msg;
1078
1079                 spnego_key = cifs_get_spnego_key(ses);
1080                 if (IS_ERR(spnego_key)) {
1081                         rc = PTR_ERR(spnego_key);
1082                         spnego_key = NULL;
1083                         goto ssetup_exit;
1084                 }
1085
1086                 msg = spnego_key->payload.data;
1087                 /* check version field to make sure that cifs.upcall is
1088                    sending us a response in an expected form */
1089                 if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
1090                         cifs_dbg(VFS, "incorrect version of cifs.upcall "
1091                                    "expected %d but got %d)",
1092                                    CIFS_SPNEGO_UPCALL_VERSION, msg->version);
1093                         rc = -EKEYREJECTED;
1094                         goto ssetup_exit;
1095                 }
1096
1097                 ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len,
1098                                                  GFP_KERNEL);
1099                 if (!ses->auth_key.response) {
1100                         cifs_dbg(VFS,
1101                                 "Kerberos can't allocate (%u bytes) memory",
1102                                 msg->sesskey_len);
1103                         rc = -ENOMEM;
1104                         goto ssetup_exit;
1105                 }
1106                 ses->auth_key.len = msg->sesskey_len;
1107
1108                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1109                 capabilities |= CAP_EXTENDED_SECURITY;
1110                 pSMB->req.Capabilities = cpu_to_le32(capabilities);
1111                 iov[1].iov_base = msg->data + msg->sesskey_len;
1112                 iov[1].iov_len = msg->secblob_len;
1113                 pSMB->req.SecurityBlobLength = cpu_to_le16(iov[1].iov_len);
1114
1115                 if (ses->capabilities & CAP_UNICODE) {
1116                         /* unicode strings must be word aligned */
1117                         if ((iov[0].iov_len + iov[1].iov_len) % 2) {
1118                                 *bcc_ptr = 0;
1119                                 bcc_ptr++;
1120                         }
1121                         unicode_oslm_strings(&bcc_ptr, nls_cp);
1122                         unicode_domain_string(&bcc_ptr, ses, nls_cp);
1123                 } else
1124                 /* BB: is this right? */
1125                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
1126 #else /* ! CONFIG_CIFS_UPCALL */
1127                 cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
1128                 rc = -ENOSYS;
1129                 goto ssetup_exit;
1130 #endif /* CONFIG_CIFS_UPCALL */
1131         } else if (type == RawNTLMSSP) {
1132                 if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
1133                         cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
1134                         rc = -ENOSYS;
1135                         goto ssetup_exit;
1136                 }
1137
1138                 cifs_dbg(FYI, "ntlmssp session setup phase %d\n", phase);
1139                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1140                 capabilities |= CAP_EXTENDED_SECURITY;
1141                 pSMB->req.Capabilities |= cpu_to_le32(capabilities);
1142                 switch(phase) {
1143                 case NtLmNegotiate:
1144                         build_ntlmssp_negotiate_blob(
1145                                 pSMB->req.SecurityBlob, ses);
1146                         iov[1].iov_len = sizeof(NEGOTIATE_MESSAGE);
1147                         iov[1].iov_base = pSMB->req.SecurityBlob;
1148                         pSMB->req.SecurityBlobLength =
1149                                 cpu_to_le16(sizeof(NEGOTIATE_MESSAGE));
1150                         break;
1151                 case NtLmAuthenticate:
1152                         /*
1153                          * 5 is an empirical value, large enough to hold
1154                          * authenticate message plus max 10 of av paris,
1155                          * domain, user, workstation names, flags, etc.
1156                          */
1157                         ntlmsspblob = kzalloc(
1158                                 5*sizeof(struct _AUTHENTICATE_MESSAGE),
1159                                 GFP_KERNEL);
1160                         if (!ntlmsspblob) {
1161                                 rc = -ENOMEM;
1162                                 goto ssetup_exit;
1163                         }
1164
1165                         rc = build_ntlmssp_auth_blob(ntlmsspblob,
1166                                                 &blob_len, ses, nls_cp);
1167                         if (rc)
1168                                 goto ssetup_exit;
1169                         iov[1].iov_len = blob_len;
1170                         iov[1].iov_base = ntlmsspblob;
1171                         pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
1172                         /*
1173                          * Make sure that we tell the server that we are using
1174                          * the uid that it just gave us back on the response
1175                          * (challenge)
1176                          */
1177                         smb_buf->Uid = ses->Suid;
1178                         break;
1179                 default:
1180                         cifs_dbg(VFS, "invalid phase %d\n", phase);
1181                         rc = -ENOSYS;
1182                         goto ssetup_exit;
1183                 }
1184                 /* unicode strings must be word aligned */
1185                 if ((iov[0].iov_len + iov[1].iov_len) % 2) {
1186                         *bcc_ptr = 0;
1187                         bcc_ptr++;
1188                 }
1189                 unicode_oslm_strings(&bcc_ptr, nls_cp);
1190         } else {
1191                 cifs_dbg(VFS, "secType %d not supported!\n", type);
1192                 rc = -ENOSYS;
1193                 goto ssetup_exit;
1194         }
1195
1196         iov[2].iov_base = str_area;
1197         iov[2].iov_len = (long) bcc_ptr - (long) str_area;
1198
1199         count = iov[1].iov_len + iov[2].iov_len;
1200         smb_buf->smb_buf_length =
1201                 cpu_to_be32(be32_to_cpu(smb_buf->smb_buf_length) + count);
1202
1203         put_bcc(count, smb_buf);
1204
1205         rc = SendReceive2(xid, ses, iov, 3 /* num_iovecs */, &resp_buf_type,
1206                           CIFS_LOG_ERROR);
1207         /* SMB request buf freed in SendReceive2 */
1208
1209         pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
1210         smb_buf = (struct smb_hdr *)iov[0].iov_base;
1211
1212         if ((type == RawNTLMSSP) && (resp_buf_type != CIFS_NO_BUFFER) &&
1213             (smb_buf->Status.CifsError ==
1214                         cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))) {
1215                 if (phase != NtLmNegotiate) {
1216                         cifs_dbg(VFS, "Unexpected more processing error\n");
1217                         goto ssetup_exit;
1218                 }
1219                 /* NTLMSSP Negotiate sent now processing challenge (response) */
1220                 phase = NtLmChallenge; /* process ntlmssp challenge */
1221                 rc = 0; /* MORE_PROC rc is not an error here, but expected */
1222         }
1223         if (rc)
1224                 goto ssetup_exit;
1225
1226         if (smb_buf->WordCount != 4) {
1227                 rc = -EIO;
1228                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1229                 goto ssetup_exit;
1230         }
1231         action = le16_to_cpu(pSMB->resp.Action);
1232         if (action & GUEST_LOGIN)
1233                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1234         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1235         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1236         /* response can have either 3 or 4 word count - Samba sends 3 */
1237         /* and lanman response is 3 */
1238         bytes_remaining = get_bcc(smb_buf);
1239         bcc_ptr = pByteArea(smb_buf);
1240
1241         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1242         if (blob_len > bytes_remaining) {
1243                 cifs_dbg(VFS, "bad security blob length %d\n",
1244                          blob_len);
1245                 rc = -EINVAL;
1246                 goto ssetup_exit;
1247         }
1248         if (phase == NtLmChallenge) {
1249                 rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
1250                 if (rc)
1251                         goto ssetup_exit;
1252         }
1253         bcc_ptr += blob_len;
1254         bytes_remaining -= blob_len;
1255
1256         /* BB check if Unicode and decode strings */
1257         if (bytes_remaining == 0) {
1258                 /* no string area to decode, do nothing */
1259         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1260                 /* unicode string area must be word-aligned */
1261                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1262                         ++bcc_ptr;
1263                         --bytes_remaining;
1264                 }
1265                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
1266         } else {
1267                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
1268         }
1269
1270 ssetup_exit:
1271         if (spnego_key) {
1272                 key_invalidate(spnego_key);
1273                 key_put(spnego_key);
1274         }
1275         kfree(str_area);
1276         kfree(ntlmsspblob);
1277         ntlmsspblob = NULL;
1278         if (resp_buf_type == CIFS_SMALL_BUFFER) {
1279                 cifs_dbg(FYI, "ssetup freeing small buf %p\n", iov[0].iov_base);
1280                 cifs_small_buf_release(iov[0].iov_base);
1281         } else if (resp_buf_type == CIFS_LARGE_BUFFER)
1282                 cifs_buf_release(iov[0].iov_base);
1283
1284         /* if ntlmssp, and negotiate succeeded, proceed to authenticate phase */
1285         if ((phase == NtLmChallenge) && (rc == 0))
1286                 goto ssetup_ntlmssp_authenticate;
1287
1288         if (!rc) {
1289                 mutex_lock(&ses->server->srv_mutex);
1290                 if (!ses->server->session_estab) {
1291                         if (ses->server->sign) {
1292                                 ses->server->session_key.response =
1293                                         kmemdup(ses->auth_key.response,
1294                                         ses->auth_key.len, GFP_KERNEL);
1295                                 if (!ses->server->session_key.response) {
1296                                         rc = -ENOMEM;
1297                                         mutex_unlock(&ses->server->srv_mutex);
1298                                         goto keycp_exit;
1299                                 }
1300                                 ses->server->session_key.len =
1301                                                         ses->auth_key.len;
1302                         }
1303                         ses->server->sequence_number = 0x2;
1304                         ses->server->session_estab = true;
1305                 }
1306                 mutex_unlock(&ses->server->srv_mutex);
1307
1308                 cifs_dbg(FYI, "CIFS session established successfully\n");
1309                 spin_lock(&GlobalMid_Lock);
1310                 ses->status = CifsGood;
1311                 ses->need_reconnect = false;
1312                 spin_unlock(&GlobalMid_Lock);
1313         }
1314
1315 keycp_exit:
1316         kfree(ses->auth_key.response);
1317         ses->auth_key.response = NULL;
1318         kfree(ses->ntlmssp);
1319
1320         return rc;
1321
1322 out:
1323         rc = sess_data->result;
1324         kfree(sess_data);
1325         return rc;
1326 }