fs/cifs/sess.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   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  */
  10
  11 #include "cifspdu.h"
  12 #include "cifsglob.h"
  13 #include "cifsproto.h"
  14 #include "cifs_unicode.h"
  15 #include "cifs_debug.h"
  16 #include "ntlmssp.h"
  17 #include "nterr.h"
  18 #include <linux/utsname.h>
  19 #include <linux/slab.h>
  20 #include <linux/version.h>
  21 #include "cifsfs.h"
  22 #include "cifs_spnego.h"
  23 #include "smb2proto.h"
  24 #include "fs_context.h"
  25
  26 static int
  27 cifs_ses_add_channel(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
  28                      struct cifs_server_iface *iface);
  29
  30 bool
  31 is_server_using_iface(struct TCP_Server_Info *server,
  32                       struct cifs_server_iface *iface)
  33 {
  34         struct sockaddr_in *i4 = (struct sockaddr_in *)&iface->sockaddr;
  35         struct sockaddr_in6 *i6 = (struct sockaddr_in6 *)&iface->sockaddr;
  36         struct sockaddr_in *s4 = (struct sockaddr_in *)&server->dstaddr;
  37         struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&server->dstaddr;
  38
  39         if (server->dstaddr.ss_family != iface->sockaddr.ss_family)
  40                 return false;
  41         if (server->dstaddr.ss_family == AF_INET) {
  42                 if (s4->sin_addr.s_addr != i4->sin_addr.s_addr)
  43                         return false;
  44         } else if (server->dstaddr.ss_family == AF_INET6) {
  45                 if (memcmp(&s6->sin6_addr, &i6->sin6_addr,
  46                            sizeof(i6->sin6_addr)) != 0)
  47                         return false;
  48         } else {
  49                 /* unknown family.. */
  50                 return false;
  51         }
  52         return true;
  53 }
  54
  55 bool is_ses_using_iface(struct cifs_ses *ses, struct cifs_server_iface *iface)
  56 {
  57         int i;
  58
  59         spin_lock(&ses->chan_lock);
  60         for (i = 0; i < ses->chan_count; i++) {
  61                 if (is_server_using_iface(ses->chans[i].server, iface)) {
  62                         spin_unlock(&ses->chan_lock);
  63                         return true;
  64                 }
  65         }
  66         spin_unlock(&ses->chan_lock);
  67         return false;
  68 }
  69
  70 /* channel helper functions. assumed that chan_lock is held by caller. */
  71
  72 unsigned int
  73 cifs_ses_get_chan_index(struct cifs_ses *ses,
  74                         struct TCP_Server_Info *server)
  75 {
  76         unsigned int i;
  77
  78         for (i = 0; i < ses->chan_count; i++) {
  79                 if (ses->chans[i].server == server)
  80                         return i;
  81         }
  82
  83         /* If we didn't find the channel, it is likely a bug */
  84         if (server)
  85                 cifs_dbg(VFS, "unable to get chan index for server: 0x%llx",
  86                          server->conn_id);
  87         WARN_ON(1);
  88         return 0;
  89 }
  90
  91 void
  92 cifs_chan_set_in_reconnect(struct cifs_ses *ses,
  93                              struct TCP_Server_Info *server)
  94 {
  95         unsigned int chan_index = cifs_ses_get_chan_index(ses, server);
  96
  97         ses->chans[chan_index].in_reconnect = true;
  98 }
  99
 100 void
 101 cifs_chan_clear_in_reconnect(struct cifs_ses *ses,
 102                              struct TCP_Server_Info *server)
 103 {
 104         unsigned int chan_index = cifs_ses_get_chan_index(ses, server);
 105
 106         ses->chans[chan_index].in_reconnect = false;
 107 }
 108
 109 bool
 110 cifs_chan_in_reconnect(struct cifs_ses *ses,
 111                           struct TCP_Server_Info *server)
 112 {
 113         unsigned int chan_index = cifs_ses_get_chan_index(ses, server);
 114
 115         return CIFS_CHAN_IN_RECONNECT(ses, chan_index);
 116 }
 117
 118 void
 119 cifs_chan_set_need_reconnect(struct cifs_ses *ses,
 120                              struct TCP_Server_Info *server)
 121 {
 122         unsigned int chan_index = cifs_ses_get_chan_index(ses, server);
 123
 124         set_bit(chan_index, &ses->chans_need_reconnect);
 125         cifs_dbg(FYI, "Set reconnect bitmask for chan %u; now 0x%lx\n",
 126                  chan_index, ses->chans_need_reconnect);
 127 }
 128
 129 void
 130 cifs_chan_clear_need_reconnect(struct cifs_ses *ses,
 131                                struct TCP_Server_Info *server)
 132 {
 133         unsigned int chan_index = cifs_ses_get_chan_index(ses, server);
 134
 135         clear_bit(chan_index, &ses->chans_need_reconnect);
 136         cifs_dbg(FYI, "Cleared reconnect bitmask for chan %u; now 0x%lx\n",
 137                  chan_index, ses->chans_need_reconnect);
 138 }
 139
 140 bool
 141 cifs_chan_needs_reconnect(struct cifs_ses *ses,
 142                           struct TCP_Server_Info *server)
 143 {
 144         unsigned int chan_index = cifs_ses_get_chan_index(ses, server);
 145
 146         return CIFS_CHAN_NEEDS_RECONNECT(ses, chan_index);
 147 }
 148
 149 /* returns number of channels added */
 150 int cifs_try_adding_channels(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses)
 151 {
 152         int old_chan_count, new_chan_count;
 153         int left;
 154         int i = 0;
 155         int rc = 0;
 156         int tries = 0;
 157         struct cifs_server_iface *ifaces = NULL;
 158         size_t iface_count;
 159
 160         spin_lock(&ses->chan_lock);
 161
 162         new_chan_count = old_chan_count = ses->chan_count;
 163         left = ses->chan_max - ses->chan_count;
 164
 165         if (left <= 0) {
 166                 spin_unlock(&ses->chan_lock);
 167                 cifs_dbg(FYI,
 168                          "ses already at max_channels (%zu), nothing to open\n",
 169                          ses->chan_max);
 170                 return 0;
 171         }
 172
 173         if (ses->server->dialect < SMB30_PROT_ID) {
 174                 spin_unlock(&ses->chan_lock);
 175                 cifs_dbg(VFS, "multichannel is not supported on this protocol version, use 3.0 or above\n");
 176                 return 0;
 177         }
 178
 179         if (!(ses->server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
 180                 ses->chan_max = 1;
 181                 spin_unlock(&ses->chan_lock);
 182                 cifs_dbg(VFS, "server %s does not support multichannel\n", ses->server->hostname);
 183                 return 0;
 184         }
 185         spin_unlock(&ses->chan_lock);
 186
 187         /*
 188          * Make a copy of the iface list at the time and use that
 189          * instead so as to not hold the iface spinlock for opening
 190          * channels
 191          */
 192         spin_lock(&ses->iface_lock);
 193         iface_count = ses->iface_count;
 194         if (iface_count <= 0) {
 195                 spin_unlock(&ses->iface_lock);
 196                 cifs_dbg(VFS, "no iface list available to open channels\n");
 197                 return 0;
 198         }
 199         ifaces = kmemdup(ses->iface_list, iface_count*sizeof(*ifaces),
 200                          GFP_ATOMIC);
 201         if (!ifaces) {
 202                 spin_unlock(&ses->iface_lock);
 203                 return 0;
 204         }
 205         spin_unlock(&ses->iface_lock);
 206
 207         /*
 208          * Keep connecting to same, fastest, iface for all channels as
 209          * long as its RSS. Try next fastest one if not RSS or channel
 210          * creation fails.
 211          */
 212         while (left > 0) {
 213                 struct cifs_server_iface *iface;
 214
 215                 tries++;
 216                 if (tries > 3*ses->chan_max) {
 217                         cifs_dbg(FYI, "too many channel open attempts (%d channels left to open)\n",
 218                                  left);
 219                         break;
 220                 }
 221
 222                 iface = &ifaces[i];
 223                 if (is_ses_using_iface(ses, iface) && !iface->rss_capable) {
 224                         i = (i+1) % iface_count;
 225                         continue;
 226                 }
 227
 228                 rc = cifs_ses_add_channel(cifs_sb, ses, iface);
 229                 if (rc) {
 230                         cifs_dbg(FYI, "failed to open extra channel on iface#%d rc=%d\n",
 231                                  i, rc);
 232                         i = (i+1) % iface_count;
 233                         continue;
 234                 }
 235
 236                 cifs_dbg(FYI, "successfully opened new channel on iface#%d\n",
 237                          i);
 238                 left--;
 239                 new_chan_count++;
 240         }
 241
 242         kfree(ifaces);
 243         return new_chan_count - old_chan_count;
 244 }
 245
 246 /*
 247  * If server is a channel of ses, return the corresponding enclosing
 248  * cifs_chan otherwise return NULL.
 249  */
 250 struct cifs_chan *
 251 cifs_ses_find_chan(struct cifs_ses *ses, struct TCP_Server_Info *server)
 252 {
 253         int i;
 254
 255         spin_lock(&ses->chan_lock);
 256         for (i = 0; i < ses->chan_count; i++) {
 257                 if (ses->chans[i].server == server) {
 258                         spin_unlock(&ses->chan_lock);
 259                         return &ses->chans[i];
 260                 }
 261         }
 262         spin_unlock(&ses->chan_lock);
 263         return NULL;
 264 }
 265
 266 static int
 267 cifs_ses_add_channel(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
 268                      struct cifs_server_iface *iface)
 269 {
 270         struct TCP_Server_Info *chan_server;
 271         struct cifs_chan *chan;
 272         struct smb3_fs_context ctx = {NULL};
 273         static const char unc_fmt[] = "\\%s\\foo";
 274         char unc[sizeof(unc_fmt)+SERVER_NAME_LEN_WITH_NULL] = {0};
 275         struct sockaddr_in *ipv4 = (struct sockaddr_in *)&iface->sockaddr;
 276         struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&iface->sockaddr;
 277         int rc;
 278         unsigned int xid = get_xid();
 279
 280         if (iface->sockaddr.ss_family == AF_INET)
 281                 cifs_dbg(FYI, "adding channel to ses %p (speed:%zu bps rdma:%s ip:%pI4)\n",
 282                          ses, iface->speed, iface->rdma_capable ? "yes" : "no",
 283                          &ipv4->sin_addr);
 284         else
 285                 cifs_dbg(FYI, "adding channel to ses %p (speed:%zu bps rdma:%s ip:%pI6)\n",
 286                          ses, iface->speed, iface->rdma_capable ? "yes" : "no",
 287                          &ipv6->sin6_addr);
 288
 289         /*
 290          * Setup a ctx with mostly the same info as the existing
 291          * session and overwrite it with the requested iface data.
 292          *
 293          * We need to setup at least the fields used for negprot and
 294          * sesssetup.
 295          *
 296          * We only need the ctx here, so we can reuse memory from
 297          * the session and server without caring about memory
 298          * management.
 299          */
 300
 301         /* Always make new connection for now (TODO?) */
 302         ctx.nosharesock = true;
 303
 304         /* Auth */
 305         ctx.domainauto = ses->domainAuto;
 306         ctx.domainname = ses->domainName;
 307
 308         /* no hostname for extra channels */
 309         ctx.server_hostname = "";
 310
 311         ctx.username = ses->user_name;
 312         ctx.password = ses->password;
 313         ctx.sectype = ses->sectype;
 314         ctx.sign = ses->sign;
 315
 316         /* UNC and paths */
 317         /* XXX: Use ses->server->hostname? */
 318         sprintf(unc, unc_fmt, ses->ip_addr);
 319         ctx.UNC = unc;
 320         ctx.prepath = "";
 321
 322         /* Reuse same version as master connection */
 323         ctx.vals = ses->server->vals;
 324         ctx.ops = ses->server->ops;
 325
 326         ctx.noblocksnd = ses->server->noblocksnd;
 327         ctx.noautotune = ses->server->noautotune;
 328         ctx.sockopt_tcp_nodelay = ses->server->tcp_nodelay;
 329         ctx.echo_interval = ses->server->echo_interval / HZ;
 330         ctx.max_credits = ses->server->max_credits;
 331
 332         /*
 333          * This will be used for encoding/decoding user/domain/pw
 334          * during sess setup auth.
 335          */
 336         ctx.local_nls = cifs_sb->local_nls;
 337
 338         /* Use RDMA if possible */
 339         ctx.rdma = iface->rdma_capable;
 340         memcpy(&ctx.dstaddr, &iface->sockaddr, sizeof(struct sockaddr_storage));
 341
 342         /* reuse master con client guid */
 343         memcpy(&ctx.client_guid, ses->server->client_guid,
 344                SMB2_CLIENT_GUID_SIZE);
 345         ctx.use_client_guid = true;
 346
 347         chan_server = cifs_get_tcp_session(&ctx, ses->server);
 348
 349         spin_lock(&ses->chan_lock);
 350         chan = &ses->chans[ses->chan_count];
 351         chan->server = chan_server;
 352         if (IS_ERR(chan->server)) {
 353                 rc = PTR_ERR(chan->server);
 354                 chan->server = NULL;
 355                 spin_unlock(&ses->chan_lock);
 356                 goto out;
 357         }
 358         ses->chan_count++;
 359         atomic_set(&ses->chan_seq, 0);
 360
 361         /* Mark this channel as needing connect/setup */
 362         cifs_chan_set_need_reconnect(ses, chan->server);
 363
 364         spin_unlock(&ses->chan_lock);
 365
 366         mutex_lock(&ses->session_mutex);
 367         /*
 368          * We need to allocate the server crypto now as we will need
 369          * to sign packets before we generate the channel signing key
 370          * (we sign with the session key)
 371          */
 372         rc = smb311_crypto_shash_allocate(chan->server);
 373         if (rc) {
 374                 cifs_dbg(VFS, "%s: crypto alloc failed\n", __func__);
 375                 mutex_unlock(&ses->session_mutex);
 376                 goto out;
 377         }
 378
 379         rc = cifs_negotiate_protocol(xid, ses, chan->server);
 380         if (!rc)
 381                 rc = cifs_setup_session(xid, ses, chan->server, cifs_sb->local_nls);
 382
 383         mutex_unlock(&ses->session_mutex);
 384
 385 out:
 386         if (rc && chan->server) {
 387                 spin_lock(&ses->chan_lock);
 388                 /* we rely on all bits beyond chan_count to be clear */
 389                 cifs_chan_clear_need_reconnect(ses, chan->server);
 390                 ses->chan_count--;
 391                 /*
 392                  * chan_count should never reach 0 as at least the primary
 393                  * channel is always allocated
 394                  */
 395                 WARN_ON(ses->chan_count < 1);
 396                 spin_unlock(&ses->chan_lock);
 397         }
 398
 399         if (rc && chan->server)
 400                 cifs_put_tcp_session(chan->server, 0);
 401
 402         return rc;
 403 }
 404
 405 static __u32 cifs_ssetup_hdr(struct cifs_ses *ses,
 406                              struct TCP_Server_Info *server,
 407                              SESSION_SETUP_ANDX *pSMB)
 408 {
 409         __u32 capabilities = 0;
 410
 411         /* init fields common to all four types of SessSetup */
 412         /* Note that offsets for first seven fields in req struct are same  */
 413         /*      in CIFS Specs so does not matter which of 3 forms of struct */
 414         /*      that we use in next few lines                               */
 415         /* Note that header is initialized to zero in header_assemble */
 416         pSMB->req.AndXCommand = 0xFF;
 417         pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32,
 418                                         CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4,
 419                                         USHRT_MAX));
 420         pSMB->req.MaxMpxCount = cpu_to_le16(server->maxReq);
 421         pSMB->req.VcNumber = cpu_to_le16(1);
 422
 423         /* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
 424
 425         /* BB verify whether signing required on neg or just on auth frame
 426            (and NTLM case) */
 427
 428         capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
 429                         CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
 430
 431         if (server->sign)
 432                 pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 433
 434         if (ses->capabilities & CAP_UNICODE) {
 435                 pSMB->req.hdr.Flags2 |= SMBFLG2_UNICODE;
 436                 capabilities |= CAP_UNICODE;
 437         }
 438         if (ses->capabilities & CAP_STATUS32) {
 439                 pSMB->req.hdr.Flags2 |= SMBFLG2_ERR_STATUS;
 440                 capabilities |= CAP_STATUS32;
 441         }
 442         if (ses->capabilities & CAP_DFS) {
 443                 pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
 444                 capabilities |= CAP_DFS;
 445         }
 446         if (ses->capabilities & CAP_UNIX)
 447                 capabilities |= CAP_UNIX;
 448
 449         return capabilities;
 450 }
 451
 452 static void
 453 unicode_oslm_strings(char **pbcc_area, const struct nls_table *nls_cp)
 454 {
 455         char *bcc_ptr = *pbcc_area;
 456         int bytes_ret = 0;
 457
 458         /* Copy OS version */
 459         bytes_ret = cifs_strtoUTF16((__le16 *)bcc_ptr, "Linux version ", 32,
 460                                     nls_cp);
 461         bcc_ptr += 2 * bytes_ret;
 462         bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, init_utsname()->release,
 463                                     32, nls_cp);
 464         bcc_ptr += 2 * bytes_ret;
 465         bcc_ptr += 2; /* trailing null */
 466
 467         bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
 468                                     32, nls_cp);
 469         bcc_ptr += 2 * bytes_ret;
 470         bcc_ptr += 2; /* trailing null */
 471
 472         *pbcc_area = bcc_ptr;
 473 }
 474
 475 static void unicode_domain_string(char **pbcc_area, struct cifs_ses *ses,
 476                                    const struct nls_table *nls_cp)
 477 {
 478         char *bcc_ptr = *pbcc_area;
 479         int bytes_ret = 0;
 480
 481         /* copy domain */
 482         if (ses->domainName == NULL) {
 483                 /* Sending null domain better than using a bogus domain name (as
 484                 we did briefly in 2.6.18) since server will use its default */
 485                 *bcc_ptr = 0;
 486                 *(bcc_ptr+1) = 0;
 487                 bytes_ret = 0;
 488         } else
 489                 bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->domainName,
 490                                             CIFS_MAX_DOMAINNAME_LEN, nls_cp);
 491         bcc_ptr += 2 * bytes_ret;
 492         bcc_ptr += 2;  /* account for null terminator */
 493
 494         *pbcc_area = bcc_ptr;
 495 }
 496
 497
 498 static void unicode_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 499                                    const struct nls_table *nls_cp)
 500 {
 501         char *bcc_ptr = *pbcc_area;
 502         int bytes_ret = 0;
 503
 504         /* BB FIXME add check that strings total less
 505         than 335 or will need to send them as arrays */
 506
 507         /* unicode strings, must be word aligned before the call */
 508 /*      if ((long) bcc_ptr % 2) {
 509                 *bcc_ptr = 0;
 510                 bcc_ptr++;
 511         } */
 512         /* copy user */
 513         if (ses->user_name == NULL) {
 514                 /* null user mount */
 515                 *bcc_ptr = 0;
 516                 *(bcc_ptr+1) = 0;
 517         } else {
 518                 bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->user_name,
 519                                             CIFS_MAX_USERNAME_LEN, nls_cp);
 520         }
 521         bcc_ptr += 2 * bytes_ret;
 522         bcc_ptr += 2; /* account for null termination */
 523
 524         unicode_domain_string(&bcc_ptr, ses, nls_cp);
 525         unicode_oslm_strings(&bcc_ptr, nls_cp);
 526
 527         *pbcc_area = bcc_ptr;
 528 }
 529
 530 static void ascii_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 531                                  const struct nls_table *nls_cp)
 532 {
 533         char *bcc_ptr = *pbcc_area;
 534         int len;
 535
 536         /* copy user */
 537         /* BB what about null user mounts - check that we do this BB */
 538         /* copy user */
 539         if (ses->user_name != NULL) {
 540                 len = strscpy(bcc_ptr, ses->user_name, CIFS_MAX_USERNAME_LEN);
 541                 if (WARN_ON_ONCE(len < 0))
 542                         len = CIFS_MAX_USERNAME_LEN - 1;
 543                 bcc_ptr += len;
 544         }
 545         /* else null user mount */
 546         *bcc_ptr = 0;
 547         bcc_ptr++; /* account for null termination */
 548
 549         /* copy domain */
 550         if (ses->domainName != NULL) {
 551                 len = strscpy(bcc_ptr, ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
 552                 if (WARN_ON_ONCE(len < 0))
 553                         len = CIFS_MAX_DOMAINNAME_LEN - 1;
 554                 bcc_ptr += len;
 555         } /* else we will send a null domain name
 556              so the server will default to its own domain */
 557         *bcc_ptr = 0;
 558         bcc_ptr++;
 559
 560         /* BB check for overflow here */
 561
 562         strcpy(bcc_ptr, "Linux version ");
 563         bcc_ptr += strlen("Linux version ");
 564         strcpy(bcc_ptr, init_utsname()->release);
 565         bcc_ptr += strlen(init_utsname()->release) + 1;
 566
 567         strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
 568         bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
 569
 570         *pbcc_area = bcc_ptr;
 571 }
 572
 573 static void
 574 decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
 575                       const struct nls_table *nls_cp)
 576 {
 577         int len;
 578         char *data = *pbcc_area;
 579
 580         cifs_dbg(FYI, "bleft %d\n", bleft);
 581
 582         kfree(ses->serverOS);
 583         ses->serverOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 584         cifs_dbg(FYI, "serverOS=%s\n", ses->serverOS);
 585         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 586         data += len;
 587         bleft -= len;
 588         if (bleft <= 0)
 589                 return;
 590
 591         kfree(ses->serverNOS);
 592         ses->serverNOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 593         cifs_dbg(FYI, "serverNOS=%s\n", ses->serverNOS);
 594         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 595         data += len;
 596         bleft -= len;
 597         if (bleft <= 0)
 598                 return;
 599
 600         kfree(ses->serverDomain);
 601         ses->serverDomain = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 602         cifs_dbg(FYI, "serverDomain=%s\n", ses->serverDomain);
 603
 604         return;
 605 }
 606
 607 static void decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
 608                                 struct cifs_ses *ses,
 609                                 const struct nls_table *nls_cp)
 610 {
 611         int len;
 612         char *bcc_ptr = *pbcc_area;
 613
 614         cifs_dbg(FYI, "decode sessetup ascii. bleft %d\n", bleft);
 615
 616         len = strnlen(bcc_ptr, bleft);
 617         if (len >= bleft)
 618                 return;
 619
 620         kfree(ses->serverOS);
 621
 622         ses->serverOS = kmalloc(len + 1, GFP_KERNEL);
 623         if (ses->serverOS) {
 624                 memcpy(ses->serverOS, bcc_ptr, len);
 625                 ses->serverOS[len] = 0;
 626                 if (strncmp(ses->serverOS, "OS/2", 4) == 0)
 627                         cifs_dbg(FYI, "OS/2 server\n");
 628         }
 629
 630         bcc_ptr += len + 1;
 631         bleft -= len + 1;
 632
 633         len = strnlen(bcc_ptr, bleft);
 634         if (len >= bleft)
 635                 return;
 636
 637         kfree(ses->serverNOS);
 638
 639         ses->serverNOS = kmalloc(len + 1, GFP_KERNEL);
 640         if (ses->serverNOS) {
 641                 memcpy(ses->serverNOS, bcc_ptr, len);
 642                 ses->serverNOS[len] = 0;
 643         }
 644
 645         bcc_ptr += len + 1;
 646         bleft -= len + 1;
 647
 648         len = strnlen(bcc_ptr, bleft);
 649         if (len > bleft)
 650                 return;
 651
 652         /* No domain field in LANMAN case. Domain is
 653            returned by old servers in the SMB negprot response */
 654         /* BB For newer servers which do not support Unicode,
 655            but thus do return domain here we could add parsing
 656            for it later, but it is not very important */
 657         cifs_dbg(FYI, "ascii: bytes left %d\n", bleft);
 658 }
 659
 660 int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
 661                                     struct cifs_ses *ses)
 662 {
 663         unsigned int tioffset; /* challenge message target info area */
 664         unsigned int tilen; /* challenge message target info area length  */
 665         CHALLENGE_MESSAGE *pblob = (CHALLENGE_MESSAGE *)bcc_ptr;
 666         __u32 server_flags;
 667
 668         if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
 669                 cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);
 670                 return -EINVAL;
 671         }
 672
 673         if (memcmp(pblob->Signature, "NTLMSSP", 8)) {
 674                 cifs_dbg(VFS, "blob signature incorrect %s\n",
 675                          pblob->Signature);
 676                 return -EINVAL;
 677         }
 678         if (pblob->MessageType != NtLmChallenge) {
 679                 cifs_dbg(VFS, "Incorrect message type %d\n",
 680                          pblob->MessageType);
 681                 return -EINVAL;
 682         }
 683
 684         server_flags = le32_to_cpu(pblob->NegotiateFlags);
 685         cifs_dbg(FYI, "%s: negotiate=0x%08x challenge=0x%08x\n", __func__,
 686                  ses->ntlmssp->client_flags, server_flags);
 687
 688         if ((ses->ntlmssp->client_flags & (NTLMSSP_NEGOTIATE_SEAL | NTLMSSP_NEGOTIATE_SIGN)) &&
 689             (!(server_flags & NTLMSSP_NEGOTIATE_56) && !(server_flags & NTLMSSP_NEGOTIATE_128))) {
 690                 cifs_dbg(VFS, "%s: requested signing/encryption but server did not return either 56-bit or 128-bit session key size\n",
 691                          __func__);
 692                 return -EINVAL;
 693         }
 694         if (!(server_flags & NTLMSSP_NEGOTIATE_NTLM) && !(server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) {
 695                 cifs_dbg(VFS, "%s: server does not seem to support either NTLMv1 or NTLMv2\n", __func__);
 696                 return -EINVAL;
 697         }
 698         if (ses->server->sign && !(server_flags & NTLMSSP_NEGOTIATE_SIGN)) {
 699                 cifs_dbg(VFS, "%s: forced packet signing but server does not seem to support it\n",
 700                          __func__);
 701                 return -EOPNOTSUPP;
 702         }
 703         if ((ses->ntlmssp->client_flags & NTLMSSP_NEGOTIATE_KEY_XCH) &&
 704             !(server_flags & NTLMSSP_NEGOTIATE_KEY_XCH))
 705                 pr_warn_once("%s: authentication has been weakened as server does not support key exchange\n",
 706                              __func__);
 707
 708         ses->ntlmssp->server_flags = server_flags;
 709
 710         memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);
 711         /* In particular we can examine sign flags */
 712         /* BB spec says that if AvId field of MsvAvTimestamp is populated then
 713                 we must set the MIC field of the AUTHENTICATE_MESSAGE */
 714
 715         tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
 716         tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
 717         if (tioffset > blob_len || tioffset + tilen > blob_len) {
 718                 cifs_dbg(VFS, "tioffset + tilen too high %u + %u\n",
 719                          tioffset, tilen);
 720                 return -EINVAL;
 721         }
 722         if (tilen) {
 723                 ses->auth_key.response = kmemdup(bcc_ptr + tioffset, tilen,
 724                                                  GFP_KERNEL);
 725                 if (!ses->auth_key.response) {
 726                         cifs_dbg(VFS, "Challenge target info alloc failure\n");
 727                         return -ENOMEM;
 728                 }
 729                 ses->auth_key.len = tilen;
 730         }
 731
 732         return 0;
 733 }
 734
 735 static int size_of_ntlmssp_blob(struct cifs_ses *ses, int base_size)
 736 {
 737         int sz = base_size + ses->auth_key.len
 738                 - CIFS_SESS_KEY_SIZE + CIFS_CPHTXT_SIZE + 2;
 739
 740         if (ses->domainName)
 741                 sz += sizeof(__le16) * strnlen(ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
 742         else
 743                 sz += sizeof(__le16);
 744
 745         if (ses->user_name)
 746                 sz += sizeof(__le16) * strnlen(ses->user_name, CIFS_MAX_USERNAME_LEN);
 747         else
 748                 sz += sizeof(__le16);
 749
 750         if (ses->workstation_name[0])
 751                 sz += sizeof(__le16) * strnlen(ses->workstation_name,
 752                                                ntlmssp_workstation_name_size(ses));
 753         else
 754                 sz += sizeof(__le16);
 755
 756         return sz;
 757 }
 758
 759 static inline void cifs_security_buffer_from_str(SECURITY_BUFFER *pbuf,
 760                                                  char *str_value,
 761                                                  int str_length,
 762                                                  unsigned char *pstart,
 763                                                  unsigned char **pcur,
 764                                                  const struct nls_table *nls_cp)
 765 {
 766         unsigned char *tmp = pstart;
 767         int len;
 768
 769         if (!pbuf)
 770                 return;
 771
 772         if (!pcur)
 773                 pcur = &tmp;
 774
 775         if (!str_value) {
 776                 pbuf->BufferOffset = cpu_to_le32(*pcur - pstart);
 777                 pbuf->Length = 0;
 778                 pbuf->MaximumLength = 0;
 779                 *pcur += sizeof(__le16);
 780         } else {
 781                 len = cifs_strtoUTF16((__le16 *)*pcur,
 782                                       str_value,
 783                                       str_length,
 784                                       nls_cp);
 785                 len *= sizeof(__le16);
 786                 pbuf->BufferOffset = cpu_to_le32(*pcur - pstart);
 787                 pbuf->Length = cpu_to_le16(len);
 788                 pbuf->MaximumLength = cpu_to_le16(len);
 789                 *pcur += len;
 790         }
 791 }
 792
 793 /* BB Move to ntlmssp.c eventually */
 794
 795 int build_ntlmssp_negotiate_blob(unsigned char **pbuffer,
 796                                  u16 *buflen,
 797                                  struct cifs_ses *ses,
 798                                  struct TCP_Server_Info *server,
 799                                  const struct nls_table *nls_cp)
 800 {
 801         int rc = 0;
 802         NEGOTIATE_MESSAGE *sec_blob;
 803         __u32 flags;
 804         unsigned char *tmp;
 805         int len;
 806
 807         len = size_of_ntlmssp_blob(ses, sizeof(NEGOTIATE_MESSAGE));
 808         *pbuffer = kmalloc(len, GFP_KERNEL);
 809         if (!*pbuffer) {
 810                 rc = -ENOMEM;
 811                 cifs_dbg(VFS, "Error %d during NTLMSSP allocation\n", rc);
 812                 *buflen = 0;
 813                 goto setup_ntlm_neg_ret;
 814         }
 815         sec_blob = (NEGOTIATE_MESSAGE *)*pbuffer;
 816
 817         memset(*pbuffer, 0, sizeof(NEGOTIATE_MESSAGE));
 818         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 819         sec_blob->MessageType = NtLmNegotiate;
 820
 821         /* BB is NTLMV2 session security format easier to use here? */
 822         flags = NTLMSSP_NEGOTIATE_56 |  NTLMSSP_REQUEST_TARGET |
 823                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 824                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC |
 825                 NTLMSSP_NEGOTIATE_ALWAYS_SIGN | NTLMSSP_NEGOTIATE_SEAL |
 826                 NTLMSSP_NEGOTIATE_SIGN;
 827         if (!server->session_estab || ses->ntlmssp->sesskey_per_smbsess)
 828                 flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 829
 830         tmp = *pbuffer + sizeof(NEGOTIATE_MESSAGE);
 831         ses->ntlmssp->client_flags = flags;
 832         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 833
 834         /* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */
 835         cifs_security_buffer_from_str(&sec_blob->DomainName,
 836                                       NULL,
 837                                       CIFS_MAX_DOMAINNAME_LEN,
 838                                       *pbuffer, &tmp,
 839                                       nls_cp);
 840
 841         cifs_security_buffer_from_str(&sec_blob->WorkstationName,
 842                                       NULL,
 843                                       CIFS_MAX_WORKSTATION_LEN,
 844                                       *pbuffer, &tmp,
 845                                       nls_cp);
 846
 847         *buflen = tmp - *pbuffer;
 848 setup_ntlm_neg_ret:
 849         return rc;
 850 }
 851
 852 /*
 853  * Build ntlmssp blob with additional fields, such as version,
 854  * supported by modern servers. For safety limit to SMB3 or later
 855  * See notes in MS-NLMP Section 2.2.2.1 e.g.
 856  */
 857 int build_ntlmssp_smb3_negotiate_blob(unsigned char **pbuffer,
 858                                  u16 *buflen,
 859                                  struct cifs_ses *ses,
 860                                  struct TCP_Server_Info *server,
 861                                  const struct nls_table *nls_cp)
 862 {
 863         int rc = 0;
 864         struct negotiate_message *sec_blob;
 865         __u32 flags;
 866         unsigned char *tmp;
 867         int len;
 868
 869         len = size_of_ntlmssp_blob(ses, sizeof(struct negotiate_message));
 870         *pbuffer = kmalloc(len, GFP_KERNEL);
 871         if (!*pbuffer) {
 872                 rc = -ENOMEM;
 873                 cifs_dbg(VFS, "Error %d during NTLMSSP allocation\n", rc);
 874                 *buflen = 0;
 875                 goto setup_ntlm_smb3_neg_ret;
 876         }
 877         sec_blob = (struct negotiate_message *)*pbuffer;
 878
 879         memset(*pbuffer, 0, sizeof(struct negotiate_message));
 880         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 881         sec_blob->MessageType = NtLmNegotiate;
 882
 883         /* BB is NTLMV2 session security format easier to use here? */
 884         flags = NTLMSSP_NEGOTIATE_56 |  NTLMSSP_REQUEST_TARGET |
 885                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 886                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC |
 887                 NTLMSSP_NEGOTIATE_ALWAYS_SIGN | NTLMSSP_NEGOTIATE_SEAL |
 888                 NTLMSSP_NEGOTIATE_SIGN | NTLMSSP_NEGOTIATE_VERSION;
 889         if (!server->session_estab || ses->ntlmssp->sesskey_per_smbsess)
 890                 flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 891
 892         sec_blob->Version.ProductMajorVersion = LINUX_VERSION_MAJOR;
 893         sec_blob->Version.ProductMinorVersion = LINUX_VERSION_PATCHLEVEL;
 894         sec_blob->Version.ProductBuild = cpu_to_le16(SMB3_PRODUCT_BUILD);
 895         sec_blob->Version.NTLMRevisionCurrent = NTLMSSP_REVISION_W2K3;
 896
 897         tmp = *pbuffer + sizeof(struct negotiate_message);
 898         ses->ntlmssp->client_flags = flags;
 899         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 900
 901         /* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */
 902         cifs_security_buffer_from_str(&sec_blob->DomainName,
 903                                       NULL,
 904                                       CIFS_MAX_DOMAINNAME_LEN,
 905                                       *pbuffer, &tmp,
 906                                       nls_cp);
 907
 908         cifs_security_buffer_from_str(&sec_blob->WorkstationName,
 909                                       NULL,
 910                                       CIFS_MAX_WORKSTATION_LEN,
 911                                       *pbuffer, &tmp,
 912                                       nls_cp);
 913
 914         *buflen = tmp - *pbuffer;
 915 setup_ntlm_smb3_neg_ret:
 916         return rc;
 917 }
 918
 919
 920 int build_ntlmssp_auth_blob(unsigned char **pbuffer,
 921                                         u16 *buflen,
 922                                    struct cifs_ses *ses,
 923                                    struct TCP_Server_Info *server,
 924                                    const struct nls_table *nls_cp)
 925 {
 926         int rc;
 927         AUTHENTICATE_MESSAGE *sec_blob;
 928         __u32 flags;
 929         unsigned char *tmp;
 930         int len;
 931
 932         rc = setup_ntlmv2_rsp(ses, nls_cp);
 933         if (rc) {
 934                 cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc);
 935                 *buflen = 0;
 936                 goto setup_ntlmv2_ret;
 937         }
 938
 939         len = size_of_ntlmssp_blob(ses, sizeof(AUTHENTICATE_MESSAGE));
 940         *pbuffer = kmalloc(len, GFP_KERNEL);
 941         if (!*pbuffer) {
 942                 rc = -ENOMEM;
 943                 cifs_dbg(VFS, "Error %d during NTLMSSP allocation\n", rc);
 944                 *buflen = 0;
 945                 goto setup_ntlmv2_ret;
 946         }
 947         sec_blob = (AUTHENTICATE_MESSAGE *)*pbuffer;
 948
 949         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 950         sec_blob->MessageType = NtLmAuthenticate;
 951
 952         flags = ses->ntlmssp->server_flags | NTLMSSP_REQUEST_TARGET |
 953                 NTLMSSP_NEGOTIATE_TARGET_INFO | NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED;
 954
 955         tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);
 956         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 957
 958         sec_blob->LmChallengeResponse.BufferOffset =
 959                                 cpu_to_le32(sizeof(AUTHENTICATE_MESSAGE));
 960         sec_blob->LmChallengeResponse.Length = 0;
 961         sec_blob->LmChallengeResponse.MaximumLength = 0;
 962
 963         sec_blob->NtChallengeResponse.BufferOffset =
 964                                 cpu_to_le32(tmp - *pbuffer);
 965         if (ses->user_name != NULL) {
 966                 memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 967                                 ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 968                 tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
 969
 970                 sec_blob->NtChallengeResponse.Length =
 971                                 cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 972                 sec_blob->NtChallengeResponse.MaximumLength =
 973                                 cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 974         } else {
 975                 /*
 976                  * don't send an NT Response for anonymous access
 977                  */
 978                 sec_blob->NtChallengeResponse.Length = 0;
 979                 sec_blob->NtChallengeResponse.MaximumLength = 0;
 980         }
 981
 982         cifs_security_buffer_from_str(&sec_blob->DomainName,
 983                                       ses->domainName,
 984                                       CIFS_MAX_DOMAINNAME_LEN,
 985                                       *pbuffer, &tmp,
 986                                       nls_cp);
 987
 988         cifs_security_buffer_from_str(&sec_blob->UserName,
 989                                       ses->user_name,
 990                                       CIFS_MAX_USERNAME_LEN,
 991                                       *pbuffer, &tmp,
 992                                       nls_cp);
 993
 994         cifs_security_buffer_from_str(&sec_blob->WorkstationName,
 995                                       ses->workstation_name,
 996                                       ntlmssp_workstation_name_size(ses),
 997                                       *pbuffer, &tmp,
 998                                       nls_cp);
 999
1000         if ((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) &&
1001             (!ses->server->session_estab || ses->ntlmssp->sesskey_per_smbsess) &&
1002             !calc_seckey(ses)) {
1003                 memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
1004                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
1005                 sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);
1006                 sec_blob->SessionKey.MaximumLength =
1007                                 cpu_to_le16(CIFS_CPHTXT_SIZE);
1008                 tmp += CIFS_CPHTXT_SIZE;
1009         } else {
1010                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
1011                 sec_blob->SessionKey.Length = 0;
1012                 sec_blob->SessionKey.MaximumLength = 0;
1013         }
1014
1015         *buflen = tmp - *pbuffer;
1016 setup_ntlmv2_ret:
1017         return rc;
1018 }
1019
1020 enum securityEnum
1021 cifs_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
1022 {
1023         switch (server->negflavor) {
1024         case CIFS_NEGFLAVOR_EXTENDED:
1025                 switch (requested) {
1026                 case Kerberos:
1027                 case RawNTLMSSP:
1028                         return requested;
1029                 case Unspecified:
1030                         if (server->sec_ntlmssp &&
1031                             (global_secflags & CIFSSEC_MAY_NTLMSSP))
1032                                 return RawNTLMSSP;
1033                         if ((server->sec_kerberos || server->sec_mskerberos) &&
1034                             (global_secflags & CIFSSEC_MAY_KRB5))
1035                                 return Kerberos;
1036                         fallthrough;
1037                 default:
1038                         return Unspecified;
1039                 }
1040         case CIFS_NEGFLAVOR_UNENCAP:
1041                 switch (requested) {
1042                 case NTLMv2:
1043                         return requested;
1044                 case Unspecified:
1045                         if (global_secflags & CIFSSEC_MAY_NTLMV2)
1046                                 return NTLMv2;
1047                         break;
1048                 default:
1049                         break;
1050                 }
1051                 fallthrough;
1052         default:
1053                 return Unspecified;
1054         }
1055 }
1056
1057 struct sess_data {
1058         unsigned int xid;
1059         struct cifs_ses *ses;
1060         struct TCP_Server_Info *server;
1061         struct nls_table *nls_cp;
1062         void (*func)(struct sess_data *);
1063         int result;
1064
1065         /* we will send the SMB in three pieces:
1066          * a fixed length beginning part, an optional
1067          * SPNEGO blob (which can be zero length), and a
1068          * last part which will include the strings
1069          * and rest of bcc area. This allows us to avoid
1070          * a large buffer 17K allocation
1071          */
1072         int buf0_type;
1073         struct kvec iov[3];
1074 };
1075
1076 static int
1077 sess_alloc_buffer(struct sess_data *sess_data, int wct)
1078 {
1079         int rc;
1080         struct cifs_ses *ses = sess_data->ses;
1081         struct smb_hdr *smb_buf;
1082
1083         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
1084                                   (void **)&smb_buf);
1085
1086         if (rc)
1087                 return rc;
1088
1089         sess_data->iov[0].iov_base = (char *)smb_buf;
1090         sess_data->iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
1091         /*
1092          * This variable will be used to clear the buffer
1093          * allocated above in case of any error in the calling function.
1094          */
1095         sess_data->buf0_type = CIFS_SMALL_BUFFER;
1096
1097         /* 2000 big enough to fit max user, domain, NOS name etc. */
1098         sess_data->iov[2].iov_base = kmalloc(2000, GFP_KERNEL);
1099         if (!sess_data->iov[2].iov_base) {
1100                 rc = -ENOMEM;
1101                 goto out_free_smb_buf;
1102         }
1103
1104         return 0;
1105
1106 out_free_smb_buf:
1107         cifs_small_buf_release(smb_buf);
1108         sess_data->iov[0].iov_base = NULL;
1109         sess_data->iov[0].iov_len = 0;
1110         sess_data->buf0_type = CIFS_NO_BUFFER;
1111         return rc;
1112 }
1113
1114 static void
1115 sess_free_buffer(struct sess_data *sess_data)
1116 {
1117
1118         free_rsp_buf(sess_data->buf0_type, sess_data->iov[0].iov_base);
1119         sess_data->buf0_type = CIFS_NO_BUFFER;
1120         kfree(sess_data->iov[2].iov_base);
1121 }
1122
1123 static int
1124 sess_establish_session(struct sess_data *sess_data)
1125 {
1126         struct cifs_ses *ses = sess_data->ses;
1127         struct TCP_Server_Info *server = sess_data->server;
1128
1129         cifs_server_lock(server);
1130         if (!server->session_estab) {
1131                 if (server->sign) {
1132                         server->session_key.response =
1133                                 kmemdup(ses->auth_key.response,
1134                                 ses->auth_key.len, GFP_KERNEL);
1135                         if (!server->session_key.response) {
1136                                 cifs_server_unlock(server);
1137                                 return -ENOMEM;
1138                         }
1139                         server->session_key.len =
1140                                                 ses->auth_key.len;
1141                 }
1142                 server->sequence_number = 0x2;
1143                 server->session_estab = true;
1144         }
1145         cifs_server_unlock(server);
1146
1147         cifs_dbg(FYI, "CIFS session established successfully\n");
1148         return 0;
1149 }
1150
1151 static int
1152 sess_sendreceive(struct sess_data *sess_data)
1153 {
1154         int rc;
1155         struct smb_hdr *smb_buf = (struct smb_hdr *) sess_data->iov[0].iov_base;
1156         __u16 count;
1157         struct kvec rsp_iov = { NULL, 0 };
1158
1159         count = sess_data->iov[1].iov_len + sess_data->iov[2].iov_len;
1160         be32_add_cpu(&smb_buf->smb_buf_length, count);
1161         put_bcc(count, smb_buf);
1162
1163         rc = SendReceive2(sess_data->xid, sess_data->ses,
1164                           sess_data->iov, 3 /* num_iovecs */,
1165                           &sess_data->buf0_type,
1166                           CIFS_LOG_ERROR, &rsp_iov);
1167         cifs_small_buf_release(sess_data->iov[0].iov_base);
1168         memcpy(&sess_data->iov[0], &rsp_iov, sizeof(struct kvec));
1169
1170         return rc;
1171 }
1172
1173 static void
1174 sess_auth_ntlmv2(struct sess_data *sess_data)
1175 {
1176         int rc = 0;
1177         struct smb_hdr *smb_buf;
1178         SESSION_SETUP_ANDX *pSMB;
1179         char *bcc_ptr;
1180         struct cifs_ses *ses = sess_data->ses;
1181         struct TCP_Server_Info *server = sess_data->server;
1182         __u32 capabilities;
1183         __u16 bytes_remaining;
1184
1185         /* old style NTLM sessionsetup */
1186         /* wct = 13 */
1187         rc = sess_alloc_buffer(sess_data, 13);
1188         if (rc)
1189                 goto out;
1190
1191         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1192         bcc_ptr = sess_data->iov[2].iov_base;
1193         capabilities = cifs_ssetup_hdr(ses, server, pSMB);
1194
1195         pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
1196
1197         /* LM2 password would be here if we supported it */
1198         pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
1199
1200         if (ses->user_name != NULL) {
1201                 /* calculate nlmv2 response and session key */
1202                 rc = setup_ntlmv2_rsp(ses, sess_data->nls_cp);
1203                 if (rc) {
1204                         cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n", rc);
1205                         goto out;
1206                 }
1207
1208                 memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
1209                                 ses->auth_key.len - CIFS_SESS_KEY_SIZE);
1210                 bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
1211
1212                 /* set case sensitive password length after tilen may get
1213                  * assigned, tilen is 0 otherwise.
1214                  */
1215                 pSMB->req_no_secext.CaseSensitivePasswordLength =
1216                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
1217         } else {
1218                 pSMB->req_no_secext.CaseSensitivePasswordLength = 0;
1219         }
1220
1221         if (ses->capabilities & CAP_UNICODE) {
1222                 if (sess_data->iov[0].iov_len % 2) {
1223                         *bcc_ptr = 0;
1224                         bcc_ptr++;
1225                 }
1226                 unicode_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
1227         } else {
1228                 ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
1229         }
1230
1231
1232         sess_data->iov[2].iov_len = (long) bcc_ptr -
1233                         (long) sess_data->iov[2].iov_base;
1234
1235         rc = sess_sendreceive(sess_data);
1236         if (rc)
1237                 goto out;
1238
1239         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1240         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1241
1242         if (smb_buf->WordCount != 3) {
1243                 rc = -EIO;
1244                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1245                 goto out;
1246         }
1247
1248         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
1249                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1250
1251         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1252         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1253
1254         bytes_remaining = get_bcc(smb_buf);
1255         bcc_ptr = pByteArea(smb_buf);
1256
1257         /* BB check if Unicode and decode strings */
1258         if (bytes_remaining == 0) {
1259                 /* no string area to decode, do nothing */
1260         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1261                 /* unicode string area must be word-aligned */
1262                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1263                         ++bcc_ptr;
1264                         --bytes_remaining;
1265                 }
1266                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
1267                                       sess_data->nls_cp);
1268         } else {
1269                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
1270                                     sess_data->nls_cp);
1271         }
1272
1273         rc = sess_establish_session(sess_data);
1274 out:
1275         sess_data->result = rc;
1276         sess_data->func = NULL;
1277         sess_free_buffer(sess_data);
1278         kfree(ses->auth_key.response);
1279         ses->auth_key.response = NULL;
1280 }
1281
1282 #ifdef CONFIG_CIFS_UPCALL
1283 static void
1284 sess_auth_kerberos(struct sess_data *sess_data)
1285 {
1286         int rc = 0;
1287         struct smb_hdr *smb_buf;
1288         SESSION_SETUP_ANDX *pSMB;
1289         char *bcc_ptr;
1290         struct cifs_ses *ses = sess_data->ses;
1291         struct TCP_Server_Info *server = sess_data->server;
1292         __u32 capabilities;
1293         __u16 bytes_remaining;
1294         struct key *spnego_key = NULL;
1295         struct cifs_spnego_msg *msg;
1296         u16 blob_len;
1297
1298         /* extended security */
1299         /* wct = 12 */
1300         rc = sess_alloc_buffer(sess_data, 12);
1301         if (rc)
1302                 goto out;
1303
1304         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1305         bcc_ptr = sess_data->iov[2].iov_base;
1306         capabilities = cifs_ssetup_hdr(ses, server, pSMB);
1307
1308         spnego_key = cifs_get_spnego_key(ses, server);
1309         if (IS_ERR(spnego_key)) {
1310                 rc = PTR_ERR(spnego_key);
1311                 spnego_key = NULL;
1312                 goto out;
1313         }
1314
1315         msg = spnego_key->payload.data[0];
1316         /*
1317          * check version field to make sure that cifs.upcall is
1318          * sending us a response in an expected form
1319          */
1320         if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
1321                 cifs_dbg(VFS, "incorrect version of cifs.upcall (expected %d but got %d)\n",
1322                          CIFS_SPNEGO_UPCALL_VERSION, msg->version);
1323                 rc = -EKEYREJECTED;
1324                 goto out_put_spnego_key;
1325         }
1326
1327         ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len,
1328                                          GFP_KERNEL);
1329         if (!ses->auth_key.response) {
1330                 cifs_dbg(VFS, "Kerberos can't allocate (%u bytes) memory\n",
1331                          msg->sesskey_len);
1332                 rc = -ENOMEM;
1333                 goto out_put_spnego_key;
1334         }
1335         ses->auth_key.len = msg->sesskey_len;
1336
1337         pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1338         capabilities |= CAP_EXTENDED_SECURITY;
1339         pSMB->req.Capabilities = cpu_to_le32(capabilities);
1340         sess_data->iov[1].iov_base = msg->data + msg->sesskey_len;
1341         sess_data->iov[1].iov_len = msg->secblob_len;
1342         pSMB->req.SecurityBlobLength = cpu_to_le16(sess_data->iov[1].iov_len);
1343
1344         if (ses->capabilities & CAP_UNICODE) {
1345                 /* unicode strings must be word aligned */
1346                 if ((sess_data->iov[0].iov_len
1347                         + sess_data->iov[1].iov_len) % 2) {
1348                         *bcc_ptr = 0;
1349                         bcc_ptr++;
1350                 }
1351                 unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1352                 unicode_domain_string(&bcc_ptr, ses, sess_data->nls_cp);
1353         } else {
1354                 /* BB: is this right? */
1355                 ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
1356         }
1357
1358         sess_data->iov[2].iov_len = (long) bcc_ptr -
1359                         (long) sess_data->iov[2].iov_base;
1360
1361         rc = sess_sendreceive(sess_data);
1362         if (rc)
1363                 goto out_put_spnego_key;
1364
1365         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1366         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1367
1368         if (smb_buf->WordCount != 4) {
1369                 rc = -EIO;
1370                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1371                 goto out_put_spnego_key;
1372         }
1373
1374         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
1375                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1376
1377         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1378         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1379
1380         bytes_remaining = get_bcc(smb_buf);
1381         bcc_ptr = pByteArea(smb_buf);
1382
1383         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1384         if (blob_len > bytes_remaining) {
1385                 cifs_dbg(VFS, "bad security blob length %d\n",
1386                                 blob_len);
1387                 rc = -EINVAL;
1388                 goto out_put_spnego_key;
1389         }
1390         bcc_ptr += blob_len;
1391         bytes_remaining -= blob_len;
1392
1393         /* BB check if Unicode and decode strings */
1394         if (bytes_remaining == 0) {
1395                 /* no string area to decode, do nothing */
1396         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1397                 /* unicode string area must be word-aligned */
1398                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1399                         ++bcc_ptr;
1400                         --bytes_remaining;
1401                 }
1402                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
1403                                       sess_data->nls_cp);
1404         } else {
1405                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
1406                                     sess_data->nls_cp);
1407         }
1408
1409         rc = sess_establish_session(sess_data);
1410 out_put_spnego_key:
1411         key_invalidate(spnego_key);
1412         key_put(spnego_key);
1413 out:
1414         sess_data->result = rc;
1415         sess_data->func = NULL;
1416         sess_free_buffer(sess_data);
1417         kfree(ses->auth_key.response);
1418         ses->auth_key.response = NULL;
1419 }
1420
1421 #endif /* ! CONFIG_CIFS_UPCALL */
1422
1423 /*
1424  * The required kvec buffers have to be allocated before calling this
1425  * function.
1426  */
1427 static int
1428 _sess_auth_rawntlmssp_assemble_req(struct sess_data *sess_data)
1429 {
1430         SESSION_SETUP_ANDX *pSMB;
1431         struct cifs_ses *ses = sess_data->ses;
1432         struct TCP_Server_Info *server = sess_data->server;
1433         __u32 capabilities;
1434         char *bcc_ptr;
1435
1436         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1437
1438         capabilities = cifs_ssetup_hdr(ses, server, pSMB);
1439         if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
1440                 cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
1441                 return -ENOSYS;
1442         }
1443
1444         pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1445         capabilities |= CAP_EXTENDED_SECURITY;
1446         pSMB->req.Capabilities |= cpu_to_le32(capabilities);
1447
1448         bcc_ptr = sess_data->iov[2].iov_base;
1449         /* unicode strings must be word aligned */
1450         if ((sess_data->iov[0].iov_len + sess_data->iov[1].iov_len) % 2) {
1451                 *bcc_ptr = 0;
1452                 bcc_ptr++;
1453         }
1454         unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1455
1456         sess_data->iov[2].iov_len = (long) bcc_ptr -
1457                                         (long) sess_data->iov[2].iov_base;
1458
1459         return 0;
1460 }
1461
1462 static void
1463 sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data);
1464
1465 static void
1466 sess_auth_rawntlmssp_negotiate(struct sess_data *sess_data)
1467 {
1468         int rc;
1469         struct smb_hdr *smb_buf;
1470         SESSION_SETUP_ANDX *pSMB;
1471         struct cifs_ses *ses = sess_data->ses;
1472         struct TCP_Server_Info *server = sess_data->server;
1473         __u16 bytes_remaining;
1474         char *bcc_ptr;
1475         unsigned char *ntlmsspblob = NULL;
1476         u16 blob_len;
1477
1478         cifs_dbg(FYI, "rawntlmssp session setup negotiate phase\n");
1479
1480         /*
1481          * if memory allocation is successful, caller of this function
1482          * frees it.
1483          */
1484         ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
1485         if (!ses->ntlmssp) {
1486                 rc = -ENOMEM;
1487                 goto out;
1488         }
1489         ses->ntlmssp->sesskey_per_smbsess = false;
1490
1491         /* wct = 12 */
1492         rc = sess_alloc_buffer(sess_data, 12);
1493         if (rc)
1494                 goto out;
1495
1496         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1497
1498         /* Build security blob before we assemble the request */
1499         rc = build_ntlmssp_negotiate_blob(&ntlmsspblob,
1500                                      &blob_len, ses, server,
1501                                      sess_data->nls_cp);
1502         if (rc)
1503                 goto out_free_ntlmsspblob;
1504
1505         sess_data->iov[1].iov_len = blob_len;
1506         sess_data->iov[1].iov_base = ntlmsspblob;
1507         pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
1508
1509         rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
1510         if (rc)
1511                 goto out_free_ntlmsspblob;
1512
1513         rc = sess_sendreceive(sess_data);
1514
1515         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1516         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1517
1518         /* If true, rc here is expected and not an error */
1519         if (sess_data->buf0_type != CIFS_NO_BUFFER &&
1520             smb_buf->Status.CifsError ==
1521                         cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
1522                 rc = 0;
1523
1524         if (rc)
1525                 goto out_free_ntlmsspblob;
1526
1527         cifs_dbg(FYI, "rawntlmssp session setup challenge phase\n");
1528
1529         if (smb_buf->WordCount != 4) {
1530                 rc = -EIO;
1531                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1532                 goto out_free_ntlmsspblob;
1533         }
1534
1535         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1536         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1537
1538         bytes_remaining = get_bcc(smb_buf);
1539         bcc_ptr = pByteArea(smb_buf);
1540
1541         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1542         if (blob_len > bytes_remaining) {
1543                 cifs_dbg(VFS, "bad security blob length %d\n",
1544                                 blob_len);
1545                 rc = -EINVAL;
1546                 goto out_free_ntlmsspblob;
1547         }
1548
1549         rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
1550
1551 out_free_ntlmsspblob:
1552         kfree(ntlmsspblob);
1553 out:
1554         sess_free_buffer(sess_data);
1555
1556         if (!rc) {
1557                 sess_data->func = sess_auth_rawntlmssp_authenticate;
1558                 return;
1559         }
1560
1561         /* Else error. Cleanup */
1562         kfree(ses->auth_key.response);
1563         ses->auth_key.response = NULL;
1564         kfree(ses->ntlmssp);
1565         ses->ntlmssp = NULL;
1566
1567         sess_data->func = NULL;
1568         sess_data->result = rc;
1569 }
1570
1571 static void
1572 sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data)
1573 {
1574         int rc;
1575         struct smb_hdr *smb_buf;
1576         SESSION_SETUP_ANDX *pSMB;
1577         struct cifs_ses *ses = sess_data->ses;
1578         struct TCP_Server_Info *server = sess_data->server;
1579         __u16 bytes_remaining;
1580         char *bcc_ptr;
1581         unsigned char *ntlmsspblob = NULL;
1582         u16 blob_len;
1583
1584         cifs_dbg(FYI, "rawntlmssp session setup authenticate phase\n");
1585
1586         /* wct = 12 */
1587         rc = sess_alloc_buffer(sess_data, 12);
1588         if (rc)
1589                 goto out;
1590
1591         /* Build security blob before we assemble the request */
1592         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1593         smb_buf = (struct smb_hdr *)pSMB;
1594         rc = build_ntlmssp_auth_blob(&ntlmsspblob,
1595                                         &blob_len, ses, server,
1596                                         sess_data->nls_cp);
1597         if (rc)
1598                 goto out_free_ntlmsspblob;
1599         sess_data->iov[1].iov_len = blob_len;
1600         sess_data->iov[1].iov_base = ntlmsspblob;
1601         pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
1602         /*
1603          * Make sure that we tell the server that we are using
1604          * the uid that it just gave us back on the response
1605          * (challenge)
1606          */
1607         smb_buf->Uid = ses->Suid;
1608
1609         rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
1610         if (rc)
1611                 goto out_free_ntlmsspblob;
1612
1613         rc = sess_sendreceive(sess_data);
1614         if (rc)
1615                 goto out_free_ntlmsspblob;
1616
1617         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1618         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1619         if (smb_buf->WordCount != 4) {
1620                 rc = -EIO;
1621                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1622                 goto out_free_ntlmsspblob;
1623         }
1624
1625         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
1626                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1627
1628         if (ses->Suid != smb_buf->Uid) {
1629                 ses->Suid = smb_buf->Uid;
1630                 cifs_dbg(FYI, "UID changed! new UID = %llu\n", ses->Suid);
1631         }
1632
1633         bytes_remaining = get_bcc(smb_buf);
1634         bcc_ptr = pByteArea(smb_buf);
1635         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1636         if (blob_len > bytes_remaining) {
1637                 cifs_dbg(VFS, "bad security blob length %d\n",
1638                                 blob_len);
1639                 rc = -EINVAL;
1640                 goto out_free_ntlmsspblob;
1641         }
1642         bcc_ptr += blob_len;
1643         bytes_remaining -= blob_len;
1644
1645
1646         /* BB check if Unicode and decode strings */
1647         if (bytes_remaining == 0) {
1648                 /* no string area to decode, do nothing */
1649         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1650                 /* unicode string area must be word-aligned */
1651                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1652                         ++bcc_ptr;
1653                         --bytes_remaining;
1654                 }
1655                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
1656                                       sess_data->nls_cp);
1657         } else {
1658                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
1659                                     sess_data->nls_cp);
1660         }
1661
1662 out_free_ntlmsspblob:
1663         kfree(ntlmsspblob);
1664 out:
1665         sess_free_buffer(sess_data);
1666
1667         if (!rc)
1668                 rc = sess_establish_session(sess_data);
1669
1670         /* Cleanup */
1671         kfree(ses->auth_key.response);
1672         ses->auth_key.response = NULL;
1673         kfree(ses->ntlmssp);
1674         ses->ntlmssp = NULL;
1675
1676         sess_data->func = NULL;
1677         sess_data->result = rc;
1678 }
1679
1680 static int select_sec(struct sess_data *sess_data)
1681 {
1682         int type;
1683         struct cifs_ses *ses = sess_data->ses;
1684         struct TCP_Server_Info *server = sess_data->server;
1685
1686         type = cifs_select_sectype(server, ses->sectype);
1687         cifs_dbg(FYI, "sess setup type %d\n", type);
1688         if (type == Unspecified) {
1689                 cifs_dbg(VFS, "Unable to select appropriate authentication method!\n");
1690                 return -EINVAL;
1691         }
1692
1693         switch (type) {
1694         case NTLMv2:
1695                 sess_data->func = sess_auth_ntlmv2;
1696                 break;
1697         case Kerberos:
1698 #ifdef CONFIG_CIFS_UPCALL
1699                 sess_data->func = sess_auth_kerberos;
1700                 break;
1701 #else
1702                 cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
1703                 return -ENOSYS;
1704 #endif /* CONFIG_CIFS_UPCALL */
1705         case RawNTLMSSP:
1706                 sess_data->func = sess_auth_rawntlmssp_negotiate;
1707                 break;
1708         default:
1709                 cifs_dbg(VFS, "secType %d not supported!\n", type);
1710                 return -ENOSYS;
1711         }
1712
1713         return 0;
1714 }
1715
1716 int CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
1717                    struct TCP_Server_Info *server,
1718                    const struct nls_table *nls_cp)
1719 {
1720         int rc = 0;
1721         struct sess_data *sess_data;
1722
1723         if (ses == NULL) {
1724                 WARN(1, "%s: ses == NULL!", __func__);
1725                 return -EINVAL;
1726         }
1727
1728         sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
1729         if (!sess_data)
1730                 return -ENOMEM;
1731
1732         sess_data->xid = xid;
1733         sess_data->ses = ses;
1734         sess_data->server = server;
1735         sess_data->buf0_type = CIFS_NO_BUFFER;
1736         sess_data->nls_cp = (struct nls_table *) nls_cp;
1737
1738         rc = select_sec(sess_data);
1739         if (rc)
1740                 goto out;
1741
1742         while (sess_data->func)
1743                 sess_data->func(sess_data);
1744
1745         /* Store result before we free sess_data */
1746         rc = sess_data->result;
1747
1748 out:
1749         kfree(sess_data);
1750         return rc;
1751 }