fs/cifs/cifssmb.c

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