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