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