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, 2007
   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
  33 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
  34                          unsigned char *p24);
  35
  36 static __u32 cifs_ssetup_hdr(struct cifsSesInfo *ses, SESSION_SETUP_ANDX *pSMB)
  37 {
  38         __u32 capabilities = 0;
  39
  40         /* init fields common to all four types of SessSetup */
  41         /* note that header is initialized to zero in header_assemble */
  42         pSMB->req.AndXCommand = 0xFF;
  43         pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
  44         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
  45
  46         /* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
  47
  48         /* BB verify whether signing required on neg or just on auth frame
  49            (and NTLM case) */
  50
  51         capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
  52                         CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
  53
  54         if (ses->server->secMode &
  55             (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
  56                 pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
  57
  58         if (ses->capabilities & CAP_UNICODE) {
  59                 pSMB->req.hdr.Flags2 |= SMBFLG2_UNICODE;
  60                 capabilities |= CAP_UNICODE;
  61         }
  62         if (ses->capabilities & CAP_STATUS32) {
  63                 pSMB->req.hdr.Flags2 |= SMBFLG2_ERR_STATUS;
  64                 capabilities |= CAP_STATUS32;
  65         }
  66         if (ses->capabilities & CAP_DFS) {
  67                 pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
  68                 capabilities |= CAP_DFS;
  69         }
  70         if (ses->capabilities & CAP_UNIX)
  71                 capabilities |= CAP_UNIX;
  72
  73         /* BB check whether to init vcnum BB */
  74         return capabilities;
  75 }
  76
  77 static void
  78 unicode_oslm_strings(char **pbcc_area, const struct nls_table *nls_cp)
  79 {
  80         char *bcc_ptr = *pbcc_area;
  81         int bytes_ret = 0;
  82
  83         /* Copy OS version */
  84         bytes_ret = cifs_strtoUCS((__le16 *)bcc_ptr, "Linux version ", 32,
  85                                   nls_cp);
  86         bcc_ptr += 2 * bytes_ret;
  87         bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, init_utsname()->release,
  88                                   32, nls_cp);
  89         bcc_ptr += 2 * bytes_ret;
  90         bcc_ptr += 2; /* trailing null */
  91
  92         bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
  93                                   32, nls_cp);
  94         bcc_ptr += 2 * bytes_ret;
  95         bcc_ptr += 2; /* trailing null */
  96
  97         *pbcc_area = bcc_ptr;
  98 }
  99
 100 static void unicode_domain_string(char **pbcc_area, struct cifsSesInfo *ses,
 101                                    const struct nls_table *nls_cp)
 102 {
 103         char *bcc_ptr = *pbcc_area;
 104         int bytes_ret = 0;
 105
 106         /* copy domain */
 107         if (ses->domainName == NULL) {
 108                 /* Sending null domain better than using a bogus domain name (as
 109                 we did briefly in 2.6.18) since server will use its default */
 110                 *bcc_ptr = 0;
 111                 *(bcc_ptr+1) = 0;
 112                 bytes_ret = 0;
 113         } else
 114                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName,
 115                                           256, nls_cp);
 116         bcc_ptr += 2 * bytes_ret;
 117         bcc_ptr += 2;  /* account for null terminator */
 118
 119         *pbcc_area = bcc_ptr;
 120 }
 121
 122
 123 static void unicode_ssetup_strings(char **pbcc_area, struct cifsSesInfo *ses,
 124                                    const struct nls_table *nls_cp)
 125 {
 126         char *bcc_ptr = *pbcc_area;
 127         int bytes_ret = 0;
 128
 129         /* BB FIXME add check that strings total less
 130         than 335 or will need to send them as arrays */
 131
 132         /* unicode strings, must be word aligned before the call */
 133 /*      if ((long) bcc_ptr % 2) {
 134                 *bcc_ptr = 0;
 135                 bcc_ptr++;
 136         } */
 137         /* copy user */
 138         if (ses->userName == NULL) {
 139                 /* null user mount */
 140                 *bcc_ptr = 0;
 141                 *(bcc_ptr+1) = 0;
 142         } else { /* 300 should be long enough for any conceivable user name */
 143                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->userName,
 144                                           300, nls_cp);
 145         }
 146         bcc_ptr += 2 * bytes_ret;
 147         bcc_ptr += 2; /* account for null termination */
 148
 149         unicode_domain_string(&bcc_ptr, ses, nls_cp);
 150         unicode_oslm_strings(&bcc_ptr, nls_cp);
 151
 152         *pbcc_area = bcc_ptr;
 153 }
 154
 155 static void ascii_ssetup_strings(char **pbcc_area, struct cifsSesInfo *ses,
 156                                  const struct nls_table *nls_cp)
 157 {
 158         char *bcc_ptr = *pbcc_area;
 159
 160         /* copy user */
 161         /* BB what about null user mounts - check that we do this BB */
 162         /* copy user */
 163         if (ses->userName == NULL) {
 164                 /* BB what about null user mounts - check that we do this BB */
 165         } else { /* 300 should be long enough for any conceivable user name */
 166                 strncpy(bcc_ptr, ses->userName, 300);
 167         }
 168         /* BB improve check for overflow */
 169         bcc_ptr += strnlen(ses->userName, 300);
 170         *bcc_ptr = 0;
 171         bcc_ptr++; /* account for null termination */
 172
 173         /* copy domain */
 174
 175         if (ses->domainName != NULL) {
 176                 strncpy(bcc_ptr, ses->domainName, 256);
 177                 bcc_ptr += strnlen(ses->domainName, 256);
 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 int decode_unicode_ssetup(char **pbcc_area, int bleft,
 197                                  struct cifsSesInfo *ses,
 198                                  const struct nls_table *nls_cp)
 199 {
 200         int rc = 0;
 201         int words_left, len;
 202         char *data = *pbcc_area;
 203
 204
 205
 206         cFYI(1, ("bleft %d", bleft));
 207
 208
 209         /* SMB header is unaligned, so cifs servers word align start of
 210            Unicode strings */
 211         data++;
 212         bleft--; /* Windows servers do not always double null terminate
 213                     their final Unicode string - in which case we
 214                     now will not attempt to decode the byte of junk
 215                     which follows it */
 216
 217         words_left = bleft / 2;
 218
 219         /* save off server operating system */
 220         len = UniStrnlen((wchar_t *) data, words_left);
 221
 222 /* We look for obvious messed up bcc or strings in response so we do not go off
 223    the end since (at least) WIN2K and Windows XP have a major bug in not null
 224    terminating last Unicode string in response  */
 225         if (len >= words_left)
 226                 return rc;
 227
 228         kfree(ses->serverOS);
 229         /* UTF-8 string will not grow more than four times as big as UCS-16 */
 230         ses->serverOS = kzalloc(4 * len, GFP_KERNEL);
 231         if (ses->serverOS != NULL)
 232                 cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len, nls_cp);
 233         data += 2 * (len + 1);
 234         words_left -= len + 1;
 235
 236         /* save off server network operating system */
 237         len = UniStrnlen((wchar_t *) data, words_left);
 238
 239         if (len >= words_left)
 240                 return rc;
 241
 242         kfree(ses->serverNOS);
 243         ses->serverNOS = kzalloc(4 * len, GFP_KERNEL); /* BB this is wrong length FIXME BB */
 244         if (ses->serverNOS != NULL) {
 245                 cifs_strfromUCS_le(ses->serverNOS, (__le16 *)data, len,
 246                                    nls_cp);
 247                 if (strncmp(ses->serverNOS, "NT LAN Manager 4", 16) == 0) {
 248                         cFYI(1, ("NT4 server"));
 249                         ses->flags |= CIFS_SES_NT4;
 250                 }
 251         }
 252         data += 2 * (len + 1);
 253         words_left -= len + 1;
 254
 255         /* save off server domain */
 256         len = UniStrnlen((wchar_t *) data, words_left);
 257
 258         if (len > words_left)
 259                 return rc;
 260
 261         kfree(ses->serverDomain);
 262         ses->serverDomain = kzalloc(2 * (len + 1), GFP_KERNEL); /* BB FIXME wrong length */
 263         if (ses->serverDomain != NULL) {
 264                 cifs_strfromUCS_le(ses->serverDomain, (__le16 *)data, len,
 265                                    nls_cp);
 266                 ses->serverDomain[2*len] = 0;
 267                 ses->serverDomain[(2*len) + 1] = 0;
 268         }
 269         data += 2 * (len + 1);
 270         words_left -= len + 1;
 271
 272         cFYI(1, ("words left: %d", words_left));
 273
 274         return rc;
 275 }
 276
 277 static int decode_ascii_ssetup(char **pbcc_area, int bleft,
 278                                struct cifsSesInfo *ses,
 279                                const struct nls_table *nls_cp)
 280 {
 281         int rc = 0;
 282         int len;
 283         char *bcc_ptr = *pbcc_area;
 284
 285         cFYI(1, ("decode sessetup ascii. bleft %d", bleft));
 286
 287         len = strnlen(bcc_ptr, bleft);
 288         if (len >= bleft)
 289                 return rc;
 290
 291         kfree(ses->serverOS);
 292
 293         ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
 294         if (ses->serverOS)
 295                 strncpy(ses->serverOS, bcc_ptr, len);
 296         if (strncmp(ses->serverOS, "OS/2", 4) == 0) {
 297                         cFYI(1, ("OS/2 server"));
 298                         ses->flags |= CIFS_SES_OS2;
 299         }
 300
 301         bcc_ptr += len + 1;
 302         bleft -= len + 1;
 303
 304         len = strnlen(bcc_ptr, bleft);
 305         if (len >= bleft)
 306                 return rc;
 307
 308         kfree(ses->serverNOS);
 309
 310         ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
 311         if (ses->serverNOS)
 312                 strncpy(ses->serverNOS, bcc_ptr, len);
 313
 314         bcc_ptr += len + 1;
 315         bleft -= len + 1;
 316
 317         len = strnlen(bcc_ptr, bleft);
 318         if (len > bleft)
 319                 return rc;
 320
 321         /* No domain field in LANMAN case. Domain is
 322            returned by old servers in the SMB negprot response */
 323         /* BB For newer servers which do not support Unicode,
 324            but thus do return domain here we could add parsing
 325            for it later, but it is not very important */
 326         cFYI(1, ("ascii: bytes left %d", bleft));
 327
 328         return rc;
 329 }
 330
 331 int
 332 CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
 333                 const struct nls_table *nls_cp)
 334 {
 335         int rc = 0;
 336         int wct;
 337         struct smb_hdr *smb_buf;
 338         char *bcc_ptr;
 339         char *str_area;
 340         SESSION_SETUP_ANDX *pSMB;
 341         __u32 capabilities;
 342         int count;
 343         int resp_buf_type = 0;
 344         struct kvec iov[2];
 345         enum securityEnum type;
 346         __u16 action;
 347         int bytes_remaining;
 348
 349         if (ses == NULL)
 350                 return -EINVAL;
 351
 352         type = ses->server->secType;
 353
 354         cFYI(1, ("sess setup type %d", type));
 355         if (type == LANMAN) {
 356 #ifndef CONFIG_CIFS_WEAK_PW_HASH
 357                 /* LANMAN and plaintext are less secure and off by default.
 358                 So we make this explicitly be turned on in kconfig (in the
 359                 build) and turned on at runtime (changed from the default)
 360                 in proc/fs/cifs or via mount parm.  Unfortunately this is
 361                 needed for old Win (e.g. Win95), some obscure NAS and OS/2 */
 362                 return -EOPNOTSUPP;
 363 #endif
 364                 wct = 10; /* lanman 2 style sessionsetup */
 365         } else if ((type == NTLM) || (type == NTLMv2)) {
 366                 /* For NTLMv2 failures eventually may need to retry NTLM */
 367                 wct = 13; /* old style NTLM sessionsetup */
 368         } else /* same size: negotiate or auth, NTLMSSP or extended security */
 369                 wct = 12;
 370
 371         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
 372                             (void **)&smb_buf);
 373         if (rc)
 374                 return rc;
 375
 376         pSMB = (SESSION_SETUP_ANDX *)smb_buf;
 377
 378         capabilities = cifs_ssetup_hdr(ses, pSMB);
 379
 380         /* we will send the SMB in two pieces,
 381         a fixed length beginning part, and a
 382         second part which will include the strings
 383         and rest of bcc area, in order to avoid having
 384         to do a large buffer 17K allocation */
 385         iov[0].iov_base = (char *)pSMB;
 386         iov[0].iov_len = smb_buf->smb_buf_length + 4;
 387
 388         /* 2000 big enough to fit max user, domain, NOS name etc. */
 389         str_area = kmalloc(2000, GFP_KERNEL);
 390         if (str_area == NULL) {
 391                 cifs_small_buf_release(smb_buf);
 392                 return -ENOMEM;
 393         }
 394         bcc_ptr = str_area;
 395
 396         ses->flags &= ~CIFS_SES_LANMAN;
 397
 398         if (type == LANMAN) {
 399 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 400                 char lnm_session_key[CIFS_SESS_KEY_SIZE];
 401
 402                 /* no capabilities flags in old lanman negotiation */
 403
 404                 pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
 405                 /* BB calculate hash with password */
 406                 /* and copy into bcc */
 407
 408                 calc_lanman_hash(ses, lnm_session_key);
 409                 ses->flags |= CIFS_SES_LANMAN;
 410 /* #ifdef CONFIG_CIFS_DEBUG2
 411                 cifs_dump_mem("cryptkey: ",ses->server->cryptKey,
 412                         CIFS_SESS_KEY_SIZE);
 413 #endif */
 414                 memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_SESS_KEY_SIZE);
 415                 bcc_ptr += CIFS_SESS_KEY_SIZE;
 416
 417                 /* can not sign if LANMAN negotiated so no need
 418                 to calculate signing key? but what if server
 419                 changed to do higher than lanman dialect and
 420                 we reconnected would we ever calc signing_key? */
 421
 422                 cFYI(1, ("Negotiating LANMAN setting up strings"));
 423                 /* Unicode not allowed for LANMAN dialects */
 424                 ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 425 #endif
 426         } else if (type == NTLM) {
 427                 char ntlm_session_key[CIFS_SESS_KEY_SIZE];
 428
 429                 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 430                 pSMB->req_no_secext.CaseInsensitivePasswordLength =
 431                         cpu_to_le16(CIFS_SESS_KEY_SIZE);
 432                 pSMB->req_no_secext.CaseSensitivePasswordLength =
 433                         cpu_to_le16(CIFS_SESS_KEY_SIZE);
 434
 435                 /* calculate session key */
 436                 SMBNTencrypt(ses->password, ses->server->cryptKey,
 437                              ntlm_session_key);
 438
 439                 if (first_time) /* should this be moved into common code
 440                                   with similar ntlmv2 path? */
 441                         cifs_calculate_mac_key(&ses->server->mac_signing_key,
 442                                 ntlm_session_key, ses->password);
 443                 /* copy session key */
 444
 445                 memcpy(bcc_ptr, (char *)ntlm_session_key, CIFS_SESS_KEY_SIZE);
 446                 bcc_ptr += CIFS_SESS_KEY_SIZE;
 447                 memcpy(bcc_ptr, (char *)ntlm_session_key, CIFS_SESS_KEY_SIZE);
 448                 bcc_ptr += CIFS_SESS_KEY_SIZE;
 449                 if (ses->capabilities & CAP_UNICODE) {
 450                         /* unicode strings must be word aligned */
 451                         if (iov[0].iov_len % 2) {
 452                                 *bcc_ptr = 0;
 453                                 bcc_ptr++;
 454                         }
 455                         unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
 456                 } else
 457                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 458         } else if (type == NTLMv2) {
 459                 char *v2_sess_key =
 460                         kmalloc(sizeof(struct ntlmv2_resp), GFP_KERNEL);
 461
 462                 /* BB FIXME change all users of v2_sess_key to
 463                    struct ntlmv2_resp */
 464
 465                 if (v2_sess_key == NULL) {
 466                         cifs_small_buf_release(smb_buf);
 467                         return -ENOMEM;
 468                 }
 469
 470                 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 471
 472                 /* LM2 password would be here if we supported it */
 473                 pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
 474                 /*      cpu_to_le16(LM2_SESS_KEY_SIZE); */
 475
 476                 pSMB->req_no_secext.CaseSensitivePasswordLength =
 477                         cpu_to_le16(sizeof(struct ntlmv2_resp));
 478
 479                 /* calculate session key */
 480                 setup_ntlmv2_rsp(ses, v2_sess_key, nls_cp);
 481                 if (first_time) /* should this be moved into common code
 482                                    with similar ntlmv2 path? */
 483                 /*   cifs_calculate_ntlmv2_mac_key(ses->server->mac_signing_key,
 484                                 response BB FIXME, v2_sess_key); */
 485
 486                 /* copy session key */
 487
 488         /*      memcpy(bcc_ptr, (char *)ntlm_session_key,LM2_SESS_KEY_SIZE);
 489                 bcc_ptr += LM2_SESS_KEY_SIZE; */
 490                 memcpy(bcc_ptr, (char *)v2_sess_key,
 491                        sizeof(struct ntlmv2_resp));
 492                 bcc_ptr += sizeof(struct ntlmv2_resp);
 493                 kfree(v2_sess_key);
 494                 if (ses->capabilities & CAP_UNICODE) {
 495                         if (iov[0].iov_len % 2) {
 496                                 *bcc_ptr = 0;
 497                                 bcc_ptr++;
 498                         }
 499                         unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
 500                 } else
 501                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 502         } else /* NTLMSSP or SPNEGO */ {
 503                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
 504                 capabilities |= CAP_EXTENDED_SECURITY;
 505                 pSMB->req.Capabilities = cpu_to_le32(capabilities);
 506                 /* BB set password lengths */
 507         }
 508
 509         count = (long) bcc_ptr - (long) str_area;
 510         smb_buf->smb_buf_length += count;
 511
 512         BCC_LE(smb_buf) = cpu_to_le16(count);
 513
 514         iov[1].iov_base = str_area;
 515         iov[1].iov_len = count;
 516         rc = SendReceive2(xid, ses, iov, 2 /* num_iovecs */, &resp_buf_type,
 517                           0 /* not long op */, 1 /* log NT STATUS if any */ );
 518         /* SMB request buf freed in SendReceive2 */
 519
 520         cFYI(1, ("ssetup rc from sendrecv2 is %d", rc));
 521         if (rc)
 522                 goto ssetup_exit;
 523
 524         pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
 525         smb_buf = (struct smb_hdr *)iov[0].iov_base;
 526
 527         if ((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
 528                 rc = -EIO;
 529                 cERROR(1, ("bad word count %d", smb_buf->WordCount));
 530                 goto ssetup_exit;
 531         }
 532         action = le16_to_cpu(pSMB->resp.Action);
 533         if (action & GUEST_LOGIN)
 534                 cFYI(1, ("Guest login")); /* BB mark SesInfo struct? */
 535         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
 536         cFYI(1, ("UID = %d ", ses->Suid));
 537         /* response can have either 3 or 4 word count - Samba sends 3 */
 538         /* and lanman response is 3 */
 539         bytes_remaining = BCC(smb_buf);
 540         bcc_ptr = pByteArea(smb_buf);
 541
 542         if (smb_buf->WordCount == 4) {
 543                 __u16 blob_len;
 544                 blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
 545                 bcc_ptr += blob_len;
 546                 if (blob_len > bytes_remaining) {
 547                         cERROR(1, ("bad security blob length %d", blob_len));
 548                         rc = -EINVAL;
 549                         goto ssetup_exit;
 550                 }
 551                 bytes_remaining -= blob_len;
 552         }
 553
 554         /* BB check if Unicode and decode strings */
 555         if (smb_buf->Flags2 & SMBFLG2_UNICODE)
 556                 rc = decode_unicode_ssetup(&bcc_ptr, bytes_remaining,
 557                                                    ses, nls_cp);
 558         else
 559                 rc = decode_ascii_ssetup(&bcc_ptr, bytes_remaining,
 560                                          ses, nls_cp);
 561
 562 ssetup_exit:
 563         kfree(str_area);
 564         if (resp_buf_type == CIFS_SMALL_BUFFER) {
 565                 cFYI(1, ("ssetup freeing small buf %p", iov[0].iov_base));
 566                 cifs_small_buf_release(iov[0].iov_base);
 567         } else if (resp_buf_type == CIFS_LARGE_BUFFER)
 568                 cifs_buf_release(iov[0].iov_base);
 569
 570         return rc;
 571 }