fs/cifs/cifssmb.c

   1 /*
   2  *   fs/cifs/cifssmb.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2010
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   Contains the routines for constructing the SMB PDUs themselves
   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  /* SMB/CIFS PDU handling routines here - except for leftovers in connect.c   */
  25  /* These are mostly routines that operate on a pathname, or on a tree id     */
  26  /* (mounted volume), but there are eight handle based routines which must be */
  27  /* treated slightly differently for reconnection purposes since we never     */
  28  /* want to reuse a stale file handle and only the caller knows the file info */
  29
  30 #include <linux/fs.h>
  31 #include <linux/kernel.h>
  32 #include <linux/vfs.h>
  33 #include <linux/slab.h>
  34 #include <linux/posix_acl_xattr.h>
  35 #include <linux/pagemap.h>
  36 #include <linux/swap.h>
  37 #include <linux/task_io_accounting_ops.h>
  38 #include <linux/uaccess.h>
  39 #include "cifspdu.h"
  40 #include "cifsglob.h"
  41 #include "cifsacl.h"
  42 #include "cifsproto.h"
  43 #include "cifs_unicode.h"
  44 #include "cifs_debug.h"
  45 #include "fscache.h"
  46 #include "smbdirect.h"
  47
  48 #ifdef CONFIG_CIFS_POSIX
  49 static struct {
  50         int index;
  51         char *name;
  52 } protocols[] = {
  53 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  54         {LANMAN_PROT, "\2LM1.2X002"},
  55         {LANMAN2_PROT, "\2LANMAN2.1"},
  56 #endif /* weak password hashing for legacy clients */
  57         {CIFS_PROT, "\2NT LM 0.12"},
  58         {POSIX_PROT, "\2POSIX 2"},
  59         {BAD_PROT, "\2"}
  60 };
  61 #else
  62 static struct {
  63         int index;
  64         char *name;
  65 } protocols[] = {
  66 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  67         {LANMAN_PROT, "\2LM1.2X002"},
  68         {LANMAN2_PROT, "\2LANMAN2.1"},
  69 #endif /* weak password hashing for legacy clients */
  70         {CIFS_PROT, "\2NT LM 0.12"},
  71         {BAD_PROT, "\2"}
  72 };
  73 #endif
  74
  75 /* define the number of elements in the cifs dialect array */
  76 #ifdef CONFIG_CIFS_POSIX
  77 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  78 #define CIFS_NUM_PROT 4
  79 #else
  80 #define CIFS_NUM_PROT 2
  81 #endif /* CIFS_WEAK_PW_HASH */
  82 #else /* not posix */
  83 #ifdef CONFIG_CIFS_WEAK_PW_HASH
  84 #define CIFS_NUM_PROT 3
  85 #else
  86 #define CIFS_NUM_PROT 1
  87 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
  88 #endif /* CIFS_POSIX */
  89
  90 /*
  91  * Mark as invalid, all open files on tree connections since they
  92  * were closed when session to server was lost.
  93  */
  94 void
  95 cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
  96 {
  97         struct cifsFileInfo *open_file = NULL;
  98         struct list_head *tmp;
  99         struct list_head *tmp1;
 100
 101         /* list all files open on tree connection and mark them invalid */
 102         spin_lock(&tcon->open_file_lock);
 103         list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
 104                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
 105                 open_file->invalidHandle = true;
 106                 open_file->oplock_break_cancelled = true;
 107         }
 108         spin_unlock(&tcon->open_file_lock);
 109
 110         mutex_lock(&tcon->crfid.fid_mutex);
 111         tcon->crfid.is_valid = false;
 112         memset(tcon->crfid.fid, 0, sizeof(struct cifs_fid));
 113         mutex_unlock(&tcon->crfid.fid_mutex);
 114
 115         /*
 116          * BB Add call to invalidate_inodes(sb) for all superblocks mounted
 117          * to this tcon.
 118          */
 119 }
 120
 121 /* reconnect the socket, tcon, and smb session if needed */
 122 static int
 123 cifs_reconnect_tcon(struct cifs_tcon *tcon, int smb_command)
 124 {
 125         int rc;
 126         struct cifs_ses *ses;
 127         struct TCP_Server_Info *server;
 128         struct nls_table *nls_codepage;
 129
 130         /*
 131          * SMBs NegProt, SessSetup, uLogoff do not have tcon yet so check for
 132          * tcp and smb session status done differently for those three - in the
 133          * calling routine
 134          */
 135         if (!tcon)
 136                 return 0;
 137
 138         ses = tcon->ses;
 139         server = ses->server;
 140
 141         /*
 142          * only tree disconnect, open, and write, (and ulogoff which does not
 143          * have tcon) are allowed as we start force umount
 144          */
 145         if (tcon->tidStatus == CifsExiting) {
 146                 if (smb_command != SMB_COM_WRITE_ANDX &&
 147                     smb_command != SMB_COM_OPEN_ANDX &&
 148                     smb_command != SMB_COM_TREE_DISCONNECT) {
 149                         cifs_dbg(FYI, "can not send cmd %d while umounting\n",
 150                                  smb_command);
 151                         return -ENODEV;
 152                 }
 153         }
 154
 155         /*
 156          * Give demultiplex thread up to 10 seconds to reconnect, should be
 157          * greater than cifs socket timeout which is 7 seconds
 158          */
 159         while (server->tcpStatus == CifsNeedReconnect) {
 160                 rc = wait_event_interruptible_timeout(server->response_q,
 161                                                       (server->tcpStatus != CifsNeedReconnect),
 162                                                       10 * HZ);
 163                 if (rc < 0) {
 164                         cifs_dbg(FYI, "%s: aborting reconnect due to a received"
 165                                  " signal by the process\n", __func__);
 166                         return -ERESTARTSYS;
 167                 }
 168
 169                 /* are we still trying to reconnect? */
 170                 if (server->tcpStatus != CifsNeedReconnect)
 171                         break;
 172
 173                 /*
 174                  * on "soft" mounts we wait once. Hard mounts keep
 175                  * retrying until process is killed or server comes
 176                  * back on-line
 177                  */
 178                 if (!tcon->retry) {
 179                         cifs_dbg(FYI, "gave up waiting on reconnect in smb_init\n");
 180                         return -EHOSTDOWN;
 181                 }
 182         }
 183
 184         if (!ses->need_reconnect && !tcon->need_reconnect)
 185                 return 0;
 186
 187         nls_codepage = load_nls_default();
 188
 189         /*
 190          * need to prevent multiple threads trying to simultaneously
 191          * reconnect the same SMB session
 192          */
 193         mutex_lock(&ses->session_mutex);
 194
 195         /*
 196          * Recheck after acquire mutex. If another thread is negotiating
 197          * and the server never sends an answer the socket will be closed
 198          * and tcpStatus set to reconnect.
 199          */
 200         if (server->tcpStatus == CifsNeedReconnect) {
 201                 rc = -EHOSTDOWN;
 202                 mutex_unlock(&ses->session_mutex);
 203                 goto out;
 204         }
 205
 206         rc = cifs_negotiate_protocol(0, ses);
 207         if (rc == 0 && ses->need_reconnect)
 208                 rc = cifs_setup_session(0, ses, nls_codepage);
 209
 210         /* do we need to reconnect tcon? */
 211         if (rc || !tcon->need_reconnect) {
 212                 mutex_unlock(&ses->session_mutex);
 213                 goto out;
 214         }
 215
 216         cifs_mark_open_files_invalid(tcon);
 217         rc = CIFSTCon(0, ses, tcon->treeName, tcon, nls_codepage);
 218         mutex_unlock(&ses->session_mutex);
 219         cifs_dbg(FYI, "reconnect tcon rc = %d\n", rc);
 220
 221         if (rc) {
 222                 printk_once(KERN_WARNING "reconnect tcon failed rc = %d\n", rc);
 223                 goto out;
 224         }
 225
 226         atomic_inc(&tconInfoReconnectCount);
 227
 228         /* tell server Unix caps we support */
 229         if (ses->capabilities & CAP_UNIX)
 230                 reset_cifs_unix_caps(0, tcon, NULL, NULL);
 231
 232         /*
 233          * Removed call to reopen open files here. It is safer (and faster) to
 234          * reopen files one at a time as needed in read and write.
 235          *
 236          * FIXME: what about file locks? don't we need to reclaim them ASAP?
 237          */
 238
 239 out:
 240         /*
 241          * Check if handle based operation so we know whether we can continue
 242          * or not without returning to caller to reset file handle
 243          */
 244         switch (smb_command) {
 245         case SMB_COM_READ_ANDX:
 246         case SMB_COM_WRITE_ANDX:
 247         case SMB_COM_CLOSE:
 248         case SMB_COM_FIND_CLOSE2:
 249         case SMB_COM_LOCKING_ANDX:
 250                 rc = -EAGAIN;
 251         }
 252
 253         unload_nls(nls_codepage);
 254         return rc;
 255 }
 256
 257 /* Allocate and return pointer to an SMB request buffer, and set basic
 258    SMB information in the SMB header.  If the return code is zero, this
 259    function must have filled in request_buf pointer */
 260 static int
 261 small_smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
 262                 void **request_buf)
 263 {
 264         int rc;
 265
 266         rc = cifs_reconnect_tcon(tcon, smb_command);
 267         if (rc)
 268                 return rc;
 269
 270         *request_buf = cifs_small_buf_get();
 271         if (*request_buf == NULL) {
 272                 /* BB should we add a retry in here if not a writepage? */
 273                 return -ENOMEM;
 274         }
 275
 276         header_assemble((struct smb_hdr *) *request_buf, smb_command,
 277                         tcon, wct);
 278
 279         if (tcon != NULL)
 280                 cifs_stats_inc(&tcon->num_smbs_sent);
 281
 282         return 0;
 283 }
 284
 285 int
 286 small_smb_init_no_tc(const int smb_command, const int wct,
 287                      struct cifs_ses *ses, void **request_buf)
 288 {
 289         int rc;
 290         struct smb_hdr *buffer;
 291
 292         rc = small_smb_init(smb_command, wct, NULL, request_buf);
 293         if (rc)
 294                 return rc;
 295
 296         buffer = (struct smb_hdr *)*request_buf;
 297         buffer->Mid = get_next_mid(ses->server);
 298         if (ses->capabilities & CAP_UNICODE)
 299                 buffer->Flags2 |= SMBFLG2_UNICODE;
 300         if (ses->capabilities & CAP_STATUS32)
 301                 buffer->Flags2 |= SMBFLG2_ERR_STATUS;
 302
 303         /* uid, tid can stay at zero as set in header assemble */
 304
 305         /* BB add support for turning on the signing when
 306         this function is used after 1st of session setup requests */
 307
 308         return rc;
 309 }
 310
 311 /* If the return code is zero, this function must fill in request_buf pointer */
 312 static int
 313 __smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
 314                         void **request_buf, void **response_buf)
 315 {
 316         *request_buf = cifs_buf_get();
 317         if (*request_buf == NULL) {
 318                 /* BB should we add a retry in here if not a writepage? */
 319                 return -ENOMEM;
 320         }
 321     /* Although the original thought was we needed the response buf for  */
 322     /* potential retries of smb operations it turns out we can determine */
 323     /* from the mid flags when the request buffer can be resent without  */
 324     /* having to use a second distinct buffer for the response */
 325         if (response_buf)
 326                 *response_buf = *request_buf;
 327
 328         header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
 329                         wct);
 330
 331         if (tcon != NULL)
 332                 cifs_stats_inc(&tcon->num_smbs_sent);
 333
 334         return 0;
 335 }
 336
 337 /* If the return code is zero, this function must fill in request_buf pointer */
 338 static int
 339 smb_init(int smb_command, int wct, struct cifs_tcon *tcon,
 340          void **request_buf, void **response_buf)
 341 {
 342         int rc;
 343
 344         rc = cifs_reconnect_tcon(tcon, smb_command);
 345         if (rc)
 346                 return rc;
 347
 348         return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
 349 }
 350
 351 static int
 352 smb_init_no_reconnect(int smb_command, int wct, struct cifs_tcon *tcon,
 353                         void **request_buf, void **response_buf)
 354 {
 355         if (tcon->ses->need_reconnect || tcon->need_reconnect)
 356                 return -EHOSTDOWN;
 357
 358         return __smb_init(smb_command, wct, tcon, request_buf, response_buf);
 359 }
 360
 361 static int validate_t2(struct smb_t2_rsp *pSMB)
 362 {
 363         unsigned int total_size;
 364
 365         /* check for plausible wct */
 366         if (pSMB->hdr.WordCount < 10)
 367                 goto vt2_err;
 368
 369         /* check for parm and data offset going beyond end of smb */
 370         if (get_unaligned_le16(&pSMB->t2_rsp.ParameterOffset) > 1024 ||
 371             get_unaligned_le16(&pSMB->t2_rsp.DataOffset) > 1024)
 372                 goto vt2_err;
 373
 374         total_size = get_unaligned_le16(&pSMB->t2_rsp.ParameterCount);
 375         if (total_size >= 512)
 376                 goto vt2_err;
 377
 378         /* check that bcc is at least as big as parms + data, and that it is
 379          * less than negotiated smb buffer
 380          */
 381         total_size += get_unaligned_le16(&pSMB->t2_rsp.DataCount);
 382         if (total_size > get_bcc(&pSMB->hdr) ||
 383             total_size >= CIFSMaxBufSize + MAX_CIFS_HDR_SIZE)
 384                 goto vt2_err;
 385
 386         return 0;
 387 vt2_err:
 388         cifs_dump_mem("Invalid transact2 SMB: ", (char *)pSMB,
 389                 sizeof(struct smb_t2_rsp) + 16);
 390         return -EINVAL;
 391 }
 392
 393 static int
 394 decode_ext_sec_blob(struct cifs_ses *ses, NEGOTIATE_RSP *pSMBr)
 395 {
 396         int     rc = 0;
 397         u16     count;
 398         char    *guid = pSMBr->u.extended_response.GUID;
 399         struct TCP_Server_Info *server = ses->server;
 400
 401         count = get_bcc(&pSMBr->hdr);
 402         if (count < SMB1_CLIENT_GUID_SIZE)
 403                 return -EIO;
 404
 405         spin_lock(&cifs_tcp_ses_lock);
 406         if (server->srv_count > 1) {
 407                 spin_unlock(&cifs_tcp_ses_lock);
 408                 if (memcmp(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE) != 0) {
 409                         cifs_dbg(FYI, "server UID changed\n");
 410                         memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
 411                 }
 412         } else {
 413                 spin_unlock(&cifs_tcp_ses_lock);
 414                 memcpy(server->server_GUID, guid, SMB1_CLIENT_GUID_SIZE);
 415         }
 416
 417         if (count == SMB1_CLIENT_GUID_SIZE) {
 418                 server->sec_ntlmssp = true;
 419         } else {
 420                 count -= SMB1_CLIENT_GUID_SIZE;
 421                 rc = decode_negTokenInit(
 422                         pSMBr->u.extended_response.SecurityBlob, count, server);
 423                 if (rc != 1)
 424                         return -EINVAL;
 425         }
 426
 427         return 0;
 428 }
 429
 430 int
 431 cifs_enable_signing(struct TCP_Server_Info *server, bool mnt_sign_required)
 432 {
 433         bool srv_sign_required = server->sec_mode & server->vals->signing_required;
 434         bool srv_sign_enabled = server->sec_mode & server->vals->signing_enabled;
 435         bool mnt_sign_enabled = global_secflags & CIFSSEC_MAY_SIGN;
 436
 437         /*
 438          * Is signing required by mnt options? If not then check
 439          * global_secflags to see if it is there.
 440          */
 441         if (!mnt_sign_required)
 442                 mnt_sign_required = ((global_secflags & CIFSSEC_MUST_SIGN) ==
 443                                                 CIFSSEC_MUST_SIGN);
 444
 445         /*
 446          * If signing is required then it's automatically enabled too,
 447          * otherwise, check to see if the secflags allow it.
 448          */
 449         mnt_sign_enabled = mnt_sign_required ? mnt_sign_required :
 450                                 (global_secflags & CIFSSEC_MAY_SIGN);
 451
 452         /* If server requires signing, does client allow it? */
 453         if (srv_sign_required) {
 454                 if (!mnt_sign_enabled) {
 455                         cifs_dbg(VFS, "Server requires signing, but it's disabled in SecurityFlags!");
 456                         return -ENOTSUPP;
 457                 }
 458                 server->sign = true;
 459         }
 460
 461         /* If client requires signing, does server allow it? */
 462         if (mnt_sign_required) {
 463                 if (!srv_sign_enabled) {
 464                         cifs_dbg(VFS, "Server does not support signing!");
 465                         return -ENOTSUPP;
 466                 }
 467                 server->sign = true;
 468         }
 469
 470         if (cifs_rdma_enabled(server) && server->sign)
 471                 cifs_dbg(VFS, "Signing is enabled, and RDMA read/write will be disabled");
 472
 473         return 0;
 474 }
 475
 476 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 477 static int
 478 decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
 479 {
 480         __s16 tmp;
 481         struct lanman_neg_rsp *rsp = (struct lanman_neg_rsp *)pSMBr;
 482
 483         if (server->dialect != LANMAN_PROT && server->dialect != LANMAN2_PROT)
 484                 return -EOPNOTSUPP;
 485
 486         server->sec_mode = le16_to_cpu(rsp->SecurityMode);
 487         server->maxReq = min_t(unsigned int,
 488                                le16_to_cpu(rsp->MaxMpxCount),
 489                                cifs_max_pending);
 490         set_credits(server, server->maxReq);
 491         server->maxBuf = le16_to_cpu(rsp->MaxBufSize);
 492         /* even though we do not use raw we might as well set this
 493         accurately, in case we ever find a need for it */
 494         if ((le16_to_cpu(rsp->RawMode) & RAW_ENABLE) == RAW_ENABLE) {
 495                 server->max_rw = 0xFF00;
 496                 server->capabilities = CAP_MPX_MODE | CAP_RAW_MODE;
 497         } else {
 498                 server->max_rw = 0;/* do not need to use raw anyway */
 499                 server->capabilities = CAP_MPX_MODE;
 500         }
 501         tmp = (__s16)le16_to_cpu(rsp->ServerTimeZone);
 502         if (tmp == -1) {
 503                 /* OS/2 often does not set timezone therefore
 504                  * we must use server time to calc time zone.
 505                  * Could deviate slightly from the right zone.
 506                  * Smallest defined timezone difference is 15 minutes
 507                  * (i.e. Nepal).  Rounding up/down is done to match
 508                  * this requirement.
 509                  */
 510                 int val, seconds, remain, result;
 511                 struct timespec64 ts;
 512                 time64_t utc = ktime_get_real_seconds();
 513                 ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
 514                                     rsp->SrvTime.Time, 0);
 515                 cifs_dbg(FYI, "SrvTime %lld sec since 1970 (utc: %lld) diff: %lld\n",
 516                          ts.tv_sec, utc,
 517                          utc - ts.tv_sec);
 518                 val = (int)(utc - ts.tv_sec);
 519                 seconds = abs(val);
 520                 result = (seconds / MIN_TZ_ADJ) * MIN_TZ_ADJ;
 521                 remain = seconds % MIN_TZ_ADJ;
 522                 if (remain >= (MIN_TZ_ADJ / 2))
 523                         result += MIN_TZ_ADJ;
 524                 if (val < 0)
 525                         result = -result;
 526                 server->timeAdj = result;
 527         } else {
 528                 server->timeAdj = (int)tmp;
 529                 server->timeAdj *= 60; /* also in seconds */
 530         }
 531         cifs_dbg(FYI, "server->timeAdj: %d seconds\n", server->timeAdj);
 532
 533
 534         /* BB get server time for time conversions and add
 535         code to use it and timezone since this is not UTC */
 536
 537         if (rsp->EncryptionKeyLength ==
 538                         cpu_to_le16(CIFS_CRYPTO_KEY_SIZE)) {
 539                 memcpy(server->cryptkey, rsp->EncryptionKey,
 540                         CIFS_CRYPTO_KEY_SIZE);
 541         } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
 542                 return -EIO; /* need cryptkey unless plain text */
 543         }
 544
 545         cifs_dbg(FYI, "LANMAN negotiated\n");
 546         return 0;
 547 }
 548 #else
 549 static inline int
 550 decode_lanman_negprot_rsp(struct TCP_Server_Info *server, NEGOTIATE_RSP *pSMBr)
 551 {
 552         cifs_dbg(VFS, "mount failed, cifs module not built with CIFS_WEAK_PW_HASH support\n");
 553         return -EOPNOTSUPP;
 554 }
 555 #endif
 556
 557 static bool
 558 should_set_ext_sec_flag(enum securityEnum sectype)
 559 {
 560         switch (sectype) {
 561         case RawNTLMSSP:
 562         case Kerberos:
 563                 return true;
 564         case Unspecified:
 565                 if (global_secflags &
 566                     (CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_NTLMSSP))
 567                         return true;
 568                 /* Fallthrough */
 569         default:
 570                 return false;
 571         }
 572 }
 573
 574 int
 575 CIFSSMBNegotiate(const unsigned int xid, struct cifs_ses *ses)
 576 {
 577         NEGOTIATE_REQ *pSMB;
 578         NEGOTIATE_RSP *pSMBr;
 579         int rc = 0;
 580         int bytes_returned;
 581         int i;
 582         struct TCP_Server_Info *server = ses->server;
 583         u16 count;
 584
 585         if (!server) {
 586                 WARN(1, "%s: server is NULL!\n", __func__);
 587                 return -EIO;
 588         }
 589
 590         rc = smb_init(SMB_COM_NEGOTIATE, 0, NULL /* no tcon yet */ ,
 591                       (void **) &pSMB, (void **) &pSMBr);
 592         if (rc)
 593                 return rc;
 594
 595         pSMB->hdr.Mid = get_next_mid(server);
 596         pSMB->hdr.Flags2 |= (SMBFLG2_UNICODE | SMBFLG2_ERR_STATUS);
 597
 598         if (should_set_ext_sec_flag(ses->sectype)) {
 599                 cifs_dbg(FYI, "Requesting extended security.");
 600                 pSMB->hdr.Flags2 |= SMBFLG2_EXT_SEC;
 601         }
 602
 603         count = 0;
 604         /*
 605          * We know that all the name entries in the protocols array
 606          * are short (< 16 bytes anyway) and are NUL terminated.
 607          */
 608         for (i = 0; i < CIFS_NUM_PROT; i++) {
 609                 size_t len = strlen(protocols[i].name) + 1;
 610
 611                 memcpy(pSMB->DialectsArray+count, protocols[i].name, len);
 612                 count += len;
 613         }
 614         inc_rfc1001_len(pSMB, count);
 615         pSMB->ByteCount = cpu_to_le16(count);
 616
 617         rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
 618                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 619         if (rc != 0)
 620                 goto neg_err_exit;
 621
 622         server->dialect = le16_to_cpu(pSMBr->DialectIndex);
 623         cifs_dbg(FYI, "Dialect: %d\n", server->dialect);
 624         /* Check wct = 1 error case */
 625         if ((pSMBr->hdr.WordCount < 13) || (server->dialect == BAD_PROT)) {
 626                 /* core returns wct = 1, but we do not ask for core - otherwise
 627                 small wct just comes when dialect index is -1 indicating we
 628                 could not negotiate a common dialect */
 629                 rc = -EOPNOTSUPP;
 630                 goto neg_err_exit;
 631         } else if (pSMBr->hdr.WordCount == 13) {
 632                 server->negflavor = CIFS_NEGFLAVOR_LANMAN;
 633                 rc = decode_lanman_negprot_rsp(server, pSMBr);
 634                 goto signing_check;
 635         } else if (pSMBr->hdr.WordCount != 17) {
 636                 /* unknown wct */
 637                 rc = -EOPNOTSUPP;
 638                 goto neg_err_exit;
 639         }
 640         /* else wct == 17, NTLM or better */
 641
 642         server->sec_mode = pSMBr->SecurityMode;
 643         if ((server->sec_mode & SECMODE_USER) == 0)
 644                 cifs_dbg(FYI, "share mode security\n");
 645
 646         /* one byte, so no need to convert this or EncryptionKeyLen from
 647            little endian */
 648         server->maxReq = min_t(unsigned int, le16_to_cpu(pSMBr->MaxMpxCount),
 649                                cifs_max_pending);
 650         set_credits(server, server->maxReq);
 651         /* probably no need to store and check maxvcs */
 652         server->maxBuf = le32_to_cpu(pSMBr->MaxBufferSize);
 653         server->max_rw = le32_to_cpu(pSMBr->MaxRawSize);
 654         cifs_dbg(NOISY, "Max buf = %d\n", ses->server->maxBuf);
 655         server->capabilities = le32_to_cpu(pSMBr->Capabilities);
 656         server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
 657         server->timeAdj *= 60;
 658
 659         if (pSMBr->EncryptionKeyLength == CIFS_CRYPTO_KEY_SIZE) {
 660                 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
 661                 memcpy(ses->server->cryptkey, pSMBr->u.EncryptionKey,
 662                        CIFS_CRYPTO_KEY_SIZE);
 663         } else if (pSMBr->hdr.Flags2 & SMBFLG2_EXT_SEC ||
 664                         server->capabilities & CAP_EXTENDED_SECURITY) {
 665                 server->negflavor = CIFS_NEGFLAVOR_EXTENDED;
 666                 rc = decode_ext_sec_blob(ses, pSMBr);
 667         } else if (server->sec_mode & SECMODE_PW_ENCRYPT) {
 668                 rc = -EIO; /* no crypt key only if plain text pwd */
 669         } else {
 670                 server->negflavor = CIFS_NEGFLAVOR_UNENCAP;
 671                 server->capabilities &= ~CAP_EXTENDED_SECURITY;
 672         }
 673
 674 signing_check:
 675         if (!rc)
 676                 rc = cifs_enable_signing(server, ses->sign);
 677 neg_err_exit:
 678         cifs_buf_release(pSMB);
 679
 680         cifs_dbg(FYI, "negprot rc %d\n", rc);
 681         return rc;
 682 }
 683
 684 int
 685 CIFSSMBTDis(const unsigned int xid, struct cifs_tcon *tcon)
 686 {
 687         struct smb_hdr *smb_buffer;
 688         int rc = 0;
 689
 690         cifs_dbg(FYI, "In tree disconnect\n");
 691
 692         /* BB: do we need to check this? These should never be NULL. */
 693         if ((tcon->ses == NULL) || (tcon->ses->server == NULL))
 694                 return -EIO;
 695
 696         /*
 697          * No need to return error on this operation if tid invalidated and
 698          * closed on server already e.g. due to tcp session crashing. Also,
 699          * the tcon is no longer on the list, so no need to take lock before
 700          * checking this.
 701          */
 702         if ((tcon->need_reconnect) || (tcon->ses->need_reconnect))
 703                 return 0;
 704
 705         rc = small_smb_init(SMB_COM_TREE_DISCONNECT, 0, tcon,
 706                             (void **)&smb_buffer);
 707         if (rc)
 708                 return rc;
 709
 710         rc = SendReceiveNoRsp(xid, tcon->ses, (char *)smb_buffer, 0);
 711         cifs_small_buf_release(smb_buffer);
 712         if (rc)
 713                 cifs_dbg(FYI, "Tree disconnect failed %d\n", rc);
 714
 715         /* No need to return error on this operation if tid invalidated and
 716            closed on server already e.g. due to tcp session crashing */
 717         if (rc == -EAGAIN)
 718                 rc = 0;
 719
 720         return rc;
 721 }
 722
 723 /*
 724  * This is a no-op for now. We're not really interested in the reply, but
 725  * rather in the fact that the server sent one and that server->lstrp
 726  * gets updated.
 727  *
 728  * FIXME: maybe we should consider checking that the reply matches request?
 729  */
 730 static void
 731 cifs_echo_callback(struct mid_q_entry *mid)
 732 {
 733         struct TCP_Server_Info *server = mid->callback_data;
 734
 735         DeleteMidQEntry(mid);
 736         add_credits(server, 1, CIFS_ECHO_OP);
 737 }
 738
 739 int
 740 CIFSSMBEcho(struct TCP_Server_Info *server)
 741 {
 742         ECHO_REQ *smb;
 743         int rc = 0;
 744         struct kvec iov[2];
 745         struct smb_rqst rqst = { .rq_iov = iov,
 746                                  .rq_nvec = 2 };
 747
 748         cifs_dbg(FYI, "In echo request\n");
 749
 750         rc = small_smb_init(SMB_COM_ECHO, 0, NULL, (void **)&smb);
 751         if (rc)
 752                 return rc;
 753
 754         if (server->capabilities & CAP_UNICODE)
 755                 smb->hdr.Flags2 |= SMBFLG2_UNICODE;
 756
 757         /* set up echo request */
 758         smb->hdr.Tid = 0xffff;
 759         smb->hdr.WordCount = 1;
 760         put_unaligned_le16(1, &smb->EchoCount);
 761         put_bcc(1, &smb->hdr);
 762         smb->Data[0] = 'a';
 763         inc_rfc1001_len(smb, 3);
 764
 765         iov[0].iov_len = 4;
 766         iov[0].iov_base = smb;
 767         iov[1].iov_len = get_rfc1002_length(smb);
 768         iov[1].iov_base = (char *)smb + 4;
 769
 770         rc = cifs_call_async(server, &rqst, NULL, cifs_echo_callback, NULL,
 771                              server, CIFS_ASYNC_OP | CIFS_ECHO_OP);
 772         if (rc)
 773                 cifs_dbg(FYI, "Echo request failed: %d\n", rc);
 774
 775         cifs_small_buf_release(smb);
 776
 777         return rc;
 778 }
 779
 780 int
 781 CIFSSMBLogoff(const unsigned int xid, struct cifs_ses *ses)
 782 {
 783         LOGOFF_ANDX_REQ *pSMB;
 784         int rc = 0;
 785
 786         cifs_dbg(FYI, "In SMBLogoff for session disconnect\n");
 787
 788         /*
 789          * BB: do we need to check validity of ses and server? They should
 790          * always be valid since we have an active reference. If not, that
 791          * should probably be a BUG()
 792          */
 793         if (!ses || !ses->server)
 794                 return -EIO;
 795
 796         mutex_lock(&ses->session_mutex);
 797         if (ses->need_reconnect)
 798                 goto session_already_dead; /* no need to send SMBlogoff if uid
 799                                               already closed due to reconnect */
 800         rc = small_smb_init(SMB_COM_LOGOFF_ANDX, 2, NULL, (void **)&pSMB);
 801         if (rc) {
 802                 mutex_unlock(&ses->session_mutex);
 803                 return rc;
 804         }
 805
 806         pSMB->hdr.Mid = get_next_mid(ses->server);
 807
 808         if (ses->server->sign)
 809                 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 810
 811         pSMB->hdr.Uid = ses->Suid;
 812
 813         pSMB->AndXCommand = 0xFF;
 814         rc = SendReceiveNoRsp(xid, ses, (char *) pSMB, 0);
 815         cifs_small_buf_release(pSMB);
 816 session_already_dead:
 817         mutex_unlock(&ses->session_mutex);
 818
 819         /* if session dead then we do not need to do ulogoff,
 820                 since server closed smb session, no sense reporting
 821                 error */
 822         if (rc == -EAGAIN)
 823                 rc = 0;
 824         return rc;
 825 }
 826
 827 int
 828 CIFSPOSIXDelFile(const unsigned int xid, struct cifs_tcon *tcon,
 829                  const char *fileName, __u16 type,
 830                  const struct nls_table *nls_codepage, int remap)
 831 {
 832         TRANSACTION2_SPI_REQ *pSMB = NULL;
 833         TRANSACTION2_SPI_RSP *pSMBr = NULL;
 834         struct unlink_psx_rq *pRqD;
 835         int name_len;
 836         int rc = 0;
 837         int bytes_returned = 0;
 838         __u16 params, param_offset, offset, byte_count;
 839
 840         cifs_dbg(FYI, "In POSIX delete\n");
 841 PsxDelete:
 842         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
 843                       (void **) &pSMBr);
 844         if (rc)
 845                 return rc;
 846
 847         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 848                 name_len =
 849                     cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
 850                                        PATH_MAX, nls_codepage, remap);
 851                 name_len++;     /* trailing null */
 852                 name_len *= 2;
 853         } else { /* BB add path length overrun check */
 854                 name_len = strnlen(fileName, PATH_MAX);
 855                 name_len++;     /* trailing null */
 856                 strncpy(pSMB->FileName, fileName, name_len);
 857         }
 858
 859         params = 6 + name_len;
 860         pSMB->MaxParameterCount = cpu_to_le16(2);
 861         pSMB->MaxDataCount = 0; /* BB double check this with jra */
 862         pSMB->MaxSetupCount = 0;
 863         pSMB->Reserved = 0;
 864         pSMB->Flags = 0;
 865         pSMB->Timeout = 0;
 866         pSMB->Reserved2 = 0;
 867         param_offset = offsetof(struct smb_com_transaction2_spi_req,
 868                                 InformationLevel) - 4;
 869         offset = param_offset + params;
 870
 871         /* Setup pointer to Request Data (inode type) */
 872         pRqD = (struct unlink_psx_rq *)(((char *)&pSMB->hdr.Protocol) + offset);
 873         pRqD->type = cpu_to_le16(type);
 874         pSMB->ParameterOffset = cpu_to_le16(param_offset);
 875         pSMB->DataOffset = cpu_to_le16(offset);
 876         pSMB->SetupCount = 1;
 877         pSMB->Reserved3 = 0;
 878         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
 879         byte_count = 3 /* pad */  + params + sizeof(struct unlink_psx_rq);
 880
 881         pSMB->DataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
 882         pSMB->TotalDataCount = cpu_to_le16(sizeof(struct unlink_psx_rq));
 883         pSMB->ParameterCount = cpu_to_le16(params);
 884         pSMB->TotalParameterCount = pSMB->ParameterCount;
 885         pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_UNLINK);
 886         pSMB->Reserved4 = 0;
 887         inc_rfc1001_len(pSMB, byte_count);
 888         pSMB->ByteCount = cpu_to_le16(byte_count);
 889         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
 890                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 891         if (rc)
 892                 cifs_dbg(FYI, "Posix delete returned %d\n", rc);
 893         cifs_buf_release(pSMB);
 894
 895         cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
 896
 897         if (rc == -EAGAIN)
 898                 goto PsxDelete;
 899
 900         return rc;
 901 }
 902
 903 int
 904 CIFSSMBDelFile(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 905                struct cifs_sb_info *cifs_sb)
 906 {
 907         DELETE_FILE_REQ *pSMB = NULL;
 908         DELETE_FILE_RSP *pSMBr = NULL;
 909         int rc = 0;
 910         int bytes_returned;
 911         int name_len;
 912         int remap = cifs_remap(cifs_sb);
 913
 914 DelFileRetry:
 915         rc = smb_init(SMB_COM_DELETE, 1, tcon, (void **) &pSMB,
 916                       (void **) &pSMBr);
 917         if (rc)
 918                 return rc;
 919
 920         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 921                 name_len = cifsConvertToUTF16((__le16 *) pSMB->fileName, name,
 922                                               PATH_MAX, cifs_sb->local_nls,
 923                                               remap);
 924                 name_len++;     /* trailing null */
 925                 name_len *= 2;
 926         } else {                /* BB improve check for buffer overruns BB */
 927                 name_len = strnlen(name, PATH_MAX);
 928                 name_len++;     /* trailing null */
 929                 strncpy(pSMB->fileName, name, name_len);
 930         }
 931         pSMB->SearchAttributes =
 932             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM);
 933         pSMB->BufferFormat = 0x04;
 934         inc_rfc1001_len(pSMB, name_len + 1);
 935         pSMB->ByteCount = cpu_to_le16(name_len + 1);
 936         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
 937                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 938         cifs_stats_inc(&tcon->stats.cifs_stats.num_deletes);
 939         if (rc)
 940                 cifs_dbg(FYI, "Error in RMFile = %d\n", rc);
 941
 942         cifs_buf_release(pSMB);
 943         if (rc == -EAGAIN)
 944                 goto DelFileRetry;
 945
 946         return rc;
 947 }
 948
 949 int
 950 CIFSSMBRmDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 951              struct cifs_sb_info *cifs_sb)
 952 {
 953         DELETE_DIRECTORY_REQ *pSMB = NULL;
 954         DELETE_DIRECTORY_RSP *pSMBr = NULL;
 955         int rc = 0;
 956         int bytes_returned;
 957         int name_len;
 958         int remap = cifs_remap(cifs_sb);
 959
 960         cifs_dbg(FYI, "In CIFSSMBRmDir\n");
 961 RmDirRetry:
 962         rc = smb_init(SMB_COM_DELETE_DIRECTORY, 0, tcon, (void **) &pSMB,
 963                       (void **) &pSMBr);
 964         if (rc)
 965                 return rc;
 966
 967         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
 968                 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
 969                                               PATH_MAX, cifs_sb->local_nls,
 970                                               remap);
 971                 name_len++;     /* trailing null */
 972                 name_len *= 2;
 973         } else {                /* BB improve check for buffer overruns BB */
 974                 name_len = strnlen(name, PATH_MAX);
 975                 name_len++;     /* trailing null */
 976                 strncpy(pSMB->DirName, name, name_len);
 977         }
 978
 979         pSMB->BufferFormat = 0x04;
 980         inc_rfc1001_len(pSMB, name_len + 1);
 981         pSMB->ByteCount = cpu_to_le16(name_len + 1);
 982         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
 983                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
 984         cifs_stats_inc(&tcon->stats.cifs_stats.num_rmdirs);
 985         if (rc)
 986                 cifs_dbg(FYI, "Error in RMDir = %d\n", rc);
 987
 988         cifs_buf_release(pSMB);
 989         if (rc == -EAGAIN)
 990                 goto RmDirRetry;
 991         return rc;
 992 }
 993
 994 int
 995 CIFSSMBMkDir(const unsigned int xid, struct cifs_tcon *tcon, const char *name,
 996              struct cifs_sb_info *cifs_sb)
 997 {
 998         int rc = 0;
 999         CREATE_DIRECTORY_REQ *pSMB = NULL;
1000         CREATE_DIRECTORY_RSP *pSMBr = NULL;
1001         int bytes_returned;
1002         int name_len;
1003         int remap = cifs_remap(cifs_sb);
1004
1005         cifs_dbg(FYI, "In CIFSSMBMkDir\n");
1006 MkDirRetry:
1007         rc = smb_init(SMB_COM_CREATE_DIRECTORY, 0, tcon, (void **) &pSMB,
1008                       (void **) &pSMBr);
1009         if (rc)
1010                 return rc;
1011
1012         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1013                 name_len = cifsConvertToUTF16((__le16 *) pSMB->DirName, name,
1014                                               PATH_MAX, cifs_sb->local_nls,
1015                                               remap);
1016                 name_len++;     /* trailing null */
1017                 name_len *= 2;
1018         } else {                /* BB improve check for buffer overruns BB */
1019                 name_len = strnlen(name, PATH_MAX);
1020                 name_len++;     /* trailing null */
1021                 strncpy(pSMB->DirName, name, name_len);
1022         }
1023
1024         pSMB->BufferFormat = 0x04;
1025         inc_rfc1001_len(pSMB, name_len + 1);
1026         pSMB->ByteCount = cpu_to_le16(name_len + 1);
1027         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1028                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1029         cifs_stats_inc(&tcon->stats.cifs_stats.num_mkdirs);
1030         if (rc)
1031                 cifs_dbg(FYI, "Error in Mkdir = %d\n", rc);
1032
1033         cifs_buf_release(pSMB);
1034         if (rc == -EAGAIN)
1035                 goto MkDirRetry;
1036         return rc;
1037 }
1038
1039 int
1040 CIFSPOSIXCreate(const unsigned int xid, struct cifs_tcon *tcon,
1041                 __u32 posix_flags, __u64 mode, __u16 *netfid,
1042                 FILE_UNIX_BASIC_INFO *pRetData, __u32 *pOplock,
1043                 const char *name, const struct nls_table *nls_codepage,
1044                 int remap)
1045 {
1046         TRANSACTION2_SPI_REQ *pSMB = NULL;
1047         TRANSACTION2_SPI_RSP *pSMBr = NULL;
1048         int name_len;
1049         int rc = 0;
1050         int bytes_returned = 0;
1051         __u16 params, param_offset, offset, byte_count, count;
1052         OPEN_PSX_REQ *pdata;
1053         OPEN_PSX_RSP *psx_rsp;
1054
1055         cifs_dbg(FYI, "In POSIX Create\n");
1056 PsxCreat:
1057         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
1058                       (void **) &pSMBr);
1059         if (rc)
1060                 return rc;
1061
1062         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1063                 name_len =
1064                     cifsConvertToUTF16((__le16 *) pSMB->FileName, name,
1065                                        PATH_MAX, nls_codepage, remap);
1066                 name_len++;     /* trailing null */
1067                 name_len *= 2;
1068         } else {        /* BB improve the check for buffer overruns BB */
1069                 name_len = strnlen(name, PATH_MAX);
1070                 name_len++;     /* trailing null */
1071                 strncpy(pSMB->FileName, name, name_len);
1072         }
1073
1074         params = 6 + name_len;
1075         count = sizeof(OPEN_PSX_REQ);
1076         pSMB->MaxParameterCount = cpu_to_le16(2);
1077         pSMB->MaxDataCount = cpu_to_le16(1000); /* large enough */
1078         pSMB->MaxSetupCount = 0;
1079         pSMB->Reserved = 0;
1080         pSMB->Flags = 0;
1081         pSMB->Timeout = 0;
1082         pSMB->Reserved2 = 0;
1083         param_offset = offsetof(struct smb_com_transaction2_spi_req,
1084                                 InformationLevel) - 4;
1085         offset = param_offset + params;
1086         pdata = (OPEN_PSX_REQ *)(((char *)&pSMB->hdr.Protocol) + offset);
1087         pdata->Level = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
1088         pdata->Permissions = cpu_to_le64(mode);
1089         pdata->PosixOpenFlags = cpu_to_le32(posix_flags);
1090         pdata->OpenFlags =  cpu_to_le32(*pOplock);
1091         pSMB->ParameterOffset = cpu_to_le16(param_offset);
1092         pSMB->DataOffset = cpu_to_le16(offset);
1093         pSMB->SetupCount = 1;
1094         pSMB->Reserved3 = 0;
1095         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
1096         byte_count = 3 /* pad */  + params + count;
1097
1098         pSMB->DataCount = cpu_to_le16(count);
1099         pSMB->ParameterCount = cpu_to_le16(params);
1100         pSMB->TotalDataCount = pSMB->DataCount;
1101         pSMB->TotalParameterCount = pSMB->ParameterCount;
1102         pSMB->InformationLevel = cpu_to_le16(SMB_POSIX_OPEN);
1103         pSMB->Reserved4 = 0;
1104         inc_rfc1001_len(pSMB, byte_count);
1105         pSMB->ByteCount = cpu_to_le16(byte_count);
1106         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1107                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1108         if (rc) {
1109                 cifs_dbg(FYI, "Posix create returned %d\n", rc);
1110                 goto psx_create_err;
1111         }
1112
1113         cifs_dbg(FYI, "copying inode info\n");
1114         rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1115
1116         if (rc || get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)) {
1117                 rc = -EIO;      /* bad smb */
1118                 goto psx_create_err;
1119         }
1120
1121         /* copy return information to pRetData */
1122         psx_rsp = (OPEN_PSX_RSP *)((char *) &pSMBr->hdr.Protocol
1123                         + le16_to_cpu(pSMBr->t2.DataOffset));
1124
1125         *pOplock = le16_to_cpu(psx_rsp->OplockFlags);
1126         if (netfid)
1127                 *netfid = psx_rsp->Fid;   /* cifs fid stays in le */
1128         /* Let caller know file was created so we can set the mode. */
1129         /* Do we care about the CreateAction in any other cases? */
1130         if (cpu_to_le32(FILE_CREATE) == psx_rsp->CreateAction)
1131                 *pOplock |= CIFS_CREATE_ACTION;
1132         /* check to make sure response data is there */
1133         if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
1134                 pRetData->Type = cpu_to_le32(-1); /* unknown */
1135                 cifs_dbg(NOISY, "unknown type\n");
1136         } else {
1137                 if (get_bcc(&pSMBr->hdr) < sizeof(OPEN_PSX_RSP)
1138                                         + sizeof(FILE_UNIX_BASIC_INFO)) {
1139                         cifs_dbg(VFS, "Open response data too small\n");
1140                         pRetData->Type = cpu_to_le32(-1);
1141                         goto psx_create_err;
1142                 }
1143                 memcpy((char *) pRetData,
1144                         (char *)psx_rsp + sizeof(OPEN_PSX_RSP),
1145                         sizeof(FILE_UNIX_BASIC_INFO));
1146         }
1147
1148 psx_create_err:
1149         cifs_buf_release(pSMB);
1150
1151         if (posix_flags & SMB_O_DIRECTORY)
1152                 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixmkdirs);
1153         else
1154                 cifs_stats_inc(&tcon->stats.cifs_stats.num_posixopens);
1155
1156         if (rc == -EAGAIN)
1157                 goto PsxCreat;
1158
1159         return rc;
1160 }
1161
1162 static __u16 convert_disposition(int disposition)
1163 {
1164         __u16 ofun = 0;
1165
1166         switch (disposition) {
1167                 case FILE_SUPERSEDE:
1168                         ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1169                         break;
1170                 case FILE_OPEN:
1171                         ofun = SMBOPEN_OAPPEND;
1172                         break;
1173                 case FILE_CREATE:
1174                         ofun = SMBOPEN_OCREATE;
1175                         break;
1176                 case FILE_OPEN_IF:
1177                         ofun = SMBOPEN_OCREATE | SMBOPEN_OAPPEND;
1178                         break;
1179                 case FILE_OVERWRITE:
1180                         ofun = SMBOPEN_OTRUNC;
1181                         break;
1182                 case FILE_OVERWRITE_IF:
1183                         ofun = SMBOPEN_OCREATE | SMBOPEN_OTRUNC;
1184                         break;
1185                 default:
1186                         cifs_dbg(FYI, "unknown disposition %d\n", disposition);
1187                         ofun =  SMBOPEN_OAPPEND; /* regular open */
1188         }
1189         return ofun;
1190 }
1191
1192 static int
1193 access_flags_to_smbopen_mode(const int access_flags)
1194 {
1195         int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
1196
1197         if (masked_flags == GENERIC_READ)
1198                 return SMBOPEN_READ;
1199         else if (masked_flags == GENERIC_WRITE)
1200                 return SMBOPEN_WRITE;
1201
1202         /* just go for read/write */
1203         return SMBOPEN_READWRITE;
1204 }
1205
1206 int
1207 SMBLegacyOpen(const unsigned int xid, struct cifs_tcon *tcon,
1208             const char *fileName, const int openDisposition,
1209             const int access_flags, const int create_options, __u16 *netfid,
1210             int *pOplock, FILE_ALL_INFO *pfile_info,
1211             const struct nls_table *nls_codepage, int remap)
1212 {
1213         int rc = -EACCES;
1214         OPENX_REQ *pSMB = NULL;
1215         OPENX_RSP *pSMBr = NULL;
1216         int bytes_returned;
1217         int name_len;
1218         __u16 count;
1219
1220 OldOpenRetry:
1221         rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1222                       (void **) &pSMBr);
1223         if (rc)
1224                 return rc;
1225
1226         pSMB->AndXCommand = 0xFF;       /* none */
1227
1228         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1229                 count = 1;      /* account for one byte pad to word boundary */
1230                 name_len =
1231                    cifsConvertToUTF16((__le16 *) (pSMB->fileName + 1),
1232                                       fileName, PATH_MAX, nls_codepage, remap);
1233                 name_len++;     /* trailing null */
1234                 name_len *= 2;
1235         } else {                /* BB improve check for buffer overruns BB */
1236                 count = 0;      /* no pad */
1237                 name_len = strnlen(fileName, PATH_MAX);
1238                 name_len++;     /* trailing null */
1239                 strncpy(pSMB->fileName, fileName, name_len);
1240         }
1241         if (*pOplock & REQ_OPLOCK)
1242                 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1243         else if (*pOplock & REQ_BATCHOPLOCK)
1244                 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1245
1246         pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1247         pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
1248         pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1249         /* set file as system file if special file such
1250            as fifo and server expecting SFU style and
1251            no Unix extensions */
1252
1253         if (create_options & CREATE_OPTION_SPECIAL)
1254                 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1255         else /* BB FIXME BB */
1256                 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1257
1258         if (create_options & CREATE_OPTION_READONLY)
1259                 pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
1260
1261         /* BB FIXME BB */
1262 /*      pSMB->CreateOptions = cpu_to_le32(create_options &
1263                                                  CREATE_OPTIONS_MASK); */
1264         /* BB FIXME END BB */
1265
1266         pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1267         pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1268         count += name_len;
1269         inc_rfc1001_len(pSMB, count);
1270
1271         pSMB->ByteCount = cpu_to_le16(count);
1272         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1273                         (struct smb_hdr *)pSMBr, &bytes_returned, 0);
1274         cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1275         if (rc) {
1276                 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1277         } else {
1278         /* BB verify if wct == 15 */
1279
1280 /*              *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
1281
1282                 *netfid = pSMBr->Fid;   /* cifs fid stays in le */
1283                 /* Let caller know file was created so we can set the mode. */
1284                 /* Do we care about the CreateAction in any other cases? */
1285         /* BB FIXME BB */
1286 /*              if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1287                         *pOplock |= CIFS_CREATE_ACTION; */
1288         /* BB FIXME END */
1289
1290                 if (pfile_info) {
1291                         pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1292                         pfile_info->LastAccessTime = 0; /* BB fixme */
1293                         pfile_info->LastWriteTime = 0; /* BB fixme */
1294                         pfile_info->ChangeTime = 0;  /* BB fixme */
1295                         pfile_info->Attributes =
1296                                 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1297                         /* the file_info buf is endian converted by caller */
1298                         pfile_info->AllocationSize =
1299                                 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1300                         pfile_info->EndOfFile = pfile_info->AllocationSize;
1301                         pfile_info->NumberOfLinks = cpu_to_le32(1);
1302                         pfile_info->DeletePending = 0;
1303                 }
1304         }
1305
1306         cifs_buf_release(pSMB);
1307         if (rc == -EAGAIN)
1308                 goto OldOpenRetry;
1309         return rc;
1310 }
1311
1312 int
1313 CIFS_open(const unsigned int xid, struct cifs_open_parms *oparms, int *oplock,
1314           FILE_ALL_INFO *buf)
1315 {
1316         int rc = -EACCES;
1317         OPEN_REQ *req = NULL;
1318         OPEN_RSP *rsp = NULL;
1319         int bytes_returned;
1320         int name_len;
1321         __u16 count;
1322         struct cifs_sb_info *cifs_sb = oparms->cifs_sb;
1323         struct cifs_tcon *tcon = oparms->tcon;
1324         int remap = cifs_remap(cifs_sb);
1325         const struct nls_table *nls = cifs_sb->local_nls;
1326         int create_options = oparms->create_options;
1327         int desired_access = oparms->desired_access;
1328         int disposition = oparms->disposition;
1329         const char *path = oparms->path;
1330
1331 openRetry:
1332         rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **)&req,
1333                       (void **)&rsp);
1334         if (rc)
1335                 return rc;
1336
1337         /* no commands go after this */
1338         req->AndXCommand = 0xFF;
1339
1340         if (req->hdr.Flags2 & SMBFLG2_UNICODE) {
1341                 /* account for one byte pad to word boundary */
1342                 count = 1;
1343                 name_len = cifsConvertToUTF16((__le16 *)(req->fileName + 1),
1344                                               path, PATH_MAX, nls, remap);
1345                 /* trailing null */
1346                 name_len++;
1347                 name_len *= 2;
1348                 req->NameLength = cpu_to_le16(name_len);
1349         } else {
1350                 /* BB improve check for buffer overruns BB */
1351                 /* no pad */
1352                 count = 0;
1353                 name_len = strnlen(path, PATH_MAX);
1354                 /* trailing null */
1355                 name_len++;
1356                 req->NameLength = cpu_to_le16(name_len);
1357                 strncpy(req->fileName, path, name_len);
1358         }
1359
1360         if (*oplock & REQ_OPLOCK)
1361                 req->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1362         else if (*oplock & REQ_BATCHOPLOCK)
1363                 req->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1364
1365         req->DesiredAccess = cpu_to_le32(desired_access);
1366         req->AllocationSize = 0;
1367
1368         /*
1369          * Set file as system file if special file such as fifo and server
1370          * expecting SFU style and no Unix extensions.
1371          */
1372         if (create_options & CREATE_OPTION_SPECIAL)
1373                 req->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1374         else
1375                 req->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1376
1377         /*
1378          * XP does not handle ATTR_POSIX_SEMANTICS but it helps speed up case
1379          * sensitive checks for other servers such as Samba.
1380          */
1381         if (tcon->ses->capabilities & CAP_UNIX)
1382                 req->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1383
1384         if (create_options & CREATE_OPTION_READONLY)
1385                 req->FileAttributes |= cpu_to_le32(ATTR_READONLY);
1386
1387         req->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1388         req->CreateDisposition = cpu_to_le32(disposition);
1389         req->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1390
1391         /* BB Expirement with various impersonation levels and verify */
1392         req->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1393         req->SecurityFlags = SECURITY_CONTEXT_TRACKING|SECURITY_EFFECTIVE_ONLY;
1394
1395         count += name_len;
1396         inc_rfc1001_len(req, count);
1397
1398         req->ByteCount = cpu_to_le16(count);
1399         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *)req,
1400                          (struct smb_hdr *)rsp, &bytes_returned, 0);
1401         cifs_stats_inc(&tcon->stats.cifs_stats.num_opens);
1402         if (rc) {
1403                 cifs_dbg(FYI, "Error in Open = %d\n", rc);
1404                 cifs_buf_release(req);
1405                 if (rc == -EAGAIN)
1406                         goto openRetry;
1407                 return rc;
1408         }
1409
1410         /* 1 byte no need to le_to_cpu */
1411         *oplock = rsp->OplockLevel;
1412         /* cifs fid stays in le */
1413         oparms->fid->netfid = rsp->Fid;
1414
1415         /* Let caller know file was created so we can set the mode. */
1416         /* Do we care about the CreateAction in any other cases? */
1417         if (cpu_to_le32(FILE_CREATE) == rsp->CreateAction)
1418                 *oplock |= CIFS_CREATE_ACTION;
1419
1420         if (buf) {
1421                 /* copy from CreationTime to Attributes */
1422                 memcpy((char *)buf, (char *)&rsp->CreationTime, 36);
1423                 /* the file_info buf is endian converted by caller */
1424                 buf->AllocationSize = rsp->AllocationSize;
1425                 buf->EndOfFile = rsp->EndOfFile;
1426                 buf->NumberOfLinks = cpu_to_le32(1);
1427                 buf->DeletePending = 0;
1428         }
1429
1430         cifs_buf_release(req);
1431         return rc;
1432 }
1433
1434 /*
1435  * Discard any remaining data in the current SMB. To do this, we borrow the
1436  * current bigbuf.
1437  */
1438 int
1439 cifs_discard_remaining_data(struct TCP_Server_Info *server)
1440 {
1441         unsigned int rfclen = server->pdu_size;
1442         int remaining = rfclen + server->vals->header_preamble_size -
1443                 server->total_read;
1444
1445         while (remaining > 0) {
1446                 int length;
1447
1448                 length = cifs_read_from_socket(server, server->bigbuf,
1449                                 min_t(unsigned int, remaining,
1450                                     CIFSMaxBufSize + MAX_HEADER_SIZE(server)));
1451                 if (length < 0)
1452                         return length;
1453                 server->total_read += length;
1454                 remaining -= length;
1455         }
1456
1457         return 0;
1458 }
1459
1460 static int
1461 __cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid,
1462                      bool malformed)
1463 {
1464         int length;
1465
1466         length = cifs_discard_remaining_data(server);
1467         dequeue_mid(mid, malformed);
1468         mid->resp_buf = server->smallbuf;
1469         server->smallbuf = NULL;
1470         return length;
1471 }
1472
1473 static int
1474 cifs_readv_discard(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1475 {
1476         struct cifs_readdata *rdata = mid->callback_data;
1477
1478         return  __cifs_readv_discard(server, mid, rdata->result);
1479 }
1480
1481 int
1482 cifs_readv_receive(struct TCP_Server_Info *server, struct mid_q_entry *mid)
1483 {
1484         int length, len;
1485         unsigned int data_offset, data_len;
1486         struct cifs_readdata *rdata = mid->callback_data;
1487         char *buf = server->smallbuf;
1488         unsigned int buflen = server->pdu_size +
1489                 server->vals->header_preamble_size;
1490         bool use_rdma_mr = false;
1491
1492         cifs_dbg(FYI, "%s: mid=%llu offset=%llu bytes=%u\n",
1493                  __func__, mid->mid, rdata->offset, rdata->bytes);
1494
1495         /*
1496          * read the rest of READ_RSP header (sans Data array), or whatever we
1497          * can if there's not enough data. At this point, we've read down to
1498          * the Mid.
1499          */
1500         len = min_t(unsigned int, buflen, server->vals->read_rsp_size) -
1501                                                         HEADER_SIZE(server) + 1;
1502
1503         length = cifs_read_from_socket(server,
1504                                        buf + HEADER_SIZE(server) - 1, len);
1505         if (length < 0)
1506                 return length;
1507         server->total_read += length;
1508
1509         if (server->ops->is_session_expired &&
1510             server->ops->is_session_expired(buf)) {
1511                 cifs_reconnect(server);
1512                 wake_up(&server->response_q);
1513                 return -1;
1514         }
1515
1516         if (server->ops->is_status_pending &&
1517             server->ops->is_status_pending(buf, server, 0)) {
1518                 cifs_discard_remaining_data(server);
1519                 return -1;
1520         }
1521
1522         /* set up first two iov for signature check and to get credits */
1523         rdata->iov[0].iov_base = buf;
1524         rdata->iov[0].iov_len = server->vals->header_preamble_size;
1525         rdata->iov[1].iov_base = buf + server->vals->header_preamble_size;
1526         rdata->iov[1].iov_len =
1527                 server->total_read - server->vals->header_preamble_size;
1528         cifs_dbg(FYI, "0: iov_base=%p iov_len=%zu\n",
1529                  rdata->iov[0].iov_base, rdata->iov[0].iov_len);
1530         cifs_dbg(FYI, "1: iov_base=%p iov_len=%zu\n",
1531                  rdata->iov[1].iov_base, rdata->iov[1].iov_len);
1532
1533         /* Was the SMB read successful? */
1534         rdata->result = server->ops->map_error(buf, false);
1535         if (rdata->result != 0) {
1536                 cifs_dbg(FYI, "%s: server returned error %d\n",
1537                          __func__, rdata->result);
1538                 /* normal error on read response */
1539                 return __cifs_readv_discard(server, mid, false);
1540         }
1541
1542         /* Is there enough to get to the rest of the READ_RSP header? */
1543         if (server->total_read < server->vals->read_rsp_size) {
1544                 cifs_dbg(FYI, "%s: server returned short header. got=%u expected=%zu\n",
1545                          __func__, server->total_read,
1546                          server->vals->read_rsp_size);
1547                 rdata->result = -EIO;
1548                 return cifs_readv_discard(server, mid);
1549         }
1550
1551         data_offset = server->ops->read_data_offset(buf) +
1552                 server->vals->header_preamble_size;
1553         if (data_offset < server->total_read) {
1554                 /*
1555                  * win2k8 sometimes sends an offset of 0 when the read
1556                  * is beyond the EOF. Treat it as if the data starts just after
1557                  * the header.
1558                  */
1559                 cifs_dbg(FYI, "%s: data offset (%u) inside read response header\n",
1560                          __func__, data_offset);
1561                 data_offset = server->total_read;
1562         } else if (data_offset > MAX_CIFS_SMALL_BUFFER_SIZE) {
1563                 /* data_offset is beyond the end of smallbuf */
1564                 cifs_dbg(FYI, "%s: data offset (%u) beyond end of smallbuf\n",
1565                          __func__, data_offset);
1566                 rdata->result = -EIO;
1567                 return cifs_readv_discard(server, mid);
1568         }
1569
1570         cifs_dbg(FYI, "%s: total_read=%u data_offset=%u\n",
1571                  __func__, server->total_read, data_offset);
1572
1573         len = data_offset - server->total_read;
1574         if (len > 0) {
1575                 /* read any junk before data into the rest of smallbuf */
1576                 length = cifs_read_from_socket(server,
1577                                                buf + server->total_read, len);
1578                 if (length < 0)
1579                         return length;
1580                 server->total_read += length;
1581         }
1582
1583         /* how much data is in the response? */
1584 #ifdef CONFIG_CIFS_SMB_DIRECT
1585         use_rdma_mr = rdata->mr;
1586 #endif
1587         data_len = server->ops->read_data_length(buf, use_rdma_mr);
1588         if (!use_rdma_mr && (data_offset + data_len > buflen)) {
1589                 /* data_len is corrupt -- discard frame */
1590                 rdata->result = -EIO;
1591                 return cifs_readv_discard(server, mid);
1592         }
1593
1594         length = rdata->read_into_pages(server, rdata, data_len);
1595         if (length < 0)
1596                 return length;
1597
1598         server->total_read += length;
1599
1600         cifs_dbg(FYI, "total_read=%u buflen=%u remaining=%u\n",
1601                  server->total_read, buflen, data_len);
1602
1603         /* discard anything left over */
1604         if (server->total_read < buflen)
1605                 return cifs_readv_discard(server, mid);
1606
1607         dequeue_mid(mid, false);
1608         mid->resp_buf = server->smallbuf;
1609         server->smallbuf = NULL;
1610         return length;
1611 }
1612
1613 static void
1614 cifs_readv_callback(struct mid_q_entry *mid)
1615 {
1616         struct cifs_readdata *rdata = mid->callback_data;
1617         struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1618         struct TCP_Server_Info *server = tcon->ses->server;
1619         struct smb_rqst rqst = { .rq_iov = rdata->iov,
1620                                  .rq_nvec = 2,
1621                                  .rq_pages = rdata->pages,
1622                                  .rq_npages = rdata->nr_pages,
1623                                  .rq_pagesz = rdata->pagesz,
1624                                  .rq_tailsz = rdata->tailsz };
1625
1626         cifs_dbg(FYI, "%s: mid=%llu state=%d result=%d bytes=%u\n",
1627                  __func__, mid->mid, mid->mid_state, rdata->result,
1628                  rdata->bytes);
1629
1630         switch (mid->mid_state) {
1631         case MID_RESPONSE_RECEIVED:
1632                 /* result already set, check signature */
1633                 if (server->sign) {
1634                         int rc = 0;
1635
1636                         rc = cifs_verify_signature(&rqst, server,
1637                                                   mid->sequence_number);
1638                         if (rc)
1639                                 cifs_dbg(VFS, "SMB signature verification returned error = %d\n",
1640                                          rc);
1641                 }
1642                 /* FIXME: should this be counted toward the initiating task? */
1643                 task_io_account_read(rdata->got_bytes);
1644                 cifs_stats_bytes_read(tcon, rdata->got_bytes);
1645                 break;
1646         case MID_REQUEST_SUBMITTED:
1647         case MID_RETRY_NEEDED:
1648                 rdata->result = -EAGAIN;
1649                 if (server->sign && rdata->got_bytes)
1650                         /* reset bytes number since we can not check a sign */
1651                         rdata->got_bytes = 0;
1652                 /* FIXME: should this be counted toward the initiating task? */
1653                 task_io_account_read(rdata->got_bytes);
1654                 cifs_stats_bytes_read(tcon, rdata->got_bytes);
1655                 break;
1656         default:
1657                 rdata->result = -EIO;
1658         }
1659
1660         queue_work(cifsiod_wq, &rdata->work);
1661         DeleteMidQEntry(mid);
1662         add_credits(server, 1, 0);
1663 }
1664
1665 /* cifs_async_readv - send an async write, and set up mid to handle result */
1666 int
1667 cifs_async_readv(struct cifs_readdata *rdata)
1668 {
1669         int rc;
1670         READ_REQ *smb = NULL;
1671         int wct;
1672         struct cifs_tcon *tcon = tlink_tcon(rdata->cfile->tlink);
1673         struct smb_rqst rqst = { .rq_iov = rdata->iov,
1674                                  .rq_nvec = 2 };
1675
1676         cifs_dbg(FYI, "%s: offset=%llu bytes=%u\n",
1677                  __func__, rdata->offset, rdata->bytes);
1678
1679         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1680                 wct = 12;
1681         else {
1682                 wct = 10; /* old style read */
1683                 if ((rdata->offset >> 32) > 0)  {
1684                         /* can not handle this big offset for old */
1685                         return -EIO;
1686                 }
1687         }
1688
1689         rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **)&smb);
1690         if (rc)
1691                 return rc;
1692
1693         smb->hdr.Pid = cpu_to_le16((__u16)rdata->pid);
1694         smb->hdr.PidHigh = cpu_to_le16((__u16)(rdata->pid >> 16));
1695
1696         smb->AndXCommand = 0xFF;        /* none */
1697         smb->Fid = rdata->cfile->fid.netfid;
1698         smb->OffsetLow = cpu_to_le32(rdata->offset & 0xFFFFFFFF);
1699         if (wct == 12)
1700                 smb->OffsetHigh = cpu_to_le32(rdata->offset >> 32);
1701         smb->Remaining = 0;
1702         smb->MaxCount = cpu_to_le16(rdata->bytes & 0xFFFF);
1703         smb->MaxCountHigh = cpu_to_le32(rdata->bytes >> 16);
1704         if (wct == 12)
1705                 smb->ByteCount = 0;
1706         else {
1707                 /* old style read */
1708                 struct smb_com_readx_req *smbr =
1709                         (struct smb_com_readx_req *)smb;
1710                 smbr->ByteCount = 0;
1711         }
1712
1713         /* 4 for RFC1001 length + 1 for BCC */
1714         rdata->iov[0].iov_base = smb;
1715         rdata->iov[0].iov_len = 4;
1716         rdata->iov[1].iov_base = (char *)smb + 4;
1717         rdata->iov[1].iov_len = get_rfc1002_length(smb);
1718
1719         kref_get(&rdata->refcount);
1720         rc = cifs_call_async(tcon->ses->server, &rqst, cifs_readv_receive,
1721                              cifs_readv_callback, NULL, rdata, 0);
1722
1723         if (rc == 0)
1724                 cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1725         else
1726                 kref_put(&rdata->refcount, cifs_readdata_release);
1727
1728         cifs_small_buf_release(smb);
1729         return rc;
1730 }
1731
1732 int
1733 CIFSSMBRead(const unsigned int xid, struct cifs_io_parms *io_parms,
1734             unsigned int *nbytes, char **buf, int *pbuf_type)
1735 {
1736         int rc = -EACCES;
1737         READ_REQ *pSMB = NULL;
1738         READ_RSP *pSMBr = NULL;
1739         char *pReadData = NULL;
1740         int wct;
1741         int resp_buf_type = 0;
1742         struct kvec iov[1];
1743         struct kvec rsp_iov;
1744         __u32 pid = io_parms->pid;
1745         __u16 netfid = io_parms->netfid;
1746         __u64 offset = io_parms->offset;
1747         struct cifs_tcon *tcon = io_parms->tcon;
1748         unsigned int count = io_parms->length;
1749
1750         cifs_dbg(FYI, "Reading %d bytes on fid %d\n", count, netfid);
1751         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1752                 wct = 12;
1753         else {
1754                 wct = 10; /* old style read */
1755                 if ((offset >> 32) > 0)  {
1756                         /* can not handle this big offset for old */
1757                         return -EIO;
1758                 }
1759         }
1760
1761         *nbytes = 0;
1762         rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1763         if (rc)
1764                 return rc;
1765
1766         pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1767         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1768
1769         /* tcon and ses pointer are checked in smb_init */
1770         if (tcon->ses->server == NULL)
1771                 return -ECONNABORTED;
1772
1773         pSMB->AndXCommand = 0xFF;       /* none */
1774         pSMB->Fid = netfid;
1775         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1776         if (wct == 12)
1777                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1778
1779         pSMB->Remaining = 0;
1780         pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1781         pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1782         if (wct == 12)
1783                 pSMB->ByteCount = 0;  /* no need to do le conversion since 0 */
1784         else {
1785                 /* old style read */
1786                 struct smb_com_readx_req *pSMBW =
1787                         (struct smb_com_readx_req *)pSMB;
1788                 pSMBW->ByteCount = 0;
1789         }
1790
1791         iov[0].iov_base = (char *)pSMB;
1792         iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
1793         rc = SendReceive2(xid, tcon->ses, iov, 1, &resp_buf_type,
1794                           CIFS_LOG_ERROR, &rsp_iov);
1795         cifs_small_buf_release(pSMB);
1796         cifs_stats_inc(&tcon->stats.cifs_stats.num_reads);
1797         pSMBr = (READ_RSP *)rsp_iov.iov_base;
1798         if (rc) {
1799                 cifs_dbg(VFS, "Send error in read = %d\n", rc);
1800         } else {
1801                 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1802                 data_length = data_length << 16;
1803                 data_length += le16_to_cpu(pSMBr->DataLength);
1804                 *nbytes = data_length;
1805
1806                 /*check that DataLength would not go beyond end of SMB */
1807                 if ((data_length > CIFSMaxBufSize)
1808                                 || (data_length > count)) {
1809                         cifs_dbg(FYI, "bad length %d for count %d\n",
1810                                  data_length, count);
1811                         rc = -EIO;
1812                         *nbytes = 0;
1813                 } else {
1814                         pReadData = (char *) (&pSMBr->hdr.Protocol) +
1815                                         le16_to_cpu(pSMBr->DataOffset);
1816 /*                      if (rc = copy_to_user(buf, pReadData, data_length)) {
1817                                 cifs_dbg(VFS, "Faulting on read rc = %d\n",rc);
1818                                 rc = -EFAULT;
1819                         }*/ /* can not use copy_to_user when using page cache*/
1820                         if (*buf)
1821                                 memcpy(*buf, pReadData, data_length);
1822                 }
1823         }
1824
1825         if (*buf) {
1826                 free_rsp_buf(resp_buf_type, rsp_iov.iov_base);
1827         } else if (resp_buf_type != CIFS_NO_BUFFER) {
1828                 /* return buffer to caller to free */
1829                 *buf = rsp_iov.iov_base;
1830                 if (resp_buf_type == CIFS_SMALL_BUFFER)
1831                         *pbuf_type = CIFS_SMALL_BUFFER;
1832                 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1833                         *pbuf_type = CIFS_LARGE_BUFFER;
1834         } /* else no valid buffer on return - leave as null */
1835
1836         /* Note: On -EAGAIN error only caller can retry on handle based calls
1837                 since file handle passed in no longer valid */
1838         return rc;
1839 }
1840
1841
1842 int
1843 CIFSSMBWrite(const unsigned int xid, struct cifs_io_parms *io_parms,
1844              unsigned int *nbytes, const char *buf)
1845 {
1846         int rc = -EACCES;
1847         WRITE_REQ *pSMB = NULL;
1848         WRITE_RSP *pSMBr = NULL;
1849         int bytes_returned, wct;
1850         __u32 bytes_sent;
1851         __u16 byte_count;
1852         __u32 pid = io_parms->pid;
1853         __u16 netfid = io_parms->netfid;
1854         __u64 offset = io_parms->offset;
1855         struct cifs_tcon *tcon = io_parms->tcon;
1856         unsigned int count = io_parms->length;
1857
1858         *nbytes = 0;
1859
1860         /* cifs_dbg(FYI, "write at %lld %d bytes\n", offset, count);*/
1861         if (tcon->ses == NULL)
1862                 return -ECONNABORTED;
1863
1864         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1865                 wct = 14;
1866         else {
1867                 wct = 12;
1868                 if ((offset >> 32) > 0) {
1869                         /* can not handle big offset for old srv */
1870                         return -EIO;
1871                 }
1872         }
1873
1874         rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1875                       (void **) &pSMBr);
1876         if (rc)
1877                 return rc;
1878
1879         pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
1880         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
1881
1882         /* tcon and ses pointer are checked in smb_init */
1883         if (tcon->ses->server == NULL)
1884                 return -ECONNABORTED;
1885
1886         pSMB->AndXCommand = 0xFF;       /* none */
1887         pSMB->Fid = netfid;
1888         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1889         if (wct == 14)
1890                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1891
1892         pSMB->Reserved = 0xFFFFFFFF;
1893         pSMB->WriteMode = 0;
1894         pSMB->Remaining = 0;
1895
1896         /* Can increase buffer size if buffer is big enough in some cases ie we
1897         can send more if LARGE_WRITE_X capability returned by the server and if
1898         our buffer is big enough or if we convert to iovecs on socket writes
1899         and eliminate the copy to the CIFS buffer */
1900         if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1901                 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1902         } else {
1903                 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1904                          & ~0xFF;
1905         }
1906
1907         if (bytes_sent > count)
1908                 bytes_sent = count;
1909         pSMB->DataOffset =
1910                 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1911         if (buf)
1912                 memcpy(pSMB->Data, buf, bytes_sent);
1913         else if (count != 0) {
1914                 /* No buffer */
1915                 cifs_buf_release(pSMB);
1916                 return -EINVAL;
1917         } /* else setting file size with write of zero bytes */
1918         if (wct == 14)
1919                 byte_count = bytes_sent + 1; /* pad */
1920         else /* wct == 12 */
1921                 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1922
1923         pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1924         pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1925         inc_rfc1001_len(pSMB, byte_count);
1926
1927         if (wct == 14)
1928                 pSMB->ByteCount = cpu_to_le16(byte_count);
1929         else { /* old style write has byte count 4 bytes earlier
1930                   so 4 bytes pad  */
1931                 struct smb_com_writex_req *pSMBW =
1932                         (struct smb_com_writex_req *)pSMB;
1933                 pSMBW->ByteCount = cpu_to_le16(byte_count);
1934         }
1935
1936         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1937                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1938         cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
1939         if (rc) {
1940                 cifs_dbg(FYI, "Send error in write = %d\n", rc);
1941         } else {
1942                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1943                 *nbytes = (*nbytes) << 16;
1944                 *nbytes += le16_to_cpu(pSMBr->Count);
1945
1946                 /*
1947                  * Mask off high 16 bits when bytes written as returned by the
1948                  * server is greater than bytes requested by the client. Some
1949                  * OS/2 servers are known to set incorrect CountHigh values.
1950                  */
1951                 if (*nbytes > count)
1952                         *nbytes &= 0xFFFF;
1953         }
1954
1955         cifs_buf_release(pSMB);
1956
1957         /* Note: On -EAGAIN error only caller can retry on handle based calls
1958                 since file handle passed in no longer valid */
1959
1960         return rc;
1961 }
1962
1963 void
1964 cifs_writedata_release(struct kref *refcount)
1965 {
1966         struct cifs_writedata *wdata = container_of(refcount,
1967                                         struct cifs_writedata, refcount);
1968 #ifdef CONFIG_CIFS_SMB_DIRECT
1969         if (wdata->mr) {
1970                 smbd_deregister_mr(wdata->mr);
1971                 wdata->mr = NULL;
1972         }
1973 #endif
1974
1975         if (wdata->cfile)
1976                 cifsFileInfo_put(wdata->cfile);
1977
1978         kvfree(wdata->pages);
1979         kfree(wdata);
1980 }
1981
1982 /*
1983  * Write failed with a retryable error. Resend the write request. It's also
1984  * possible that the page was redirtied so re-clean the page.
1985  */
1986 static void
1987 cifs_writev_requeue(struct cifs_writedata *wdata)
1988 {
1989         int i, rc = 0;
1990         struct inode *inode = d_inode(wdata->cfile->dentry);
1991         struct TCP_Server_Info *server;
1992         unsigned int rest_len;
1993
1994         server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1995         i = 0;
1996         rest_len = wdata->bytes;
1997         do {
1998                 struct cifs_writedata *wdata2;
1999                 unsigned int j, nr_pages, wsize, tailsz, cur_len;
2000
2001                 wsize = server->ops->wp_retry_size(inode);
2002                 if (wsize < rest_len) {
2003                         nr_pages = wsize / PAGE_SIZE;
2004                         if (!nr_pages) {
2005                                 rc = -ENOTSUPP;
2006                                 break;
2007                         }
2008                         cur_len = nr_pages * PAGE_SIZE;
2009                         tailsz = PAGE_SIZE;
2010                 } else {
2011                         nr_pages = DIV_ROUND_UP(rest_len, PAGE_SIZE);
2012                         cur_len = rest_len;
2013                         tailsz = rest_len - (nr_pages - 1) * PAGE_SIZE;
2014                 }
2015
2016                 wdata2 = cifs_writedata_alloc(nr_pages, cifs_writev_complete);
2017                 if (!wdata2) {
2018                         rc = -ENOMEM;
2019                         break;
2020                 }
2021
2022                 for (j = 0; j < nr_pages; j++) {
2023                         wdata2->pages[j] = wdata->pages[i + j];
2024                         lock_page(wdata2->pages[j]);
2025                         clear_page_dirty_for_io(wdata2->pages[j]);
2026                 }
2027
2028                 wdata2->sync_mode = wdata->sync_mode;
2029                 wdata2->nr_pages = nr_pages;
2030                 wdata2->offset = page_offset(wdata2->pages[0]);
2031                 wdata2->pagesz = PAGE_SIZE;
2032                 wdata2->tailsz = tailsz;
2033                 wdata2->bytes = cur_len;
2034
2035                 wdata2->cfile = find_writable_file(CIFS_I(inode), false);
2036                 if (!wdata2->cfile) {
2037                         cifs_dbg(VFS, "No writable handle to retry writepages\n");
2038                         rc = -EBADF;
2039                 } else {
2040                         wdata2->pid = wdata2->cfile->pid;
2041                         rc = server->ops->async_writev(wdata2,
2042                                                        cifs_writedata_release);
2043                 }
2044
2045                 for (j = 0; j < nr_pages; j++) {
2046                         unlock_page(wdata2->pages[j]);
2047                         if (rc != 0 && !is_retryable_error(rc)) {
2048                                 SetPageError(wdata2->pages[j]);
2049                                 end_page_writeback(wdata2->pages[j]);
2050                                 put_page(wdata2->pages[j]);
2051                         }
2052                 }
2053
2054                 kref_put(&wdata2->refcount, cifs_writedata_release);
2055                 if (rc) {
2056                         if (is_retryable_error(rc))
2057                                 continue;
2058                         i += nr_pages;
2059                         break;
2060                 }
2061
2062                 rest_len -= cur_len;
2063                 i += nr_pages;
2064         } while (i < wdata->nr_pages);
2065
2066         /* cleanup remaining pages from the original wdata */
2067         for (; i < wdata->nr_pages; i++) {
2068                 SetPageError(wdata->pages[i]);
2069                 end_page_writeback(wdata->pages[i]);
2070                 put_page(wdata->pages[i]);
2071         }
2072
2073         if (rc != 0 && !is_retryable_error(rc))
2074                 mapping_set_error(inode->i_mapping, rc);
2075         kref_put(&wdata->refcount, cifs_writedata_release);
2076 }
2077
2078 void
2079 cifs_writev_complete(struct work_struct *work)
2080 {
2081         struct cifs_writedata *wdata = container_of(work,
2082                                                 struct cifs_writedata, work);
2083         struct inode *inode = d_inode(wdata->cfile->dentry);
2084         int i = 0;
2085
2086         if (wdata->result == 0) {
2087                 spin_lock(&inode->i_lock);
2088                 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2089                 spin_unlock(&inode->i_lock);
2090                 cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2091                                          wdata->bytes);
2092         } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2093                 return cifs_writev_requeue(wdata);
2094
2095         for (i = 0; i < wdata->nr_pages; i++) {
2096                 struct page *page = wdata->pages[i];
2097                 if (wdata->result == -EAGAIN)
2098                         __set_page_dirty_nobuffers(page);
2099                 else if (wdata->result < 0)
2100                         SetPageError(page);
2101                 end_page_writeback(page);
2102                 put_page(page);
2103         }
2104         if (wdata->result != -EAGAIN)
2105                 mapping_set_error(inode->i_mapping, wdata->result);
2106         kref_put(&wdata->refcount, cifs_writedata_release);
2107 }
2108
2109 struct cifs_writedata *
2110 cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
2111 {
2112         struct page **pages =
2113                 kcalloc(nr_pages, sizeof(struct page *), GFP_NOFS);
2114         if (pages)
2115                 return cifs_writedata_direct_alloc(pages, complete);
2116
2117         return NULL;
2118 }
2119
2120 struct cifs_writedata *
2121 cifs_writedata_direct_alloc(struct page **pages, work_func_t complete)
2122 {
2123         struct cifs_writedata *wdata;
2124
2125         wdata = kzalloc(sizeof(*wdata), GFP_NOFS);
2126         if (wdata != NULL) {
2127                 wdata->pages = pages;
2128                 kref_init(&wdata->refcount);
2129                 INIT_LIST_HEAD(&wdata->list);
2130                 init_completion(&wdata->done);
2131                 INIT_WORK(&wdata->work, complete);
2132         }
2133         return wdata;
2134 }
2135
2136 /*
2137  * Check the mid_state and signature on received buffer (if any), and queue the
2138  * workqueue completion task.
2139  */
2140 static void
2141 cifs_writev_callback(struct mid_q_entry *mid)
2142 {
2143         struct cifs_writedata *wdata = mid->callback_data;
2144         struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2145         unsigned int written;
2146         WRITE_RSP *smb = (WRITE_RSP *)mid->resp_buf;
2147
2148         switch (mid->mid_state) {
2149         case MID_RESPONSE_RECEIVED:
2150                 wdata->result = cifs_check_receive(mid, tcon->ses->server, 0);
2151                 if (wdata->result != 0)
2152                         break;
2153
2154                 written = le16_to_cpu(smb->CountHigh);
2155                 written <<= 16;
2156                 written += le16_to_cpu(smb->Count);
2157                 /*
2158                  * Mask off high 16 bits when bytes written as returned
2159                  * by the server is greater than bytes requested by the
2160                  * client. OS/2 servers are known to set incorrect
2161                  * CountHigh values.
2162                  */
2163                 if (written > wdata->bytes)
2164                         written &= 0xFFFF;
2165
2166                 if (written < wdata->bytes)
2167                         wdata->result = -ENOSPC;
2168                 else
2169                         wdata->bytes = written;
2170                 break;
2171         case MID_REQUEST_SUBMITTED:
2172         case MID_RETRY_NEEDED:
2173                 wdata->result = -EAGAIN;
2174                 break;
2175         default:
2176                 wdata->result = -EIO;
2177                 break;
2178         }
2179
2180         queue_work(cifsiod_wq, &wdata->work);
2181         DeleteMidQEntry(mid);
2182         add_credits(tcon->ses->server, 1, 0);
2183 }
2184
2185 /* cifs_async_writev - send an async write, and set up mid to handle result */
2186 int
2187 cifs_async_writev(struct cifs_writedata *wdata,
2188                   void (*release)(struct kref *kref))
2189 {
2190         int rc = -EACCES;
2191         WRITE_REQ *smb = NULL;
2192         int wct;
2193         struct cifs_tcon *tcon = tlink_tcon(wdata->cfile->tlink);
2194         struct kvec iov[2];
2195         struct smb_rqst rqst = { };
2196
2197         if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2198                 wct = 14;
2199         } else {
2200                 wct = 12;
2201                 if (wdata->offset >> 32 > 0) {
2202                         /* can not handle big offset for old srv */
2203                         return -EIO;
2204                 }
2205         }
2206
2207         rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **)&smb);
2208         if (rc)
2209                 goto async_writev_out;
2210
2211         smb->hdr.Pid = cpu_to_le16((__u16)wdata->pid);
2212         smb->hdr.PidHigh = cpu_to_le16((__u16)(wdata->pid >> 16));
2213
2214         smb->AndXCommand = 0xFF;        /* none */
2215         smb->Fid = wdata->cfile->fid.netfid;
2216         smb->OffsetLow = cpu_to_le32(wdata->offset & 0xFFFFFFFF);
2217         if (wct == 14)
2218                 smb->OffsetHigh = cpu_to_le32(wdata->offset >> 32);
2219         smb->Reserved = 0xFFFFFFFF;
2220         smb->WriteMode = 0;
2221         smb->Remaining = 0;
2222
2223         smb->DataOffset =
2224             cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2225
2226         /* 4 for RFC1001 length + 1 for BCC */
2227         iov[0].iov_len = 4;
2228         iov[0].iov_base = smb;
2229         iov[1].iov_len = get_rfc1002_length(smb) + 1;
2230         iov[1].iov_base = (char *)smb + 4;
2231
2232         rqst.rq_iov = iov;
2233         rqst.rq_nvec = 2;
2234         rqst.rq_pages = wdata->pages;
2235         rqst.rq_npages = wdata->nr_pages;
2236         rqst.rq_pagesz = wdata->pagesz;
2237         rqst.rq_tailsz = wdata->tailsz;
2238
2239         cifs_dbg(FYI, "async write at %llu %u bytes\n",
2240                  wdata->offset, wdata->bytes);
2241
2242         smb->DataLengthLow = cpu_to_le16(wdata->bytes & 0xFFFF);
2243         smb->DataLengthHigh = cpu_to_le16(wdata->bytes >> 16);
2244
2245         if (wct == 14) {
2246                 inc_rfc1001_len(&smb->hdr, wdata->bytes + 1);
2247                 put_bcc(wdata->bytes + 1, &smb->hdr);
2248         } else {
2249                 /* wct == 12 */
2250                 struct smb_com_writex_req *smbw =
2251                                 (struct smb_com_writex_req *)smb;
2252                 inc_rfc1001_len(&smbw->hdr, wdata->bytes + 5);
2253                 put_bcc(wdata->bytes + 5, &smbw->hdr);
2254                 iov[1].iov_len += 4; /* pad bigger by four bytes */
2255         }
2256
2257         kref_get(&wdata->refcount);
2258         rc = cifs_call_async(tcon->ses->server, &rqst, NULL,
2259                                 cifs_writev_callback, NULL, wdata, 0);
2260
2261         if (rc == 0)
2262                 cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
2263         else
2264                 kref_put(&wdata->refcount, release);
2265
2266 async_writev_out:
2267         cifs_small_buf_release(smb);
2268         return rc;
2269 }
2270
2271 int
2272 CIFSSMBWrite2(const unsigned int xid, struct cifs_io_parms *io_parms,
2273               unsigned int *nbytes, struct kvec *iov, int n_vec)
2274 {
2275         int rc = -EACCES;
2276         WRITE_REQ *pSMB = NULL;
2277         int wct;
2278         int smb_hdr_len;
2279         int resp_buf_type = 0;
2280         __u32 pid = io_parms->pid;
2281         __u16 netfid = io_parms->netfid;
2282         __u64 offset = io_parms->offset;
2283         struct cifs_tcon *tcon = io_parms->tcon;
2284         unsigned int count = io_parms->length;
2285         struct kvec rsp_iov;
2286
2287         *nbytes = 0;
2288
2289         cifs_dbg(FYI, "write2 at %lld %d bytes\n", (long long)offset, count);
2290
2291         if (tcon->ses->capabilities & CAP_LARGE_FILES) {
2292                 wct = 14;
2293         } else {
2294                 wct = 12;
2295                 if ((offset >> 32) > 0) {
2296                         /* can not handle big offset for old srv */
2297                         return -EIO;
2298                 }
2299         }
2300         rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
2301         if (rc)
2302                 return rc;
2303
2304         pSMB->hdr.Pid = cpu_to_le16((__u16)pid);
2305         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid >> 16));
2306
2307         /* tcon and ses pointer are checked in smb_init */
2308         if (tcon->ses->server == NULL)
2309                 return -ECONNABORTED;
2310
2311         pSMB->AndXCommand = 0xFF;       /* none */
2312         pSMB->Fid = netfid;
2313         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
2314         if (wct == 14)
2315                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
2316         pSMB->Reserved = 0xFFFFFFFF;
2317         pSMB->WriteMode = 0;
2318         pSMB->Remaining = 0;
2319
2320         pSMB->DataOffset =
2321             cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
2322
2323         pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
2324         pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
2325         /* header + 1 byte pad */
2326         smb_hdr_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 1;
2327         if (wct == 14)
2328                 inc_rfc1001_len(pSMB, count + 1);
2329         else /* wct == 12 */
2330                 inc_rfc1001_len(pSMB, count + 5); /* smb data starts later */
2331         if (wct == 14)
2332                 pSMB->ByteCount = cpu_to_le16(count + 1);
2333         else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
2334                 struct smb_com_writex_req *pSMBW =
2335                                 (struct smb_com_writex_req *)pSMB;
2336                 pSMBW->ByteCount = cpu_to_le16(count + 5);
2337         }
2338         iov[0].iov_base = pSMB;
2339         if (wct == 14)
2340                 iov[0].iov_len = smb_hdr_len + 4;
2341         else /* wct == 12 pad bigger by four bytes */
2342                 iov[0].iov_len = smb_hdr_len + 8;
2343
2344         rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type, 0,
2345                           &rsp_iov);
2346         cifs_small_buf_release(pSMB);
2347         cifs_stats_inc(&tcon->stats.cifs_stats.num_writes);
2348         if (rc) {
2349                 cifs_dbg(FYI, "Send error Write2 = %d\n", rc);
2350         } else if (resp_buf_type == 0) {
2351                 /* presumably this can not happen, but best to be safe */
2352                 rc = -EIO;
2353         } else {
2354                 WRITE_RSP *pSMBr = (WRITE_RSP *)rsp_iov.iov_base;
2355                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
2356                 *nbytes = (*nbytes) << 16;
2357                 *nbytes += le16_to_cpu(pSMBr->Count);
2358
2359                 /*
2360                  * Mask off high 16 bits when bytes written as returned by the
2361                  * server is greater than bytes requested by the client. OS/2
2362                  * servers are known to set incorrect CountHigh values.
2363                  */
2364                 if (*nbytes > count)
2365                         *nbytes &= 0xFFFF;
2366         }
2367
2368         free_rsp_buf(resp_buf_type, rsp_iov.iov_base);
2369
2370         /* Note: On -EAGAIN error only caller can retry on handle based calls
2371                 since file handle passed in no longer valid */
2372
2373         return rc;
2374 }
2375
2376 int cifs_lockv(const unsigned int xid, struct cifs_tcon *tcon,
2377                const __u16 netfid, const __u8 lock_type, const __u32 num_unlock,
2378                const __u32 num_lock, LOCKING_ANDX_RANGE *buf)
2379 {
2380         int rc = 0;
2381         LOCK_REQ *pSMB = NULL;
2382         struct kvec iov[2];
2383         struct kvec rsp_iov;
2384         int resp_buf_type;
2385         __u16 count;
2386
2387         cifs_dbg(FYI, "cifs_lockv num lock %d num unlock %d\n",
2388                  num_lock, num_unlock);
2389
2390         rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2391         if (rc)
2392                 return rc;
2393
2394         pSMB->Timeout = 0;
2395         pSMB->NumberOfLocks = cpu_to_le16(num_lock);
2396         pSMB->NumberOfUnlocks = cpu_to_le16(num_unlock);
2397         pSMB->LockType = lock_type;
2398         pSMB->AndXCommand = 0xFF; /* none */
2399         pSMB->Fid = netfid; /* netfid stays le */
2400
2401         count = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2402         inc_rfc1001_len(pSMB, count);
2403         pSMB->ByteCount = cpu_to_le16(count);
2404
2405         iov[0].iov_base = (char *)pSMB;
2406         iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4 -
2407                          (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2408         iov[1].iov_base = (char *)buf;
2409         iov[1].iov_len = (num_unlock + num_lock) * sizeof(LOCKING_ANDX_RANGE);
2410
2411         cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
2412         rc = SendReceive2(xid, tcon->ses, iov, 2, &resp_buf_type, CIFS_NO_RESP,
2413                           &rsp_iov);
2414         cifs_small_buf_release(pSMB);
2415         if (rc)
2416                 cifs_dbg(FYI, "Send error in cifs_lockv = %d\n", rc);
2417
2418         return rc;
2419 }
2420
2421 int
2422 CIFSSMBLock(const unsigned int xid, struct cifs_tcon *tcon,
2423             const __u16 smb_file_id, const __u32 netpid, const __u64 len,
2424             const __u64 offset, const __u32 numUnlock,
2425             const __u32 numLock, const __u8 lockType,
2426             const bool waitFlag, const __u8 oplock_level)
2427 {
2428         int rc = 0;
2429         LOCK_REQ *pSMB = NULL;
2430 /*      LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
2431         int bytes_returned;
2432         int flags = 0;
2433         __u16 count;
2434
2435         cifs_dbg(FYI, "CIFSSMBLock timeout %d numLock %d\n",
2436                  (int)waitFlag, numLock);
2437         rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
2438
2439         if (rc)
2440                 return rc;
2441
2442         if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
2443                 /* no response expected */
2444                 flags = CIFS_ASYNC_OP | CIFS_OBREAK_OP;
2445                 pSMB->Timeout = 0;
2446         } else if (waitFlag) {
2447                 flags = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2448                 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
2449         } else {
2450                 pSMB->Timeout = 0;
2451         }
2452
2453         pSMB->NumberOfLocks = cpu_to_le16(numLock);
2454         pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
2455         pSMB->LockType = lockType;
2456         pSMB->OplockLevel = oplock_level;
2457         pSMB->AndXCommand = 0xFF;       /* none */
2458         pSMB->Fid = smb_file_id; /* netfid stays le */
2459
2460         if ((numLock != 0) || (numUnlock != 0)) {
2461                 pSMB->Locks[0].Pid = cpu_to_le16(netpid);
2462                 /* BB where to store pid high? */
2463                 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
2464                 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
2465                 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
2466                 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
2467                 count = sizeof(LOCKING_ANDX_RANGE);
2468         } else {
2469                 /* oplock break */
2470                 count = 0;
2471         }
2472         inc_rfc1001_len(pSMB, count);
2473         pSMB->ByteCount = cpu_to_le16(count);
2474
2475         if (waitFlag)
2476                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2477                         (struct smb_hdr *) pSMB, &bytes_returned);
2478         else
2479                 rc = SendReceiveNoRsp(xid, tcon->ses, (char *)pSMB, flags);
2480         cifs_small_buf_release(pSMB);
2481         cifs_stats_inc(&tcon->stats.cifs_stats.num_locks);
2482         if (rc)
2483                 cifs_dbg(FYI, "Send error in Lock = %d\n", rc);
2484
2485         /* Note: On -EAGAIN error only caller can retry on handle based calls
2486         since file handle passed in no longer valid */
2487         return rc;
2488 }
2489
2490 int
2491 CIFSSMBPosixLock(const unsigned int xid, struct cifs_tcon *tcon,
2492                 const __u16 smb_file_id, const __u32 netpid,
2493                 const loff_t start_offset, const __u64 len,
2494                 struct file_lock *pLockData, const __u16 lock_type,
2495                 const bool waitFlag)
2496 {
2497         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
2498         struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2499         struct cifs_posix_lock *parm_data;
2500         int rc = 0;
2501         int timeout = 0;
2502         int bytes_returned = 0;
2503         int resp_buf_type = 0;
2504         __u16 params, param_offset, offset, byte_count, count;
2505         struct kvec iov[1];
2506         struct kvec rsp_iov;
2507
2508         cifs_dbg(FYI, "Posix Lock\n");
2509
2510         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
2511
2512         if (rc)
2513                 return rc;
2514
2515         pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
2516
2517         params = 6;
2518         pSMB->MaxSetupCount = 0;
2519         pSMB->Reserved = 0;
2520         pSMB->Flags = 0;
2521         pSMB->Reserved2 = 0;
2522         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2523         offset = param_offset + params;
2524
2525         count = sizeof(struct cifs_posix_lock);
2526         pSMB->MaxParameterCount = cpu_to_le16(2);
2527         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2528         pSMB->SetupCount = 1;
2529         pSMB->Reserved3 = 0;
2530         if (pLockData)
2531                 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
2532         else
2533                 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2534         byte_count = 3 /* pad */  + params + count;
2535         pSMB->DataCount = cpu_to_le16(count);
2536         pSMB->ParameterCount = cpu_to_le16(params);
2537         pSMB->TotalDataCount = pSMB->DataCount;
2538         pSMB->TotalParameterCount = pSMB->ParameterCount;
2539         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2540         parm_data = (struct cifs_posix_lock *)
2541                         (((char *) &pSMB->hdr.Protocol) + offset);
2542
2543         parm_data->lock_type = cpu_to_le16(lock_type);
2544         if (waitFlag) {
2545                 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
2546                 parm_data->lock_flags = cpu_to_le16(1);
2547                 pSMB->Timeout = cpu_to_le32(-1);
2548         } else
2549                 pSMB->Timeout = 0;
2550
2551         parm_data->pid = cpu_to_le32(netpid);
2552         parm_data->start = cpu_to_le64(start_offset);
2553         parm_data->length = cpu_to_le64(len);  /* normalize negative numbers */
2554
2555         pSMB->DataOffset = cpu_to_le16(offset);
2556         pSMB->Fid = smb_file_id;
2557         pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
2558         pSMB->Reserved4 = 0;
2559         inc_rfc1001_len(pSMB, byte_count);
2560         pSMB->ByteCount = cpu_to_le16(byte_count);
2561         if (waitFlag) {
2562                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
2563                         (struct smb_hdr *) pSMBr, &bytes_returned);
2564         } else {
2565                 iov[0].iov_base = (char *)pSMB;
2566                 iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
2567                 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
2568                                 &resp_buf_type, timeout, &rsp_iov);
2569                 pSMBr = (struct smb_com_transaction2_sfi_rsp *)rsp_iov.iov_base;
2570         }
2571         cifs_small_buf_release(pSMB);
2572
2573         if (rc) {
2574                 cifs_dbg(FYI, "Send error in Posix Lock = %d\n", rc);
2575         } else if (pLockData) {
2576                 /* lock structure can be returned on get */
2577                 __u16 data_offset;
2578                 __u16 data_count;
2579                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2580
2581                 if (rc || get_bcc(&pSMBr->hdr) < sizeof(*parm_data)) {
2582                         rc = -EIO;      /* bad smb */
2583                         goto plk_err_exit;
2584                 }
2585                 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2586                 data_count  = le16_to_cpu(pSMBr->t2.DataCount);
2587                 if (data_count < sizeof(struct cifs_posix_lock)) {
2588                         rc = -EIO;
2589                         goto plk_err_exit;
2590                 }
2591                 parm_data = (struct cifs_posix_lock *)
2592                         ((char *)&pSMBr->hdr.Protocol + data_offset);
2593                 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
2594                         pLockData->fl_type = F_UNLCK;
2595                 else {
2596                         if (parm_data->lock_type ==
2597                                         cpu_to_le16(CIFS_RDLCK))
2598                                 pLockData->fl_type = F_RDLCK;
2599                         else if (parm_data->lock_type ==
2600                                         cpu_to_le16(CIFS_WRLCK))
2601                                 pLockData->fl_type = F_WRLCK;
2602
2603                         pLockData->fl_start = le64_to_cpu(parm_data->start);
2604                         pLockData->fl_end = pLockData->fl_start +
2605                                         le64_to_cpu(parm_data->length) - 1;
2606                         pLockData->fl_pid = -le32_to_cpu(parm_data->pid);
2607                 }
2608         }
2609
2610 plk_err_exit:
2611         free_rsp_buf(resp_buf_type, rsp_iov.iov_base);
2612
2613         /* Note: On -EAGAIN error only caller can retry on handle based calls
2614            since file handle passed in no longer valid */
2615
2616         return rc;
2617 }
2618
2619
2620 int
2621 CIFSSMBClose(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2622 {
2623         int rc = 0;
2624         CLOSE_REQ *pSMB = NULL;
2625         cifs_dbg(FYI, "In CIFSSMBClose\n");
2626
2627 /* do not retry on dead session on close */
2628         rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
2629         if (rc == -EAGAIN)
2630                 return 0;
2631         if (rc)
2632                 return rc;
2633
2634         pSMB->FileID = (__u16) smb_file_id;
2635         pSMB->LastWriteTime = 0xFFFFFFFF;
2636         pSMB->ByteCount = 0;
2637         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2638         cifs_small_buf_release(pSMB);
2639         cifs_stats_inc(&tcon->stats.cifs_stats.num_closes);
2640         if (rc) {
2641                 if (rc != -EINTR) {
2642                         /* EINTR is expected when user ctl-c to kill app */
2643                         cifs_dbg(VFS, "Send error in Close = %d\n", rc);
2644                 }
2645         }
2646
2647         /* Since session is dead, file will be closed on server already */
2648         if (rc == -EAGAIN)
2649                 rc = 0;
2650
2651         return rc;
2652 }
2653
2654 int
2655 CIFSSMBFlush(const unsigned int xid, struct cifs_tcon *tcon, int smb_file_id)
2656 {
2657         int rc = 0;
2658         FLUSH_REQ *pSMB = NULL;
2659         cifs_dbg(FYI, "In CIFSSMBFlush\n");
2660
2661         rc = small_smb_init(SMB_COM_FLUSH, 1, tcon, (void **) &pSMB);
2662         if (rc)
2663                 return rc;
2664
2665         pSMB->FileID = (__u16) smb_file_id;
2666         pSMB->ByteCount = 0;
2667         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
2668         cifs_small_buf_release(pSMB);
2669         cifs_stats_inc(&tcon->stats.cifs_stats.num_flushes);
2670         if (rc)
2671                 cifs_dbg(VFS, "Send error in Flush = %d\n", rc);
2672
2673         return rc;
2674 }
2675
2676 int
2677 CIFSSMBRename(const unsigned int xid, struct cifs_tcon *tcon,
2678               const char *from_name, const char *to_name,
2679               struct cifs_sb_info *cifs_sb)
2680 {
2681         int rc = 0;
2682         RENAME_REQ *pSMB = NULL;
2683         RENAME_RSP *pSMBr = NULL;
2684         int bytes_returned;
2685         int name_len, name_len2;
2686         __u16 count;
2687         int remap = cifs_remap(cifs_sb);
2688
2689         cifs_dbg(FYI, "In CIFSSMBRename\n");
2690 renameRetry:
2691         rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
2692                       (void **) &pSMBr);
2693         if (rc)
2694                 return rc;
2695
2696         pSMB->BufferFormat = 0x04;
2697         pSMB->SearchAttributes =
2698             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2699                         ATTR_DIRECTORY);
2700
2701         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2702                 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2703                                               from_name, PATH_MAX,
2704                                               cifs_sb->local_nls, remap);
2705                 name_len++;     /* trailing null */
2706                 name_len *= 2;
2707                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
2708         /* protocol requires ASCII signature byte on Unicode string */
2709                 pSMB->OldFileName[name_len + 1] = 0x00;
2710                 name_len2 =
2711                     cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2712                                        to_name, PATH_MAX, cifs_sb->local_nls,
2713                                        remap);
2714                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
2715                 name_len2 *= 2; /* convert to bytes */
2716         } else {        /* BB improve the check for buffer overruns BB */
2717                 name_len = strnlen(from_name, PATH_MAX);
2718                 name_len++;     /* trailing null */
2719                 strncpy(pSMB->OldFileName, from_name, name_len);
2720                 name_len2 = strnlen(to_name, PATH_MAX);
2721                 name_len2++;    /* trailing null */
2722                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
2723                 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
2724                 name_len2++;    /* trailing null */
2725                 name_len2++;    /* signature byte */
2726         }
2727
2728         count = 1 /* 1st signature byte */  + name_len + name_len2;
2729         inc_rfc1001_len(pSMB, count);
2730         pSMB->ByteCount = cpu_to_le16(count);
2731
2732         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2733                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2734         cifs_stats_inc(&tcon->stats.cifs_stats.num_renames);
2735         if (rc)
2736                 cifs_dbg(FYI, "Send error in rename = %d\n", rc);
2737
2738         cifs_buf_release(pSMB);
2739
2740         if (rc == -EAGAIN)
2741                 goto renameRetry;
2742
2743         return rc;
2744 }
2745
2746 int CIFSSMBRenameOpenFile(const unsigned int xid, struct cifs_tcon *pTcon,
2747                 int netfid, const char *target_name,
2748                 const struct nls_table *nls_codepage, int remap)
2749 {
2750         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
2751         struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
2752         struct set_file_rename *rename_info;
2753         char *data_offset;
2754         char dummy_string[30];
2755         int rc = 0;
2756         int bytes_returned = 0;
2757         int len_of_str;
2758         __u16 params, param_offset, offset, count, byte_count;
2759
2760         cifs_dbg(FYI, "Rename to File by handle\n");
2761         rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2762                         (void **) &pSMBr);
2763         if (rc)
2764                 return rc;
2765
2766         params = 6;
2767         pSMB->MaxSetupCount = 0;
2768         pSMB->Reserved = 0;
2769         pSMB->Flags = 0;
2770         pSMB->Timeout = 0;
2771         pSMB->Reserved2 = 0;
2772         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2773         offset = param_offset + params;
2774
2775         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2776         rename_info = (struct set_file_rename *) data_offset;
2777         pSMB->MaxParameterCount = cpu_to_le16(2);
2778         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2779         pSMB->SetupCount = 1;
2780         pSMB->Reserved3 = 0;
2781         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2782         byte_count = 3 /* pad */  + params;
2783         pSMB->ParameterCount = cpu_to_le16(params);
2784         pSMB->TotalParameterCount = pSMB->ParameterCount;
2785         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2786         pSMB->DataOffset = cpu_to_le16(offset);
2787         /* construct random name ".cifs_tmp<inodenum><mid>" */
2788         rename_info->overwrite = cpu_to_le32(1);
2789         rename_info->root_fid  = 0;
2790         /* unicode only call */
2791         if (target_name == NULL) {
2792                 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2793                 len_of_str =
2794                         cifsConvertToUTF16((__le16 *)rename_info->target_name,
2795                                         dummy_string, 24, nls_codepage, remap);
2796         } else {
2797                 len_of_str =
2798                         cifsConvertToUTF16((__le16 *)rename_info->target_name,
2799                                         target_name, PATH_MAX, nls_codepage,
2800                                         remap);
2801         }
2802         rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2803         count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str);
2804         byte_count += count;
2805         pSMB->DataCount = cpu_to_le16(count);
2806         pSMB->TotalDataCount = pSMB->DataCount;
2807         pSMB->Fid = netfid;
2808         pSMB->InformationLevel =
2809                 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2810         pSMB->Reserved4 = 0;
2811         inc_rfc1001_len(pSMB, byte_count);
2812         pSMB->ByteCount = cpu_to_le16(byte_count);
2813         rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2814                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2815         cifs_stats_inc(&pTcon->stats.cifs_stats.num_t2renames);
2816         if (rc)
2817                 cifs_dbg(FYI, "Send error in Rename (by file handle) = %d\n",
2818                          rc);
2819
2820         cifs_buf_release(pSMB);
2821
2822         /* Note: On -EAGAIN error only caller can retry on handle based calls
2823                 since file handle passed in no longer valid */
2824
2825         return rc;
2826 }
2827
2828 int
2829 CIFSSMBCopy(const unsigned int xid, struct cifs_tcon *tcon,
2830             const char *fromName, const __u16 target_tid, const char *toName,
2831             const int flags, const struct nls_table *nls_codepage, int remap)
2832 {
2833         int rc = 0;
2834         COPY_REQ *pSMB = NULL;
2835         COPY_RSP *pSMBr = NULL;
2836         int bytes_returned;
2837         int name_len, name_len2;
2838         __u16 count;
2839
2840         cifs_dbg(FYI, "In CIFSSMBCopy\n");
2841 copyRetry:
2842         rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2843                         (void **) &pSMBr);
2844         if (rc)
2845                 return rc;
2846
2847         pSMB->BufferFormat = 0x04;
2848         pSMB->Tid2 = target_tid;
2849
2850         pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2851
2852         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2853                 name_len = cifsConvertToUTF16((__le16 *) pSMB->OldFileName,
2854                                               fromName, PATH_MAX, nls_codepage,
2855                                               remap);
2856                 name_len++;     /* trailing null */
2857                 name_len *= 2;
2858                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
2859                 /* protocol requires ASCII signature byte on Unicode string */
2860                 pSMB->OldFileName[name_len + 1] = 0x00;
2861                 name_len2 =
2862                     cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
2863                                        toName, PATH_MAX, nls_codepage, remap);
2864                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
2865                 name_len2 *= 2; /* convert to bytes */
2866         } else {        /* BB improve the check for buffer overruns BB */
2867                 name_len = strnlen(fromName, PATH_MAX);
2868                 name_len++;     /* trailing null */
2869                 strncpy(pSMB->OldFileName, fromName, name_len);
2870                 name_len2 = strnlen(toName, PATH_MAX);
2871                 name_len2++;    /* trailing null */
2872                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
2873                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2874                 name_len2++;    /* trailing null */
2875                 name_len2++;    /* signature byte */
2876         }
2877
2878         count = 1 /* 1st signature byte */  + name_len + name_len2;
2879         inc_rfc1001_len(pSMB, count);
2880         pSMB->ByteCount = cpu_to_le16(count);
2881
2882         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2883                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2884         if (rc) {
2885                 cifs_dbg(FYI, "Send error in copy = %d with %d files copied\n",
2886                          rc, le16_to_cpu(pSMBr->CopyCount));
2887         }
2888         cifs_buf_release(pSMB);
2889
2890         if (rc == -EAGAIN)
2891                 goto copyRetry;
2892
2893         return rc;
2894 }
2895
2896 int
2897 CIFSUnixCreateSymLink(const unsigned int xid, struct cifs_tcon *tcon,
2898                       const char *fromName, const char *toName,
2899                       const struct nls_table *nls_codepage, int remap)
2900 {
2901         TRANSACTION2_SPI_REQ *pSMB = NULL;
2902         TRANSACTION2_SPI_RSP *pSMBr = NULL;
2903         char *data_offset;
2904         int name_len;
2905         int name_len_target;
2906         int rc = 0;
2907         int bytes_returned = 0;
2908         __u16 params, param_offset, offset, byte_count;
2909
2910         cifs_dbg(FYI, "In Symlink Unix style\n");
2911 createSymLinkRetry:
2912         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2913                       (void **) &pSMBr);
2914         if (rc)
2915                 return rc;
2916
2917         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2918                 name_len =
2919                     cifsConvertToUTF16((__le16 *) pSMB->FileName, fromName,
2920                                 /* find define for this maxpathcomponent */
2921                                         PATH_MAX, nls_codepage, remap);
2922                 name_len++;     /* trailing null */
2923                 name_len *= 2;
2924
2925         } else {        /* BB improve the check for buffer overruns BB */
2926                 name_len = strnlen(fromName, PATH_MAX);
2927                 name_len++;     /* trailing null */
2928                 strncpy(pSMB->FileName, fromName, name_len);
2929         }
2930         params = 6 + name_len;
2931         pSMB->MaxSetupCount = 0;
2932         pSMB->Reserved = 0;
2933         pSMB->Flags = 0;
2934         pSMB->Timeout = 0;
2935         pSMB->Reserved2 = 0;
2936         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2937                                 InformationLevel) - 4;
2938         offset = param_offset + params;
2939
2940         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2941         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2942                 name_len_target =
2943                     cifsConvertToUTF16((__le16 *) data_offset, toName,
2944                                 /* find define for this maxpathcomponent */
2945                                         PATH_MAX, nls_codepage, remap);
2946                 name_len_target++;      /* trailing null */
2947                 name_len_target *= 2;
2948         } else {        /* BB improve the check for buffer overruns BB */
2949                 name_len_target = strnlen(toName, PATH_MAX);
2950                 name_len_target++;      /* trailing null */
2951                 strncpy(data_offset, toName, name_len_target);
2952         }
2953
2954         pSMB->MaxParameterCount = cpu_to_le16(2);
2955         /* BB find exact max on data count below from sess */
2956         pSMB->MaxDataCount = cpu_to_le16(1000);
2957         pSMB->SetupCount = 1;
2958         pSMB->Reserved3 = 0;
2959         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2960         byte_count = 3 /* pad */  + params + name_len_target;
2961         pSMB->DataCount = cpu_to_le16(name_len_target);
2962         pSMB->ParameterCount = cpu_to_le16(params);
2963         pSMB->TotalDataCount = pSMB->DataCount;
2964         pSMB->TotalParameterCount = pSMB->ParameterCount;
2965         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2966         pSMB->DataOffset = cpu_to_le16(offset);
2967         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2968         pSMB->Reserved4 = 0;
2969         inc_rfc1001_len(pSMB, byte_count);
2970         pSMB->ByteCount = cpu_to_le16(byte_count);
2971         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2972                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2973         cifs_stats_inc(&tcon->stats.cifs_stats.num_symlinks);
2974         if (rc)
2975                 cifs_dbg(FYI, "Send error in SetPathInfo create symlink = %d\n",
2976                          rc);
2977
2978         cifs_buf_release(pSMB);
2979
2980         if (rc == -EAGAIN)
2981                 goto createSymLinkRetry;
2982
2983         return rc;
2984 }
2985
2986 int
2987 CIFSUnixCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
2988                        const char *fromName, const char *toName,
2989                        const struct nls_table *nls_codepage, int remap)
2990 {
2991         TRANSACTION2_SPI_REQ *pSMB = NULL;
2992         TRANSACTION2_SPI_RSP *pSMBr = NULL;
2993         char *data_offset;
2994         int name_len;
2995         int name_len_target;
2996         int rc = 0;
2997         int bytes_returned = 0;
2998         __u16 params, param_offset, offset, byte_count;
2999
3000         cifs_dbg(FYI, "In Create Hard link Unix style\n");
3001 createHardLinkRetry:
3002         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3003                       (void **) &pSMBr);
3004         if (rc)
3005                 return rc;
3006
3007         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3008                 name_len = cifsConvertToUTF16((__le16 *) pSMB->FileName, toName,
3009                                               PATH_MAX, nls_codepage, remap);
3010                 name_len++;     /* trailing null */
3011                 name_len *= 2;
3012
3013         } else {        /* BB improve the check for buffer overruns BB */
3014                 name_len = strnlen(toName, PATH_MAX);
3015                 name_len++;     /* trailing null */
3016                 strncpy(pSMB->FileName, toName, name_len);
3017         }
3018         params = 6 + name_len;
3019         pSMB->MaxSetupCount = 0;
3020         pSMB->Reserved = 0;
3021         pSMB->Flags = 0;
3022         pSMB->Timeout = 0;
3023         pSMB->Reserved2 = 0;
3024         param_offset = offsetof(struct smb_com_transaction2_spi_req,
3025                                 InformationLevel) - 4;
3026         offset = param_offset + params;
3027
3028         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
3029         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3030                 name_len_target =
3031                     cifsConvertToUTF16((__le16 *) data_offset, fromName,
3032                                        PATH_MAX, nls_codepage, remap);
3033                 name_len_target++;      /* trailing null */
3034                 name_len_target *= 2;
3035         } else {        /* BB improve the check for buffer overruns BB */
3036                 name_len_target = strnlen(fromName, PATH_MAX);
3037                 name_len_target++;      /* trailing null */
3038                 strncpy(data_offset, fromName, name_len_target);
3039         }
3040
3041         pSMB->MaxParameterCount = cpu_to_le16(2);
3042         /* BB find exact max on data count below from sess*/
3043         pSMB->MaxDataCount = cpu_to_le16(1000);
3044         pSMB->SetupCount = 1;
3045         pSMB->Reserved3 = 0;
3046         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3047         byte_count = 3 /* pad */  + params + name_len_target;
3048         pSMB->ParameterCount = cpu_to_le16(params);
3049         pSMB->TotalParameterCount = pSMB->ParameterCount;
3050         pSMB->DataCount = cpu_to_le16(name_len_target);
3051         pSMB->TotalDataCount = pSMB->DataCount;
3052         pSMB->ParameterOffset = cpu_to_le16(param_offset);
3053         pSMB->DataOffset = cpu_to_le16(offset);
3054         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
3055         pSMB->Reserved4 = 0;
3056         inc_rfc1001_len(pSMB, byte_count);
3057         pSMB->ByteCount = cpu_to_le16(byte_count);
3058         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3059                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3060         cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
3061         if (rc)
3062                 cifs_dbg(FYI, "Send error in SetPathInfo (hard link) = %d\n",
3063                          rc);
3064
3065         cifs_buf_release(pSMB);
3066         if (rc == -EAGAIN)
3067                 goto createHardLinkRetry;
3068
3069         return rc;
3070 }
3071
3072 int
3073 CIFSCreateHardLink(const unsigned int xid, struct cifs_tcon *tcon,
3074                    const char *from_name, const char *to_name,
3075                    struct cifs_sb_info *cifs_sb)
3076 {
3077         int rc = 0;
3078         NT_RENAME_REQ *pSMB = NULL;
3079         RENAME_RSP *pSMBr = NULL;
3080         int bytes_returned;
3081         int name_len, name_len2;
3082         __u16 count;
3083         int remap = cifs_remap(cifs_sb);
3084
3085         cifs_dbg(FYI, "In CIFSCreateHardLink\n");
3086 winCreateHardLinkRetry:
3087
3088         rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
3089                       (void **) &pSMBr);
3090         if (rc)
3091                 return rc;
3092
3093         pSMB->SearchAttributes =
3094             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3095                         ATTR_DIRECTORY);
3096         pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
3097         pSMB->ClusterCount = 0;
3098
3099         pSMB->BufferFormat = 0x04;
3100
3101         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3102                 name_len =
3103                     cifsConvertToUTF16((__le16 *) pSMB->OldFileName, from_name,
3104                                        PATH_MAX, cifs_sb->local_nls, remap);
3105                 name_len++;     /* trailing null */
3106                 name_len *= 2;
3107
3108                 /* protocol specifies ASCII buffer format (0x04) for unicode */
3109                 pSMB->OldFileName[name_len] = 0x04;
3110                 pSMB->OldFileName[name_len + 1] = 0x00; /* pad */
3111                 name_len2 =
3112                     cifsConvertToUTF16((__le16 *)&pSMB->OldFileName[name_len+2],
3113                                        to_name, PATH_MAX, cifs_sb->local_nls,
3114                                        remap);
3115                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
3116                 name_len2 *= 2; /* convert to bytes */
3117         } else {        /* BB improve the check for buffer overruns BB */
3118                 name_len = strnlen(from_name, PATH_MAX);
3119                 name_len++;     /* trailing null */
3120                 strncpy(pSMB->OldFileName, from_name, name_len);
3121                 name_len2 = strnlen(to_name, PATH_MAX);
3122                 name_len2++;    /* trailing null */
3123                 pSMB->OldFileName[name_len] = 0x04;     /* 2nd buffer format */
3124                 strncpy(&pSMB->OldFileName[name_len + 1], to_name, name_len2);
3125                 name_len2++;    /* trailing null */
3126                 name_len2++;    /* signature byte */
3127         }
3128
3129         count = 1 /* string type byte */  + name_len + name_len2;
3130         inc_rfc1001_len(pSMB, count);
3131         pSMB->ByteCount = cpu_to_le16(count);
3132
3133         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3134                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3135         cifs_stats_inc(&tcon->stats.cifs_stats.num_hardlinks);
3136         if (rc)
3137                 cifs_dbg(FYI, "Send error in hard link (NT rename) = %d\n", rc);
3138
3139         cifs_buf_release(pSMB);
3140         if (rc == -EAGAIN)
3141                 goto winCreateHardLinkRetry;
3142
3143         return rc;
3144 }
3145
3146 int
3147 CIFSSMBUnixQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
3148                         const unsigned char *searchName, char **symlinkinfo,
3149                         const struct nls_table *nls_codepage, int remap)
3150 {
3151 /* SMB_QUERY_FILE_UNIX_LINK */
3152         TRANSACTION2_QPI_REQ *pSMB = NULL;
3153         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3154         int rc = 0;
3155         int bytes_returned;
3156         int name_len;
3157         __u16 params, byte_count;
3158         char *data_start;
3159
3160         cifs_dbg(FYI, "In QPathSymLinkInfo (Unix) for path %s\n", searchName);
3161
3162 querySymLinkRetry:
3163         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3164                       (void **) &pSMBr);
3165         if (rc)
3166                 return rc;
3167
3168         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3169                 name_len =
3170                         cifsConvertToUTF16((__le16 *) pSMB->FileName,
3171                                            searchName, PATH_MAX, nls_codepage,
3172                                            remap);
3173                 name_len++;     /* trailing null */
3174                 name_len *= 2;
3175         } else {        /* BB improve the check for buffer overruns BB */
3176                 name_len = strnlen(searchName, PATH_MAX);
3177                 name_len++;     /* trailing null */
3178                 strncpy(pSMB->FileName, searchName, name_len);
3179         }
3180
3181         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
3182         pSMB->TotalDataCount = 0;
3183         pSMB->MaxParameterCount = cpu_to_le16(2);
3184         pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
3185         pSMB->MaxSetupCount = 0;
3186         pSMB->Reserved = 0;
3187         pSMB->Flags = 0;
3188         pSMB->Timeout = 0;
3189         pSMB->Reserved2 = 0;
3190         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3191         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3192         pSMB->DataCount = 0;
3193         pSMB->DataOffset = 0;
3194         pSMB->SetupCount = 1;
3195         pSMB->Reserved3 = 0;
3196         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3197         byte_count = params + 1 /* pad */ ;
3198         pSMB->TotalParameterCount = cpu_to_le16(params);
3199         pSMB->ParameterCount = pSMB->TotalParameterCount;
3200         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
3201         pSMB->Reserved4 = 0;
3202         inc_rfc1001_len(pSMB, byte_count);
3203         pSMB->ByteCount = cpu_to_le16(byte_count);
3204
3205         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3206                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3207         if (rc) {
3208                 cifs_dbg(FYI, "Send error in QuerySymLinkInfo = %d\n", rc);
3209         } else {
3210                 /* decode response */
3211
3212                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3213                 /* BB also check enough total bytes returned */
3214                 if (rc || get_bcc(&pSMBr->hdr) < 2)
3215                         rc = -EIO;
3216                 else {
3217                         bool is_unicode;
3218                         u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3219
3220                         data_start = ((char *) &pSMBr->hdr.Protocol) +
3221                                            le16_to_cpu(pSMBr->t2.DataOffset);
3222
3223                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3224                                 is_unicode = true;
3225                         else
3226                                 is_unicode = false;
3227
3228                         /* BB FIXME investigate remapping reserved chars here */
3229                         *symlinkinfo = cifs_strndup_from_utf16(data_start,
3230                                         count, is_unicode, nls_codepage);
3231                         if (!*symlinkinfo)
3232                                 rc = -ENOMEM;
3233                 }
3234         }
3235         cifs_buf_release(pSMB);
3236         if (rc == -EAGAIN)
3237                 goto querySymLinkRetry;
3238         return rc;
3239 }
3240
3241 /*
3242  *      Recent Windows versions now create symlinks more frequently
3243  *      and they use the "reparse point" mechanism below.  We can of course
3244  *      do symlinks nicely to Samba and other servers which support the
3245  *      CIFS Unix Extensions and we can also do SFU symlinks and "client only"
3246  *      "MF" symlinks optionally, but for recent Windows we really need to
3247  *      reenable the code below and fix the cifs_symlink callers to handle this.
3248  *      In the interim this code has been moved to its own config option so
3249  *      it is not compiled in by default until callers fixed up and more tested.
3250  */
3251 int
3252 CIFSSMBQuerySymLink(const unsigned int xid, struct cifs_tcon *tcon,
3253                     __u16 fid, char **symlinkinfo,
3254                     const struct nls_table *nls_codepage)
3255 {
3256         int rc = 0;
3257         int bytes_returned;
3258         struct smb_com_transaction_ioctl_req *pSMB;
3259         struct smb_com_transaction_ioctl_rsp *pSMBr;
3260         bool is_unicode;
3261         unsigned int sub_len;
3262         char *sub_start;
3263         struct reparse_symlink_data *reparse_buf;
3264         struct reparse_posix_data *posix_buf;
3265         __u32 data_offset, data_count;
3266         char *end_of_smb;
3267
3268         cifs_dbg(FYI, "In Windows reparse style QueryLink for fid %u\n", fid);
3269         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3270                       (void **) &pSMBr);
3271         if (rc)
3272                 return rc;
3273
3274         pSMB->TotalParameterCount = 0 ;
3275         pSMB->TotalDataCount = 0;
3276         pSMB->MaxParameterCount = cpu_to_le32(2);
3277         /* BB find exact data count max from sess structure BB */
3278         pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3279         pSMB->MaxSetupCount = 4;
3280         pSMB->Reserved = 0;
3281         pSMB->ParameterOffset = 0;
3282         pSMB->DataCount = 0;
3283         pSMB->DataOffset = 0;
3284         pSMB->SetupCount = 4;
3285         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3286         pSMB->ParameterCount = pSMB->TotalParameterCount;
3287         pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
3288         pSMB->IsFsctl = 1; /* FSCTL */
3289         pSMB->IsRootFlag = 0;
3290         pSMB->Fid = fid; /* file handle always le */
3291         pSMB->ByteCount = 0;
3292
3293         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3294                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3295         if (rc) {
3296                 cifs_dbg(FYI, "Send error in QueryReparseLinkInfo = %d\n", rc);
3297                 goto qreparse_out;
3298         }
3299
3300         data_offset = le32_to_cpu(pSMBr->DataOffset);
3301         data_count = le32_to_cpu(pSMBr->DataCount);
3302         if (get_bcc(&pSMBr->hdr) < 2 || data_offset > 512) {
3303                 /* BB also check enough total bytes returned */
3304                 rc = -EIO;      /* bad smb */
3305                 goto qreparse_out;
3306         }
3307         if (!data_count || (data_count > 2048)) {
3308                 rc = -EIO;
3309                 cifs_dbg(FYI, "Invalid return data count on get reparse info ioctl\n");
3310                 goto qreparse_out;
3311         }
3312         end_of_smb = 2 + get_bcc(&pSMBr->hdr) + (char *)&pSMBr->ByteCount;
3313         reparse_buf = (struct reparse_symlink_data *)
3314                                 ((char *)&pSMBr->hdr.Protocol + data_offset);
3315         if ((char *)reparse_buf >= end_of_smb) {
3316                 rc = -EIO;
3317                 goto qreparse_out;
3318         }
3319         if (reparse_buf->ReparseTag == cpu_to_le32(IO_REPARSE_TAG_NFS)) {
3320                 cifs_dbg(FYI, "NFS style reparse tag\n");
3321                 posix_buf =  (struct reparse_posix_data *)reparse_buf;
3322
3323                 if (posix_buf->InodeType != cpu_to_le64(NFS_SPECFILE_LNK)) {
3324                         cifs_dbg(FYI, "unsupported file type 0x%llx\n",
3325                                  le64_to_cpu(posix_buf->InodeType));
3326                         rc = -EOPNOTSUPP;
3327                         goto qreparse_out;
3328                 }
3329                 is_unicode = true;
3330                 sub_len = le16_to_cpu(reparse_buf->ReparseDataLength);
3331                 if (posix_buf->PathBuffer + sub_len > end_of_smb) {
3332                         cifs_dbg(FYI, "reparse buf beyond SMB\n");
3333                         rc = -EIO;
3334                         goto qreparse_out;
3335                 }
3336                 *symlinkinfo = cifs_strndup_from_utf16(posix_buf->PathBuffer,
3337                                 sub_len, is_unicode, nls_codepage);
3338                 goto qreparse_out;
3339         } else if (reparse_buf->ReparseTag !=
3340                         cpu_to_le32(IO_REPARSE_TAG_SYMLINK)) {
3341                 rc = -EOPNOTSUPP;
3342                 goto qreparse_out;
3343         }
3344
3345         /* Reparse tag is NTFS symlink */
3346         sub_start = le16_to_cpu(reparse_buf->SubstituteNameOffset) +
3347                                 reparse_buf->PathBuffer;
3348         sub_len = le16_to_cpu(reparse_buf->SubstituteNameLength);
3349         if (sub_start + sub_len > end_of_smb) {
3350                 cifs_dbg(FYI, "reparse buf beyond SMB\n");
3351                 rc = -EIO;
3352                 goto qreparse_out;
3353         }
3354         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3355                 is_unicode = true;
3356         else
3357                 is_unicode = false;
3358
3359         /* BB FIXME investigate remapping reserved chars here */
3360         *symlinkinfo = cifs_strndup_from_utf16(sub_start, sub_len, is_unicode,
3361                                                nls_codepage);
3362         if (!*symlinkinfo)
3363                 rc = -ENOMEM;
3364 qreparse_out:
3365         cifs_buf_release(pSMB);
3366
3367         /*
3368          * Note: On -EAGAIN error only caller can retry on handle based calls
3369          * since file handle passed in no longer valid.
3370          */
3371         return rc;
3372 }
3373
3374 int
3375 CIFSSMB_set_compression(const unsigned int xid, struct cifs_tcon *tcon,
3376                     __u16 fid)
3377 {
3378         int rc = 0;
3379         int bytes_returned;
3380         struct smb_com_transaction_compr_ioctl_req *pSMB;
3381         struct smb_com_transaction_ioctl_rsp *pSMBr;
3382
3383         cifs_dbg(FYI, "Set compression for %u\n", fid);
3384         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
3385                       (void **) &pSMBr);
3386         if (rc)
3387                 return rc;
3388
3389         pSMB->compression_state = cpu_to_le16(COMPRESSION_FORMAT_DEFAULT);
3390
3391         pSMB->TotalParameterCount = 0;
3392         pSMB->TotalDataCount = cpu_to_le32(2);
3393         pSMB->MaxParameterCount = 0;
3394         pSMB->MaxDataCount = 0;
3395         pSMB->MaxSetupCount = 4;
3396         pSMB->Reserved = 0;
3397         pSMB->ParameterOffset = 0;
3398         pSMB->DataCount = cpu_to_le32(2);
3399         pSMB->DataOffset =
3400                 cpu_to_le32(offsetof(struct smb_com_transaction_compr_ioctl_req,
3401                                 compression_state) - 4);  /* 84 */
3402         pSMB->SetupCount = 4;
3403         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
3404         pSMB->ParameterCount = 0;
3405         pSMB->FunctionCode = cpu_to_le32(FSCTL_SET_COMPRESSION);
3406         pSMB->IsFsctl = 1; /* FSCTL */
3407         pSMB->IsRootFlag = 0;
3408         pSMB->Fid = fid; /* file handle always le */
3409         /* 3 byte pad, followed by 2 byte compress state */
3410         pSMB->ByteCount = cpu_to_le16(5);
3411         inc_rfc1001_len(pSMB, 5);
3412
3413         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3414                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3415         if (rc)
3416                 cifs_dbg(FYI, "Send error in SetCompression = %d\n", rc);
3417
3418         cifs_buf_release(pSMB);
3419
3420         /*
3421          * Note: On -EAGAIN error only caller can retry on handle based calls
3422          * since file handle passed in no longer valid.
3423          */
3424         return rc;
3425 }
3426
3427
3428 #ifdef CONFIG_CIFS_POSIX
3429
3430 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
3431 static void cifs_convert_ace(struct posix_acl_xattr_entry *ace,
3432                              struct cifs_posix_ace *cifs_ace)
3433 {
3434         /* u8 cifs fields do not need le conversion */
3435         ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
3436         ace->e_tag  = cpu_to_le16(cifs_ace->cifs_e_tag);
3437         ace->e_id   = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
3438 /*
3439         cifs_dbg(FYI, "perm %d tag %d id %d\n",
3440                  ace->e_perm, ace->e_tag, ace->e_id);
3441 */
3442
3443         return;
3444 }
3445
3446 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
3447 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
3448                                const int acl_type, const int size_of_data_area)
3449 {
3450         int size =  0;
3451         int i;
3452         __u16 count;
3453         struct cifs_posix_ace *pACE;
3454         struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
3455         struct posix_acl_xattr_header *local_acl = (void *)trgt;
3456
3457         if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
3458                 return -EOPNOTSUPP;
3459
3460         if (acl_type == ACL_TYPE_ACCESS) {
3461                 count = le16_to_cpu(cifs_acl->access_entry_count);
3462                 pACE = &cifs_acl->ace_array[0];
3463                 size = sizeof(struct cifs_posix_acl);
3464                 size += sizeof(struct cifs_posix_ace) * count;
3465                 /* check if we would go beyond end of SMB */
3466                 if (size_of_data_area < size) {
3467                         cifs_dbg(FYI, "bad CIFS POSIX ACL size %d vs. %d\n",
3468                                  size_of_data_area, size);
3469                         return -EINVAL;
3470                 }
3471         } else if (acl_type == ACL_TYPE_DEFAULT) {
3472                 count = le16_to_cpu(cifs_acl->access_entry_count);
3473                 size = sizeof(struct cifs_posix_acl);
3474                 size += sizeof(struct cifs_posix_ace) * count;
3475 /* skip past access ACEs to get to default ACEs */
3476                 pACE = &cifs_acl->ace_array[count];
3477                 count = le16_to_cpu(cifs_acl->default_entry_count);
3478                 size += sizeof(struct cifs_posix_ace) * count;
3479                 /* check if we would go beyond end of SMB */
3480                 if (size_of_data_area < size)
3481                         return -EINVAL;
3482         } else {
3483                 /* illegal type */
3484                 return -EINVAL;
3485         }
3486
3487         size = posix_acl_xattr_size(count);
3488         if ((buflen == 0) || (local_acl == NULL)) {
3489                 /* used to query ACL EA size */
3490         } else if (size > buflen) {
3491                 return -ERANGE;
3492         } else /* buffer big enough */ {
3493                 struct posix_acl_xattr_entry *ace = (void *)(local_acl + 1);
3494
3495                 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
3496                 for (i = 0; i < count ; i++) {
3497                         cifs_convert_ace(&ace[i], pACE);
3498                         pACE++;
3499                 }
3500         }
3501         return size;
3502 }
3503
3504 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
3505                                      const struct posix_acl_xattr_entry *local_ace)
3506 {
3507         __u16 rc = 0; /* 0 = ACL converted ok */
3508
3509         cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
3510         cifs_ace->cifs_e_tag =  le16_to_cpu(local_ace->e_tag);
3511         /* BB is there a better way to handle the large uid? */
3512         if (local_ace->e_id == cpu_to_le32(-1)) {
3513         /* Probably no need to le convert -1 on any arch but can not hurt */
3514                 cifs_ace->cifs_uid = cpu_to_le64(-1);
3515         } else
3516                 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
3517 /*
3518         cifs_dbg(FYI, "perm %d tag %d id %d\n",
3519                  ace->e_perm, ace->e_tag, ace->e_id);
3520 */
3521         return rc;
3522 }
3523
3524 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
3525 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
3526                                const int buflen, const int acl_type)
3527 {
3528         __u16 rc = 0;
3529         struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
3530         struct posix_acl_xattr_header *local_acl = (void *)pACL;
3531         struct posix_acl_xattr_entry *ace = (void *)(local_acl + 1);
3532         int count;
3533         int i;
3534
3535         if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
3536                 return 0;
3537
3538         count = posix_acl_xattr_count((size_t)buflen);
3539         cifs_dbg(FYI, "setting acl with %d entries from buf of length %d and version of %d\n",
3540                  count, buflen, le32_to_cpu(local_acl->a_version));
3541         if (le32_to_cpu(local_acl->a_version) != 2) {
3542                 cifs_dbg(FYI, "unknown POSIX ACL version %d\n",
3543                          le32_to_cpu(local_acl->a_version));
3544                 return 0;
3545         }
3546         cifs_acl->version = cpu_to_le16(1);
3547         if (acl_type == ACL_TYPE_ACCESS) {
3548                 cifs_acl->access_entry_count = cpu_to_le16(count);
3549                 cifs_acl->default_entry_count = cpu_to_le16(0xFFFF);
3550         } else if (acl_type == ACL_TYPE_DEFAULT) {
3551                 cifs_acl->default_entry_count = cpu_to_le16(count);
3552                 cifs_acl->access_entry_count = cpu_to_le16(0xFFFF);
3553         } else {
3554                 cifs_dbg(FYI, "unknown ACL type %d\n", acl_type);
3555                 return 0;
3556         }
3557         for (i = 0; i < count; i++) {
3558                 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i], &ace[i]);
3559                 if (rc != 0) {
3560                         /* ACE not converted */
3561                         break;
3562                 }
3563         }
3564         if (rc == 0) {
3565                 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
3566                 rc += sizeof(struct cifs_posix_acl);
3567                 /* BB add check to make sure ACL does not overflow SMB */
3568         }
3569         return rc;
3570 }
3571
3572 int
3573 CIFSSMBGetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
3574                    const unsigned char *searchName,
3575                    char *acl_inf, const int buflen, const int acl_type,
3576                    const struct nls_table *nls_codepage, int remap)
3577 {
3578 /* SMB_QUERY_POSIX_ACL */
3579         TRANSACTION2_QPI_REQ *pSMB = NULL;
3580         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3581         int rc = 0;
3582         int bytes_returned;
3583         int name_len;
3584         __u16 params, byte_count;
3585
3586         cifs_dbg(FYI, "In GetPosixACL (Unix) for path %s\n", searchName);
3587
3588 queryAclRetry:
3589         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3590                 (void **) &pSMBr);
3591         if (rc)
3592                 return rc;
3593
3594         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3595                 name_len =
3596                         cifsConvertToUTF16((__le16 *) pSMB->FileName,
3597                                            searchName, PATH_MAX, nls_codepage,
3598                                            remap);
3599                 name_len++;     /* trailing null */
3600                 name_len *= 2;
3601                 pSMB->FileName[name_len] = 0;
3602                 pSMB->FileName[name_len+1] = 0;
3603         } else {        /* BB improve the check for buffer overruns BB */
3604                 name_len = strnlen(searchName, PATH_MAX);
3605                 name_len++;     /* trailing null */
3606                 strncpy(pSMB->FileName, searchName, name_len);
3607         }
3608
3609         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
3610         pSMB->TotalDataCount = 0;
3611         pSMB->MaxParameterCount = cpu_to_le16(2);
3612         /* BB find exact max data count below from sess structure BB */
3613         pSMB->MaxDataCount = cpu_to_le16(4000);
3614         pSMB->MaxSetupCount = 0;
3615         pSMB->Reserved = 0;
3616         pSMB->Flags = 0;
3617         pSMB->Timeout = 0;
3618         pSMB->Reserved2 = 0;
3619         pSMB->ParameterOffset = cpu_to_le16(
3620                 offsetof(struct smb_com_transaction2_qpi_req,
3621                          InformationLevel) - 4);
3622         pSMB->DataCount = 0;
3623         pSMB->DataOffset = 0;
3624         pSMB->SetupCount = 1;
3625         pSMB->Reserved3 = 0;
3626         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3627         byte_count = params + 1 /* pad */ ;
3628         pSMB->TotalParameterCount = cpu_to_le16(params);
3629         pSMB->ParameterCount = pSMB->TotalParameterCount;
3630         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
3631         pSMB->Reserved4 = 0;
3632         inc_rfc1001_len(pSMB, byte_count);
3633         pSMB->ByteCount = cpu_to_le16(byte_count);
3634
3635         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3636                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3637         cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3638         if (rc) {
3639                 cifs_dbg(FYI, "Send error in Query POSIX ACL = %d\n", rc);
3640         } else {
3641                 /* decode response */
3642
3643                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3644                 /* BB also check enough total bytes returned */
3645                 if (rc || get_bcc(&pSMBr->hdr) < 2)
3646                         rc = -EIO;      /* bad smb */
3647                 else {
3648                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3649                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3650                         rc = cifs_copy_posix_acl(acl_inf,
3651                                 (char *)&pSMBr->hdr.Protocol+data_offset,
3652                                 buflen, acl_type, count);
3653                 }
3654         }
3655         cifs_buf_release(pSMB);
3656         if (rc == -EAGAIN)
3657                 goto queryAclRetry;
3658         return rc;
3659 }
3660
3661 int
3662 CIFSSMBSetPosixACL(const unsigned int xid, struct cifs_tcon *tcon,
3663                    const unsigned char *fileName,
3664                    const char *local_acl, const int buflen,
3665                    const int acl_type,
3666                    const struct nls_table *nls_codepage, int remap)
3667 {
3668         struct smb_com_transaction2_spi_req *pSMB = NULL;
3669         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
3670         char *parm_data;
3671         int name_len;
3672         int rc = 0;
3673         int bytes_returned = 0;
3674         __u16 params, byte_count, data_count, param_offset, offset;
3675
3676         cifs_dbg(FYI, "In SetPosixACL (Unix) for path %s\n", fileName);
3677 setAclRetry:
3678         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3679                       (void **) &pSMBr);
3680         if (rc)
3681                 return rc;
3682         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3683                 name_len =
3684                         cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
3685                                            PATH_MAX, nls_codepage, remap);
3686                 name_len++;     /* trailing null */
3687                 name_len *= 2;
3688         } else {        /* BB improve the check for buffer overruns BB */
3689                 name_len = strnlen(fileName, PATH_MAX);
3690                 name_len++;     /* trailing null */
3691                 strncpy(pSMB->FileName, fileName, name_len);
3692         }
3693         params = 6 + name_len;
3694         pSMB->MaxParameterCount = cpu_to_le16(2);
3695         /* BB find max SMB size from sess */
3696         pSMB->MaxDataCount = cpu_to_le16(1000);
3697         pSMB->MaxSetupCount = 0;
3698         pSMB->Reserved = 0;
3699         pSMB->Flags = 0;
3700         pSMB->Timeout = 0;
3701         pSMB->Reserved2 = 0;
3702         param_offset = offsetof(struct smb_com_transaction2_spi_req,
3703                                 InformationLevel) - 4;
3704         offset = param_offset + params;
3705         parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
3706         pSMB->ParameterOffset = cpu_to_le16(param_offset);
3707
3708         /* convert to on the wire format for POSIX ACL */
3709         data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
3710
3711         if (data_count == 0) {
3712                 rc = -EOPNOTSUPP;
3713                 goto setACLerrorExit;
3714         }
3715         pSMB->DataOffset = cpu_to_le16(offset);
3716         pSMB->SetupCount = 1;
3717         pSMB->Reserved3 = 0;
3718         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
3719         pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
3720         byte_count = 3 /* pad */  + params + data_count;
3721         pSMB->DataCount = cpu_to_le16(data_count);
3722         pSMB->TotalDataCount = pSMB->DataCount;
3723         pSMB->ParameterCount = cpu_to_le16(params);
3724         pSMB->TotalParameterCount = pSMB->ParameterCount;
3725         pSMB->Reserved4 = 0;
3726         inc_rfc1001_len(pSMB, byte_count);
3727         pSMB->ByteCount = cpu_to_le16(byte_count);
3728         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3729                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3730         if (rc)
3731                 cifs_dbg(FYI, "Set POSIX ACL returned %d\n", rc);
3732
3733 setACLerrorExit:
3734         cifs_buf_release(pSMB);
3735         if (rc == -EAGAIN)
3736                 goto setAclRetry;
3737         return rc;
3738 }
3739
3740 /* BB fix tabs in this function FIXME BB */
3741 int
3742 CIFSGetExtAttr(const unsigned int xid, struct cifs_tcon *tcon,
3743                const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
3744 {
3745         int rc = 0;
3746         struct smb_t2_qfi_req *pSMB = NULL;
3747         struct smb_t2_qfi_rsp *pSMBr = NULL;
3748         int bytes_returned;
3749         __u16 params, byte_count;
3750
3751         cifs_dbg(FYI, "In GetExtAttr\n");
3752         if (tcon == NULL)
3753                 return -ENODEV;
3754
3755 GetExtAttrRetry:
3756         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3757                         (void **) &pSMBr);
3758         if (rc)
3759                 return rc;
3760
3761         params = 2 /* level */ + 2 /* fid */;
3762         pSMB->t2.TotalDataCount = 0;
3763         pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3764         /* BB find exact max data count below from sess structure BB */
3765         pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3766         pSMB->t2.MaxSetupCount = 0;
3767         pSMB->t2.Reserved = 0;
3768         pSMB->t2.Flags = 0;
3769         pSMB->t2.Timeout = 0;
3770         pSMB->t2.Reserved2 = 0;
3771         pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3772                                                Fid) - 4);
3773         pSMB->t2.DataCount = 0;
3774         pSMB->t2.DataOffset = 0;
3775         pSMB->t2.SetupCount = 1;
3776         pSMB->t2.Reserved3 = 0;
3777         pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3778         byte_count = params + 1 /* pad */ ;
3779         pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3780         pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3781         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3782         pSMB->Pad = 0;
3783         pSMB->Fid = netfid;
3784         inc_rfc1001_len(pSMB, byte_count);
3785         pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3786
3787         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3788                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3789         if (rc) {
3790                 cifs_dbg(FYI, "error %d in GetExtAttr\n", rc);
3791         } else {
3792                 /* decode response */
3793                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3794                 /* BB also check enough total bytes returned */
3795                 if (rc || get_bcc(&pSMBr->hdr) < 2)
3796                         /* If rc should we check for EOPNOSUPP and
3797                            disable the srvino flag? or in caller? */
3798                         rc = -EIO;      /* bad smb */
3799                 else {
3800                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3801                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3802                         struct file_chattr_info *pfinfo;
3803                         /* BB Do we need a cast or hash here ? */
3804                         if (count != 16) {
3805                                 cifs_dbg(FYI, "Illegal size ret in GetExtAttr\n");
3806                                 rc = -EIO;
3807                                 goto GetExtAttrOut;
3808                         }
3809                         pfinfo = (struct file_chattr_info *)
3810                                  (data_offset + (char *) &pSMBr->hdr.Protocol);
3811                         *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3812                         *pMask = le64_to_cpu(pfinfo->mask);
3813                 }
3814         }
3815 GetExtAttrOut:
3816         cifs_buf_release(pSMB);
3817         if (rc == -EAGAIN)
3818                 goto GetExtAttrRetry;
3819         return rc;
3820 }
3821
3822 #endif /* CONFIG_POSIX */
3823
3824 #ifdef CONFIG_CIFS_ACL
3825 /*
3826  * Initialize NT TRANSACT SMB into small smb request buffer.  This assumes that
3827  * all NT TRANSACTS that we init here have total parm and data under about 400
3828  * bytes (to fit in small cifs buffer size), which is the case so far, it
3829  * easily fits. NB: Setup words themselves and ByteCount MaxSetupCount (size of
3830  * returned setup area) and MaxParameterCount (returned parms size) must be set
3831  * by caller
3832  */
3833 static int
3834 smb_init_nttransact(const __u16 sub_command, const int setup_count,
3835                    const int parm_len, struct cifs_tcon *tcon,
3836                    void **ret_buf)
3837 {
3838         int rc;
3839         __u32 temp_offset;
3840         struct smb_com_ntransact_req *pSMB;
3841
3842         rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
3843                                 (void **)&pSMB);
3844         if (rc)
3845                 return rc;
3846         *ret_buf = (void *)pSMB;
3847         pSMB->Reserved = 0;
3848         pSMB->TotalParameterCount = cpu_to_le32(parm_len);
3849         pSMB->TotalDataCount  = 0;
3850         pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
3851         pSMB->ParameterCount = pSMB->TotalParameterCount;
3852         pSMB->DataCount  = pSMB->TotalDataCount;
3853         temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
3854                         (setup_count * 2) - 4 /* for rfc1001 length itself */;
3855         pSMB->ParameterOffset = cpu_to_le32(temp_offset);
3856         pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
3857         pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
3858         pSMB->SubCommand = cpu_to_le16(sub_command);
3859         return 0;
3860 }
3861
3862 static int
3863 validate_ntransact(char *buf, char **ppparm, char **ppdata,
3864                    __u32 *pparmlen, __u32 *pdatalen)
3865 {
3866         char *end_of_smb;
3867         __u32 data_count, data_offset, parm_count, parm_offset;
3868         struct smb_com_ntransact_rsp *pSMBr;
3869         u16 bcc;
3870
3871         *pdatalen = 0;
3872         *pparmlen = 0;
3873
3874         if (buf == NULL)
3875                 return -EINVAL;
3876
3877         pSMBr = (struct smb_com_ntransact_rsp *)buf;
3878
3879         bcc = get_bcc(&pSMBr->hdr);
3880         end_of_smb = 2 /* sizeof byte count */ + bcc +
3881                         (char *)&pSMBr->ByteCount;
3882
3883         data_offset = le32_to_cpu(pSMBr->DataOffset);
3884         data_count = le32_to_cpu(pSMBr->DataCount);
3885         parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
3886         parm_count = le32_to_cpu(pSMBr->ParameterCount);
3887
3888         *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
3889         *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
3890
3891         /* should we also check that parm and data areas do not overlap? */
3892         if (*ppparm > end_of_smb) {
3893                 cifs_dbg(FYI, "parms start after end of smb\n");
3894                 return -EINVAL;
3895         } else if (parm_count + *ppparm > end_of_smb) {
3896                 cifs_dbg(FYI, "parm end after end of smb\n");
3897                 return -EINVAL;
3898         } else if (*ppdata > end_of_smb) {
3899                 cifs_dbg(FYI, "data starts after end of smb\n");
3900                 return -EINVAL;
3901         } else if (data_count + *ppdata > end_of_smb) {
3902                 cifs_dbg(FYI, "data %p + count %d (%p) past smb end %p start %p\n",
3903                          *ppdata, data_count, (data_count + *ppdata),
3904                          end_of_smb, pSMBr);
3905                 return -EINVAL;
3906         } else if (parm_count + data_count > bcc) {
3907                 cifs_dbg(FYI, "parm count and data count larger than SMB\n");
3908                 return -EINVAL;
3909         }
3910         *pdatalen = data_count;
3911         *pparmlen = parm_count;
3912         return 0;
3913 }
3914
3915 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3916 int
3917 CIFSSMBGetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
3918                   struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3919 {
3920         int rc = 0;
3921         int buf_type = 0;
3922         QUERY_SEC_DESC_REQ *pSMB;
3923         struct kvec iov[1];
3924         struct kvec rsp_iov;
3925
3926         cifs_dbg(FYI, "GetCifsACL\n");
3927
3928         *pbuflen = 0;
3929         *acl_inf = NULL;
3930
3931         rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3932                         8 /* parm len */, tcon, (void **) &pSMB);
3933         if (rc)
3934                 return rc;
3935
3936         pSMB->MaxParameterCount = cpu_to_le32(4);
3937         /* BB TEST with big acls that might need to be e.g. larger than 16K */
3938         pSMB->MaxSetupCount = 0;
3939         pSMB->Fid = fid; /* file handle always le */
3940         pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3941                                      CIFS_ACL_DACL);
3942         pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3943         inc_rfc1001_len(pSMB, 11);
3944         iov[0].iov_base = (char *)pSMB;
3945         iov[0].iov_len = be32_to_cpu(pSMB->hdr.smb_buf_length) + 4;
3946
3947         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3948                           0, &rsp_iov);
3949         cifs_small_buf_release(pSMB);
3950         cifs_stats_inc(&tcon->stats.cifs_stats.num_acl_get);
3951         if (rc) {
3952                 cifs_dbg(FYI, "Send error in QuerySecDesc = %d\n", rc);
3953         } else {                /* decode response */
3954                 __le32 *parm;
3955                 __u32 parm_len;
3956                 __u32 acl_len;
3957                 struct smb_com_ntransact_rsp *pSMBr;
3958                 char *pdata;
3959
3960 /* validate_nttransact */
3961                 rc = validate_ntransact(rsp_iov.iov_base, (char **)&parm,
3962                                         &pdata, &parm_len, pbuflen);
3963                 if (rc)
3964                         goto qsec_out;
3965                 pSMBr = (struct smb_com_ntransact_rsp *)rsp_iov.iov_base;
3966
3967                 cifs_dbg(FYI, "smb %p parm %p data %p\n",
3968                          pSMBr, parm, *acl_inf);
3969
3970                 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3971                         rc = -EIO;      /* bad smb */
3972                         *pbuflen = 0;
3973                         goto qsec_out;
3974                 }
3975
3976 /* BB check that data area is minimum length and as big as acl_len */
3977
3978                 acl_len = le32_to_cpu(*parm);
3979                 if (acl_len != *pbuflen) {
3980                         cifs_dbg(VFS, "acl length %d does not match %d\n",
3981                                  acl_len, *pbuflen);
3982                         if (*pbuflen > acl_len)
3983                                 *pbuflen = acl_len;
3984                 }
3985
3986                 /* check if buffer is big enough for the acl
3987                    header followed by the smallest SID */
3988                 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3989                     (*pbuflen >= 64 * 1024)) {
3990                         cifs_dbg(VFS, "bad acl length %d\n", *pbuflen);
3991                         rc = -EINVAL;
3992                         *pbuflen = 0;
3993                 } else {
3994                         *acl_inf = kmemdup(pdata, *pbuflen, GFP_KERNEL);
3995                         if (*acl_inf == NULL) {
3996                                 *pbuflen = 0;
3997                                 rc = -ENOMEM;
3998                         }
3999                 }
4000         }
4001 qsec_out:
4002         free_rsp_buf(buf_type, rsp_iov.iov_base);
4003         return rc;
4004 }
4005
4006 int
4007 CIFSSMBSetCIFSACL(const unsigned int xid, struct cifs_tcon *tcon, __u16 fid,
4008                         struct cifs_ntsd *pntsd, __u32 acllen, int aclflag)
4009 {
4010         __u16 byte_count, param_count, data_count, param_offset, data_offset;
4011         int rc = 0;
4012         int bytes_returned = 0;
4013         SET_SEC_DESC_REQ *pSMB = NULL;
4014         void *pSMBr;
4015
4016 setCifsAclRetry:
4017         rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB, &pSMBr);
4018         if (rc)
4019                 return rc;
4020
4021         pSMB->MaxSetupCount = 0;
4022         pSMB->Reserved = 0;
4023
4024         param_count = 8;
4025         param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
4026         data_count = acllen;
4027         data_offset = param_offset + param_count;
4028         byte_count = 3 /* pad */  + param_count;
4029
4030         pSMB->DataCount = cpu_to_le32(data_count);
4031         pSMB->TotalDataCount = pSMB->DataCount;
4032         pSMB->MaxParameterCount = cpu_to_le32(4);
4033         pSMB->MaxDataCount = cpu_to_le32(16384);
4034         pSMB->ParameterCount = cpu_to_le32(param_count);
4035         pSMB->ParameterOffset = cpu_to_le32(param_offset);
4036         pSMB->TotalParameterCount = pSMB->ParameterCount;
4037         pSMB->DataOffset = cpu_to_le32(data_offset);
4038         pSMB->SetupCount = 0;
4039         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
4040         pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
4041
4042         pSMB->Fid = fid; /* file handle always le */
4043         pSMB->Reserved2 = 0;
4044         pSMB->AclFlags = cpu_to_le32(aclflag);
4045
4046         if (pntsd && acllen) {
4047                 memcpy((char *)pSMBr + offsetof(struct smb_hdr, Protocol) +
4048                                 data_offset, pntsd, acllen);
4049                 inc_rfc1001_len(pSMB, byte_count + data_count);
4050         } else
4051                 inc_rfc1001_len(pSMB, byte_count);
4052
4053         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4054                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4055
4056         cifs_dbg(FYI, "SetCIFSACL bytes_returned: %d, rc: %d\n",
4057                  bytes_returned, rc);
4058         if (rc)
4059                 cifs_dbg(FYI, "Set CIFS ACL returned %d\n", rc);
4060         cifs_buf_release(pSMB);
4061
4062         if (rc == -EAGAIN)
4063                 goto setCifsAclRetry;
4064
4065         return (rc);
4066 }
4067
4068 #endif /* CONFIG_CIFS_ACL */
4069
4070 /* Legacy Query Path Information call for lookup to old servers such
4071    as Win9x/WinME */
4072 int
4073 SMBQueryInformation(const unsigned int xid, struct cifs_tcon *tcon,
4074                     const char *search_name, FILE_ALL_INFO *data,
4075                     const struct nls_table *nls_codepage, int remap)
4076 {
4077         QUERY_INFORMATION_REQ *pSMB;
4078         QUERY_INFORMATION_RSP *pSMBr;
4079         int rc = 0;
4080         int bytes_returned;
4081         int name_len;
4082
4083         cifs_dbg(FYI, "In SMBQPath path %s\n", search_name);
4084 QInfRetry:
4085         rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
4086                       (void **) &pSMBr);
4087         if (rc)
4088                 return rc;
4089
4090         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4091                 name_len =
4092                         cifsConvertToUTF16((__le16 *) pSMB->FileName,
4093                                            search_name, PATH_MAX, nls_codepage,
4094                                            remap);
4095                 name_len++;     /* trailing null */
4096                 name_len *= 2;
4097         } else {
4098                 name_len = strnlen(search_name, PATH_MAX);
4099                 name_len++;     /* trailing null */
4100                 strncpy(pSMB->FileName, search_name, name_len);
4101         }
4102         pSMB->BufferFormat = 0x04;
4103         name_len++; /* account for buffer type byte */
4104         inc_rfc1001_len(pSMB, (__u16)name_len);
4105         pSMB->ByteCount = cpu_to_le16(name_len);
4106
4107         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4108                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4109         if (rc) {
4110                 cifs_dbg(FYI, "Send error in QueryInfo = %d\n", rc);
4111         } else if (data) {
4112                 struct timespec64 ts;
4113                 __u32 time = le32_to_cpu(pSMBr->last_write_time);
4114
4115                 /* decode response */
4116                 /* BB FIXME - add time zone adjustment BB */
4117                 memset(data, 0, sizeof(FILE_ALL_INFO));
4118                 ts.tv_nsec = 0;
4119                 ts.tv_sec = time;
4120                 /* decode time fields */
4121                 data->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
4122                 data->LastWriteTime = data->ChangeTime;
4123                 data->LastAccessTime = 0;
4124                 data->AllocationSize =
4125                         cpu_to_le64(le32_to_cpu(pSMBr->size));
4126                 data->EndOfFile = data->AllocationSize;
4127                 data->Attributes =
4128                         cpu_to_le32(le16_to_cpu(pSMBr->attr));
4129         } else
4130                 rc = -EIO; /* bad buffer passed in */
4131
4132         cifs_buf_release(pSMB);
4133
4134         if (rc == -EAGAIN)
4135                 goto QInfRetry;
4136
4137         return rc;
4138 }
4139
4140 int
4141 CIFSSMBQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
4142                  u16 netfid, FILE_ALL_INFO *pFindData)
4143 {
4144         struct smb_t2_qfi_req *pSMB = NULL;
4145         struct smb_t2_qfi_rsp *pSMBr = NULL;
4146         int rc = 0;
4147         int bytes_returned;
4148         __u16 params, byte_count;
4149
4150 QFileInfoRetry:
4151         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4152                       (void **) &pSMBr);
4153         if (rc)
4154                 return rc;
4155
4156         params = 2 /* level */ + 2 /* fid */;
4157         pSMB->t2.TotalDataCount = 0;
4158         pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4159         /* BB find exact max data count below from sess structure BB */
4160         pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4161         pSMB->t2.MaxSetupCount = 0;
4162         pSMB->t2.Reserved = 0;
4163         pSMB->t2.Flags = 0;
4164         pSMB->t2.Timeout = 0;
4165         pSMB->t2.Reserved2 = 0;
4166         pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4167                                                Fid) - 4);
4168         pSMB->t2.DataCount = 0;
4169         pSMB->t2.DataOffset = 0;
4170         pSMB->t2.SetupCount = 1;
4171         pSMB->t2.Reserved3 = 0;
4172         pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4173         byte_count = params + 1 /* pad */ ;
4174         pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4175         pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4176         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4177         pSMB->Pad = 0;
4178         pSMB->Fid = netfid;
4179         inc_rfc1001_len(pSMB, byte_count);
4180         pSMB->t2.ByteCount = cpu_to_le16(byte_count);
4181
4182         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4183                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4184         if (rc) {
4185                 cifs_dbg(FYI, "Send error in QFileInfo = %d", rc);
4186         } else {                /* decode response */
4187                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4188
4189                 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4190                         rc = -EIO;
4191                 else if (get_bcc(&pSMBr->hdr) < 40)
4192                         rc = -EIO;      /* bad smb */
4193                 else if (pFindData) {
4194                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4195                         memcpy((char *) pFindData,
4196                                (char *) &pSMBr->hdr.Protocol +
4197                                data_offset, sizeof(FILE_ALL_INFO));
4198                 } else
4199                     rc = -ENOMEM;
4200         }
4201         cifs_buf_release(pSMB);
4202         if (rc == -EAGAIN)
4203                 goto QFileInfoRetry;
4204
4205         return rc;
4206 }
4207
4208 int
4209 CIFSSMBQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
4210                  const char *search_name, FILE_ALL_INFO *data,
4211                  int legacy /* old style infolevel */,
4212                  const struct nls_table *nls_codepage, int remap)
4213 {
4214         /* level 263 SMB_QUERY_FILE_ALL_INFO */
4215         TRANSACTION2_QPI_REQ *pSMB = NULL;
4216         TRANSACTION2_QPI_RSP *pSMBr = NULL;
4217         int rc = 0;
4218         int bytes_returned;
4219         int name_len;
4220         __u16 params, byte_count;
4221
4222         /* cifs_dbg(FYI, "In QPathInfo path %s\n", search_name); */
4223 QPathInfoRetry:
4224         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4225                       (void **) &pSMBr);
4226         if (rc)
4227                 return rc;
4228
4229         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4230                 name_len =
4231                     cifsConvertToUTF16((__le16 *) pSMB->FileName, search_name,
4232                                        PATH_MAX, nls_codepage, remap);
4233                 name_len++;     /* trailing null */
4234                 name_len *= 2;
4235         } else {        /* BB improve the check for buffer overruns BB */
4236                 name_len = strnlen(search_name, PATH_MAX);
4237                 name_len++;     /* trailing null */
4238                 strncpy(pSMB->FileName, search_name, name_len);
4239         }
4240
4241         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4242         pSMB->TotalDataCount = 0;
4243         pSMB->MaxParameterCount = cpu_to_le16(2);
4244         /* BB find exact max SMB PDU from sess structure BB */
4245         pSMB->MaxDataCount = cpu_to_le16(4000);
4246         pSMB->MaxSetupCount = 0;
4247         pSMB->Reserved = 0;
4248         pSMB->Flags = 0;
4249         pSMB->Timeout = 0;
4250         pSMB->Reserved2 = 0;
4251         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4252         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4253         pSMB->DataCount = 0;
4254         pSMB->DataOffset = 0;
4255         pSMB->SetupCount = 1;
4256         pSMB->Reserved3 = 0;
4257         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4258         byte_count = params + 1 /* pad */ ;
4259         pSMB->TotalParameterCount = cpu_to_le16(params);
4260         pSMB->ParameterCount = pSMB->TotalParameterCount;
4261         if (legacy)
4262                 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
4263         else
4264                 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
4265         pSMB->Reserved4 = 0;
4266         inc_rfc1001_len(pSMB, byte_count);
4267         pSMB->ByteCount = cpu_to_le16(byte_count);
4268
4269         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4270                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4271         if (rc) {
4272                 cifs_dbg(FYI, "Send error in QPathInfo = %d\n", rc);
4273         } else {                /* decode response */
4274                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4275
4276                 if (rc) /* BB add auto retry on EOPNOTSUPP? */
4277                         rc = -EIO;
4278                 else if (!legacy && get_bcc(&pSMBr->hdr) < 40)
4279                         rc = -EIO;      /* bad smb */
4280                 else if (legacy && get_bcc(&pSMBr->hdr) < 24)
4281                         rc = -EIO;  /* 24 or 26 expected but we do not read
4282                                         last field */
4283                 else if (data) {
4284                         int size;
4285                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4286
4287                         /*
4288                          * On legacy responses we do not read the last field,
4289                          * EAsize, fortunately since it varies by subdialect and
4290                          * also note it differs on Set vs Get, ie two bytes or 4
4291                          * bytes depending but we don't care here.
4292                          */
4293                         if (legacy)
4294                                 size = sizeof(FILE_INFO_STANDARD);
4295                         else
4296                                 size = sizeof(FILE_ALL_INFO);
4297                         memcpy((char *) data, (char *) &pSMBr->hdr.Protocol +
4298                                data_offset, size);
4299                 } else
4300                     rc = -ENOMEM;
4301         }
4302         cifs_buf_release(pSMB);
4303         if (rc == -EAGAIN)
4304                 goto QPathInfoRetry;
4305
4306         return rc;
4307 }
4308
4309 int
4310 CIFSSMBUnixQFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
4311                  u16 netfid, FILE_UNIX_BASIC_INFO *pFindData)
4312 {
4313         struct smb_t2_qfi_req *pSMB = NULL;
4314         struct smb_t2_qfi_rsp *pSMBr = NULL;
4315         int rc = 0;
4316         int bytes_returned;
4317         __u16 params, byte_count;
4318
4319 UnixQFileInfoRetry:
4320         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4321                       (void **) &pSMBr);
4322         if (rc)
4323                 return rc;
4324
4325         params = 2 /* level */ + 2 /* fid */;
4326         pSMB->t2.TotalDataCount = 0;
4327         pSMB->t2.MaxParameterCount = cpu_to_le16(4);
4328         /* BB find exact max data count below from sess structure BB */
4329         pSMB->t2.MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
4330         pSMB->t2.MaxSetupCount = 0;
4331         pSMB->t2.Reserved = 0;
4332         pSMB->t2.Flags = 0;
4333         pSMB->t2.Timeout = 0;
4334         pSMB->t2.Reserved2 = 0;
4335         pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
4336                                                Fid) - 4);
4337         pSMB->t2.DataCount = 0;
4338         pSMB->t2.DataOffset = 0;
4339         pSMB->t2.SetupCount = 1;
4340         pSMB->t2.Reserved3 = 0;
4341         pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
4342         byte_count = params + 1 /* pad */ ;
4343         pSMB->t2.TotalParameterCount = cpu_to_le16(params);
4344         pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
4345         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4346         pSMB->Pad = 0;
4347         pSMB->Fid = netfid;
4348         inc_rfc1001_len(pSMB, byte_count);
4349         pSMB->t2.ByteCount = cpu_to_le16(byte_count);
4350
4351         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4352                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4353         if (rc) {
4354                 cifs_dbg(FYI, "Send error in UnixQFileInfo = %d", rc);
4355         } else {                /* decode response */
4356                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4357
4358                 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4359                         cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4360                         rc = -EIO;      /* bad smb */
4361                 } else {
4362                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4363                         memcpy((char *) pFindData,
4364                                (char *) &pSMBr->hdr.Protocol +
4365                                data_offset,
4366                                sizeof(FILE_UNIX_BASIC_INFO));
4367                 }
4368         }
4369
4370         cifs_buf_release(pSMB);
4371         if (rc == -EAGAIN)
4372                 goto UnixQFileInfoRetry;
4373
4374         return rc;
4375 }
4376
4377 int
4378 CIFSSMBUnixQPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
4379                      const unsigned char *searchName,
4380                      FILE_UNIX_BASIC_INFO *pFindData,
4381                      const struct nls_table *nls_codepage, int remap)
4382 {
4383 /* SMB_QUERY_FILE_UNIX_BASIC */
4384         TRANSACTION2_QPI_REQ *pSMB = NULL;
4385         TRANSACTION2_QPI_RSP *pSMBr = NULL;
4386         int rc = 0;
4387         int bytes_returned = 0;
4388         int name_len;
4389         __u16 params, byte_count;
4390
4391         cifs_dbg(FYI, "In QPathInfo (Unix) the path %s\n", searchName);
4392 UnixQPathInfoRetry:
4393         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4394                       (void **) &pSMBr);
4395         if (rc)
4396                 return rc;
4397
4398         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4399                 name_len =
4400                     cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4401                                        PATH_MAX, nls_codepage, remap);
4402                 name_len++;     /* trailing null */
4403                 name_len *= 2;
4404         } else {        /* BB improve the check for buffer overruns BB */
4405                 name_len = strnlen(searchName, PATH_MAX);
4406                 name_len++;     /* trailing null */
4407                 strncpy(pSMB->FileName, searchName, name_len);
4408         }
4409
4410         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
4411         pSMB->TotalDataCount = 0;
4412         pSMB->MaxParameterCount = cpu_to_le16(2);
4413         /* BB find exact max SMB PDU from sess structure BB */
4414         pSMB->MaxDataCount = cpu_to_le16(4000);
4415         pSMB->MaxSetupCount = 0;
4416         pSMB->Reserved = 0;
4417         pSMB->Flags = 0;
4418         pSMB->Timeout = 0;
4419         pSMB->Reserved2 = 0;
4420         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4421         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4422         pSMB->DataCount = 0;
4423         pSMB->DataOffset = 0;
4424         pSMB->SetupCount = 1;
4425         pSMB->Reserved3 = 0;
4426         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4427         byte_count = params + 1 /* pad */ ;
4428         pSMB->TotalParameterCount = cpu_to_le16(params);
4429         pSMB->ParameterCount = pSMB->TotalParameterCount;
4430         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
4431         pSMB->Reserved4 = 0;
4432         inc_rfc1001_len(pSMB, byte_count);
4433         pSMB->ByteCount = cpu_to_le16(byte_count);
4434
4435         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4436                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4437         if (rc) {
4438                 cifs_dbg(FYI, "Send error in UnixQPathInfo = %d", rc);
4439         } else {                /* decode response */
4440                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4441
4442                 if (rc || get_bcc(&pSMBr->hdr) < sizeof(FILE_UNIX_BASIC_INFO)) {
4443                         cifs_dbg(VFS, "Malformed FILE_UNIX_BASIC_INFO response. Unix Extensions can be disabled on mount by specifying the nosfu mount option.\n");
4444                         rc = -EIO;      /* bad smb */
4445                 } else {
4446                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4447                         memcpy((char *) pFindData,
4448                                (char *) &pSMBr->hdr.Protocol +
4449                                data_offset,
4450                                sizeof(FILE_UNIX_BASIC_INFO));
4451                 }
4452         }
4453         cifs_buf_release(pSMB);
4454         if (rc == -EAGAIN)
4455                 goto UnixQPathInfoRetry;
4456
4457         return rc;
4458 }
4459
4460 /* xid, tcon, searchName and codepage are input parms, rest are returned */
4461 int
4462 CIFSFindFirst(const unsigned int xid, struct cifs_tcon *tcon,
4463               const char *searchName, struct cifs_sb_info *cifs_sb,
4464               __u16 *pnetfid, __u16 search_flags,
4465               struct cifs_search_info *psrch_inf, bool msearch)
4466 {
4467 /* level 257 SMB_ */
4468         TRANSACTION2_FFIRST_REQ *pSMB = NULL;
4469         TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
4470         T2_FFIRST_RSP_PARMS *parms;
4471         int rc = 0;
4472         int bytes_returned = 0;
4473         int name_len, remap;
4474         __u16 params, byte_count;
4475         struct nls_table *nls_codepage;
4476
4477         cifs_dbg(FYI, "In FindFirst for %s\n", searchName);
4478
4479 findFirstRetry:
4480         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4481                       (void **) &pSMBr);
4482         if (rc)
4483                 return rc;
4484
4485         nls_codepage = cifs_sb->local_nls;
4486         remap = cifs_remap(cifs_sb);
4487
4488         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4489                 name_len =
4490                     cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
4491                                        PATH_MAX, nls_codepage, remap);
4492                 /* We can not add the asterik earlier in case
4493                 it got remapped to 0xF03A as if it were part of the
4494                 directory name instead of a wildcard */
4495                 name_len *= 2;
4496                 if (msearch) {
4497                         pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4498                         pSMB->FileName[name_len+1] = 0;
4499                         pSMB->FileName[name_len+2] = '*';
4500                         pSMB->FileName[name_len+3] = 0;
4501                         name_len += 4; /* now the trailing null */
4502                         /* null terminate just in case */
4503                         pSMB->FileName[name_len] = 0;
4504                         pSMB->FileName[name_len+1] = 0;
4505                         name_len += 2;
4506                 }
4507         } else {        /* BB add check for overrun of SMB buf BB */
4508                 name_len = strnlen(searchName, PATH_MAX);
4509 /* BB fix here and in unicode clause above ie
4510                 if (name_len > buffersize-header)
4511                         free buffer exit; BB */
4512                 strncpy(pSMB->FileName, searchName, name_len);
4513                 if (msearch) {
4514                         pSMB->FileName[name_len] = CIFS_DIR_SEP(cifs_sb);
4515                         pSMB->FileName[name_len+1] = '*';
4516                         pSMB->FileName[name_len+2] = 0;
4517                         name_len += 3;
4518                 }
4519         }
4520
4521         params = 12 + name_len /* includes null */ ;
4522         pSMB->TotalDataCount = 0;       /* no EAs */
4523         pSMB->MaxParameterCount = cpu_to_le16(10);
4524         pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4525         pSMB->MaxSetupCount = 0;
4526         pSMB->Reserved = 0;
4527         pSMB->Flags = 0;
4528         pSMB->Timeout = 0;
4529         pSMB->Reserved2 = 0;
4530         byte_count = params + 1 /* pad */ ;
4531         pSMB->TotalParameterCount = cpu_to_le16(params);
4532         pSMB->ParameterCount = pSMB->TotalParameterCount;
4533         pSMB->ParameterOffset = cpu_to_le16(
4534               offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
4535                 - 4);
4536         pSMB->DataCount = 0;
4537         pSMB->DataOffset = 0;
4538         pSMB->SetupCount = 1;   /* one byte, no need to make endian neutral */
4539         pSMB->Reserved3 = 0;
4540         pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
4541         pSMB->SearchAttributes =
4542             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
4543                         ATTR_DIRECTORY);
4544         pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
4545         pSMB->SearchFlags = cpu_to_le16(search_flags);
4546         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4547
4548         /* BB what should we set StorageType to? Does it matter? BB */
4549         pSMB->SearchStorageType = 0;
4550         inc_rfc1001_len(pSMB, byte_count);
4551         pSMB->ByteCount = cpu_to_le16(byte_count);
4552
4553         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4554                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4555         cifs_stats_inc(&tcon->stats.cifs_stats.num_ffirst);
4556
4557         if (rc) {/* BB add logic to retry regular search if Unix search
4558                         rejected unexpectedly by server */
4559                 /* BB Add code to handle unsupported level rc */
4560                 cifs_dbg(FYI, "Error in FindFirst = %d\n", rc);
4561
4562                 cifs_buf_release(pSMB);
4563
4564                 /* BB eventually could optimize out free and realloc of buf */
4565                 /*    for this case */
4566                 if (rc == -EAGAIN)
4567                         goto findFirstRetry;
4568         } else { /* decode response */
4569                 /* BB remember to free buffer if error BB */
4570                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4571                 if (rc == 0) {
4572                         unsigned int lnoff;
4573
4574                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4575                                 psrch_inf->unicode = true;
4576                         else
4577                                 psrch_inf->unicode = false;
4578
4579                         psrch_inf->ntwrk_buf_start = (char *)pSMBr;
4580                         psrch_inf->smallBuf = 0;
4581                         psrch_inf->srch_entries_start =
4582                                 (char *) &pSMBr->hdr.Protocol +
4583                                         le16_to_cpu(pSMBr->t2.DataOffset);
4584                         parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
4585                                le16_to_cpu(pSMBr->t2.ParameterOffset));
4586
4587                         if (parms->EndofSearch)
4588                                 psrch_inf->endOfSearch = true;
4589                         else
4590                                 psrch_inf->endOfSearch = false;
4591
4592                         psrch_inf->entries_in_buffer =
4593                                         le16_to_cpu(parms->SearchCount);
4594                         psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
4595                                 psrch_inf->entries_in_buffer;
4596                         lnoff = le16_to_cpu(parms->LastNameOffset);
4597                         if (CIFSMaxBufSize < lnoff) {
4598                                 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4599                                 psrch_inf->last_entry = NULL;
4600                                 return rc;
4601                         }
4602
4603                         psrch_inf->last_entry = psrch_inf->srch_entries_start +
4604                                                         lnoff;
4605
4606                         if (pnetfid)
4607                                 *pnetfid = parms->SearchHandle;
4608                 } else {
4609                         cifs_buf_release(pSMB);
4610                 }
4611         }
4612
4613         return rc;
4614 }
4615
4616 int CIFSFindNext(const unsigned int xid, struct cifs_tcon *tcon,
4617                  __u16 searchHandle, __u16 search_flags,
4618                  struct cifs_search_info *psrch_inf)
4619 {
4620         TRANSACTION2_FNEXT_REQ *pSMB = NULL;
4621         TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
4622         T2_FNEXT_RSP_PARMS *parms;
4623         char *response_data;
4624         int rc = 0;
4625         int bytes_returned;
4626         unsigned int name_len;
4627         __u16 params, byte_count;
4628
4629         cifs_dbg(FYI, "In FindNext\n");
4630
4631         if (psrch_inf->endOfSearch)
4632                 return -ENOENT;
4633
4634         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4635                 (void **) &pSMBr);
4636         if (rc)
4637                 return rc;
4638
4639         params = 14; /* includes 2 bytes of null string, converted to LE below*/
4640         byte_count = 0;
4641         pSMB->TotalDataCount = 0;       /* no EAs */
4642         pSMB->MaxParameterCount = cpu_to_le16(8);
4643         pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize & 0xFFFFFF00);
4644         pSMB->MaxSetupCount = 0;
4645         pSMB->Reserved = 0;
4646         pSMB->Flags = 0;
4647         pSMB->Timeout = 0;
4648         pSMB->Reserved2 = 0;
4649         pSMB->ParameterOffset =  cpu_to_le16(
4650               offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
4651         pSMB->DataCount = 0;
4652         pSMB->DataOffset = 0;
4653         pSMB->SetupCount = 1;
4654         pSMB->Reserved3 = 0;
4655         pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
4656         pSMB->SearchHandle = searchHandle;      /* always kept as le */
4657         pSMB->SearchCount =
4658                 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
4659         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
4660         pSMB->ResumeKey = psrch_inf->resume_key;
4661         pSMB->SearchFlags = cpu_to_le16(search_flags);
4662
4663         name_len = psrch_inf->resume_name_len;
4664         params += name_len;
4665         if (name_len < PATH_MAX) {
4666                 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
4667                 byte_count += name_len;
4668                 /* 14 byte parm len above enough for 2 byte null terminator */
4669                 pSMB->ResumeFileName[name_len] = 0;
4670                 pSMB->ResumeFileName[name_len+1] = 0;
4671         } else {
4672                 rc = -EINVAL;
4673                 goto FNext2_err_exit;
4674         }
4675         byte_count = params + 1 /* pad */ ;
4676         pSMB->TotalParameterCount = cpu_to_le16(params);
4677         pSMB->ParameterCount = pSMB->TotalParameterCount;
4678         inc_rfc1001_len(pSMB, byte_count);
4679         pSMB->ByteCount = cpu_to_le16(byte_count);
4680
4681         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4682                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4683         cifs_stats_inc(&tcon->stats.cifs_stats.num_fnext);
4684         if (rc) {
4685                 if (rc == -EBADF) {
4686                         psrch_inf->endOfSearch = true;
4687                         cifs_buf_release(pSMB);
4688                         rc = 0; /* search probably was closed at end of search*/
4689                 } else
4690                         cifs_dbg(FYI, "FindNext returned = %d\n", rc);
4691         } else {                /* decode response */
4692                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4693
4694                 if (rc == 0) {
4695                         unsigned int lnoff;
4696
4697                         /* BB fixme add lock for file (srch_info) struct here */
4698                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
4699                                 psrch_inf->unicode = true;
4700                         else
4701                                 psrch_inf->unicode = false;
4702                         response_data = (char *) &pSMBr->hdr.Protocol +
4703                                le16_to_cpu(pSMBr->t2.ParameterOffset);
4704                         parms = (T2_FNEXT_RSP_PARMS *)response_data;
4705                         response_data = (char *)&pSMBr->hdr.Protocol +
4706                                 le16_to_cpu(pSMBr->t2.DataOffset);
4707                         if (psrch_inf->smallBuf)
4708                                 cifs_small_buf_release(
4709                                         psrch_inf->ntwrk_buf_start);
4710                         else
4711                                 cifs_buf_release(psrch_inf->ntwrk_buf_start);
4712                         psrch_inf->srch_entries_start = response_data;
4713                         psrch_inf->ntwrk_buf_start = (char *)pSMB;
4714                         psrch_inf->smallBuf = 0;
4715                         if (parms->EndofSearch)
4716                                 psrch_inf->endOfSearch = true;
4717                         else
4718                                 psrch_inf->endOfSearch = false;
4719                         psrch_inf->entries_in_buffer =
4720                                                 le16_to_cpu(parms->SearchCount);
4721                         psrch_inf->index_of_last_entry +=
4722                                 psrch_inf->entries_in_buffer;
4723                         lnoff = le16_to_cpu(parms->LastNameOffset);
4724                         if (CIFSMaxBufSize < lnoff) {
4725                                 cifs_dbg(VFS, "ignoring corrupt resume name\n");
4726                                 psrch_inf->last_entry = NULL;
4727                                 return rc;
4728                         } else
4729                                 psrch_inf->last_entry =
4730                                         psrch_inf->srch_entries_start + lnoff;
4731
4732 /*  cifs_dbg(FYI, "fnxt2 entries in buf %d index_of_last %d\n",
4733     psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry); */
4734
4735                         /* BB fixme add unlock here */
4736                 }
4737
4738         }
4739
4740         /* BB On error, should we leave previous search buf (and count and
4741         last entry fields) intact or free the previous one? */
4742
4743         /* Note: On -EAGAIN error only caller can retry on handle based calls
4744         since file handle passed in no longer valid */
4745 FNext2_err_exit:
4746         if (rc != 0)
4747                 cifs_buf_release(pSMB);
4748         return rc;
4749 }
4750
4751 int
4752 CIFSFindClose(const unsigned int xid, struct cifs_tcon *tcon,
4753               const __u16 searchHandle)
4754 {
4755         int rc = 0;
4756         FINDCLOSE_REQ *pSMB = NULL;
4757
4758         cifs_dbg(FYI, "In CIFSSMBFindClose\n");
4759         rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
4760
4761         /* no sense returning error if session restarted
4762                 as file handle has been closed */
4763         if (rc == -EAGAIN)
4764                 return 0;
4765         if (rc)
4766                 return rc;
4767
4768         pSMB->FileID = searchHandle;
4769         pSMB->ByteCount = 0;
4770         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
4771         cifs_small_buf_release(pSMB);
4772         if (rc)
4773                 cifs_dbg(VFS, "Send error in FindClose = %d\n", rc);
4774
4775         cifs_stats_inc(&tcon->stats.cifs_stats.num_fclose);
4776
4777         /* Since session is dead, search handle closed on server already */
4778         if (rc == -EAGAIN)
4779                 rc = 0;
4780
4781         return rc;
4782 }
4783
4784 int
4785 CIFSGetSrvInodeNumber(const unsigned int xid, struct cifs_tcon *tcon,
4786                       const char *search_name, __u64 *inode_number,
4787                       const struct nls_table *nls_codepage, int remap)
4788 {
4789         int rc = 0;
4790         TRANSACTION2_QPI_REQ *pSMB = NULL;
4791         TRANSACTION2_QPI_RSP *pSMBr = NULL;
4792         int name_len, bytes_returned;
4793         __u16 params, byte_count;
4794
4795         cifs_dbg(FYI, "In GetSrvInodeNum for %s\n", search_name);
4796         if (tcon == NULL)
4797                 return -ENODEV;
4798
4799 GetInodeNumberRetry:
4800         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4801                       (void **) &pSMBr);
4802         if (rc)
4803                 return rc;
4804
4805         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4806                 name_len =
4807                         cifsConvertToUTF16((__le16 *) pSMB->FileName,
4808                                            search_name, PATH_MAX, nls_codepage,
4809                                            remap);
4810                 name_len++;     /* trailing null */
4811                 name_len *= 2;
4812         } else {        /* BB improve the check for buffer overruns BB */
4813                 name_len = strnlen(search_name, PATH_MAX);
4814                 name_len++;     /* trailing null */
4815                 strncpy(pSMB->FileName, search_name, name_len);
4816         }
4817
4818         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
4819         pSMB->TotalDataCount = 0;
4820         pSMB->MaxParameterCount = cpu_to_le16(2);
4821         /* BB find exact max data count below from sess structure BB */
4822         pSMB->MaxDataCount = cpu_to_le16(4000);
4823         pSMB->MaxSetupCount = 0;
4824         pSMB->Reserved = 0;
4825         pSMB->Flags = 0;
4826         pSMB->Timeout = 0;
4827         pSMB->Reserved2 = 0;
4828         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4829                 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
4830         pSMB->DataCount = 0;
4831         pSMB->DataOffset = 0;
4832         pSMB->SetupCount = 1;
4833         pSMB->Reserved3 = 0;
4834         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
4835         byte_count = params + 1 /* pad */ ;
4836         pSMB->TotalParameterCount = cpu_to_le16(params);
4837         pSMB->ParameterCount = pSMB->TotalParameterCount;
4838         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
4839         pSMB->Reserved4 = 0;
4840         inc_rfc1001_len(pSMB, byte_count);
4841         pSMB->ByteCount = cpu_to_le16(byte_count);
4842
4843         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4844                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4845         if (rc) {
4846                 cifs_dbg(FYI, "error %d in QueryInternalInfo\n", rc);
4847         } else {
4848                 /* decode response */
4849                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4850                 /* BB also check enough total bytes returned */
4851                 if (rc || get_bcc(&pSMBr->hdr) < 2)
4852                         /* If rc should we check for EOPNOSUPP and
4853                         disable the srvino flag? or in caller? */
4854                         rc = -EIO;      /* bad smb */
4855                 else {
4856                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4857                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
4858                         struct file_internal_info *pfinfo;
4859                         /* BB Do we need a cast or hash here ? */
4860                         if (count < 8) {
4861                                 cifs_dbg(FYI, "Illegal size ret in QryIntrnlInf\n");
4862                                 rc = -EIO;
4863                                 goto GetInodeNumOut;
4864                         }
4865                         pfinfo = (struct file_internal_info *)
4866                                 (data_offset + (char *) &pSMBr->hdr.Protocol);
4867                         *inode_number = le64_to_cpu(pfinfo->UniqueId);
4868                 }
4869         }
4870 GetInodeNumOut:
4871         cifs_buf_release(pSMB);
4872         if (rc == -EAGAIN)
4873                 goto GetInodeNumberRetry;
4874         return rc;
4875 }
4876
4877 int
4878 CIFSGetDFSRefer(const unsigned int xid, struct cifs_ses *ses,
4879                 const char *search_name, struct dfs_info3_param **target_nodes,
4880                 unsigned int *num_of_nodes,
4881                 const struct nls_table *nls_codepage, int remap)
4882 {
4883 /* TRANS2_GET_DFS_REFERRAL */
4884         TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
4885         TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
4886         int rc = 0;
4887         int bytes_returned;
4888         int name_len;
4889         __u16 params, byte_count;
4890         *num_of_nodes = 0;
4891         *target_nodes = NULL;
4892
4893         cifs_dbg(FYI, "In GetDFSRefer the path %s\n", search_name);
4894         if (ses == NULL || ses->tcon_ipc == NULL)
4895                 return -ENODEV;
4896
4897 getDFSRetry:
4898         rc = smb_init(SMB_COM_TRANSACTION2, 15, ses->tcon_ipc, (void **) &pSMB,
4899                       (void **) &pSMBr);
4900         if (rc)
4901                 return rc;
4902
4903         /* server pointer checked in called function,
4904         but should never be null here anyway */
4905         pSMB->hdr.Mid = get_next_mid(ses->server);
4906         pSMB->hdr.Tid = ses->tcon_ipc->tid;
4907         pSMB->hdr.Uid = ses->Suid;
4908         if (ses->capabilities & CAP_STATUS32)
4909                 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
4910         if (ses->capabilities & CAP_DFS)
4911                 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
4912
4913         if (ses->capabilities & CAP_UNICODE) {
4914                 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
4915                 name_len =
4916                     cifsConvertToUTF16((__le16 *) pSMB->RequestFileName,
4917                                        search_name, PATH_MAX, nls_codepage,
4918                                        remap);
4919                 name_len++;     /* trailing null */
4920                 name_len *= 2;
4921         } else {        /* BB improve the check for buffer overruns BB */
4922                 name_len = strnlen(search_name, PATH_MAX);
4923                 name_len++;     /* trailing null */
4924                 strncpy(pSMB->RequestFileName, search_name, name_len);
4925         }
4926
4927         if (ses->server->sign)
4928                 pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4929
4930         pSMB->hdr.Uid = ses->Suid;
4931
4932         params = 2 /* level */  + name_len /*includes null */ ;
4933         pSMB->TotalDataCount = 0;
4934         pSMB->DataCount = 0;
4935         pSMB->DataOffset = 0;
4936         pSMB->MaxParameterCount = 0;
4937         /* BB find exact max SMB PDU from sess structure BB */
4938         pSMB->MaxDataCount = cpu_to_le16(4000);
4939         pSMB->MaxSetupCount = 0;
4940         pSMB->Reserved = 0;
4941         pSMB->Flags = 0;
4942         pSMB->Timeout = 0;
4943         pSMB->Reserved2 = 0;
4944         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4945           struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
4946         pSMB->SetupCount = 1;
4947         pSMB->Reserved3 = 0;
4948         pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
4949         byte_count = params + 3 /* pad */ ;
4950         pSMB->ParameterCount = cpu_to_le16(params);
4951         pSMB->TotalParameterCount = pSMB->ParameterCount;
4952         pSMB->MaxReferralLevel = cpu_to_le16(3);
4953         inc_rfc1001_len(pSMB, byte_count);
4954         pSMB->ByteCount = cpu_to_le16(byte_count);
4955
4956         rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
4957                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4958         if (rc) {
4959                 cifs_dbg(FYI, "Send error in GetDFSRefer = %d\n", rc);
4960                 goto GetDFSRefExit;
4961         }
4962         rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4963
4964         /* BB Also check if enough total bytes returned? */
4965         if (rc || get_bcc(&pSMBr->hdr) < 17) {
4966                 rc = -EIO;      /* bad smb */
4967                 goto GetDFSRefExit;
4968         }
4969
4970         cifs_dbg(FYI, "Decoding GetDFSRefer response BCC: %d  Offset %d\n",
4971                  get_bcc(&pSMBr->hdr), le16_to_cpu(pSMBr->t2.DataOffset));
4972
4973         /* parse returned result into more usable form */
4974         rc = parse_dfs_referrals(&pSMBr->dfs_data,
4975                                  le16_to_cpu(pSMBr->t2.DataCount),
4976                                  num_of_nodes, target_nodes, nls_codepage,
4977                                  remap, search_name,
4978                                  (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) != 0);
4979
4980 GetDFSRefExit:
4981         cifs_buf_release(pSMB);
4982
4983         if (rc == -EAGAIN)
4984                 goto getDFSRetry;
4985
4986         return rc;
4987 }
4988
4989 /* Query File System Info such as free space to old servers such as Win 9x */
4990 int
4991 SMBOldQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
4992               struct kstatfs *FSData)
4993 {
4994 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4995         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4996         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4997         FILE_SYSTEM_ALLOC_INFO *response_data;
4998         int rc = 0;
4999         int bytes_returned = 0;
5000         __u16 params, byte_count;
5001
5002         cifs_dbg(FYI, "OldQFSInfo\n");
5003 oldQFSInfoRetry:
5004         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5005                 (void **) &pSMBr);
5006         if (rc)
5007                 return rc;
5008
5009         params = 2;     /* level */
5010         pSMB->TotalDataCount = 0;
5011         pSMB->MaxParameterCount = cpu_to_le16(2);
5012         pSMB->MaxDataCount = cpu_to_le16(1000);
5013         pSMB->MaxSetupCount = 0;
5014         pSMB->Reserved = 0;
5015         pSMB->Flags = 0;
5016         pSMB->Timeout = 0;
5017         pSMB->Reserved2 = 0;
5018         byte_count = params + 1 /* pad */ ;
5019         pSMB->TotalParameterCount = cpu_to_le16(params);
5020         pSMB->ParameterCount = pSMB->TotalParameterCount;
5021         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5022         struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5023         pSMB->DataCount = 0;
5024         pSMB->DataOffset = 0;
5025         pSMB->SetupCount = 1;
5026         pSMB->Reserved3 = 0;
5027         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5028         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
5029         inc_rfc1001_len(pSMB, byte_count);
5030         pSMB->ByteCount = cpu_to_le16(byte_count);
5031
5032         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5033                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5034         if (rc) {
5035                 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
5036         } else {                /* decode response */
5037                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5038
5039                 if (rc || get_bcc(&pSMBr->hdr) < 18)
5040                         rc = -EIO;      /* bad smb */
5041                 else {
5042                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5043                         cifs_dbg(FYI, "qfsinf resp BCC: %d  Offset %d\n",
5044                                  get_bcc(&pSMBr->hdr), data_offset);
5045
5046                         response_data = (FILE_SYSTEM_ALLOC_INFO *)
5047                                 (((char *) &pSMBr->hdr.Protocol) + data_offset);
5048                         FSData->f_bsize =
5049                                 le16_to_cpu(response_data->BytesPerSector) *
5050                                 le32_to_cpu(response_data->
5051                                         SectorsPerAllocationUnit);
5052                         FSData->f_blocks =
5053                                le32_to_cpu(response_data->TotalAllocationUnits);
5054                         FSData->f_bfree = FSData->f_bavail =
5055                                 le32_to_cpu(response_data->FreeAllocationUnits);
5056                         cifs_dbg(FYI, "Blocks: %lld  Free: %lld Block size %ld\n",
5057                                  (unsigned long long)FSData->f_blocks,
5058                                  (unsigned long long)FSData->f_bfree,
5059                                  FSData->f_bsize);
5060                 }
5061         }
5062         cifs_buf_release(pSMB);
5063
5064         if (rc == -EAGAIN)
5065                 goto oldQFSInfoRetry;
5066
5067         return rc;
5068 }
5069
5070 int
5071 CIFSSMBQFSInfo(const unsigned int xid, struct cifs_tcon *tcon,
5072                struct kstatfs *FSData)
5073 {
5074 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
5075         TRANSACTION2_QFSI_REQ *pSMB = NULL;
5076         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5077         FILE_SYSTEM_INFO *response_data;
5078         int rc = 0;
5079         int bytes_returned = 0;
5080         __u16 params, byte_count;
5081
5082         cifs_dbg(FYI, "In QFSInfo\n");
5083 QFSInfoRetry:
5084         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5085                       (void **) &pSMBr);
5086         if (rc)
5087                 return rc;
5088
5089         params = 2;     /* level */
5090         pSMB->TotalDataCount = 0;
5091         pSMB->MaxParameterCount = cpu_to_le16(2);
5092         pSMB->MaxDataCount = cpu_to_le16(1000);
5093         pSMB->MaxSetupCount = 0;
5094         pSMB->Reserved = 0;
5095         pSMB->Flags = 0;
5096         pSMB->Timeout = 0;
5097         pSMB->Reserved2 = 0;
5098         byte_count = params + 1 /* pad */ ;
5099         pSMB->TotalParameterCount = cpu_to_le16(params);
5100         pSMB->ParameterCount = pSMB->TotalParameterCount;
5101         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5102                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5103         pSMB->DataCount = 0;
5104         pSMB->DataOffset = 0;
5105         pSMB->SetupCount = 1;
5106         pSMB->Reserved3 = 0;
5107         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5108         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
5109         inc_rfc1001_len(pSMB, byte_count);
5110         pSMB->ByteCount = cpu_to_le16(byte_count);
5111
5112         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5113                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5114         if (rc) {
5115                 cifs_dbg(FYI, "Send error in QFSInfo = %d\n", rc);
5116         } else {                /* decode response */
5117                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5118
5119                 if (rc || get_bcc(&pSMBr->hdr) < 24)
5120                         rc = -EIO;      /* bad smb */
5121                 else {
5122                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5123
5124                         response_data =
5125                             (FILE_SYSTEM_INFO
5126                              *) (((char *) &pSMBr->hdr.Protocol) +
5127                                  data_offset);
5128                         FSData->f_bsize =
5129                             le32_to_cpu(response_data->BytesPerSector) *
5130                             le32_to_cpu(response_data->
5131                                         SectorsPerAllocationUnit);
5132                         FSData->f_blocks =
5133                             le64_to_cpu(response_data->TotalAllocationUnits);
5134                         FSData->f_bfree = FSData->f_bavail =
5135                             le64_to_cpu(response_data->FreeAllocationUnits);
5136                         cifs_dbg(FYI, "Blocks: %lld  Free: %lld Block size %ld\n",
5137                                  (unsigned long long)FSData->f_blocks,
5138                                  (unsigned long long)FSData->f_bfree,
5139                                  FSData->f_bsize);
5140                 }
5141         }
5142         cifs_buf_release(pSMB);
5143
5144         if (rc == -EAGAIN)
5145                 goto QFSInfoRetry;
5146
5147         return rc;
5148 }
5149
5150 int
5151 CIFSSMBQFSAttributeInfo(const unsigned int xid, struct cifs_tcon *tcon)
5152 {
5153 /* level 0x105  SMB_QUERY_FILE_SYSTEM_INFO */
5154         TRANSACTION2_QFSI_REQ *pSMB = NULL;
5155         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5156         FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
5157         int rc = 0;
5158         int bytes_returned = 0;
5159         __u16 params, byte_count;
5160
5161         cifs_dbg(FYI, "In QFSAttributeInfo\n");
5162 QFSAttributeRetry:
5163         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5164                       (void **) &pSMBr);
5165         if (rc)
5166                 return rc;
5167
5168         params = 2;     /* level */
5169         pSMB->TotalDataCount = 0;
5170         pSMB->MaxParameterCount = cpu_to_le16(2);
5171         /* BB find exact max SMB PDU from sess structure BB */
5172         pSMB->MaxDataCount = cpu_to_le16(1000);
5173         pSMB->MaxSetupCount = 0;
5174         pSMB->Reserved = 0;
5175         pSMB->Flags = 0;
5176         pSMB->Timeout = 0;
5177         pSMB->Reserved2 = 0;
5178         byte_count = params + 1 /* pad */ ;
5179         pSMB->TotalParameterCount = cpu_to_le16(params);
5180         pSMB->ParameterCount = pSMB->TotalParameterCount;
5181         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5182                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5183         pSMB->DataCount = 0;
5184         pSMB->DataOffset = 0;
5185         pSMB->SetupCount = 1;
5186         pSMB->Reserved3 = 0;
5187         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5188         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
5189         inc_rfc1001_len(pSMB, byte_count);
5190         pSMB->ByteCount = cpu_to_le16(byte_count);
5191
5192         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5193                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5194         if (rc) {
5195                 cifs_dbg(VFS, "Send error in QFSAttributeInfo = %d\n", rc);
5196         } else {                /* decode response */
5197                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5198
5199                 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5200                         /* BB also check if enough bytes returned */
5201                         rc = -EIO;      /* bad smb */
5202                 } else {
5203                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5204                         response_data =
5205                             (FILE_SYSTEM_ATTRIBUTE_INFO
5206                              *) (((char *) &pSMBr->hdr.Protocol) +
5207                                  data_offset);
5208                         memcpy(&tcon->fsAttrInfo, response_data,
5209                                sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
5210                 }
5211         }
5212         cifs_buf_release(pSMB);
5213
5214         if (rc == -EAGAIN)
5215                 goto QFSAttributeRetry;
5216
5217         return rc;
5218 }
5219
5220 int
5221 CIFSSMBQFSDeviceInfo(const unsigned int xid, struct cifs_tcon *tcon)
5222 {
5223 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
5224         TRANSACTION2_QFSI_REQ *pSMB = NULL;
5225         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5226         FILE_SYSTEM_DEVICE_INFO *response_data;
5227         int rc = 0;
5228         int bytes_returned = 0;
5229         __u16 params, byte_count;
5230
5231         cifs_dbg(FYI, "In QFSDeviceInfo\n");
5232 QFSDeviceRetry:
5233         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5234                       (void **) &pSMBr);
5235         if (rc)
5236                 return rc;
5237
5238         params = 2;     /* level */
5239         pSMB->TotalDataCount = 0;
5240         pSMB->MaxParameterCount = cpu_to_le16(2);
5241         /* BB find exact max SMB PDU from sess structure BB */
5242         pSMB->MaxDataCount = cpu_to_le16(1000);
5243         pSMB->MaxSetupCount = 0;
5244         pSMB->Reserved = 0;
5245         pSMB->Flags = 0;
5246         pSMB->Timeout = 0;
5247         pSMB->Reserved2 = 0;
5248         byte_count = params + 1 /* pad */ ;
5249         pSMB->TotalParameterCount = cpu_to_le16(params);
5250         pSMB->ParameterCount = pSMB->TotalParameterCount;
5251         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5252                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5253
5254         pSMB->DataCount = 0;
5255         pSMB->DataOffset = 0;
5256         pSMB->SetupCount = 1;
5257         pSMB->Reserved3 = 0;
5258         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5259         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
5260         inc_rfc1001_len(pSMB, byte_count);
5261         pSMB->ByteCount = cpu_to_le16(byte_count);
5262
5263         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5264                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5265         if (rc) {
5266                 cifs_dbg(FYI, "Send error in QFSDeviceInfo = %d\n", rc);
5267         } else {                /* decode response */
5268                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5269
5270                 if (rc || get_bcc(&pSMBr->hdr) <
5271                           sizeof(FILE_SYSTEM_DEVICE_INFO))
5272                         rc = -EIO;      /* bad smb */
5273                 else {
5274                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5275                         response_data =
5276                             (FILE_SYSTEM_DEVICE_INFO *)
5277                                 (((char *) &pSMBr->hdr.Protocol) +
5278                                  data_offset);
5279                         memcpy(&tcon->fsDevInfo, response_data,
5280                                sizeof(FILE_SYSTEM_DEVICE_INFO));
5281                 }
5282         }
5283         cifs_buf_release(pSMB);
5284
5285         if (rc == -EAGAIN)
5286                 goto QFSDeviceRetry;
5287
5288         return rc;
5289 }
5290
5291 int
5292 CIFSSMBQFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon)
5293 {
5294 /* level 0x200  SMB_QUERY_CIFS_UNIX_INFO */
5295         TRANSACTION2_QFSI_REQ *pSMB = NULL;
5296         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5297         FILE_SYSTEM_UNIX_INFO *response_data;
5298         int rc = 0;
5299         int bytes_returned = 0;
5300         __u16 params, byte_count;
5301
5302         cifs_dbg(FYI, "In QFSUnixInfo\n");
5303 QFSUnixRetry:
5304         rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5305                                    (void **) &pSMB, (void **) &pSMBr);
5306         if (rc)
5307                 return rc;
5308
5309         params = 2;     /* level */
5310         pSMB->TotalDataCount = 0;
5311         pSMB->DataCount = 0;
5312         pSMB->DataOffset = 0;
5313         pSMB->MaxParameterCount = cpu_to_le16(2);
5314         /* BB find exact max SMB PDU from sess structure BB */
5315         pSMB->MaxDataCount = cpu_to_le16(100);
5316         pSMB->MaxSetupCount = 0;
5317         pSMB->Reserved = 0;
5318         pSMB->Flags = 0;
5319         pSMB->Timeout = 0;
5320         pSMB->Reserved2 = 0;
5321         byte_count = params + 1 /* pad */ ;
5322         pSMB->ParameterCount = cpu_to_le16(params);
5323         pSMB->TotalParameterCount = pSMB->ParameterCount;
5324         pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5325                         smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5326         pSMB->SetupCount = 1;
5327         pSMB->Reserved3 = 0;
5328         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5329         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
5330         inc_rfc1001_len(pSMB, byte_count);
5331         pSMB->ByteCount = cpu_to_le16(byte_count);
5332
5333         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5334                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5335         if (rc) {
5336                 cifs_dbg(VFS, "Send error in QFSUnixInfo = %d\n", rc);
5337         } else {                /* decode response */
5338                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5339
5340                 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5341                         rc = -EIO;      /* bad smb */
5342                 } else {
5343                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5344                         response_data =
5345                             (FILE_SYSTEM_UNIX_INFO
5346                              *) (((char *) &pSMBr->hdr.Protocol) +
5347                                  data_offset);
5348                         memcpy(&tcon->fsUnixInfo, response_data,
5349                                sizeof(FILE_SYSTEM_UNIX_INFO));
5350                 }
5351         }
5352         cifs_buf_release(pSMB);
5353
5354         if (rc == -EAGAIN)
5355                 goto QFSUnixRetry;
5356
5357
5358         return rc;
5359 }
5360
5361 int
5362 CIFSSMBSetFSUnixInfo(const unsigned int xid, struct cifs_tcon *tcon, __u64 cap)
5363 {
5364 /* level 0x200  SMB_SET_CIFS_UNIX_INFO */
5365         TRANSACTION2_SETFSI_REQ *pSMB = NULL;
5366         TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
5367         int rc = 0;
5368         int bytes_returned = 0;
5369         __u16 params, param_offset, offset, byte_count;
5370
5371         cifs_dbg(FYI, "In SETFSUnixInfo\n");
5372 SETFSUnixRetry:
5373         /* BB switch to small buf init to save memory */
5374         rc = smb_init_no_reconnect(SMB_COM_TRANSACTION2, 15, tcon,
5375                                         (void **) &pSMB, (void **) &pSMBr);
5376         if (rc)
5377                 return rc;
5378
5379         params = 4;     /* 2 bytes zero followed by info level. */
5380         pSMB->MaxSetupCount = 0;
5381         pSMB->Reserved = 0;
5382         pSMB->Flags = 0;
5383         pSMB->Timeout = 0;
5384         pSMB->Reserved2 = 0;
5385         param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
5386                                 - 4;
5387         offset = param_offset + params;
5388
5389         pSMB->MaxParameterCount = cpu_to_le16(4);
5390         /* BB find exact max SMB PDU from sess structure BB */
5391         pSMB->MaxDataCount = cpu_to_le16(100);
5392         pSMB->SetupCount = 1;
5393         pSMB->Reserved3 = 0;
5394         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
5395         byte_count = 1 /* pad */ + params + 12;
5396
5397         pSMB->DataCount = cpu_to_le16(12);
5398         pSMB->ParameterCount = cpu_to_le16(params);
5399         pSMB->TotalDataCount = pSMB->DataCount;
5400         pSMB->TotalParameterCount = pSMB->ParameterCount;
5401         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5402         pSMB->DataOffset = cpu_to_le16(offset);
5403
5404         /* Params. */
5405         pSMB->FileNum = 0;
5406         pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
5407
5408         /* Data. */
5409         pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
5410         pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
5411         pSMB->ClientUnixCap = cpu_to_le64(cap);
5412
5413         inc_rfc1001_len(pSMB, byte_count);
5414         pSMB->ByteCount = cpu_to_le16(byte_count);
5415
5416         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5417                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5418         if (rc) {
5419                 cifs_dbg(VFS, "Send error in SETFSUnixInfo = %d\n", rc);
5420         } else {                /* decode response */
5421                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5422                 if (rc)
5423                         rc = -EIO;      /* bad smb */
5424         }
5425         cifs_buf_release(pSMB);
5426
5427         if (rc == -EAGAIN)
5428                 goto SETFSUnixRetry;
5429
5430         return rc;
5431 }
5432
5433
5434
5435 int
5436 CIFSSMBQFSPosixInfo(const unsigned int xid, struct cifs_tcon *tcon,
5437                    struct kstatfs *FSData)
5438 {
5439 /* level 0x201  SMB_QUERY_CIFS_POSIX_INFO */
5440         TRANSACTION2_QFSI_REQ *pSMB = NULL;
5441         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
5442         FILE_SYSTEM_POSIX_INFO *response_data;
5443         int rc = 0;
5444         int bytes_returned = 0;
5445         __u16 params, byte_count;
5446
5447         cifs_dbg(FYI, "In QFSPosixInfo\n");
5448 QFSPosixRetry:
5449         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5450                       (void **) &pSMBr);
5451         if (rc)
5452                 return rc;
5453
5454         params = 2;     /* level */
5455         pSMB->TotalDataCount = 0;
5456         pSMB->DataCount = 0;
5457         pSMB->DataOffset = 0;
5458         pSMB->MaxParameterCount = cpu_to_le16(2);
5459         /* BB find exact max SMB PDU from sess structure BB */
5460         pSMB->MaxDataCount = cpu_to_le16(100);
5461         pSMB->MaxSetupCount = 0;
5462         pSMB->Reserved = 0;
5463         pSMB->Flags = 0;
5464         pSMB->Timeout = 0;
5465         pSMB->Reserved2 = 0;
5466         byte_count = params + 1 /* pad */ ;
5467         pSMB->ParameterCount = cpu_to_le16(params);
5468         pSMB->TotalParameterCount = pSMB->ParameterCount;
5469         pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
5470                         smb_com_transaction2_qfsi_req, InformationLevel) - 4);
5471         pSMB->SetupCount = 1;
5472         pSMB->Reserved3 = 0;
5473         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
5474         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
5475         inc_rfc1001_len(pSMB, byte_count);
5476         pSMB->ByteCount = cpu_to_le16(byte_count);
5477
5478         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5479                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5480         if (rc) {
5481                 cifs_dbg(FYI, "Send error in QFSUnixInfo = %d\n", rc);
5482         } else {                /* decode response */
5483                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5484
5485                 if (rc || get_bcc(&pSMBr->hdr) < 13) {
5486                         rc = -EIO;      /* bad smb */
5487                 } else {
5488                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5489                         response_data =
5490                             (FILE_SYSTEM_POSIX_INFO
5491                              *) (((char *) &pSMBr->hdr.Protocol) +
5492                                  data_offset);
5493                         FSData->f_bsize =
5494                                         le32_to_cpu(response_data->BlockSize);
5495                         FSData->f_blocks =
5496                                         le64_to_cpu(response_data->TotalBlocks);
5497                         FSData->f_bfree =
5498                             le64_to_cpu(response_data->BlocksAvail);
5499                         if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
5500                                 FSData->f_bavail = FSData->f_bfree;
5501                         } else {
5502                                 FSData->f_bavail =
5503                                     le64_to_cpu(response_data->UserBlocksAvail);
5504                         }
5505                         if (response_data->TotalFileNodes != cpu_to_le64(-1))
5506                                 FSData->f_files =
5507                                      le64_to_cpu(response_data->TotalFileNodes);
5508                         if (response_data->FreeFileNodes != cpu_to_le64(-1))
5509                                 FSData->f_ffree =
5510                                       le64_to_cpu(response_data->FreeFileNodes);
5511                 }
5512         }
5513         cifs_buf_release(pSMB);
5514
5515         if (rc == -EAGAIN)
5516                 goto QFSPosixRetry;
5517
5518         return rc;
5519 }
5520
5521
5522 /*
5523  * We can not use write of zero bytes trick to set file size due to need for
5524  * large file support. Also note that this SetPathInfo is preferred to
5525  * SetFileInfo based method in next routine which is only needed to work around
5526  * a sharing violation bugin Samba which this routine can run into.
5527  */
5528 int
5529 CIFSSMBSetEOF(const unsigned int xid, struct cifs_tcon *tcon,
5530               const char *file_name, __u64 size, struct cifs_sb_info *cifs_sb,
5531               bool set_allocation)
5532 {
5533         struct smb_com_transaction2_spi_req *pSMB = NULL;
5534         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5535         struct file_end_of_file_info *parm_data;
5536         int name_len;
5537         int rc = 0;
5538         int bytes_returned = 0;
5539         int remap = cifs_remap(cifs_sb);
5540
5541         __u16 params, byte_count, data_count, param_offset, offset;
5542
5543         cifs_dbg(FYI, "In SetEOF\n");
5544 SetEOFRetry:
5545         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5546                       (void **) &pSMBr);
5547         if (rc)
5548                 return rc;
5549
5550         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5551                 name_len =
5552                     cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
5553                                        PATH_MAX, cifs_sb->local_nls, remap);
5554                 name_len++;     /* trailing null */
5555                 name_len *= 2;
5556         } else {        /* BB improve the check for buffer overruns BB */
5557                 name_len = strnlen(file_name, PATH_MAX);
5558                 name_len++;     /* trailing null */
5559                 strncpy(pSMB->FileName, file_name, name_len);
5560         }
5561         params = 6 + name_len;
5562         data_count = sizeof(struct file_end_of_file_info);
5563         pSMB->MaxParameterCount = cpu_to_le16(2);
5564         pSMB->MaxDataCount = cpu_to_le16(4100);
5565         pSMB->MaxSetupCount = 0;
5566         pSMB->Reserved = 0;
5567         pSMB->Flags = 0;
5568         pSMB->Timeout = 0;
5569         pSMB->Reserved2 = 0;
5570         param_offset = offsetof(struct smb_com_transaction2_spi_req,
5571                                 InformationLevel) - 4;
5572         offset = param_offset + params;
5573         if (set_allocation) {
5574                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5575                         pSMB->InformationLevel =
5576                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5577                 else
5578                         pSMB->InformationLevel =
5579                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5580         } else /* Set File Size */  {
5581             if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5582                     pSMB->InformationLevel =
5583                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5584             else
5585                     pSMB->InformationLevel =
5586                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5587         }
5588
5589         parm_data =
5590             (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
5591                                        offset);
5592         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5593         pSMB->DataOffset = cpu_to_le16(offset);
5594         pSMB->SetupCount = 1;
5595         pSMB->Reserved3 = 0;
5596         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5597         byte_count = 3 /* pad */  + params + data_count;
5598         pSMB->DataCount = cpu_to_le16(data_count);
5599         pSMB->TotalDataCount = pSMB->DataCount;
5600         pSMB->ParameterCount = cpu_to_le16(params);
5601         pSMB->TotalParameterCount = pSMB->ParameterCount;
5602         pSMB->Reserved4 = 0;
5603         inc_rfc1001_len(pSMB, byte_count);
5604         parm_data->FileSize = cpu_to_le64(size);
5605         pSMB->ByteCount = cpu_to_le16(byte_count);
5606         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5607                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5608         if (rc)
5609                 cifs_dbg(FYI, "SetPathInfo (file size) returned %d\n", rc);
5610
5611         cifs_buf_release(pSMB);
5612
5613         if (rc == -EAGAIN)
5614                 goto SetEOFRetry;
5615
5616         return rc;
5617 }
5618
5619 int
5620 CIFSSMBSetFileSize(const unsigned int xid, struct cifs_tcon *tcon,
5621                    struct cifsFileInfo *cfile, __u64 size, bool set_allocation)
5622 {
5623         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
5624         struct file_end_of_file_info *parm_data;
5625         int rc = 0;
5626         __u16 params, param_offset, offset, byte_count, count;
5627
5628         cifs_dbg(FYI, "SetFileSize (via SetFileInfo) %lld\n",
5629                  (long long)size);
5630         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5631
5632         if (rc)
5633                 return rc;
5634
5635         pSMB->hdr.Pid = cpu_to_le16((__u16)cfile->pid);
5636         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(cfile->pid >> 16));
5637
5638         params = 6;
5639         pSMB->MaxSetupCount = 0;
5640         pSMB->Reserved = 0;
5641         pSMB->Flags = 0;
5642         pSMB->Timeout = 0;
5643         pSMB->Reserved2 = 0;
5644         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5645         offset = param_offset + params;
5646
5647         count = sizeof(struct file_end_of_file_info);
5648         pSMB->MaxParameterCount = cpu_to_le16(2);
5649         /* BB find exact max SMB PDU from sess structure BB */
5650         pSMB->MaxDataCount = cpu_to_le16(1000);
5651         pSMB->SetupCount = 1;
5652         pSMB->Reserved3 = 0;
5653         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5654         byte_count = 3 /* pad */  + params + count;
5655         pSMB->DataCount = cpu_to_le16(count);
5656         pSMB->ParameterCount = cpu_to_le16(params);
5657         pSMB->TotalDataCount = pSMB->DataCount;
5658         pSMB->TotalParameterCount = pSMB->ParameterCount;
5659         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5660         parm_data =
5661                 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
5662                                 + offset);
5663         pSMB->DataOffset = cpu_to_le16(offset);
5664         parm_data->FileSize = cpu_to_le64(size);
5665         pSMB->Fid = cfile->fid.netfid;
5666         if (set_allocation) {
5667                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5668                         pSMB->InformationLevel =
5669                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
5670                 else
5671                         pSMB->InformationLevel =
5672                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
5673         } else /* Set File Size */  {
5674             if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5675                     pSMB->InformationLevel =
5676                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
5677             else
5678                     pSMB->InformationLevel =
5679                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
5680         }
5681         pSMB->Reserved4 = 0;
5682         inc_rfc1001_len(pSMB, byte_count);
5683         pSMB->ByteCount = cpu_to_le16(byte_count);
5684         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5685         cifs_small_buf_release(pSMB);
5686         if (rc) {
5687                 cifs_dbg(FYI, "Send error in SetFileInfo (SetFileSize) = %d\n",
5688                          rc);
5689         }
5690
5691         /* Note: On -EAGAIN error only caller can retry on handle based calls
5692                 since file handle passed in no longer valid */
5693
5694         return rc;
5695 }
5696
5697 /* Some legacy servers such as NT4 require that the file times be set on
5698    an open handle, rather than by pathname - this is awkward due to
5699    potential access conflicts on the open, but it is unavoidable for these
5700    old servers since the only other choice is to go from 100 nanosecond DCE
5701    time and resort to the original setpathinfo level which takes the ancient
5702    DOS time format with 2 second granularity */
5703 int
5704 CIFSSMBSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
5705                     const FILE_BASIC_INFO *data, __u16 fid, __u32 pid_of_opener)
5706 {
5707         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
5708         char *data_offset;
5709         int rc = 0;
5710         __u16 params, param_offset, offset, byte_count, count;
5711
5712         cifs_dbg(FYI, "Set Times (via SetFileInfo)\n");
5713         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5714
5715         if (rc)
5716                 return rc;
5717
5718         pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5719         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5720
5721         params = 6;
5722         pSMB->MaxSetupCount = 0;
5723         pSMB->Reserved = 0;
5724         pSMB->Flags = 0;
5725         pSMB->Timeout = 0;
5726         pSMB->Reserved2 = 0;
5727         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5728         offset = param_offset + params;
5729
5730         data_offset = (char *)pSMB +
5731                         offsetof(struct smb_hdr, Protocol) + offset;
5732
5733         count = sizeof(FILE_BASIC_INFO);
5734         pSMB->MaxParameterCount = cpu_to_le16(2);
5735         /* BB find max SMB PDU from sess */
5736         pSMB->MaxDataCount = cpu_to_le16(1000);
5737         pSMB->SetupCount = 1;
5738         pSMB->Reserved3 = 0;
5739         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5740         byte_count = 3 /* pad */  + params + count;
5741         pSMB->DataCount = cpu_to_le16(count);
5742         pSMB->ParameterCount = cpu_to_le16(params);
5743         pSMB->TotalDataCount = pSMB->DataCount;
5744         pSMB->TotalParameterCount = pSMB->ParameterCount;
5745         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5746         pSMB->DataOffset = cpu_to_le16(offset);
5747         pSMB->Fid = fid;
5748         if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5749                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5750         else
5751                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5752         pSMB->Reserved4 = 0;
5753         inc_rfc1001_len(pSMB, byte_count);
5754         pSMB->ByteCount = cpu_to_le16(byte_count);
5755         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5756         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5757         cifs_small_buf_release(pSMB);
5758         if (rc)
5759                 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
5760                          rc);
5761
5762         /* Note: On -EAGAIN error only caller can retry on handle based calls
5763                 since file handle passed in no longer valid */
5764
5765         return rc;
5766 }
5767
5768 int
5769 CIFSSMBSetFileDisposition(const unsigned int xid, struct cifs_tcon *tcon,
5770                           bool delete_file, __u16 fid, __u32 pid_of_opener)
5771 {
5772         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
5773         char *data_offset;
5774         int rc = 0;
5775         __u16 params, param_offset, offset, byte_count, count;
5776
5777         cifs_dbg(FYI, "Set File Disposition (via SetFileInfo)\n");
5778         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
5779
5780         if (rc)
5781                 return rc;
5782
5783         pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
5784         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
5785
5786         params = 6;
5787         pSMB->MaxSetupCount = 0;
5788         pSMB->Reserved = 0;
5789         pSMB->Flags = 0;
5790         pSMB->Timeout = 0;
5791         pSMB->Reserved2 = 0;
5792         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
5793         offset = param_offset + params;
5794
5795         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5796
5797         count = 1;
5798         pSMB->MaxParameterCount = cpu_to_le16(2);
5799         /* BB find max SMB PDU from sess */
5800         pSMB->MaxDataCount = cpu_to_le16(1000);
5801         pSMB->SetupCount = 1;
5802         pSMB->Reserved3 = 0;
5803         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
5804         byte_count = 3 /* pad */  + params + count;
5805         pSMB->DataCount = cpu_to_le16(count);
5806         pSMB->ParameterCount = cpu_to_le16(params);
5807         pSMB->TotalDataCount = pSMB->DataCount;
5808         pSMB->TotalParameterCount = pSMB->ParameterCount;
5809         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5810         pSMB->DataOffset = cpu_to_le16(offset);
5811         pSMB->Fid = fid;
5812         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_DISPOSITION_INFO);
5813         pSMB->Reserved4 = 0;
5814         inc_rfc1001_len(pSMB, byte_count);
5815         pSMB->ByteCount = cpu_to_le16(byte_count);
5816         *data_offset = delete_file ? 1 : 0;
5817         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
5818         cifs_small_buf_release(pSMB);
5819         if (rc)
5820                 cifs_dbg(FYI, "Send error in SetFileDisposition = %d\n", rc);
5821
5822         return rc;
5823 }
5824
5825 int
5826 CIFSSMBSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
5827                    const char *fileName, const FILE_BASIC_INFO *data,
5828                    const struct nls_table *nls_codepage, int remap)
5829 {
5830         TRANSACTION2_SPI_REQ *pSMB = NULL;
5831         TRANSACTION2_SPI_RSP *pSMBr = NULL;
5832         int name_len;
5833         int rc = 0;
5834         int bytes_returned = 0;
5835         char *data_offset;
5836         __u16 params, param_offset, offset, byte_count, count;
5837
5838         cifs_dbg(FYI, "In SetTimes\n");
5839
5840 SetTimesRetry:
5841         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5842                       (void **) &pSMBr);
5843         if (rc)
5844                 return rc;
5845
5846         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5847                 name_len =
5848                     cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
5849                                        PATH_MAX, nls_codepage, remap);
5850                 name_len++;     /* trailing null */
5851                 name_len *= 2;
5852         } else {        /* BB improve the check for buffer overruns BB */
5853                 name_len = strnlen(fileName, PATH_MAX);
5854                 name_len++;     /* trailing null */
5855                 strncpy(pSMB->FileName, fileName, name_len);
5856         }
5857
5858         params = 6 + name_len;
5859         count = sizeof(FILE_BASIC_INFO);
5860         pSMB->MaxParameterCount = cpu_to_le16(2);
5861         /* BB find max SMB PDU from sess structure BB */
5862         pSMB->MaxDataCount = cpu_to_le16(1000);
5863         pSMB->MaxSetupCount = 0;
5864         pSMB->Reserved = 0;
5865         pSMB->Flags = 0;
5866         pSMB->Timeout = 0;
5867         pSMB->Reserved2 = 0;
5868         param_offset = offsetof(struct smb_com_transaction2_spi_req,
5869                                 InformationLevel) - 4;
5870         offset = param_offset + params;
5871         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
5872         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5873         pSMB->DataOffset = cpu_to_le16(offset);
5874         pSMB->SetupCount = 1;
5875         pSMB->Reserved3 = 0;
5876         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5877         byte_count = 3 /* pad */  + params + count;
5878
5879         pSMB->DataCount = cpu_to_le16(count);
5880         pSMB->ParameterCount = cpu_to_le16(params);
5881         pSMB->TotalDataCount = pSMB->DataCount;
5882         pSMB->TotalParameterCount = pSMB->ParameterCount;
5883         if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
5884                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
5885         else
5886                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
5887         pSMB->Reserved4 = 0;
5888         inc_rfc1001_len(pSMB, byte_count);
5889         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
5890         pSMB->ByteCount = cpu_to_le16(byte_count);
5891         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5892                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5893         if (rc)
5894                 cifs_dbg(FYI, "SetPathInfo (times) returned %d\n", rc);
5895
5896         cifs_buf_release(pSMB);
5897
5898         if (rc == -EAGAIN)
5899                 goto SetTimesRetry;
5900
5901         return rc;
5902 }
5903
5904 /* Can not be used to set time stamps yet (due to old DOS time format) */
5905 /* Can be used to set attributes */
5906 #if 0  /* Possibly not needed - since it turns out that strangely NT4 has a bug
5907           handling it anyway and NT4 was what we thought it would be needed for
5908           Do not delete it until we prove whether needed for Win9x though */
5909 int
5910 CIFSSMBSetAttrLegacy(unsigned int xid, struct cifs_tcon *tcon, char *fileName,
5911                 __u16 dos_attrs, const struct nls_table *nls_codepage)
5912 {
5913         SETATTR_REQ *pSMB = NULL;
5914         SETATTR_RSP *pSMBr = NULL;
5915         int rc = 0;
5916         int bytes_returned;
5917         int name_len;
5918
5919         cifs_dbg(FYI, "In SetAttrLegacy\n");
5920
5921 SetAttrLgcyRetry:
5922         rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
5923                       (void **) &pSMBr);
5924         if (rc)
5925                 return rc;
5926
5927         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5928                 name_len =
5929                         ConvertToUTF16((__le16 *) pSMB->fileName, fileName,
5930                                        PATH_MAX, nls_codepage);
5931                 name_len++;     /* trailing null */
5932                 name_len *= 2;
5933         } else {        /* BB improve the check for buffer overruns BB */
5934                 name_len = strnlen(fileName, PATH_MAX);
5935                 name_len++;     /* trailing null */
5936                 strncpy(pSMB->fileName, fileName, name_len);
5937         }
5938         pSMB->attr = cpu_to_le16(dos_attrs);
5939         pSMB->BufferFormat = 0x04;
5940         inc_rfc1001_len(pSMB, name_len + 1);
5941         pSMB->ByteCount = cpu_to_le16(name_len + 1);
5942         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5943                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5944         if (rc)
5945                 cifs_dbg(FYI, "Error in LegacySetAttr = %d\n", rc);
5946
5947         cifs_buf_release(pSMB);
5948
5949         if (rc == -EAGAIN)
5950                 goto SetAttrLgcyRetry;
5951
5952         return rc;
5953 }
5954 #endif /* temporarily unneeded SetAttr legacy function */
5955
5956 static void
5957 cifs_fill_unix_set_info(FILE_UNIX_BASIC_INFO *data_offset,
5958                         const struct cifs_unix_set_info_args *args)
5959 {
5960         u64 uid = NO_CHANGE_64, gid = NO_CHANGE_64;
5961         u64 mode = args->mode;
5962
5963         if (uid_valid(args->uid))
5964                 uid = from_kuid(&init_user_ns, args->uid);
5965         if (gid_valid(args->gid))
5966                 gid = from_kgid(&init_user_ns, args->gid);
5967
5968         /*
5969          * Samba server ignores set of file size to zero due to bugs in some
5970          * older clients, but we should be precise - we use SetFileSize to
5971          * set file size and do not want to truncate file size to zero
5972          * accidentally as happened on one Samba server beta by putting
5973          * zero instead of -1 here
5974          */
5975         data_offset->EndOfFile = cpu_to_le64(NO_CHANGE_64);
5976         data_offset->NumOfBytes = cpu_to_le64(NO_CHANGE_64);
5977         data_offset->LastStatusChange = cpu_to_le64(args->ctime);
5978         data_offset->LastAccessTime = cpu_to_le64(args->atime);
5979         data_offset->LastModificationTime = cpu_to_le64(args->mtime);
5980         data_offset->Uid = cpu_to_le64(uid);
5981         data_offset->Gid = cpu_to_le64(gid);
5982         /* better to leave device as zero when it is  */
5983         data_offset->DevMajor = cpu_to_le64(MAJOR(args->device));
5984         data_offset->DevMinor = cpu_to_le64(MINOR(args->device));
5985         data_offset->Permissions = cpu_to_le64(mode);
5986
5987         if (S_ISREG(mode))
5988                 data_offset->Type = cpu_to_le32(UNIX_FILE);
5989         else if (S_ISDIR(mode))
5990                 data_offset->Type = cpu_to_le32(UNIX_DIR);
5991         else if (S_ISLNK(mode))
5992                 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5993         else if (S_ISCHR(mode))
5994                 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5995         else if (S_ISBLK(mode))
5996                 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5997         else if (S_ISFIFO(mode))
5998                 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5999         else if (S_ISSOCK(mode))
6000                 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
6001 }
6002
6003 int
6004 CIFSSMBUnixSetFileInfo(const unsigned int xid, struct cifs_tcon *tcon,
6005                        const struct cifs_unix_set_info_args *args,
6006                        u16 fid, u32 pid_of_opener)
6007 {
6008         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
6009         char *data_offset;
6010         int rc = 0;
6011         u16 params, param_offset, offset, byte_count, count;
6012
6013         cifs_dbg(FYI, "Set Unix Info (via SetFileInfo)\n");
6014         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
6015
6016         if (rc)
6017                 return rc;
6018
6019         pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
6020         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
6021
6022         params = 6;
6023         pSMB->MaxSetupCount = 0;
6024         pSMB->Reserved = 0;
6025         pSMB->Flags = 0;
6026         pSMB->Timeout = 0;
6027         pSMB->Reserved2 = 0;
6028         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
6029         offset = param_offset + params;
6030
6031         data_offset = (char *)pSMB +
6032                         offsetof(struct smb_hdr, Protocol) + offset;
6033
6034         count = sizeof(FILE_UNIX_BASIC_INFO);
6035
6036         pSMB->MaxParameterCount = cpu_to_le16(2);
6037         /* BB find max SMB PDU from sess */
6038         pSMB->MaxDataCount = cpu_to_le16(1000);
6039         pSMB->SetupCount = 1;
6040         pSMB->Reserved3 = 0;
6041         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
6042         byte_count = 3 /* pad */  + params + count;
6043         pSMB->DataCount = cpu_to_le16(count);
6044         pSMB->ParameterCount = cpu_to_le16(params);
6045         pSMB->TotalDataCount = pSMB->DataCount;
6046         pSMB->TotalParameterCount = pSMB->ParameterCount;
6047         pSMB->ParameterOffset = cpu_to_le16(param_offset);
6048         pSMB->DataOffset = cpu_to_le16(offset);
6049         pSMB->Fid = fid;
6050         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6051         pSMB->Reserved4 = 0;
6052         inc_rfc1001_len(pSMB, byte_count);
6053         pSMB->ByteCount = cpu_to_le16(byte_count);
6054
6055         cifs_fill_unix_set_info((FILE_UNIX_BASIC_INFO *)data_offset, args);
6056
6057         rc = SendReceiveNoRsp(xid, tcon->ses, (char *) pSMB, 0);
6058         cifs_small_buf_release(pSMB);
6059         if (rc)
6060                 cifs_dbg(FYI, "Send error in Set Time (SetFileInfo) = %d\n",
6061                          rc);
6062
6063         /* Note: On -EAGAIN error only caller can retry on handle based calls
6064                 since file handle passed in no longer valid */
6065
6066         return rc;
6067 }
6068
6069 int
6070 CIFSSMBUnixSetPathInfo(const unsigned int xid, struct cifs_tcon *tcon,
6071                        const char *file_name,
6072                        const struct cifs_unix_set_info_args *args,
6073                        const struct nls_table *nls_codepage, int remap)
6074 {
6075         TRANSACTION2_SPI_REQ *pSMB = NULL;
6076         TRANSACTION2_SPI_RSP *pSMBr = NULL;
6077         int name_len;
6078         int rc = 0;
6079         int bytes_returned = 0;
6080         FILE_UNIX_BASIC_INFO *data_offset;
6081         __u16 params, param_offset, offset, count, byte_count;
6082
6083         cifs_dbg(FYI, "In SetUID/GID/Mode\n");
6084 setPermsRetry:
6085         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6086                       (void **) &pSMBr);
6087         if (rc)
6088                 return rc;
6089
6090         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6091                 name_len =
6092                     cifsConvertToUTF16((__le16 *) pSMB->FileName, file_name,
6093                                        PATH_MAX, nls_codepage, remap);
6094                 name_len++;     /* trailing null */
6095                 name_len *= 2;
6096         } else {        /* BB improve the check for buffer overruns BB */
6097                 name_len = strnlen(file_name, PATH_MAX);
6098                 name_len++;     /* trailing null */
6099                 strncpy(pSMB->FileName, file_name, name_len);
6100         }
6101
6102         params = 6 + name_len;
6103         count = sizeof(FILE_UNIX_BASIC_INFO);
6104         pSMB->MaxParameterCount = cpu_to_le16(2);
6105         /* BB find max SMB PDU from sess structure BB */
6106         pSMB->MaxDataCount = cpu_to_le16(1000);
6107         pSMB->MaxSetupCount = 0;
6108         pSMB->Reserved = 0;
6109         pSMB->Flags = 0;
6110         pSMB->Timeout = 0;
6111         pSMB->Reserved2 = 0;
6112         param_offset = offsetof(struct smb_com_transaction2_spi_req,
6113                                 InformationLevel) - 4;
6114         offset = param_offset + params;
6115         data_offset =
6116             (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
6117                                       offset);
6118         memset(data_offset, 0, count);
6119         pSMB->DataOffset = cpu_to_le16(offset);
6120         pSMB->ParameterOffset = cpu_to_le16(param_offset);
6121         pSMB->SetupCount = 1;
6122         pSMB->Reserved3 = 0;
6123         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6124         byte_count = 3 /* pad */  + params + count;
6125         pSMB->ParameterCount = cpu_to_le16(params);
6126         pSMB->DataCount = cpu_to_le16(count);
6127         pSMB->TotalParameterCount = pSMB->ParameterCount;
6128         pSMB->TotalDataCount = pSMB->DataCount;
6129         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
6130         pSMB->Reserved4 = 0;
6131         inc_rfc1001_len(pSMB, byte_count);
6132
6133         cifs_fill_unix_set_info(data_offset, args);
6134
6135         pSMB->ByteCount = cpu_to_le16(byte_count);
6136         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6137                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6138         if (rc)
6139                 cifs_dbg(FYI, "SetPathInfo (perms) returned %d\n", rc);
6140
6141         cifs_buf_release(pSMB);
6142         if (rc == -EAGAIN)
6143                 goto setPermsRetry;
6144         return rc;
6145 }
6146
6147 #ifdef CONFIG_CIFS_XATTR
6148 /*
6149  * Do a path-based QUERY_ALL_EAS call and parse the result. This is a common
6150  * function used by listxattr and getxattr type calls. When ea_name is set,
6151  * it looks for that attribute name and stuffs that value into the EAData
6152  * buffer. When ea_name is NULL, it stuffs a list of attribute names into the
6153  * buffer. In both cases, the return value is either the length of the
6154  * resulting data or a negative error code. If EAData is a NULL pointer then
6155  * the data isn't copied to it, but the length is returned.
6156  */
6157 ssize_t
6158 CIFSSMBQAllEAs(const unsigned int xid, struct cifs_tcon *tcon,
6159                 const unsigned char *searchName, const unsigned char *ea_name,
6160                 char *EAData, size_t buf_size,
6161                 struct cifs_sb_info *cifs_sb)
6162 {
6163                 /* BB assumes one setup word */
6164         TRANSACTION2_QPI_REQ *pSMB = NULL;
6165         TRANSACTION2_QPI_RSP *pSMBr = NULL;
6166         int remap = cifs_remap(cifs_sb);
6167         struct nls_table *nls_codepage = cifs_sb->local_nls;
6168         int rc = 0;
6169         int bytes_returned;
6170         int list_len;
6171         struct fealist *ea_response_data;
6172         struct fea *temp_fea;
6173         char *temp_ptr;
6174         char *end_of_smb;
6175         __u16 params, byte_count, data_offset;
6176         unsigned int ea_name_len = ea_name ? strlen(ea_name) : 0;
6177
6178         cifs_dbg(FYI, "In Query All EAs path %s\n", searchName);
6179 QAllEAsRetry:
6180         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6181                       (void **) &pSMBr);
6182         if (rc)
6183                 return rc;
6184
6185         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6186                 list_len =
6187                     cifsConvertToUTF16((__le16 *) pSMB->FileName, searchName,
6188                                        PATH_MAX, nls_codepage, remap);
6189                 list_len++;     /* trailing null */
6190                 list_len *= 2;
6191         } else {        /* BB improve the check for buffer overruns BB */
6192                 list_len = strnlen(searchName, PATH_MAX);
6193                 list_len++;     /* trailing null */
6194                 strncpy(pSMB->FileName, searchName, list_len);
6195         }
6196
6197         params = 2 /* level */ + 4 /* reserved */ + list_len /* includes NUL */;
6198         pSMB->TotalDataCount = 0;
6199         pSMB->MaxParameterCount = cpu_to_le16(2);
6200         /* BB find exact max SMB PDU from sess structure BB */
6201         pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
6202         pSMB->MaxSetupCount = 0;
6203         pSMB->Reserved = 0;
6204         pSMB->Flags = 0;
6205         pSMB->Timeout = 0;
6206         pSMB->Reserved2 = 0;
6207         pSMB->ParameterOffset = cpu_to_le16(offsetof(
6208         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
6209         pSMB->DataCount = 0;
6210         pSMB->DataOffset = 0;
6211         pSMB->SetupCount = 1;
6212         pSMB->Reserved3 = 0;
6213         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
6214         byte_count = params + 1 /* pad */ ;
6215         pSMB->TotalParameterCount = cpu_to_le16(params);
6216         pSMB->ParameterCount = pSMB->TotalParameterCount;
6217         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
6218         pSMB->Reserved4 = 0;
6219         inc_rfc1001_len(pSMB, byte_count);
6220         pSMB->ByteCount = cpu_to_le16(byte_count);
6221
6222         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6223                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6224         if (rc) {
6225                 cifs_dbg(FYI, "Send error in QueryAllEAs = %d\n", rc);
6226                 goto QAllEAsOut;
6227         }
6228
6229
6230         /* BB also check enough total bytes returned */
6231         /* BB we need to improve the validity checking
6232         of these trans2 responses */
6233
6234         rc = validate_t2((struct smb_t2_rsp *)pSMBr);
6235         if (rc || get_bcc(&pSMBr->hdr) < 4) {
6236                 rc = -EIO;      /* bad smb */
6237                 goto QAllEAsOut;
6238         }
6239
6240         /* check that length of list is not more than bcc */
6241         /* check that each entry does not go beyond length
6242            of list */
6243         /* check that each element of each entry does not
6244            go beyond end of list */
6245         /* validate_trans2_offsets() */
6246         /* BB check if start of smb + data_offset > &bcc+ bcc */
6247
6248         data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
6249         ea_response_data = (struct fealist *)
6250                                 (((char *) &pSMBr->hdr.Protocol) + data_offset);
6251
6252         list_len = le32_to_cpu(ea_response_data->list_len);
6253         cifs_dbg(FYI, "ea length %d\n", list_len);
6254         if (list_len <= 8) {
6255                 cifs_dbg(FYI, "empty EA list returned from server\n");
6256                 /* didn't find the named attribute */
6257                 if (ea_name)
6258                         rc = -ENODATA;
6259                 goto QAllEAsOut;
6260         }
6261
6262         /* make sure list_len doesn't go past end of SMB */
6263         end_of_smb = (char *)pByteArea(&pSMBr->hdr) + get_bcc(&pSMBr->hdr);
6264         if ((char *)ea_response_data + list_len > end_of_smb) {
6265                 cifs_dbg(FYI, "EA list appears to go beyond SMB\n");
6266                 rc = -EIO;
6267                 goto QAllEAsOut;
6268         }
6269
6270         /* account for ea list len */
6271         list_len -= 4;
6272         temp_fea = ea_response_data->list;
6273         temp_ptr = (char *)temp_fea;
6274         while (list_len > 0) {
6275                 unsigned int name_len;
6276                 __u16 value_len;
6277
6278                 list_len -= 4;
6279                 temp_ptr += 4;
6280                 /* make sure we can read name_len and value_len */
6281                 if (list_len < 0) {
6282                         cifs_dbg(FYI, "EA entry goes beyond length of list\n");
6283                         rc = -EIO;
6284                         goto QAllEAsOut;
6285                 }
6286
6287                 name_len = temp_fea->name_len;
6288                 value_len = le16_to_cpu(temp_fea->value_len);
6289                 list_len -= name_len + 1 + value_len;
6290                 if (list_len < 0) {
6291                         cifs_dbg(FYI, "EA entry goes beyond length of list\n");
6292                         rc = -EIO;
6293                         goto QAllEAsOut;
6294                 }
6295
6296                 if (ea_name) {
6297                         if (ea_name_len == name_len &&
6298                             memcmp(ea_name, temp_ptr, name_len) == 0) {
6299                                 temp_ptr += name_len + 1;
6300                                 rc = value_len;
6301                                 if (buf_size == 0)
6302                                         goto QAllEAsOut;
6303                                 if ((size_t)value_len > buf_size) {
6304                                         rc = -ERANGE;
6305                                         goto QAllEAsOut;
6306                                 }
6307                                 memcpy(EAData, temp_ptr, value_len);
6308                                 goto QAllEAsOut;
6309                         }
6310                 } else {
6311                         /* account for prefix user. and trailing null */
6312                         rc += (5 + 1 + name_len);
6313                         if (rc < (int) buf_size) {
6314                                 memcpy(EAData, "user.", 5);
6315                                 EAData += 5;
6316                                 memcpy(EAData, temp_ptr, name_len);
6317                                 EAData += name_len;
6318                                 /* null terminate name */
6319                                 *EAData = 0;
6320                                 ++EAData;
6321                         } else if (buf_size == 0) {
6322                                 /* skip copy - calc size only */
6323                         } else {
6324                                 /* stop before overrun buffer */
6325                                 rc = -ERANGE;
6326                                 break;
6327                         }
6328                 }
6329                 temp_ptr += name_len + 1 + value_len;
6330                 temp_fea = (struct fea *)temp_ptr;
6331         }
6332
6333         /* didn't find the named attribute */
6334         if (ea_name)
6335                 rc = -ENODATA;
6336
6337 QAllEAsOut:
6338         cifs_buf_release(pSMB);
6339         if (rc == -EAGAIN)
6340                 goto QAllEAsRetry;
6341
6342         return (ssize_t)rc;
6343 }
6344
6345 int
6346 CIFSSMBSetEA(const unsigned int xid, struct cifs_tcon *tcon,
6347              const char *fileName, const char *ea_name, const void *ea_value,
6348              const __u16 ea_value_len, const struct nls_table *nls_codepage,
6349              struct cifs_sb_info *cifs_sb)
6350 {
6351         struct smb_com_transaction2_spi_req *pSMB = NULL;
6352         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
6353         struct fealist *parm_data;
6354         int name_len;
6355         int rc = 0;
6356         int bytes_returned = 0;
6357         __u16 params, param_offset, byte_count, offset, count;
6358         int remap = cifs_remap(cifs_sb);
6359
6360         cifs_dbg(FYI, "In SetEA\n");
6361 SetEARetry:
6362         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
6363                       (void **) &pSMBr);
6364         if (rc)
6365                 return rc;
6366
6367         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
6368                 name_len =
6369                     cifsConvertToUTF16((__le16 *) pSMB->FileName, fileName,
6370                                        PATH_MAX, nls_codepage, remap);
6371                 name_len++;     /* trailing null */
6372                 name_len *= 2;
6373         } else {        /* BB improve the check for buffer overruns BB */
6374                 name_len = strnlen(fileName, PATH_MAX);
6375                 name_len++;     /* trailing null */
6376                 strncpy(pSMB->FileName, fileName, name_len);
6377         }
6378
6379         params = 6 + name_len;
6380
6381         /* done calculating parms using name_len of file name,
6382         now use name_len to calculate length of ea name
6383         we are going to create in the inode xattrs */
6384         if (ea_name == NULL)
6385                 name_len = 0;
6386         else
6387                 name_len = strnlen(ea_name, 255);
6388
6389         count = sizeof(*parm_data) + ea_value_len + name_len;
6390         pSMB->MaxParameterCount = cpu_to_le16(2);
6391         /* BB find max SMB PDU from sess */
6392         pSMB->MaxDataCount = cpu_to_le16(1000);
6393         pSMB->MaxSetupCount = 0;
6394         pSMB->Reserved = 0;
6395         pSMB->Flags = 0;
6396         pSMB->Timeout = 0;
6397         pSMB->Reserved2 = 0;
6398         param_offset = offsetof(struct smb_com_transaction2_spi_req,
6399                                 InformationLevel) - 4;
6400         offset = param_offset + params;
6401         pSMB->InformationLevel =
6402                 cpu_to_le16(SMB_SET_FILE_EA);
6403
6404         parm_data = (void *)pSMB + offsetof(struct smb_hdr, Protocol) + offset;
6405         pSMB->ParameterOffset = cpu_to_le16(param_offset);
6406         pSMB->DataOffset = cpu_to_le16(offset);
6407         pSMB->SetupCount = 1;
6408         pSMB->Reserved3 = 0;
6409         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
6410         byte_count = 3 /* pad */  + params + count;
6411         pSMB->DataCount = cpu_to_le16(count);
6412         parm_data->list_len = cpu_to_le32(count);
6413         parm_data->list[0].EA_flags = 0;
6414         /* we checked above that name len is less than 255 */
6415         parm_data->list[0].name_len = (__u8)name_len;
6416         /* EA names are always ASCII */
6417         if (ea_name)
6418                 strncpy(parm_data->list[0].name, ea_name, name_len);
6419         parm_data->list[0].name[name_len] = 0;
6420         parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
6421         /* caller ensures that ea_value_len is less than 64K but
6422         we need to ensure that it fits within the smb */
6423
6424         /*BB add length check to see if it would fit in
6425              negotiated SMB buffer size BB */
6426         /* if (ea_value_len > buffer_size - 512 (enough for header)) */
6427         if (ea_value_len)
6428                 memcpy(parm_data->list[0].name+name_len+1,
6429                        ea_value, ea_value_len);
6430
6431         pSMB->TotalDataCount = pSMB->DataCount;
6432         pSMB->ParameterCount = cpu_to_le16(params);
6433         pSMB->TotalParameterCount = pSMB->ParameterCount;
6434         pSMB->Reserved4 = 0;
6435         inc_rfc1001_len(pSMB, byte_count);
6436         pSMB->ByteCount = cpu_to_le16(byte_count);
6437         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6438                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
6439         if (rc)
6440                 cifs_dbg(FYI, "SetPathInfo (EA) returned %d\n", rc);
6441
6442         cifs_buf_release(pSMB);
6443
6444         if (rc == -EAGAIN)
6445                 goto SetEARetry;
6446
6447         return rc;
6448 }
6449 #endif
6450
6451 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* BB unused temporarily */
6452 /*
6453  *      Years ago the kernel added a "dnotify" function for Samba server,
6454  *      to allow network clients (such as Windows) to display updated
6455  *      lists of files in directory listings automatically when
6456  *      files are added by one user when another user has the
6457  *      same directory open on their desktop.  The Linux cifs kernel
6458  *      client hooked into the kernel side of this interface for
6459  *      the same reason, but ironically when the VFS moved from
6460  *      "dnotify" to "inotify" it became harder to plug in Linux
6461  *      network file system clients (the most obvious use case
6462  *      for notify interfaces is when multiple users can update
6463  *      the contents of the same directory - exactly what network
6464  *      file systems can do) although the server (Samba) could
6465  *      still use it.  For the short term we leave the worker
6466  *      function ifdeffed out (below) until inotify is fixed
6467  *      in the VFS to make it easier to plug in network file
6468  *      system clients.  If inotify turns out to be permanently
6469  *      incompatible for network fs clients, we could instead simply
6470  *      expose this config flag by adding a future cifs (and smb2) notify ioctl.
6471  */
6472 int CIFSSMBNotify(const unsigned int xid, struct cifs_tcon *tcon,
6473                   const int notify_subdirs, const __u16 netfid,
6474                   __u32 filter, struct file *pfile, int multishot,
6475                   const struct nls_table *nls_codepage)
6476 {
6477         int rc = 0;
6478         struct smb_com_transaction_change_notify_req *pSMB = NULL;
6479         struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
6480         struct dir_notify_req *dnotify_req;
6481         int bytes_returned;
6482
6483         cifs_dbg(FYI, "In CIFSSMBNotify for file handle %d\n", (int)netfid);
6484         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
6485                       (void **) &pSMBr);
6486         if (rc)
6487                 return rc;
6488
6489         pSMB->TotalParameterCount = 0 ;
6490         pSMB->TotalDataCount = 0;
6491         pSMB->MaxParameterCount = cpu_to_le32(2);
6492         pSMB->MaxDataCount = cpu_to_le32(CIFSMaxBufSize & 0xFFFFFF00);
6493         pSMB->MaxSetupCount = 4;
6494         pSMB->Reserved = 0;
6495         pSMB->ParameterOffset = 0;
6496         pSMB->DataCount = 0;
6497         pSMB->DataOffset = 0;
6498         pSMB->SetupCount = 4; /* single byte does not need le conversion */
6499         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
6500         pSMB->ParameterCount = pSMB->TotalParameterCount;
6501         if (notify_subdirs)
6502                 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
6503         pSMB->Reserved2 = 0;
6504         pSMB->CompletionFilter = cpu_to_le32(filter);
6505         pSMB->Fid = netfid; /* file handle always le */
6506         pSMB->ByteCount = 0;
6507
6508         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
6509                          (struct smb_hdr *)pSMBr, &bytes_returned,
6510                          CIFS_ASYNC_OP);
6511         if (rc) {
6512                 cifs_dbg(FYI, "Error in Notify = %d\n", rc);
6513         } else {
6514                 /* Add file to outstanding requests */
6515                 /* BB change to kmem cache alloc */
6516                 dnotify_req = kmalloc(
6517                                                 sizeof(struct dir_notify_req),
6518                                                  GFP_KERNEL);
6519                 if (dnotify_req) {
6520                         dnotify_req->Pid = pSMB->hdr.Pid;
6521                         dnotify_req->PidHigh = pSMB->hdr.PidHigh;
6522                         dnotify_req->Mid = pSMB->hdr.Mid;
6523                         dnotify_req->Tid = pSMB->hdr.Tid;
6524                         dnotify_req->Uid = pSMB->hdr.Uid;
6525                         dnotify_req->netfid = netfid;
6526                         dnotify_req->pfile = pfile;
6527                         dnotify_req->filter = filter;
6528                         dnotify_req->multishot = multishot;
6529                         spin_lock(&GlobalMid_Lock);
6530                         list_add_tail(&dnotify_req->lhead,
6531                                         &GlobalDnotifyReqList);
6532                         spin_unlock(&GlobalMid_Lock);
6533                 } else
6534                         rc = -ENOMEM;
6535         }
6536         cifs_buf_release(pSMB);
6537         return rc;
6538 }
6539 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */