fs/cifs/cifssmb.c

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