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