fs/cifs/cifssmb.c

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