SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 == FALSE) ||
 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 == FALSE) ||
 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 int
1170 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
1171             const char *fileName, const int openDisposition,
1172             const int access_flags, const int create_options, __u16 *netfid,
1173             int *pOplock, FILE_ALL_INFO *pfile_info,
1174             const struct nls_table *nls_codepage, int remap)
1175 {
1176         int rc = -EACCES;
1177         OPENX_REQ *pSMB = NULL;
1178         OPENX_RSP *pSMBr = NULL;
1179         int bytes_returned;
1180         int name_len;
1181         __u16 count;
1182
1183 OldOpenRetry:
1184         rc = smb_init(SMB_COM_OPEN_ANDX, 15, tcon, (void **) &pSMB,
1185                       (void **) &pSMBr);
1186         if (rc)
1187                 return rc;
1188
1189         pSMB->AndXCommand = 0xFF;       /* none */
1190
1191         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1192                 count = 1;      /* account for one byte pad to word boundary */
1193                 name_len =
1194                    cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1195                                     fileName, PATH_MAX, nls_codepage, remap);
1196                 name_len++;     /* trailing null */
1197                 name_len *= 2;
1198         } else {                /* BB improve check for buffer overruns BB */
1199                 count = 0;      /* no pad */
1200                 name_len = strnlen(fileName, PATH_MAX);
1201                 name_len++;     /* trailing null */
1202                 strncpy(pSMB->fileName, fileName, name_len);
1203         }
1204         if (*pOplock & REQ_OPLOCK)
1205                 pSMB->OpenFlags = cpu_to_le16(REQ_OPLOCK);
1206         else if (*pOplock & REQ_BATCHOPLOCK)
1207                 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
1208
1209         pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
1210         /* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
1211         /* 0 = read
1212            1 = write
1213            2 = rw
1214            3 = execute
1215          */
1216         pSMB->Mode = cpu_to_le16(2);
1217         pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
1218         /* set file as system file if special file such
1219            as fifo and server expecting SFU style and
1220            no Unix extensions */
1221
1222         if (create_options & CREATE_OPTION_SPECIAL)
1223                 pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
1224         else /* BB FIXME BB */
1225                 pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
1226
1227         /* if ((omode & S_IWUGO) == 0)
1228                 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
1229         /*  Above line causes problems due to vfs splitting create into two
1230             pieces - need to set mode after file created not while it is
1231             being created */
1232
1233         /* BB FIXME BB */
1234 /*      pSMB->CreateOptions = cpu_to_le32(create_options &
1235                                                  CREATE_OPTIONS_MASK); */
1236         /* BB FIXME END BB */
1237
1238         pSMB->Sattr = cpu_to_le16(ATTR_HIDDEN | ATTR_SYSTEM | ATTR_DIRECTORY);
1239         pSMB->OpenFunction = cpu_to_le16(convert_disposition(openDisposition));
1240         count += name_len;
1241         pSMB->hdr.smb_buf_length += count;
1242
1243         pSMB->ByteCount = cpu_to_le16(count);
1244         /* long_op set to 1 to allow for oplock break timeouts */
1245         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1246                         (struct smb_hdr *)pSMBr, &bytes_returned, CIFS_LONG_OP);
1247         cifs_stats_inc(&tcon->num_opens);
1248         if (rc) {
1249                 cFYI(1, ("Error in Open = %d", rc));
1250         } else {
1251         /* BB verify if wct == 15 */
1252
1253 /*              *pOplock = pSMBr->OplockLevel; */  /* BB take from action field BB */
1254
1255                 *netfid = pSMBr->Fid;   /* cifs fid stays in le */
1256                 /* Let caller know file was created so we can set the mode. */
1257                 /* Do we care about the CreateAction in any other cases? */
1258         /* BB FIXME BB */
1259 /*              if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1260                         *pOplock |= CIFS_CREATE_ACTION; */
1261         /* BB FIXME END */
1262
1263                 if (pfile_info) {
1264                         pfile_info->CreationTime = 0; /* BB convert CreateTime*/
1265                         pfile_info->LastAccessTime = 0; /* BB fixme */
1266                         pfile_info->LastWriteTime = 0; /* BB fixme */
1267                         pfile_info->ChangeTime = 0;  /* BB fixme */
1268                         pfile_info->Attributes =
1269                                 cpu_to_le32(le16_to_cpu(pSMBr->FileAttributes));
1270                         /* the file_info buf is endian converted by caller */
1271                         pfile_info->AllocationSize =
1272                                 cpu_to_le64(le32_to_cpu(pSMBr->EndOfFile));
1273                         pfile_info->EndOfFile = pfile_info->AllocationSize;
1274                         pfile_info->NumberOfLinks = cpu_to_le32(1);
1275                 }
1276         }
1277
1278         cifs_buf_release(pSMB);
1279         if (rc == -EAGAIN)
1280                 goto OldOpenRetry;
1281         return rc;
1282 }
1283
1284 int
1285 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
1286             const char *fileName, const int openDisposition,
1287             const int access_flags, const int create_options, __u16 *netfid,
1288             int *pOplock, FILE_ALL_INFO *pfile_info,
1289             const struct nls_table *nls_codepage, int remap)
1290 {
1291         int rc = -EACCES;
1292         OPEN_REQ *pSMB = NULL;
1293         OPEN_RSP *pSMBr = NULL;
1294         int bytes_returned;
1295         int name_len;
1296         __u16 count;
1297
1298 openRetry:
1299         rc = smb_init(SMB_COM_NT_CREATE_ANDX, 24, tcon, (void **) &pSMB,
1300                       (void **) &pSMBr);
1301         if (rc)
1302                 return rc;
1303
1304         pSMB->AndXCommand = 0xFF;       /* none */
1305
1306         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1307                 count = 1;      /* account for one byte pad to word boundary */
1308                 name_len =
1309                     cifsConvertToUCS((__le16 *) (pSMB->fileName + 1),
1310                                      fileName, PATH_MAX, nls_codepage, remap);
1311                 name_len++;     /* trailing null */
1312                 name_len *= 2;
1313                 pSMB->NameLength = cpu_to_le16(name_len);
1314         } else {                /* BB improve check for buffer overruns BB */
1315                 count = 0;      /* no pad */
1316                 name_len = strnlen(fileName, PATH_MAX);
1317                 name_len++;     /* trailing null */
1318                 pSMB->NameLength = cpu_to_le16(name_len);
1319                 strncpy(pSMB->fileName, fileName, name_len);
1320         }
1321         if (*pOplock & REQ_OPLOCK)
1322                 pSMB->OpenFlags = cpu_to_le32(REQ_OPLOCK);
1323         else if (*pOplock & REQ_BATCHOPLOCK)
1324                 pSMB->OpenFlags = cpu_to_le32(REQ_BATCHOPLOCK);
1325         pSMB->DesiredAccess = cpu_to_le32(access_flags);
1326         pSMB->AllocationSize = 0;
1327         /* set file as system file if special file such
1328            as fifo and server expecting SFU style and
1329            no Unix extensions */
1330         if (create_options & CREATE_OPTION_SPECIAL)
1331                 pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
1332         else
1333                 pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
1334         /* XP does not handle ATTR_POSIX_SEMANTICS */
1335         /* but it helps speed up case sensitive checks for other
1336         servers such as Samba */
1337         if (tcon->ses->capabilities & CAP_UNIX)
1338                 pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
1339
1340         /* if ((omode & S_IWUGO) == 0)
1341                 pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
1342         /*  Above line causes problems due to vfs splitting create into two
1343                 pieces - need to set mode after file created not while it is
1344                 being created */
1345         pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
1346         pSMB->CreateDisposition = cpu_to_le32(openDisposition);
1347         pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
1348         /* BB Expirement with various impersonation levels and verify */
1349         pSMB->ImpersonationLevel = cpu_to_le32(SECURITY_IMPERSONATION);
1350         pSMB->SecurityFlags =
1351             SECURITY_CONTEXT_TRACKING | SECURITY_EFFECTIVE_ONLY;
1352
1353         count += name_len;
1354         pSMB->hdr.smb_buf_length += count;
1355
1356         pSMB->ByteCount = cpu_to_le16(count);
1357         /* long_op set to 1 to allow for oplock break timeouts */
1358         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1359                         (struct smb_hdr *)pSMBr, &bytes_returned, CIFS_LONG_OP);
1360         cifs_stats_inc(&tcon->num_opens);
1361         if (rc) {
1362                 cFYI(1, ("Error in Open = %d", rc));
1363         } else {
1364                 *pOplock = pSMBr->OplockLevel; /* 1 byte no need to le_to_cpu */
1365                 *netfid = pSMBr->Fid;   /* cifs fid stays in le */
1366                 /* Let caller know file was created so we can set the mode. */
1367                 /* Do we care about the CreateAction in any other cases? */
1368                 if (cpu_to_le32(FILE_CREATE) == pSMBr->CreateAction)
1369                         *pOplock |= CIFS_CREATE_ACTION;
1370                 if (pfile_info) {
1371                     memcpy((char *)pfile_info, (char *)&pSMBr->CreationTime,
1372                         36 /* CreationTime to Attributes */);
1373                     /* the file_info buf is endian converted by caller */
1374                     pfile_info->AllocationSize = pSMBr->AllocationSize;
1375                     pfile_info->EndOfFile = pSMBr->EndOfFile;
1376                     pfile_info->NumberOfLinks = cpu_to_le32(1);
1377                 }
1378         }
1379
1380         cifs_buf_release(pSMB);
1381         if (rc == -EAGAIN)
1382                 goto openRetry;
1383         return rc;
1384 }
1385
1386 int
1387 CIFSSMBRead(const int xid, struct cifsTconInfo *tcon, const int netfid,
1388             const unsigned int count, const __u64 lseek, unsigned int *nbytes,
1389             char **buf, int *pbuf_type)
1390 {
1391         int rc = -EACCES;
1392         READ_REQ *pSMB = NULL;
1393         READ_RSP *pSMBr = NULL;
1394         char *pReadData = NULL;
1395         int wct;
1396         int resp_buf_type = 0;
1397         struct kvec iov[1];
1398
1399         cFYI(1, ("Reading %d bytes on fid %d", count, netfid));
1400         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1401                 wct = 12;
1402         else
1403                 wct = 10; /* old style read */
1404
1405         *nbytes = 0;
1406         rc = small_smb_init(SMB_COM_READ_ANDX, wct, tcon, (void **) &pSMB);
1407         if (rc)
1408                 return rc;
1409
1410         /* tcon and ses pointer are checked in smb_init */
1411         if (tcon->ses->server == NULL)
1412                 return -ECONNABORTED;
1413
1414         pSMB->AndXCommand = 0xFF;       /* none */
1415         pSMB->Fid = netfid;
1416         pSMB->OffsetLow = cpu_to_le32(lseek & 0xFFFFFFFF);
1417         if (wct == 12)
1418                 pSMB->OffsetHigh = cpu_to_le32(lseek >> 32);
1419         else if ((lseek >> 32) > 0) /* can not handle this big offset for old */
1420                 return -EIO;
1421
1422         pSMB->Remaining = 0;
1423         pSMB->MaxCount = cpu_to_le16(count & 0xFFFF);
1424         pSMB->MaxCountHigh = cpu_to_le32(count >> 16);
1425         if (wct == 12)
1426                 pSMB->ByteCount = 0;  /* no need to do le conversion since 0 */
1427         else {
1428                 /* old style read */
1429                 struct smb_com_readx_req *pSMBW =
1430                         (struct smb_com_readx_req *)pSMB;
1431                 pSMBW->ByteCount = 0;
1432         }
1433
1434         iov[0].iov_base = (char *)pSMB;
1435         iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1436         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1437                          &resp_buf_type, CIFS_STD_OP | CIFS_LOG_ERROR);
1438         cifs_stats_inc(&tcon->num_reads);
1439         pSMBr = (READ_RSP *)iov[0].iov_base;
1440         if (rc) {
1441                 cERROR(1, ("Send error in read = %d", rc));
1442         } else {
1443                 int data_length = le16_to_cpu(pSMBr->DataLengthHigh);
1444                 data_length = data_length << 16;
1445                 data_length += le16_to_cpu(pSMBr->DataLength);
1446                 *nbytes = data_length;
1447
1448                 /*check that DataLength would not go beyond end of SMB */
1449                 if ((data_length > CIFSMaxBufSize)
1450                                 || (data_length > count)) {
1451                         cFYI(1, ("bad length %d for count %d",
1452                                  data_length, count));
1453                         rc = -EIO;
1454                         *nbytes = 0;
1455                 } else {
1456                         pReadData = (char *) (&pSMBr->hdr.Protocol) +
1457                                         le16_to_cpu(pSMBr->DataOffset);
1458 /*                      if (rc = copy_to_user(buf, pReadData, data_length)) {
1459                                 cERROR(1,("Faulting on read rc = %d",rc));
1460                                 rc = -EFAULT;
1461                         }*/ /* can not use copy_to_user when using page cache*/
1462                         if (*buf)
1463                                 memcpy(*buf, pReadData, data_length);
1464                 }
1465         }
1466
1467 /*      cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1468         if (*buf) {
1469                 if (resp_buf_type == CIFS_SMALL_BUFFER)
1470                         cifs_small_buf_release(iov[0].iov_base);
1471                 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1472                         cifs_buf_release(iov[0].iov_base);
1473         } else if (resp_buf_type != CIFS_NO_BUFFER) {
1474                 /* return buffer to caller to free */
1475                 *buf = iov[0].iov_base;
1476                 if (resp_buf_type == CIFS_SMALL_BUFFER)
1477                         *pbuf_type = CIFS_SMALL_BUFFER;
1478                 else if (resp_buf_type == CIFS_LARGE_BUFFER)
1479                         *pbuf_type = CIFS_LARGE_BUFFER;
1480         } /* else no valid buffer on return - leave as null */
1481
1482         /* Note: On -EAGAIN error only caller can retry on handle based calls
1483                 since file handle passed in no longer valid */
1484         return rc;
1485 }
1486
1487
1488 int
1489 CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
1490              const int netfid, const unsigned int count,
1491              const __u64 offset, unsigned int *nbytes, const char *buf,
1492              const char __user *ubuf, const int long_op)
1493 {
1494         int rc = -EACCES;
1495         WRITE_REQ *pSMB = NULL;
1496         WRITE_RSP *pSMBr = NULL;
1497         int bytes_returned, wct;
1498         __u32 bytes_sent;
1499         __u16 byte_count;
1500
1501         /* cFYI(1,("write at %lld %d bytes",offset,count));*/
1502         if (tcon->ses == NULL)
1503                 return -ECONNABORTED;
1504
1505         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1506                 wct = 14;
1507         else
1508                 wct = 12;
1509
1510         rc = smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB,
1511                       (void **) &pSMBr);
1512         if (rc)
1513                 return rc;
1514         /* tcon and ses pointer are checked in smb_init */
1515         if (tcon->ses->server == NULL)
1516                 return -ECONNABORTED;
1517
1518         pSMB->AndXCommand = 0xFF;       /* none */
1519         pSMB->Fid = netfid;
1520         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1521         if (wct == 14)
1522                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1523         else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1524                 return -EIO;
1525
1526         pSMB->Reserved = 0xFFFFFFFF;
1527         pSMB->WriteMode = 0;
1528         pSMB->Remaining = 0;
1529
1530         /* Can increase buffer size if buffer is big enough in some cases ie we
1531         can send more if LARGE_WRITE_X capability returned by the server and if
1532         our buffer is big enough or if we convert to iovecs on socket writes
1533         and eliminate the copy to the CIFS buffer */
1534         if (tcon->ses->capabilities & CAP_LARGE_WRITE_X) {
1535                 bytes_sent = min_t(const unsigned int, CIFSMaxBufSize, count);
1536         } else {
1537                 bytes_sent = (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE)
1538                          & ~0xFF;
1539         }
1540
1541         if (bytes_sent > count)
1542                 bytes_sent = count;
1543         pSMB->DataOffset =
1544                 cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1545         if (buf)
1546             memcpy(pSMB->Data, buf, bytes_sent);
1547         else if (ubuf) {
1548                 if (copy_from_user(pSMB->Data, ubuf, bytes_sent)) {
1549                         cifs_buf_release(pSMB);
1550                         return -EFAULT;
1551                 }
1552         } else if (count != 0) {
1553                 /* No buffer */
1554                 cifs_buf_release(pSMB);
1555                 return -EINVAL;
1556         } /* else setting file size with write of zero bytes */
1557         if (wct == 14)
1558                 byte_count = bytes_sent + 1; /* pad */
1559         else /* wct == 12 */
1560                 byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
1561
1562         pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
1563         pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
1564         pSMB->hdr.smb_buf_length += byte_count;
1565
1566         if (wct == 14)
1567                 pSMB->ByteCount = cpu_to_le16(byte_count);
1568         else { /* old style write has byte count 4 bytes earlier
1569                   so 4 bytes pad  */
1570                 struct smb_com_writex_req *pSMBW =
1571                         (struct smb_com_writex_req *)pSMB;
1572                 pSMBW->ByteCount = cpu_to_le16(byte_count);
1573         }
1574
1575         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1576                          (struct smb_hdr *) pSMBr, &bytes_returned, long_op);
1577         cifs_stats_inc(&tcon->num_writes);
1578         if (rc) {
1579                 cFYI(1, ("Send error in write = %d", rc));
1580                 *nbytes = 0;
1581         } else {
1582                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1583                 *nbytes = (*nbytes) << 16;
1584                 *nbytes += le16_to_cpu(pSMBr->Count);
1585         }
1586
1587         cifs_buf_release(pSMB);
1588
1589         /* Note: On -EAGAIN error only caller can retry on handle based calls
1590                 since file handle passed in no longer valid */
1591
1592         return rc;
1593 }
1594
1595 int
1596 CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
1597              const int netfid, const unsigned int count,
1598              const __u64 offset, unsigned int *nbytes, struct kvec *iov,
1599              int n_vec, const int long_op)
1600 {
1601         int rc = -EACCES;
1602         WRITE_REQ *pSMB = NULL;
1603         int wct;
1604         int smb_hdr_len;
1605         int resp_buf_type = 0;
1606
1607         cFYI(1, ("write2 at %lld %d bytes", (long long)offset, count));
1608
1609         if (tcon->ses->capabilities & CAP_LARGE_FILES)
1610                 wct = 14;
1611         else
1612                 wct = 12;
1613         rc = small_smb_init(SMB_COM_WRITE_ANDX, wct, tcon, (void **) &pSMB);
1614         if (rc)
1615                 return rc;
1616         /* tcon and ses pointer are checked in smb_init */
1617         if (tcon->ses->server == NULL)
1618                 return -ECONNABORTED;
1619
1620         pSMB->AndXCommand = 0xFF;       /* none */
1621         pSMB->Fid = netfid;
1622         pSMB->OffsetLow = cpu_to_le32(offset & 0xFFFFFFFF);
1623         if (wct == 14)
1624                 pSMB->OffsetHigh = cpu_to_le32(offset >> 32);
1625         else if ((offset >> 32) > 0) /* can not handle big offset for old srv */
1626                 return -EIO;
1627         pSMB->Reserved = 0xFFFFFFFF;
1628         pSMB->WriteMode = 0;
1629         pSMB->Remaining = 0;
1630
1631         pSMB->DataOffset =
1632             cpu_to_le16(offsetof(struct smb_com_write_req, Data) - 4);
1633
1634         pSMB->DataLengthLow = cpu_to_le16(count & 0xFFFF);
1635         pSMB->DataLengthHigh = cpu_to_le16(count >> 16);
1636         smb_hdr_len = pSMB->hdr.smb_buf_length + 1; /* hdr + 1 byte pad */
1637         if (wct == 14)
1638                 pSMB->hdr.smb_buf_length += count+1;
1639         else /* wct == 12 */
1640                 pSMB->hdr.smb_buf_length += count+5; /* smb data starts later */
1641         if (wct == 14)
1642                 pSMB->ByteCount = cpu_to_le16(count + 1);
1643         else /* wct == 12 */ /* bigger pad, smaller smb hdr, keep offset ok */ {
1644                 struct smb_com_writex_req *pSMBW =
1645                                 (struct smb_com_writex_req *)pSMB;
1646                 pSMBW->ByteCount = cpu_to_le16(count + 5);
1647         }
1648         iov[0].iov_base = pSMB;
1649         if (wct == 14)
1650                 iov[0].iov_len = smb_hdr_len + 4;
1651         else /* wct == 12 pad bigger by four bytes */
1652                 iov[0].iov_len = smb_hdr_len + 8;
1653
1654
1655         rc = SendReceive2(xid, tcon->ses, iov, n_vec + 1, &resp_buf_type,
1656                           long_op);
1657         cifs_stats_inc(&tcon->num_writes);
1658         if (rc) {
1659                 cFYI(1, ("Send error Write2 = %d", rc));
1660                 *nbytes = 0;
1661         } else if (resp_buf_type == 0) {
1662                 /* presumably this can not happen, but best to be safe */
1663                 rc = -EIO;
1664                 *nbytes = 0;
1665         } else {
1666                 WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
1667                 *nbytes = le16_to_cpu(pSMBr->CountHigh);
1668                 *nbytes = (*nbytes) << 16;
1669                 *nbytes += le16_to_cpu(pSMBr->Count);
1670         }
1671
1672 /*      cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
1673         if (resp_buf_type == CIFS_SMALL_BUFFER)
1674                 cifs_small_buf_release(iov[0].iov_base);
1675         else if (resp_buf_type == CIFS_LARGE_BUFFER)
1676                 cifs_buf_release(iov[0].iov_base);
1677
1678         /* Note: On -EAGAIN error only caller can retry on handle based calls
1679                 since file handle passed in no longer valid */
1680
1681         return rc;
1682 }
1683
1684
1685 int
1686 CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
1687             const __u16 smb_file_id, const __u64 len,
1688             const __u64 offset, const __u32 numUnlock,
1689             const __u32 numLock, const __u8 lockType, const int waitFlag)
1690 {
1691         int rc = 0;
1692         LOCK_REQ *pSMB = NULL;
1693         LOCK_RSP *pSMBr = NULL;
1694         int bytes_returned;
1695         int timeout = 0;
1696         __u16 count;
1697
1698         cFYI(1, ("CIFSSMBLock timeout %d numLock %d", waitFlag, numLock));
1699         rc = small_smb_init(SMB_COM_LOCKING_ANDX, 8, tcon, (void **) &pSMB);
1700
1701         if (rc)
1702                 return rc;
1703
1704         pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
1705
1706         if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
1707                 timeout = CIFS_ASYNC_OP; /* no response expected */
1708                 pSMB->Timeout = 0;
1709         } else if (waitFlag == TRUE) {
1710                 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1711                 pSMB->Timeout = cpu_to_le32(-1);/* blocking - do not time out */
1712         } else {
1713                 pSMB->Timeout = 0;
1714         }
1715
1716         pSMB->NumberOfLocks = cpu_to_le16(numLock);
1717         pSMB->NumberOfUnlocks = cpu_to_le16(numUnlock);
1718         pSMB->LockType = lockType;
1719         pSMB->AndXCommand = 0xFF;       /* none */
1720         pSMB->Fid = smb_file_id; /* netfid stays le */
1721
1722         if ((numLock != 0) || (numUnlock != 0)) {
1723                 pSMB->Locks[0].Pid = cpu_to_le16(current->tgid);
1724                 /* BB where to store pid high? */
1725                 pSMB->Locks[0].LengthLow = cpu_to_le32((u32)len);
1726                 pSMB->Locks[0].LengthHigh = cpu_to_le32((u32)(len>>32));
1727                 pSMB->Locks[0].OffsetLow = cpu_to_le32((u32)offset);
1728                 pSMB->Locks[0].OffsetHigh = cpu_to_le32((u32)(offset>>32));
1729                 count = sizeof(LOCKING_ANDX_RANGE);
1730         } else {
1731                 /* oplock break */
1732                 count = 0;
1733         }
1734         pSMB->hdr.smb_buf_length += count;
1735         pSMB->ByteCount = cpu_to_le16(count);
1736
1737         if (waitFlag) {
1738                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1739                         (struct smb_hdr *) pSMBr, &bytes_returned);
1740                 cifs_small_buf_release(pSMB);
1741         } else {
1742                 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *)pSMB,
1743                                       timeout);
1744                 /* SMB buffer freed by function above */
1745         }
1746         cifs_stats_inc(&tcon->num_locks);
1747         if (rc)
1748                 cFYI(1, ("Send error in Lock = %d", rc));
1749
1750         /* Note: On -EAGAIN error only caller can retry on handle based calls
1751         since file handle passed in no longer valid */
1752         return rc;
1753 }
1754
1755 int
1756 CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
1757                 const __u16 smb_file_id, const int get_flag, const __u64 len,
1758                 struct file_lock *pLockData, const __u16 lock_type,
1759                 const int waitFlag)
1760 {
1761         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
1762         struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1763         struct cifs_posix_lock *parm_data;
1764         int rc = 0;
1765         int timeout = 0;
1766         int bytes_returned = 0;
1767         int resp_buf_type = 0;
1768         __u16 params, param_offset, offset, byte_count, count;
1769         struct kvec iov[1];
1770
1771         cFYI(1, ("Posix Lock"));
1772
1773         if (pLockData == NULL)
1774                 return EINVAL;
1775
1776         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
1777
1778         if (rc)
1779                 return rc;
1780
1781         pSMBr = (struct smb_com_transaction2_sfi_rsp *)pSMB;
1782
1783         params = 6;
1784         pSMB->MaxSetupCount = 0;
1785         pSMB->Reserved = 0;
1786         pSMB->Flags = 0;
1787         pSMB->Reserved2 = 0;
1788         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
1789         offset = param_offset + params;
1790
1791         count = sizeof(struct cifs_posix_lock);
1792         pSMB->MaxParameterCount = cpu_to_le16(2);
1793         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
1794         pSMB->SetupCount = 1;
1795         pSMB->Reserved3 = 0;
1796         if (get_flag)
1797                 pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
1798         else
1799                 pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
1800         byte_count = 3 /* pad */  + params + count;
1801         pSMB->DataCount = cpu_to_le16(count);
1802         pSMB->ParameterCount = cpu_to_le16(params);
1803         pSMB->TotalDataCount = pSMB->DataCount;
1804         pSMB->TotalParameterCount = pSMB->ParameterCount;
1805         pSMB->ParameterOffset = cpu_to_le16(param_offset);
1806         parm_data = (struct cifs_posix_lock *)
1807                         (((char *) &pSMB->hdr.Protocol) + offset);
1808
1809         parm_data->lock_type = cpu_to_le16(lock_type);
1810         if (waitFlag) {
1811                 timeout = CIFS_BLOCKING_OP; /* blocking operation, no timeout */
1812                 parm_data->lock_flags = cpu_to_le16(1);
1813                 pSMB->Timeout = cpu_to_le32(-1);
1814         } else
1815                 pSMB->Timeout = 0;
1816
1817         parm_data->pid = cpu_to_le32(current->tgid);
1818         parm_data->start = cpu_to_le64(pLockData->fl_start);
1819         parm_data->length = cpu_to_le64(len);  /* normalize negative numbers */
1820
1821         pSMB->DataOffset = cpu_to_le16(offset);
1822         pSMB->Fid = smb_file_id;
1823         pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_LOCK);
1824         pSMB->Reserved4 = 0;
1825         pSMB->hdr.smb_buf_length += byte_count;
1826         pSMB->ByteCount = cpu_to_le16(byte_count);
1827         if (waitFlag) {
1828                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
1829                         (struct smb_hdr *) pSMBr, &bytes_returned);
1830         } else {
1831                 iov[0].iov_base = (char *)pSMB;
1832                 iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
1833                 rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovecs */,
1834                                 &resp_buf_type, timeout);
1835                 pSMB = NULL; /* request buf already freed by SendReceive2. Do
1836                                 not try to free it twice below on exit */
1837                 pSMBr = (struct smb_com_transaction2_sfi_rsp *)iov[0].iov_base;
1838         }
1839
1840         if (rc) {
1841                 cFYI(1, ("Send error in Posix Lock = %d", rc));
1842         } else if (get_flag) {
1843                 /* lock structure can be returned on get */
1844                 __u16 data_offset;
1845                 __u16 data_count;
1846                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
1847
1848                 if (rc || (pSMBr->ByteCount < sizeof(struct cifs_posix_lock))) {
1849                         rc = -EIO;      /* bad smb */
1850                         goto plk_err_exit;
1851                 }
1852                 if (pLockData == NULL) {
1853                         rc = -EINVAL;
1854                         goto plk_err_exit;
1855                 }
1856                 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
1857                 data_count  = le16_to_cpu(pSMBr->t2.DataCount);
1858                 if (data_count < sizeof(struct cifs_posix_lock)) {
1859                         rc = -EIO;
1860                         goto plk_err_exit;
1861                 }
1862                 parm_data = (struct cifs_posix_lock *)
1863                         ((char *)&pSMBr->hdr.Protocol + data_offset);
1864                 if (parm_data->lock_type == cpu_to_le16(CIFS_UNLCK))
1865                         pLockData->fl_type = F_UNLCK;
1866         }
1867
1868 plk_err_exit:
1869         if (pSMB)
1870                 cifs_small_buf_release(pSMB);
1871
1872         if (resp_buf_type == CIFS_SMALL_BUFFER)
1873                 cifs_small_buf_release(iov[0].iov_base);
1874         else if (resp_buf_type == CIFS_LARGE_BUFFER)
1875                 cifs_buf_release(iov[0].iov_base);
1876
1877         /* Note: On -EAGAIN error only caller can retry on handle based calls
1878            since file handle passed in no longer valid */
1879
1880         return rc;
1881 }
1882
1883
1884 int
1885 CIFSSMBClose(const int xid, struct cifsTconInfo *tcon, int smb_file_id)
1886 {
1887         int rc = 0;
1888         CLOSE_REQ *pSMB = NULL;
1889         cFYI(1, ("In CIFSSMBClose"));
1890
1891 /* do not retry on dead session on close */
1892         rc = small_smb_init(SMB_COM_CLOSE, 3, tcon, (void **) &pSMB);
1893         if (rc == -EAGAIN)
1894                 return 0;
1895         if (rc)
1896                 return rc;
1897
1898         pSMB->FileID = (__u16) smb_file_id;
1899         pSMB->LastWriteTime = 0xFFFFFFFF;
1900         pSMB->ByteCount = 0;
1901         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
1902         cifs_stats_inc(&tcon->num_closes);
1903         if (rc) {
1904                 if (rc != -EINTR) {
1905                         /* EINTR is expected when user ctl-c to kill app */
1906                         cERROR(1, ("Send error in Close = %d", rc));
1907                 }
1908         }
1909
1910         /* Since session is dead, file will be closed on server already */
1911         if (rc == -EAGAIN)
1912                 rc = 0;
1913
1914         return rc;
1915 }
1916
1917 int
1918 CIFSSMBRename(const int xid, struct cifsTconInfo *tcon,
1919               const char *fromName, const char *toName,
1920               const struct nls_table *nls_codepage, int remap)
1921 {
1922         int rc = 0;
1923         RENAME_REQ *pSMB = NULL;
1924         RENAME_RSP *pSMBr = NULL;
1925         int bytes_returned;
1926         int name_len, name_len2;
1927         __u16 count;
1928
1929         cFYI(1, ("In CIFSSMBRename"));
1930 renameRetry:
1931         rc = smb_init(SMB_COM_RENAME, 1, tcon, (void **) &pSMB,
1932                       (void **) &pSMBr);
1933         if (rc)
1934                 return rc;
1935
1936         pSMB->BufferFormat = 0x04;
1937         pSMB->SearchAttributes =
1938             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
1939                         ATTR_DIRECTORY);
1940
1941         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
1942                 name_len =
1943                     cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
1944                                      PATH_MAX, nls_codepage, remap);
1945                 name_len++;     /* trailing null */
1946                 name_len *= 2;
1947                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
1948         /* protocol requires ASCII signature byte on Unicode string */
1949                 pSMB->OldFileName[name_len + 1] = 0x00;
1950                 name_len2 =
1951                     cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
1952                                      toName, PATH_MAX, nls_codepage, remap);
1953                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
1954                 name_len2 *= 2; /* convert to bytes */
1955         } else {        /* BB improve the check for buffer overruns BB */
1956                 name_len = strnlen(fromName, PATH_MAX);
1957                 name_len++;     /* trailing null */
1958                 strncpy(pSMB->OldFileName, fromName, name_len);
1959                 name_len2 = strnlen(toName, PATH_MAX);
1960                 name_len2++;    /* trailing null */
1961                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
1962                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
1963                 name_len2++;    /* trailing null */
1964                 name_len2++;    /* signature byte */
1965         }
1966
1967         count = 1 /* 1st signature byte */  + name_len + name_len2;
1968         pSMB->hdr.smb_buf_length += count;
1969         pSMB->ByteCount = cpu_to_le16(count);
1970
1971         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
1972                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
1973         cifs_stats_inc(&tcon->num_renames);
1974         if (rc)
1975                 cFYI(1, ("Send error in rename = %d", rc));
1976
1977         cifs_buf_release(pSMB);
1978
1979         if (rc == -EAGAIN)
1980                 goto renameRetry;
1981
1982         return rc;
1983 }
1984
1985 int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
1986                 int netfid, char *target_name,
1987                 const struct nls_table *nls_codepage, int remap)
1988 {
1989         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
1990         struct smb_com_transaction2_sfi_rsp *pSMBr = NULL;
1991         struct set_file_rename *rename_info;
1992         char *data_offset;
1993         char dummy_string[30];
1994         int rc = 0;
1995         int bytes_returned = 0;
1996         int len_of_str;
1997         __u16 params, param_offset, offset, count, byte_count;
1998
1999         cFYI(1, ("Rename to File by handle"));
2000         rc = smb_init(SMB_COM_TRANSACTION2, 15, pTcon, (void **) &pSMB,
2001                         (void **) &pSMBr);
2002         if (rc)
2003                 return rc;
2004
2005         params = 6;
2006         pSMB->MaxSetupCount = 0;
2007         pSMB->Reserved = 0;
2008         pSMB->Flags = 0;
2009         pSMB->Timeout = 0;
2010         pSMB->Reserved2 = 0;
2011         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
2012         offset = param_offset + params;
2013
2014         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2015         rename_info = (struct set_file_rename *) data_offset;
2016         pSMB->MaxParameterCount = cpu_to_le16(2);
2017         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
2018         pSMB->SetupCount = 1;
2019         pSMB->Reserved3 = 0;
2020         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
2021         byte_count = 3 /* pad */  + params;
2022         pSMB->ParameterCount = cpu_to_le16(params);
2023         pSMB->TotalParameterCount = pSMB->ParameterCount;
2024         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2025         pSMB->DataOffset = cpu_to_le16(offset);
2026         /* construct random name ".cifs_tmp<inodenum><mid>" */
2027         rename_info->overwrite = cpu_to_le32(1);
2028         rename_info->root_fid  = 0;
2029         /* unicode only call */
2030         if (target_name == NULL) {
2031                 sprintf(dummy_string, "cifs%x", pSMB->hdr.Mid);
2032                 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2033                                         dummy_string, 24, nls_codepage, remap);
2034         } else {
2035                 len_of_str = cifsConvertToUCS((__le16 *)rename_info->target_name,
2036                                         target_name, PATH_MAX, nls_codepage,
2037                                         remap);
2038         }
2039         rename_info->target_name_len = cpu_to_le32(2 * len_of_str);
2040         count = 12 /* sizeof(struct set_file_rename) */ + (2 * len_of_str) + 2;
2041         byte_count += count;
2042         pSMB->DataCount = cpu_to_le16(count);
2043         pSMB->TotalDataCount = pSMB->DataCount;
2044         pSMB->Fid = netfid;
2045         pSMB->InformationLevel =
2046                 cpu_to_le16(SMB_SET_FILE_RENAME_INFORMATION);
2047         pSMB->Reserved4 = 0;
2048         pSMB->hdr.smb_buf_length += byte_count;
2049         pSMB->ByteCount = cpu_to_le16(byte_count);
2050         rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
2051                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2052         cifs_stats_inc(&pTcon->num_t2renames);
2053         if (rc)
2054                 cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
2055
2056         cifs_buf_release(pSMB);
2057
2058         /* Note: On -EAGAIN error only caller can retry on handle based calls
2059                 since file handle passed in no longer valid */
2060
2061         return rc;
2062 }
2063
2064 int
2065 CIFSSMBCopy(const int xid, struct cifsTconInfo *tcon, const char *fromName,
2066             const __u16 target_tid, const char *toName, const int flags,
2067             const struct nls_table *nls_codepage, int remap)
2068 {
2069         int rc = 0;
2070         COPY_REQ *pSMB = NULL;
2071         COPY_RSP *pSMBr = NULL;
2072         int bytes_returned;
2073         int name_len, name_len2;
2074         __u16 count;
2075
2076         cFYI(1, ("In CIFSSMBCopy"));
2077 copyRetry:
2078         rc = smb_init(SMB_COM_COPY, 1, tcon, (void **) &pSMB,
2079                         (void **) &pSMBr);
2080         if (rc)
2081                 return rc;
2082
2083         pSMB->BufferFormat = 0x04;
2084         pSMB->Tid2 = target_tid;
2085
2086         pSMB->Flags = cpu_to_le16(flags & COPY_TREE);
2087
2088         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2089                 name_len = cifsConvertToUCS((__le16 *) pSMB->OldFileName,
2090                                             fromName, PATH_MAX, nls_codepage,
2091                                             remap);
2092                 name_len++;     /* trailing null */
2093                 name_len *= 2;
2094                 pSMB->OldFileName[name_len] = 0x04;     /* pad */
2095                 /* protocol requires ASCII signature byte on Unicode string */
2096                 pSMB->OldFileName[name_len + 1] = 0x00;
2097                 name_len2 =
2098                     cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2099                                 toName, PATH_MAX, nls_codepage, remap);
2100                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
2101                 name_len2 *= 2; /* convert to bytes */
2102         } else {        /* BB improve the check for buffer overruns BB */
2103                 name_len = strnlen(fromName, PATH_MAX);
2104                 name_len++;     /* trailing null */
2105                 strncpy(pSMB->OldFileName, fromName, name_len);
2106                 name_len2 = strnlen(toName, PATH_MAX);
2107                 name_len2++;    /* trailing null */
2108                 pSMB->OldFileName[name_len] = 0x04;  /* 2nd buffer format */
2109                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2110                 name_len2++;    /* trailing null */
2111                 name_len2++;    /* signature byte */
2112         }
2113
2114         count = 1 /* 1st signature byte */  + name_len + name_len2;
2115         pSMB->hdr.smb_buf_length += count;
2116         pSMB->ByteCount = cpu_to_le16(count);
2117
2118         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2119                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2120         if (rc) {
2121                 cFYI(1, ("Send error in copy = %d with %d files copied",
2122                         rc, le16_to_cpu(pSMBr->CopyCount)));
2123         }
2124         if (pSMB)
2125                 cifs_buf_release(pSMB);
2126
2127         if (rc == -EAGAIN)
2128                 goto copyRetry;
2129
2130         return rc;
2131 }
2132
2133 int
2134 CIFSUnixCreateSymLink(const int xid, struct cifsTconInfo *tcon,
2135                       const char *fromName, const char *toName,
2136                       const struct nls_table *nls_codepage)
2137 {
2138         TRANSACTION2_SPI_REQ *pSMB = NULL;
2139         TRANSACTION2_SPI_RSP *pSMBr = NULL;
2140         char *data_offset;
2141         int name_len;
2142         int name_len_target;
2143         int rc = 0;
2144         int bytes_returned = 0;
2145         __u16 params, param_offset, offset, byte_count;
2146
2147         cFYI(1, ("In Symlink Unix style"));
2148 createSymLinkRetry:
2149         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2150                       (void **) &pSMBr);
2151         if (rc)
2152                 return rc;
2153
2154         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2155                 name_len =
2156                     cifs_strtoUCS((__le16 *) pSMB->FileName, fromName, PATH_MAX
2157                                   /* find define for this maxpathcomponent */
2158                                   , nls_codepage);
2159                 name_len++;     /* trailing null */
2160                 name_len *= 2;
2161
2162         } else {        /* BB improve the check for buffer overruns BB */
2163                 name_len = strnlen(fromName, PATH_MAX);
2164                 name_len++;     /* trailing null */
2165                 strncpy(pSMB->FileName, fromName, name_len);
2166         }
2167         params = 6 + name_len;
2168         pSMB->MaxSetupCount = 0;
2169         pSMB->Reserved = 0;
2170         pSMB->Flags = 0;
2171         pSMB->Timeout = 0;
2172         pSMB->Reserved2 = 0;
2173         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2174                                 InformationLevel) - 4;
2175         offset = param_offset + params;
2176
2177         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2178         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2179                 name_len_target =
2180                     cifs_strtoUCS((__le16 *) data_offset, toName, PATH_MAX
2181                                   /* find define for this maxpathcomponent */
2182                                   , nls_codepage);
2183                 name_len_target++;      /* trailing null */
2184                 name_len_target *= 2;
2185         } else {        /* BB improve the check for buffer overruns BB */
2186                 name_len_target = strnlen(toName, PATH_MAX);
2187                 name_len_target++;      /* trailing null */
2188                 strncpy(data_offset, toName, name_len_target);
2189         }
2190
2191         pSMB->MaxParameterCount = cpu_to_le16(2);
2192         /* BB find exact max on data count below from sess */
2193         pSMB->MaxDataCount = cpu_to_le16(1000);
2194         pSMB->SetupCount = 1;
2195         pSMB->Reserved3 = 0;
2196         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2197         byte_count = 3 /* pad */  + params + name_len_target;
2198         pSMB->DataCount = cpu_to_le16(name_len_target);
2199         pSMB->ParameterCount = cpu_to_le16(params);
2200         pSMB->TotalDataCount = pSMB->DataCount;
2201         pSMB->TotalParameterCount = pSMB->ParameterCount;
2202         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2203         pSMB->DataOffset = cpu_to_le16(offset);
2204         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_LINK);
2205         pSMB->Reserved4 = 0;
2206         pSMB->hdr.smb_buf_length += byte_count;
2207         pSMB->ByteCount = cpu_to_le16(byte_count);
2208         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2209                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2210         cifs_stats_inc(&tcon->num_symlinks);
2211         if (rc)
2212                 cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
2213
2214         if (pSMB)
2215                 cifs_buf_release(pSMB);
2216
2217         if (rc == -EAGAIN)
2218                 goto createSymLinkRetry;
2219
2220         return rc;
2221 }
2222
2223 int
2224 CIFSUnixCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2225                        const char *fromName, const char *toName,
2226                        const struct nls_table *nls_codepage, int remap)
2227 {
2228         TRANSACTION2_SPI_REQ *pSMB = NULL;
2229         TRANSACTION2_SPI_RSP *pSMBr = NULL;
2230         char *data_offset;
2231         int name_len;
2232         int name_len_target;
2233         int rc = 0;
2234         int bytes_returned = 0;
2235         __u16 params, param_offset, offset, byte_count;
2236
2237         cFYI(1, ("In Create Hard link Unix style"));
2238 createHardLinkRetry:
2239         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2240                       (void **) &pSMBr);
2241         if (rc)
2242                 return rc;
2243
2244         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2245                 name_len = cifsConvertToUCS((__le16 *) pSMB->FileName, toName,
2246                                             PATH_MAX, nls_codepage, remap);
2247                 name_len++;     /* trailing null */
2248                 name_len *= 2;
2249
2250         } else {        /* BB improve the check for buffer overruns BB */
2251                 name_len = strnlen(toName, PATH_MAX);
2252                 name_len++;     /* trailing null */
2253                 strncpy(pSMB->FileName, toName, name_len);
2254         }
2255         params = 6 + name_len;
2256         pSMB->MaxSetupCount = 0;
2257         pSMB->Reserved = 0;
2258         pSMB->Flags = 0;
2259         pSMB->Timeout = 0;
2260         pSMB->Reserved2 = 0;
2261         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2262                                 InformationLevel) - 4;
2263         offset = param_offset + params;
2264
2265         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
2266         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2267                 name_len_target =
2268                     cifsConvertToUCS((__le16 *) data_offset, fromName, PATH_MAX,
2269                                      nls_codepage, remap);
2270                 name_len_target++;      /* trailing null */
2271                 name_len_target *= 2;
2272         } else {        /* BB improve the check for buffer overruns BB */
2273                 name_len_target = strnlen(fromName, PATH_MAX);
2274                 name_len_target++;      /* trailing null */
2275                 strncpy(data_offset, fromName, name_len_target);
2276         }
2277
2278         pSMB->MaxParameterCount = cpu_to_le16(2);
2279         /* BB find exact max on data count below from sess*/
2280         pSMB->MaxDataCount = cpu_to_le16(1000);
2281         pSMB->SetupCount = 1;
2282         pSMB->Reserved3 = 0;
2283         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2284         byte_count = 3 /* pad */  + params + name_len_target;
2285         pSMB->ParameterCount = cpu_to_le16(params);
2286         pSMB->TotalParameterCount = pSMB->ParameterCount;
2287         pSMB->DataCount = cpu_to_le16(name_len_target);
2288         pSMB->TotalDataCount = pSMB->DataCount;
2289         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2290         pSMB->DataOffset = cpu_to_le16(offset);
2291         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_HLINK);
2292         pSMB->Reserved4 = 0;
2293         pSMB->hdr.smb_buf_length += byte_count;
2294         pSMB->ByteCount = cpu_to_le16(byte_count);
2295         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2296                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2297         cifs_stats_inc(&tcon->num_hardlinks);
2298         if (rc)
2299                 cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
2300
2301         cifs_buf_release(pSMB);
2302         if (rc == -EAGAIN)
2303                 goto createHardLinkRetry;
2304
2305         return rc;
2306 }
2307
2308 int
2309 CIFSCreateHardLink(const int xid, struct cifsTconInfo *tcon,
2310                    const char *fromName, const char *toName,
2311                    const struct nls_table *nls_codepage, int remap)
2312 {
2313         int rc = 0;
2314         NT_RENAME_REQ *pSMB = NULL;
2315         RENAME_RSP *pSMBr = NULL;
2316         int bytes_returned;
2317         int name_len, name_len2;
2318         __u16 count;
2319
2320         cFYI(1, ("In CIFSCreateHardLink"));
2321 winCreateHardLinkRetry:
2322
2323         rc = smb_init(SMB_COM_NT_RENAME, 4, tcon, (void **) &pSMB,
2324                       (void **) &pSMBr);
2325         if (rc)
2326                 return rc;
2327
2328         pSMB->SearchAttributes =
2329             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
2330                         ATTR_DIRECTORY);
2331         pSMB->Flags = cpu_to_le16(CREATE_HARD_LINK);
2332         pSMB->ClusterCount = 0;
2333
2334         pSMB->BufferFormat = 0x04;
2335
2336         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2337                 name_len =
2338                     cifsConvertToUCS((__le16 *) pSMB->OldFileName, fromName,
2339                                      PATH_MAX, nls_codepage, remap);
2340                 name_len++;     /* trailing null */
2341                 name_len *= 2;
2342                 pSMB->OldFileName[name_len] = 0;        /* pad */
2343                 pSMB->OldFileName[name_len + 1] = 0x04;
2344                 name_len2 =
2345                     cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
2346                                      toName, PATH_MAX, nls_codepage, remap);
2347                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
2348                 name_len2 *= 2; /* convert to bytes */
2349         } else {        /* BB improve the check for buffer overruns BB */
2350                 name_len = strnlen(fromName, PATH_MAX);
2351                 name_len++;     /* trailing null */
2352                 strncpy(pSMB->OldFileName, fromName, name_len);
2353                 name_len2 = strnlen(toName, PATH_MAX);
2354                 name_len2++;    /* trailing null */
2355                 pSMB->OldFileName[name_len] = 0x04;     /* 2nd buffer format */
2356                 strncpy(&pSMB->OldFileName[name_len + 1], toName, name_len2);
2357                 name_len2++;    /* trailing null */
2358                 name_len2++;    /* signature byte */
2359         }
2360
2361         count = 1 /* string type byte */  + name_len + name_len2;
2362         pSMB->hdr.smb_buf_length += count;
2363         pSMB->ByteCount = cpu_to_le16(count);
2364
2365         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2366                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2367         cifs_stats_inc(&tcon->num_hardlinks);
2368         if (rc)
2369                 cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
2370
2371         cifs_buf_release(pSMB);
2372         if (rc == -EAGAIN)
2373                 goto winCreateHardLinkRetry;
2374
2375         return rc;
2376 }
2377
2378 int
2379 CIFSSMBUnixQuerySymLink(const int xid, struct cifsTconInfo *tcon,
2380                         const unsigned char *searchName,
2381                         char *symlinkinfo, const int buflen,
2382                         const struct nls_table *nls_codepage)
2383 {
2384 /* SMB_QUERY_FILE_UNIX_LINK */
2385         TRANSACTION2_QPI_REQ *pSMB = NULL;
2386         TRANSACTION2_QPI_RSP *pSMBr = NULL;
2387         int rc = 0;
2388         int bytes_returned;
2389         int name_len;
2390         __u16 params, byte_count;
2391
2392         cFYI(1, ("In QPathSymLinkInfo (Unix) for path %s", searchName));
2393
2394 querySymLinkRetry:
2395         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2396                       (void **) &pSMBr);
2397         if (rc)
2398                 return rc;
2399
2400         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2401                 name_len =
2402                     cifs_strtoUCS((__le16 *) pSMB->FileName, searchName,
2403                                   PATH_MAX, nls_codepage);
2404                 name_len++;     /* trailing null */
2405                 name_len *= 2;
2406         } else {        /* BB improve the check for buffer overruns BB */
2407                 name_len = strnlen(searchName, PATH_MAX);
2408                 name_len++;     /* trailing null */
2409                 strncpy(pSMB->FileName, searchName, name_len);
2410         }
2411
2412         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
2413         pSMB->TotalDataCount = 0;
2414         pSMB->MaxParameterCount = cpu_to_le16(2);
2415         /* BB find exact max data count below from sess structure BB */
2416         pSMB->MaxDataCount = cpu_to_le16(4000);
2417         pSMB->MaxSetupCount = 0;
2418         pSMB->Reserved = 0;
2419         pSMB->Flags = 0;
2420         pSMB->Timeout = 0;
2421         pSMB->Reserved2 = 0;
2422         pSMB->ParameterOffset = cpu_to_le16(offsetof(
2423         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
2424         pSMB->DataCount = 0;
2425         pSMB->DataOffset = 0;
2426         pSMB->SetupCount = 1;
2427         pSMB->Reserved3 = 0;
2428         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2429         byte_count = params + 1 /* pad */ ;
2430         pSMB->TotalParameterCount = cpu_to_le16(params);
2431         pSMB->ParameterCount = pSMB->TotalParameterCount;
2432         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_LINK);
2433         pSMB->Reserved4 = 0;
2434         pSMB->hdr.smb_buf_length += byte_count;
2435         pSMB->ByteCount = cpu_to_le16(byte_count);
2436
2437         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2438                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2439         if (rc) {
2440                 cFYI(1, ("Send error in QuerySymLinkInfo = %d", rc));
2441         } else {
2442                 /* decode response */
2443
2444                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2445                 if (rc || (pSMBr->ByteCount < 2))
2446                 /* BB also check enough total bytes returned */
2447                         rc = -EIO;      /* bad smb */
2448                 else {
2449                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2450                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2451
2452                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2453                                 name_len = UniStrnlen((wchar_t *) ((char *)
2454                                         &pSMBr->hdr.Protocol + data_offset),
2455                                         min_t(const int, buflen, count) / 2);
2456                         /* BB FIXME investigate remapping reserved chars here */
2457                                 cifs_strfromUCS_le(symlinkinfo,
2458                                         (__le16 *) ((char *)&pSMBr->hdr.Protocol
2459                                                         + data_offset),
2460                                         name_len, nls_codepage);
2461                         } else {
2462                                 strncpy(symlinkinfo,
2463                                         (char *) &pSMBr->hdr.Protocol +
2464                                                 data_offset,
2465                                         min_t(const int, buflen, count));
2466                         }
2467                         symlinkinfo[buflen] = 0;
2468         /* just in case so calling code does not go off the end of buffer */
2469                 }
2470         }
2471         cifs_buf_release(pSMB);
2472         if (rc == -EAGAIN)
2473                 goto querySymLinkRetry;
2474         return rc;
2475 }
2476
2477 #ifdef CONFIG_CIFS_EXPERIMENTAL
2478 /* Initialize NT TRANSACT SMB into small smb request buffer.
2479    This assumes that all NT TRANSACTS that we init here have
2480    total parm and data under about 400 bytes (to fit in small cifs
2481    buffer size), which is the case so far, it easily fits. NB:
2482         Setup words themselves and ByteCount
2483         MaxSetupCount (size of returned setup area) and
2484         MaxParameterCount (returned parms size) must be set by caller */
2485 static int
2486 smb_init_nttransact(const __u16 sub_command, const int setup_count,
2487                    const int parm_len, struct cifsTconInfo *tcon,
2488                    void **ret_buf)
2489 {
2490         int rc;
2491         __u32 temp_offset;
2492         struct smb_com_ntransact_req *pSMB;
2493
2494         rc = small_smb_init(SMB_COM_NT_TRANSACT, 19 + setup_count, tcon,
2495                                 (void **)&pSMB);
2496         if (rc)
2497                 return rc;
2498         *ret_buf = (void *)pSMB;
2499         pSMB->Reserved = 0;
2500         pSMB->TotalParameterCount = cpu_to_le32(parm_len);
2501         pSMB->TotalDataCount  = 0;
2502         pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2503                                           MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2504         pSMB->ParameterCount = pSMB->TotalParameterCount;
2505         pSMB->DataCount  = pSMB->TotalDataCount;
2506         temp_offset = offsetof(struct smb_com_ntransact_req, Parms) +
2507                         (setup_count * 2) - 4 /* for rfc1001 length itself */;
2508         pSMB->ParameterOffset = cpu_to_le32(temp_offset);
2509         pSMB->DataOffset = cpu_to_le32(temp_offset + parm_len);
2510         pSMB->SetupCount = setup_count; /* no need to le convert byte fields */
2511         pSMB->SubCommand = cpu_to_le16(sub_command);
2512         return 0;
2513 }
2514
2515 static int
2516 validate_ntransact(char *buf, char **ppparm, char **ppdata,
2517                    __u32 *pparmlen, __u32 *pdatalen)
2518 {
2519         char *end_of_smb;
2520         __u32 data_count, data_offset, parm_count, parm_offset;
2521         struct smb_com_ntransact_rsp *pSMBr;
2522
2523         *pdatalen = 0;
2524         *pparmlen = 0;
2525
2526         if (buf == NULL)
2527                 return -EINVAL;
2528
2529         pSMBr = (struct smb_com_ntransact_rsp *)buf;
2530
2531         /* ByteCount was converted from little endian in SendReceive */
2532         end_of_smb = 2 /* sizeof byte count */ + pSMBr->ByteCount +
2533                         (char *)&pSMBr->ByteCount;
2534
2535         data_offset = le32_to_cpu(pSMBr->DataOffset);
2536         data_count = le32_to_cpu(pSMBr->DataCount);
2537         parm_offset = le32_to_cpu(pSMBr->ParameterOffset);
2538         parm_count = le32_to_cpu(pSMBr->ParameterCount);
2539
2540         *ppparm = (char *)&pSMBr->hdr.Protocol + parm_offset;
2541         *ppdata = (char *)&pSMBr->hdr.Protocol + data_offset;
2542
2543         /* should we also check that parm and data areas do not overlap? */
2544         if (*ppparm > end_of_smb) {
2545                 cFYI(1, ("parms start after end of smb"));
2546                 return -EINVAL;
2547         } else if (parm_count + *ppparm > end_of_smb) {
2548                 cFYI(1, ("parm end after end of smb"));
2549                 return -EINVAL;
2550         } else if (*ppdata > end_of_smb) {
2551                 cFYI(1, ("data starts after end of smb"));
2552                 return -EINVAL;
2553         } else if (data_count + *ppdata > end_of_smb) {
2554                 cFYI(1, ("data %p + count %d (%p) ends after end of smb %p start %p",
2555                         *ppdata, data_count, (data_count + *ppdata),
2556                         end_of_smb, pSMBr));
2557                 return -EINVAL;
2558         } else if (parm_count + data_count > pSMBr->ByteCount) {
2559                 cFYI(1, ("parm count and data count larger than SMB"));
2560                 return -EINVAL;
2561         }
2562         *pdatalen = data_count;
2563         *pparmlen = parm_count;
2564         return 0;
2565 }
2566 #endif /* CIFS_EXPERIMENTAL */
2567
2568 int
2569 CIFSSMBQueryReparseLinkInfo(const int xid, struct cifsTconInfo *tcon,
2570                         const unsigned char *searchName,
2571                         char *symlinkinfo, const int buflen, __u16 fid,
2572                         const struct nls_table *nls_codepage)
2573 {
2574         int rc = 0;
2575         int bytes_returned;
2576         int name_len;
2577         struct smb_com_transaction_ioctl_req *pSMB;
2578         struct smb_com_transaction_ioctl_rsp *pSMBr;
2579
2580         cFYI(1, ("In Windows reparse style QueryLink for path %s", searchName));
2581         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
2582                       (void **) &pSMBr);
2583         if (rc)
2584                 return rc;
2585
2586         pSMB->TotalParameterCount = 0 ;
2587         pSMB->TotalDataCount = 0;
2588         pSMB->MaxParameterCount = cpu_to_le32(2);
2589         /* BB find exact data count max from sess structure BB */
2590         pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
2591                                           MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
2592         pSMB->MaxSetupCount = 4;
2593         pSMB->Reserved = 0;
2594         pSMB->ParameterOffset = 0;
2595         pSMB->DataCount = 0;
2596         pSMB->DataOffset = 0;
2597         pSMB->SetupCount = 4;
2598         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_IOCTL);
2599         pSMB->ParameterCount = pSMB->TotalParameterCount;
2600         pSMB->FunctionCode = cpu_to_le32(FSCTL_GET_REPARSE_POINT);
2601         pSMB->IsFsctl = 1; /* FSCTL */
2602         pSMB->IsRootFlag = 0;
2603         pSMB->Fid = fid; /* file handle always le */
2604         pSMB->ByteCount = 0;
2605
2606         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2607                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2608         if (rc) {
2609                 cFYI(1, ("Send error in QueryReparseLinkInfo = %d", rc));
2610         } else {                /* decode response */
2611                 __u32 data_offset = le32_to_cpu(pSMBr->DataOffset);
2612                 __u32 data_count = le32_to_cpu(pSMBr->DataCount);
2613                 if ((pSMBr->ByteCount < 2) || (data_offset > 512))
2614                 /* BB also check enough total bytes returned */
2615                         rc = -EIO;      /* bad smb */
2616                 else {
2617                         if (data_count && (data_count < 2048)) {
2618                                 char *end_of_smb = 2 /* sizeof byte count */ +
2619                                                 pSMBr->ByteCount +
2620                                                 (char *)&pSMBr->ByteCount;
2621
2622                                 struct reparse_data *reparse_buf =
2623                                                 (struct reparse_data *)
2624                                                 ((char *)&pSMBr->hdr.Protocol
2625                                                                  + data_offset);
2626                                 if ((char *)reparse_buf >= end_of_smb) {
2627                                         rc = -EIO;
2628                                         goto qreparse_out;
2629                                 }
2630                                 if ((reparse_buf->LinkNamesBuf +
2631                                         reparse_buf->TargetNameOffset +
2632                                         reparse_buf->TargetNameLen) >
2633                                                 end_of_smb) {
2634                                         cFYI(1, ("reparse buf beyond SMB"));
2635                                         rc = -EIO;
2636                                         goto qreparse_out;
2637                                 }
2638
2639                                 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
2640                                         name_len = UniStrnlen((wchar_t *)
2641                                                 (reparse_buf->LinkNamesBuf +
2642                                                 reparse_buf->TargetNameOffset),
2643                                                 min(buflen/2,
2644                                                 reparse_buf->TargetNameLen / 2));
2645                                         cifs_strfromUCS_le(symlinkinfo,
2646                                                 (__le16 *) (reparse_buf->LinkNamesBuf +
2647                                                 reparse_buf->TargetNameOffset),
2648                                                 name_len, nls_codepage);
2649                                 } else { /* ASCII names */
2650                                         strncpy(symlinkinfo,
2651                                                 reparse_buf->LinkNamesBuf +
2652                                                 reparse_buf->TargetNameOffset,
2653                                                 min_t(const int, buflen,
2654                                                    reparse_buf->TargetNameLen));
2655                                 }
2656                         } else {
2657                                 rc = -EIO;
2658                                 cFYI(1, ("Invalid return data count on "
2659                                          "get reparse info ioctl"));
2660                         }
2661                         symlinkinfo[buflen] = 0; /* just in case so the caller
2662                                         does not go off the end of the buffer */
2663                         cFYI(1, ("readlink result - %s", symlinkinfo));
2664                 }
2665         }
2666 qreparse_out:
2667         cifs_buf_release(pSMB);
2668
2669         /* Note: On -EAGAIN error only caller can retry on handle based calls
2670                 since file handle passed in no longer valid */
2671
2672         return rc;
2673 }
2674
2675 #ifdef CONFIG_CIFS_POSIX
2676
2677 /*Convert an Access Control Entry from wire format to local POSIX xattr format*/
2678 static void cifs_convert_ace(posix_acl_xattr_entry *ace,
2679                              struct cifs_posix_ace *cifs_ace)
2680 {
2681         /* u8 cifs fields do not need le conversion */
2682         ace->e_perm = cpu_to_le16(cifs_ace->cifs_e_perm);
2683         ace->e_tag  = cpu_to_le16(cifs_ace->cifs_e_tag);
2684         ace->e_id   = cpu_to_le32(le64_to_cpu(cifs_ace->cifs_uid));
2685         /* cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id)); */
2686
2687         return;
2688 }
2689
2690 /* Convert ACL from CIFS POSIX wire format to local Linux POSIX ACL xattr */
2691 static int cifs_copy_posix_acl(char *trgt, char *src, const int buflen,
2692                                const int acl_type, const int size_of_data_area)
2693 {
2694         int size =  0;
2695         int i;
2696         __u16 count;
2697         struct cifs_posix_ace *pACE;
2698         struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)src;
2699         posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)trgt;
2700
2701         if (le16_to_cpu(cifs_acl->version) != CIFS_ACL_VERSION)
2702                 return -EOPNOTSUPP;
2703
2704         if (acl_type & ACL_TYPE_ACCESS) {
2705                 count = le16_to_cpu(cifs_acl->access_entry_count);
2706                 pACE = &cifs_acl->ace_array[0];
2707                 size = sizeof(struct cifs_posix_acl);
2708                 size += sizeof(struct cifs_posix_ace) * count;
2709                 /* check if we would go beyond end of SMB */
2710                 if (size_of_data_area < size) {
2711                         cFYI(1, ("bad CIFS POSIX ACL size %d vs. %d",
2712                                 size_of_data_area, size));
2713                         return -EINVAL;
2714                 }
2715         } else if (acl_type & ACL_TYPE_DEFAULT) {
2716                 count = le16_to_cpu(cifs_acl->access_entry_count);
2717                 size = sizeof(struct cifs_posix_acl);
2718                 size += sizeof(struct cifs_posix_ace) * count;
2719 /* skip past access ACEs to get to default ACEs */
2720                 pACE = &cifs_acl->ace_array[count];
2721                 count = le16_to_cpu(cifs_acl->default_entry_count);
2722                 size += sizeof(struct cifs_posix_ace) * count;
2723                 /* check if we would go beyond end of SMB */
2724                 if (size_of_data_area < size)
2725                         return -EINVAL;
2726         } else {
2727                 /* illegal type */
2728                 return -EINVAL;
2729         }
2730
2731         size = posix_acl_xattr_size(count);
2732         if ((buflen == 0) || (local_acl == NULL)) {
2733                 /* used to query ACL EA size */
2734         } else if (size > buflen) {
2735                 return -ERANGE;
2736         } else /* buffer big enough */ {
2737                 local_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
2738                 for (i = 0; i < count ; i++) {
2739                         cifs_convert_ace(&local_acl->a_entries[i], pACE);
2740                         pACE++;
2741                 }
2742         }
2743         return size;
2744 }
2745
2746 static __u16 convert_ace_to_cifs_ace(struct cifs_posix_ace *cifs_ace,
2747                                      const posix_acl_xattr_entry *local_ace)
2748 {
2749         __u16 rc = 0; /* 0 = ACL converted ok */
2750
2751         cifs_ace->cifs_e_perm = le16_to_cpu(local_ace->e_perm);
2752         cifs_ace->cifs_e_tag =  le16_to_cpu(local_ace->e_tag);
2753         /* BB is there a better way to handle the large uid? */
2754         if (local_ace->e_id == cpu_to_le32(-1)) {
2755         /* Probably no need to le convert -1 on any arch but can not hurt */
2756                 cifs_ace->cifs_uid = cpu_to_le64(-1);
2757         } else
2758                 cifs_ace->cifs_uid = cpu_to_le64(le32_to_cpu(local_ace->e_id));
2759         /*cFYI(1,("perm %d tag %d id %d",ace->e_perm,ace->e_tag,ace->e_id));*/
2760         return rc;
2761 }
2762
2763 /* Convert ACL from local Linux POSIX xattr to CIFS POSIX ACL wire format */
2764 static __u16 ACL_to_cifs_posix(char *parm_data, const char *pACL,
2765                                const int buflen, const int acl_type)
2766 {
2767         __u16 rc = 0;
2768         struct cifs_posix_acl *cifs_acl = (struct cifs_posix_acl *)parm_data;
2769         posix_acl_xattr_header *local_acl = (posix_acl_xattr_header *)pACL;
2770         int count;
2771         int i;
2772
2773         if ((buflen == 0) || (pACL == NULL) || (cifs_acl == NULL))
2774                 return 0;
2775
2776         count = posix_acl_xattr_count((size_t)buflen);
2777         cFYI(1, ("setting acl with %d entries from buf of length %d and "
2778                 "version of %d",
2779                 count, buflen, le32_to_cpu(local_acl->a_version)));
2780         if (le32_to_cpu(local_acl->a_version) != 2) {
2781                 cFYI(1, ("unknown POSIX ACL version %d",
2782                      le32_to_cpu(local_acl->a_version)));
2783                 return 0;
2784         }
2785         cifs_acl->version = cpu_to_le16(1);
2786         if (acl_type == ACL_TYPE_ACCESS)
2787                 cifs_acl->access_entry_count = cpu_to_le16(count);
2788         else if (acl_type == ACL_TYPE_DEFAULT)
2789                 cifs_acl->default_entry_count = cpu_to_le16(count);
2790         else {
2791                 cFYI(1, ("unknown ACL type %d", acl_type));
2792                 return 0;
2793         }
2794         for (i = 0; i < count; i++) {
2795                 rc = convert_ace_to_cifs_ace(&cifs_acl->ace_array[i],
2796                                         &local_acl->a_entries[i]);
2797                 if (rc != 0) {
2798                         /* ACE not converted */
2799                         break;
2800                 }
2801         }
2802         if (rc == 0) {
2803                 rc = (__u16)(count * sizeof(struct cifs_posix_ace));
2804                 rc += sizeof(struct cifs_posix_acl);
2805                 /* BB add check to make sure ACL does not overflow SMB */
2806         }
2807         return rc;
2808 }
2809
2810 int
2811 CIFSSMBGetPosixACL(const int xid, struct cifsTconInfo *tcon,
2812                    const unsigned char *searchName,
2813                    char *acl_inf, const int buflen, const int acl_type,
2814                    const struct nls_table *nls_codepage, int remap)
2815 {
2816 /* SMB_QUERY_POSIX_ACL */
2817         TRANSACTION2_QPI_REQ *pSMB = NULL;
2818         TRANSACTION2_QPI_RSP *pSMBr = NULL;
2819         int rc = 0;
2820         int bytes_returned;
2821         int name_len;
2822         __u16 params, byte_count;
2823
2824         cFYI(1, ("In GetPosixACL (Unix) for path %s", searchName));
2825
2826 queryAclRetry:
2827         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2828                 (void **) &pSMBr);
2829         if (rc)
2830                 return rc;
2831
2832         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2833                 name_len =
2834                         cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
2835                                          PATH_MAX, nls_codepage, remap);
2836                 name_len++;     /* trailing null */
2837                 name_len *= 2;
2838                 pSMB->FileName[name_len] = 0;
2839                 pSMB->FileName[name_len+1] = 0;
2840         } else {        /* BB improve the check for buffer overruns BB */
2841                 name_len = strnlen(searchName, PATH_MAX);
2842                 name_len++;     /* trailing null */
2843                 strncpy(pSMB->FileName, searchName, name_len);
2844         }
2845
2846         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
2847         pSMB->TotalDataCount = 0;
2848         pSMB->MaxParameterCount = cpu_to_le16(2);
2849         /* BB find exact max data count below from sess structure BB */
2850         pSMB->MaxDataCount = cpu_to_le16(4000);
2851         pSMB->MaxSetupCount = 0;
2852         pSMB->Reserved = 0;
2853         pSMB->Flags = 0;
2854         pSMB->Timeout = 0;
2855         pSMB->Reserved2 = 0;
2856         pSMB->ParameterOffset = cpu_to_le16(
2857                 offsetof(struct smb_com_transaction2_qpi_req,
2858                          InformationLevel) - 4);
2859         pSMB->DataCount = 0;
2860         pSMB->DataOffset = 0;
2861         pSMB->SetupCount = 1;
2862         pSMB->Reserved3 = 0;
2863         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
2864         byte_count = params + 1 /* pad */ ;
2865         pSMB->TotalParameterCount = cpu_to_le16(params);
2866         pSMB->ParameterCount = pSMB->TotalParameterCount;
2867         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_ACL);
2868         pSMB->Reserved4 = 0;
2869         pSMB->hdr.smb_buf_length += byte_count;
2870         pSMB->ByteCount = cpu_to_le16(byte_count);
2871
2872         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2873                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2874         cifs_stats_inc(&tcon->num_acl_get);
2875         if (rc) {
2876                 cFYI(1, ("Send error in Query POSIX ACL = %d", rc));
2877         } else {
2878                 /* decode response */
2879
2880                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
2881                 if (rc || (pSMBr->ByteCount < 2))
2882                 /* BB also check enough total bytes returned */
2883                         rc = -EIO;      /* bad smb */
2884                 else {
2885                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
2886                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
2887                         rc = cifs_copy_posix_acl(acl_inf,
2888                                 (char *)&pSMBr->hdr.Protocol+data_offset,
2889                                 buflen, acl_type, count);
2890                 }
2891         }
2892         cifs_buf_release(pSMB);
2893         if (rc == -EAGAIN)
2894                 goto queryAclRetry;
2895         return rc;
2896 }
2897
2898 int
2899 CIFSSMBSetPosixACL(const int xid, struct cifsTconInfo *tcon,
2900                    const unsigned char *fileName,
2901                    const char *local_acl, const int buflen,
2902                    const int acl_type,
2903                    const struct nls_table *nls_codepage, int remap)
2904 {
2905         struct smb_com_transaction2_spi_req *pSMB = NULL;
2906         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
2907         char *parm_data;
2908         int name_len;
2909         int rc = 0;
2910         int bytes_returned = 0;
2911         __u16 params, byte_count, data_count, param_offset, offset;
2912
2913         cFYI(1, ("In SetPosixACL (Unix) for path %s", fileName));
2914 setAclRetry:
2915         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2916                       (void **) &pSMBr);
2917         if (rc)
2918                 return rc;
2919         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
2920                 name_len =
2921                         cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
2922                                       PATH_MAX, nls_codepage, remap);
2923                 name_len++;     /* trailing null */
2924                 name_len *= 2;
2925         } else {        /* BB improve the check for buffer overruns BB */
2926                 name_len = strnlen(fileName, PATH_MAX);
2927                 name_len++;     /* trailing null */
2928                 strncpy(pSMB->FileName, fileName, name_len);
2929         }
2930         params = 6 + name_len;
2931         pSMB->MaxParameterCount = cpu_to_le16(2);
2932         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
2933         pSMB->MaxSetupCount = 0;
2934         pSMB->Reserved = 0;
2935         pSMB->Flags = 0;
2936         pSMB->Timeout = 0;
2937         pSMB->Reserved2 = 0;
2938         param_offset = offsetof(struct smb_com_transaction2_spi_req,
2939                                 InformationLevel) - 4;
2940         offset = param_offset + params;
2941         parm_data = ((char *) &pSMB->hdr.Protocol) + offset;
2942         pSMB->ParameterOffset = cpu_to_le16(param_offset);
2943
2944         /* convert to on the wire format for POSIX ACL */
2945         data_count = ACL_to_cifs_posix(parm_data, local_acl, buflen, acl_type);
2946
2947         if (data_count == 0) {
2948                 rc = -EOPNOTSUPP;
2949                 goto setACLerrorExit;
2950         }
2951         pSMB->DataOffset = cpu_to_le16(offset);
2952         pSMB->SetupCount = 1;
2953         pSMB->Reserved3 = 0;
2954         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
2955         pSMB->InformationLevel = cpu_to_le16(SMB_SET_POSIX_ACL);
2956         byte_count = 3 /* pad */  + params + data_count;
2957         pSMB->DataCount = cpu_to_le16(data_count);
2958         pSMB->TotalDataCount = pSMB->DataCount;
2959         pSMB->ParameterCount = cpu_to_le16(params);
2960         pSMB->TotalParameterCount = pSMB->ParameterCount;
2961         pSMB->Reserved4 = 0;
2962         pSMB->hdr.smb_buf_length += byte_count;
2963         pSMB->ByteCount = cpu_to_le16(byte_count);
2964         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
2965                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
2966         if (rc)
2967                 cFYI(1, ("Set POSIX ACL returned %d", rc));
2968
2969 setACLerrorExit:
2970         cifs_buf_release(pSMB);
2971         if (rc == -EAGAIN)
2972                 goto setAclRetry;
2973         return rc;
2974 }
2975
2976 /* BB fix tabs in this function FIXME BB */
2977 int
2978 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
2979                const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
2980 {
2981         int rc = 0;
2982         struct smb_t2_qfi_req *pSMB = NULL;
2983         struct smb_t2_qfi_rsp *pSMBr = NULL;
2984         int bytes_returned;
2985         __u16 params, byte_count;
2986
2987         cFYI(1, ("In GetExtAttr"));
2988         if (tcon == NULL)
2989                 return -ENODEV;
2990
2991 GetExtAttrRetry:
2992         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
2993                         (void **) &pSMBr);
2994         if (rc)
2995                 return rc;
2996
2997         params = 2 /* level */ + 2 /* fid */;
2998         pSMB->t2.TotalDataCount = 0;
2999         pSMB->t2.MaxParameterCount = cpu_to_le16(4);
3000         /* BB find exact max data count below from sess structure BB */
3001         pSMB->t2.MaxDataCount = cpu_to_le16(4000);
3002         pSMB->t2.MaxSetupCount = 0;
3003         pSMB->t2.Reserved = 0;
3004         pSMB->t2.Flags = 0;
3005         pSMB->t2.Timeout = 0;
3006         pSMB->t2.Reserved2 = 0;
3007         pSMB->t2.ParameterOffset = cpu_to_le16(offsetof(struct smb_t2_qfi_req,
3008                                                Fid) - 4);
3009         pSMB->t2.DataCount = 0;
3010         pSMB->t2.DataOffset = 0;
3011         pSMB->t2.SetupCount = 1;
3012         pSMB->t2.Reserved3 = 0;
3013         pSMB->t2.SubCommand = cpu_to_le16(TRANS2_QUERY_FILE_INFORMATION);
3014         byte_count = params + 1 /* pad */ ;
3015         pSMB->t2.TotalParameterCount = cpu_to_le16(params);
3016         pSMB->t2.ParameterCount = pSMB->t2.TotalParameterCount;
3017         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_ATTR_FLAGS);
3018         pSMB->Pad = 0;
3019         pSMB->Fid = netfid;
3020         pSMB->hdr.smb_buf_length += byte_count;
3021         pSMB->t2.ByteCount = cpu_to_le16(byte_count);
3022
3023         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3024                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3025         if (rc) {
3026                 cFYI(1, ("error %d in GetExtAttr", rc));
3027         } else {
3028                 /* decode response */
3029                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3030                 if (rc || (pSMBr->ByteCount < 2))
3031                 /* BB also check enough total bytes returned */
3032                         /* If rc should we check for EOPNOSUPP and
3033                            disable the srvino flag? or in caller? */
3034                         rc = -EIO;      /* bad smb */
3035                 else {
3036                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3037                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3038                         struct file_chattr_info *pfinfo;
3039                         /* BB Do we need a cast or hash here ? */
3040                         if (count != 16) {
3041                                 cFYI(1, ("Illegal size ret in GetExtAttr"));
3042                                 rc = -EIO;
3043                                 goto GetExtAttrOut;
3044                         }
3045                         pfinfo = (struct file_chattr_info *)
3046                                  (data_offset + (char *) &pSMBr->hdr.Protocol);
3047                         *pExtAttrBits = le64_to_cpu(pfinfo->mode);
3048                         *pMask = le64_to_cpu(pfinfo->mask);
3049                 }
3050         }
3051 GetExtAttrOut:
3052         cifs_buf_release(pSMB);
3053         if (rc == -EAGAIN)
3054                 goto GetExtAttrRetry;
3055         return rc;
3056 }
3057
3058 #endif /* CONFIG_POSIX */
3059
3060 #ifdef CONFIG_CIFS_EXPERIMENTAL
3061 /* Get Security Descriptor (by handle) from remote server for a file or dir */
3062 int
3063 CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
3064                   struct cifs_ntsd **acl_inf, __u32 *pbuflen)
3065 {
3066         int rc = 0;
3067         int buf_type = 0;
3068         QUERY_SEC_DESC_REQ *pSMB;
3069         struct kvec iov[1];
3070
3071         cFYI(1, ("GetCifsACL"));
3072
3073         *pbuflen = 0;
3074         *acl_inf = NULL;
3075
3076         rc = smb_init_nttransact(NT_TRANSACT_QUERY_SECURITY_DESC, 0,
3077                         8 /* parm len */, tcon, (void **) &pSMB);
3078         if (rc)
3079                 return rc;
3080
3081         pSMB->MaxParameterCount = cpu_to_le32(4);
3082         /* BB TEST with big acls that might need to be e.g. larger than 16K */
3083         pSMB->MaxSetupCount = 0;
3084         pSMB->Fid = fid; /* file handle always le */
3085         pSMB->AclFlags = cpu_to_le32(CIFS_ACL_OWNER | CIFS_ACL_GROUP |
3086                                      CIFS_ACL_DACL);
3087         pSMB->ByteCount = cpu_to_le16(11); /* 3 bytes pad + 8 bytes parm */
3088         pSMB->hdr.smb_buf_length += 11;
3089         iov[0].iov_base = (char *)pSMB;
3090         iov[0].iov_len = pSMB->hdr.smb_buf_length + 4;
3091
3092         rc = SendReceive2(xid, tcon->ses, iov, 1 /* num iovec */, &buf_type,
3093                          CIFS_STD_OP);
3094         cifs_stats_inc(&tcon->num_acl_get);
3095         if (rc) {
3096                 cFYI(1, ("Send error in QuerySecDesc = %d", rc));
3097         } else {                /* decode response */
3098                 __le32 *parm;
3099                 __u32 parm_len;
3100                 __u32 acl_len;
3101                 struct smb_com_ntransact_rsp *pSMBr;
3102                 char *pdata;
3103
3104 /* validate_nttransact */
3105                 rc = validate_ntransact(iov[0].iov_base, (char **)&parm,
3106                                         &pdata, &parm_len, pbuflen);
3107                 if (rc)
3108                         goto qsec_out;
3109                 pSMBr = (struct smb_com_ntransact_rsp *)iov[0].iov_base;
3110
3111                 cFYI(1, ("smb %p parm %p data %p", pSMBr, parm, *acl_inf));
3112
3113                 if (le32_to_cpu(pSMBr->ParameterCount) != 4) {
3114                         rc = -EIO;      /* bad smb */
3115                         *pbuflen = 0;
3116                         goto qsec_out;
3117                 }
3118
3119 /* BB check that data area is minimum length and as big as acl_len */
3120
3121                 acl_len = le32_to_cpu(*parm);
3122                 if (acl_len != *pbuflen) {
3123                         cERROR(1, ("acl length %d does not match %d",
3124                                    acl_len, *pbuflen));
3125                         if (*pbuflen > acl_len)
3126                                 *pbuflen = acl_len;
3127                 }
3128
3129                 /* check if buffer is big enough for the acl
3130                    header followed by the smallest SID */
3131                 if ((*pbuflen < sizeof(struct cifs_ntsd) + 8) ||
3132                     (*pbuflen >= 64 * 1024)) {
3133                         cERROR(1, ("bad acl length %d", *pbuflen));
3134                         rc = -EINVAL;
3135                         *pbuflen = 0;
3136                 } else {
3137                         *acl_inf = kmalloc(*pbuflen, GFP_KERNEL);
3138                         if (*acl_inf == NULL) {
3139                                 *pbuflen = 0;
3140                                 rc = -ENOMEM;
3141                         }
3142                         memcpy(*acl_inf, pdata, *pbuflen);
3143                 }
3144         }
3145 qsec_out:
3146         if (buf_type == CIFS_SMALL_BUFFER)
3147                 cifs_small_buf_release(iov[0].iov_base);
3148         else if (buf_type == CIFS_LARGE_BUFFER)
3149                 cifs_buf_release(iov[0].iov_base);
3150 /*      cifs_small_buf_release(pSMB); */ /* Freed earlier now in SendReceive2 */
3151         return rc;
3152 }
3153
3154 int
3155 CIFSSMBSetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
3156                         struct cifs_ntsd *pntsd, __u32 acllen)
3157 {
3158         __u16 byte_count, param_count, data_count, param_offset, data_offset;
3159         int rc = 0;
3160         int bytes_returned = 0;
3161         SET_SEC_DESC_REQ *pSMB = NULL;
3162         NTRANSACT_RSP *pSMBr = NULL;
3163
3164 setCifsAclRetry:
3165         rc = smb_init(SMB_COM_NT_TRANSACT, 19, tcon, (void **) &pSMB,
3166                         (void **) &pSMBr);
3167         if (rc)
3168                         return (rc);
3169
3170         pSMB->MaxSetupCount = 0;
3171         pSMB->Reserved = 0;
3172
3173         param_count = 8;
3174         param_offset = offsetof(struct smb_com_transaction_ssec_req, Fid) - 4;
3175         data_count = acllen;
3176         data_offset = param_offset + param_count;
3177         byte_count = 3 /* pad */  + param_count;
3178
3179         pSMB->DataCount = cpu_to_le32(data_count);
3180         pSMB->TotalDataCount = pSMB->DataCount;
3181         pSMB->MaxParameterCount = cpu_to_le32(4);
3182         pSMB->MaxDataCount = cpu_to_le32(16384);
3183         pSMB->ParameterCount = cpu_to_le32(param_count);
3184         pSMB->ParameterOffset = cpu_to_le32(param_offset);
3185         pSMB->TotalParameterCount = pSMB->ParameterCount;
3186         pSMB->DataOffset = cpu_to_le32(data_offset);
3187         pSMB->SetupCount = 0;
3188         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_SET_SECURITY_DESC);
3189         pSMB->ByteCount = cpu_to_le16(byte_count+data_count);
3190
3191         pSMB->Fid = fid; /* file handle always le */
3192         pSMB->Reserved2 = 0;
3193         pSMB->AclFlags = cpu_to_le32(CIFS_ACL_DACL);
3194
3195         if (pntsd && acllen) {
3196                 memcpy((char *) &pSMBr->hdr.Protocol + data_offset,
3197                         (char *) pntsd,
3198                         acllen);
3199                 pSMB->hdr.smb_buf_length += (byte_count + data_count);
3200
3201         } else
3202                 pSMB->hdr.smb_buf_length += byte_count;
3203
3204         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3205                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3206
3207         cFYI(1, ("SetCIFSACL bytes_returned: %d, rc: %d", bytes_returned, rc));
3208         if (rc)
3209                 cFYI(1, ("Set CIFS ACL returned %d", rc));
3210         cifs_buf_release(pSMB);
3211
3212         if (rc == -EAGAIN)
3213                 goto setCifsAclRetry;
3214
3215         return (rc);
3216 }
3217
3218 #endif /* CONFIG_CIFS_EXPERIMENTAL */
3219
3220 /* Legacy Query Path Information call for lookup to old servers such
3221    as Win9x/WinME */
3222 int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
3223                         const unsigned char *searchName,
3224                         FILE_ALL_INFO *pFinfo,
3225                         const struct nls_table *nls_codepage, int remap)
3226 {
3227         QUERY_INFORMATION_REQ *pSMB;
3228         QUERY_INFORMATION_RSP *pSMBr;
3229         int rc = 0;
3230         int bytes_returned;
3231         int name_len;
3232
3233         cFYI(1, ("In SMBQPath path %s", searchName));
3234 QInfRetry:
3235         rc = smb_init(SMB_COM_QUERY_INFORMATION, 0, tcon, (void **) &pSMB,
3236                       (void **) &pSMBr);
3237         if (rc)
3238                 return rc;
3239
3240         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3241                 name_len =
3242                         cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3243                                         PATH_MAX, nls_codepage, remap);
3244                 name_len++;     /* trailing null */
3245                 name_len *= 2;
3246         } else {
3247                 name_len = strnlen(searchName, PATH_MAX);
3248                 name_len++;     /* trailing null */
3249                 strncpy(pSMB->FileName, searchName, name_len);
3250         }
3251         pSMB->BufferFormat = 0x04;
3252         name_len++; /* account for buffer type byte */
3253         pSMB->hdr.smb_buf_length += (__u16) name_len;
3254         pSMB->ByteCount = cpu_to_le16(name_len);
3255
3256         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3257                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3258         if (rc) {
3259                 cFYI(1, ("Send error in QueryInfo = %d", rc));
3260         } else if (pFinfo) {
3261                 struct timespec ts;
3262                 __u32 time = le32_to_cpu(pSMBr->last_write_time);
3263
3264                 /* decode response */
3265                 /* BB FIXME - add time zone adjustment BB */
3266                 memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
3267                 ts.tv_nsec = 0;
3268                 ts.tv_sec = time;
3269                 /* decode time fields */
3270                 pFinfo->ChangeTime = cpu_to_le64(cifs_UnixTimeToNT(ts));
3271                 pFinfo->LastWriteTime = pFinfo->ChangeTime;
3272                 pFinfo->LastAccessTime = 0;
3273                 pFinfo->AllocationSize =
3274                         cpu_to_le64(le32_to_cpu(pSMBr->size));
3275                 pFinfo->EndOfFile = pFinfo->AllocationSize;
3276                 pFinfo->Attributes =
3277                         cpu_to_le32(le16_to_cpu(pSMBr->attr));
3278         } else
3279                 rc = -EIO; /* bad buffer passed in */
3280
3281         cifs_buf_release(pSMB);
3282
3283         if (rc == -EAGAIN)
3284                 goto QInfRetry;
3285
3286         return rc;
3287 }
3288
3289
3290
3291
3292 int
3293 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
3294                  const unsigned char *searchName,
3295                  FILE_ALL_INFO *pFindData,
3296                  int legacy /* old style infolevel */,
3297                  const struct nls_table *nls_codepage, int remap)
3298 {
3299 /* level 263 SMB_QUERY_FILE_ALL_INFO */
3300         TRANSACTION2_QPI_REQ *pSMB = NULL;
3301         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3302         int rc = 0;
3303         int bytes_returned;
3304         int name_len;
3305         __u16 params, byte_count;
3306
3307 /* cFYI(1, ("In QPathInfo path %s", searchName)); */
3308 QPathInfoRetry:
3309         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3310                       (void **) &pSMBr);
3311         if (rc)
3312                 return rc;
3313
3314         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3315                 name_len =
3316                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3317                                      PATH_MAX, nls_codepage, remap);
3318                 name_len++;     /* trailing null */
3319                 name_len *= 2;
3320         } else {        /* BB improve the check for buffer overruns BB */
3321                 name_len = strnlen(searchName, PATH_MAX);
3322                 name_len++;     /* trailing null */
3323                 strncpy(pSMB->FileName, searchName, name_len);
3324         }
3325
3326         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3327         pSMB->TotalDataCount = 0;
3328         pSMB->MaxParameterCount = cpu_to_le16(2);
3329         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3330         pSMB->MaxSetupCount = 0;
3331         pSMB->Reserved = 0;
3332         pSMB->Flags = 0;
3333         pSMB->Timeout = 0;
3334         pSMB->Reserved2 = 0;
3335         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3336         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3337         pSMB->DataCount = 0;
3338         pSMB->DataOffset = 0;
3339         pSMB->SetupCount = 1;
3340         pSMB->Reserved3 = 0;
3341         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3342         byte_count = params + 1 /* pad */ ;
3343         pSMB->TotalParameterCount = cpu_to_le16(params);
3344         pSMB->ParameterCount = pSMB->TotalParameterCount;
3345         if (legacy)
3346                 pSMB->InformationLevel = cpu_to_le16(SMB_INFO_STANDARD);
3347         else
3348                 pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_ALL_INFO);
3349         pSMB->Reserved4 = 0;
3350         pSMB->hdr.smb_buf_length += byte_count;
3351         pSMB->ByteCount = cpu_to_le16(byte_count);
3352
3353         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3354                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3355         if (rc) {
3356                 cFYI(1, ("Send error in QPathInfo = %d", rc));
3357         } else {                /* decode response */
3358                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3359
3360                 if (rc) /* BB add auto retry on EOPNOTSUPP? */
3361                         rc = -EIO;
3362                 else if (!legacy && (pSMBr->ByteCount < 40))
3363                         rc = -EIO;      /* bad smb */
3364                 else if (legacy && (pSMBr->ByteCount < 24))
3365                         rc = -EIO;  /* 24 or 26 expected but we do not read
3366                                         last field */
3367                 else if (pFindData) {
3368                         int size;
3369                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3370
3371                         /* On legacy responses we do not read the last field,
3372                         EAsize, fortunately since it varies by subdialect and
3373                         also note it differs on Set vs. Get, ie two bytes or 4
3374                         bytes depending but we don't care here */
3375                         if (legacy)
3376                                 size = sizeof(FILE_INFO_STANDARD);
3377                         else
3378                                 size = sizeof(FILE_ALL_INFO);
3379                         memcpy((char *) pFindData,
3380                                (char *) &pSMBr->hdr.Protocol +
3381                                data_offset, size);
3382                 } else
3383                     rc = -ENOMEM;
3384         }
3385         cifs_buf_release(pSMB);
3386         if (rc == -EAGAIN)
3387                 goto QPathInfoRetry;
3388
3389         return rc;
3390 }
3391
3392 int
3393 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
3394                      const unsigned char *searchName,
3395                      FILE_UNIX_BASIC_INFO * pFindData,
3396                      const struct nls_table *nls_codepage, int remap)
3397 {
3398 /* SMB_QUERY_FILE_UNIX_BASIC */
3399         TRANSACTION2_QPI_REQ *pSMB = NULL;
3400         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3401         int rc = 0;
3402         int bytes_returned = 0;
3403         int name_len;
3404         __u16 params, byte_count;
3405
3406         cFYI(1, ("In QPathInfo (Unix) the path %s", searchName));
3407 UnixQPathInfoRetry:
3408         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3409                       (void **) &pSMBr);
3410         if (rc)
3411                 return rc;
3412
3413         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3414                 name_len =
3415                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3416                                   PATH_MAX, nls_codepage, remap);
3417                 name_len++;     /* trailing null */
3418                 name_len *= 2;
3419         } else {        /* BB improve the check for buffer overruns BB */
3420                 name_len = strnlen(searchName, PATH_MAX);
3421                 name_len++;     /* trailing null */
3422                 strncpy(pSMB->FileName, searchName, name_len);
3423         }
3424
3425         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
3426         pSMB->TotalDataCount = 0;
3427         pSMB->MaxParameterCount = cpu_to_le16(2);
3428         /* BB find exact max SMB PDU from sess structure BB */
3429         pSMB->MaxDataCount = cpu_to_le16(4000);
3430         pSMB->MaxSetupCount = 0;
3431         pSMB->Reserved = 0;
3432         pSMB->Flags = 0;
3433         pSMB->Timeout = 0;
3434         pSMB->Reserved2 = 0;
3435         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3436         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3437         pSMB->DataCount = 0;
3438         pSMB->DataOffset = 0;
3439         pSMB->SetupCount = 1;
3440         pSMB->Reserved3 = 0;
3441         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3442         byte_count = params + 1 /* pad */ ;
3443         pSMB->TotalParameterCount = cpu_to_le16(params);
3444         pSMB->ParameterCount = pSMB->TotalParameterCount;
3445         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC);
3446         pSMB->Reserved4 = 0;
3447         pSMB->hdr.smb_buf_length += byte_count;
3448         pSMB->ByteCount = cpu_to_le16(byte_count);
3449
3450         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3451                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3452         if (rc) {
3453                 cFYI(1, ("Send error in QPathInfo = %d", rc));
3454         } else {                /* decode response */
3455                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3456
3457                 if (rc || (pSMBr->ByteCount < sizeof(FILE_UNIX_BASIC_INFO))) {
3458                         cERROR(1, ("Malformed FILE_UNIX_BASIC_INFO response.\n"
3459                                    "Unix Extensions can be disabled on mount "
3460                                    "by specifying the nosfu mount option."));
3461                         rc = -EIO;      /* bad smb */
3462                 } else {
3463                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3464                         memcpy((char *) pFindData,
3465                                (char *) &pSMBr->hdr.Protocol +
3466                                data_offset,
3467                                sizeof(FILE_UNIX_BASIC_INFO));
3468                 }
3469         }
3470         cifs_buf_release(pSMB);
3471         if (rc == -EAGAIN)
3472                 goto UnixQPathInfoRetry;
3473
3474         return rc;
3475 }
3476
3477 /* xid, tcon, searchName and codepage are input parms, rest are returned */
3478 int
3479 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
3480               const char *searchName,
3481               const struct nls_table *nls_codepage,
3482               __u16 *pnetfid,
3483               struct cifs_search_info *psrch_inf, int remap, const char dirsep)
3484 {
3485 /* level 257 SMB_ */
3486         TRANSACTION2_FFIRST_REQ *pSMB = NULL;
3487         TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
3488         T2_FFIRST_RSP_PARMS *parms;
3489         int rc = 0;
3490         int bytes_returned = 0;
3491         int name_len;
3492         __u16 params, byte_count;
3493
3494         cFYI(1, ("In FindFirst for %s", searchName));
3495
3496 findFirstRetry:
3497         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3498                       (void **) &pSMBr);
3499         if (rc)
3500                 return rc;
3501
3502         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3503                 name_len =
3504                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3505                                  PATH_MAX, nls_codepage, remap);
3506                 /* We can not add the asterik earlier in case
3507                 it got remapped to 0xF03A as if it were part of the
3508                 directory name instead of a wildcard */
3509                 name_len *= 2;
3510                 pSMB->FileName[name_len] = dirsep;
3511                 pSMB->FileName[name_len+1] = 0;
3512                 pSMB->FileName[name_len+2] = '*';
3513                 pSMB->FileName[name_len+3] = 0;
3514                 name_len += 4; /* now the trailing null */
3515                 pSMB->FileName[name_len] = 0; /* null terminate just in case */
3516                 pSMB->FileName[name_len+1] = 0;
3517                 name_len += 2;
3518         } else {        /* BB add check for overrun of SMB buf BB */
3519                 name_len = strnlen(searchName, PATH_MAX);
3520 /* BB fix here and in unicode clause above ie
3521                 if (name_len > buffersize-header)
3522                         free buffer exit; BB */
3523                 strncpy(pSMB->FileName, searchName, name_len);
3524                 pSMB->FileName[name_len] = dirsep;
3525                 pSMB->FileName[name_len+1] = '*';
3526                 pSMB->FileName[name_len+2] = 0;
3527                 name_len += 3;
3528         }
3529
3530         params = 12 + name_len /* includes null */ ;
3531         pSMB->TotalDataCount = 0;       /* no EAs */
3532         pSMB->MaxParameterCount = cpu_to_le16(10);
3533         pSMB->MaxDataCount = cpu_to_le16((tcon->ses->server->maxBuf -
3534                                           MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
3535         pSMB->MaxSetupCount = 0;
3536         pSMB->Reserved = 0;
3537         pSMB->Flags = 0;
3538         pSMB->Timeout = 0;
3539         pSMB->Reserved2 = 0;
3540         byte_count = params + 1 /* pad */ ;
3541         pSMB->TotalParameterCount = cpu_to_le16(params);
3542         pSMB->ParameterCount = pSMB->TotalParameterCount;
3543         pSMB->ParameterOffset = cpu_to_le16(
3544               offsetof(struct smb_com_transaction2_ffirst_req, SearchAttributes)
3545                 - 4);
3546         pSMB->DataCount = 0;
3547         pSMB->DataOffset = 0;
3548         pSMB->SetupCount = 1;   /* one byte, no need to make endian neutral */
3549         pSMB->Reserved3 = 0;
3550         pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
3551         pSMB->SearchAttributes =
3552             cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
3553                         ATTR_DIRECTORY);
3554         pSMB->SearchCount = cpu_to_le16(CIFSMaxBufSize/sizeof(FILE_UNIX_INFO));
3555         pSMB->SearchFlags = cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END |
3556                 CIFS_SEARCH_RETURN_RESUME);
3557         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3558
3559         /* BB what should we set StorageType to? Does it matter? BB */
3560         pSMB->SearchStorageType = 0;
3561         pSMB->hdr.smb_buf_length += byte_count;
3562         pSMB->ByteCount = cpu_to_le16(byte_count);
3563
3564         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3565                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3566         cifs_stats_inc(&tcon->num_ffirst);
3567
3568         if (rc) {/* BB add logic to retry regular search if Unix search
3569                         rejected unexpectedly by server */
3570                 /* BB Add code to handle unsupported level rc */
3571                 cFYI(1, ("Error in FindFirst = %d", rc));
3572
3573                 cifs_buf_release(pSMB);
3574
3575                 /* BB eventually could optimize out free and realloc of buf */
3576                 /*    for this case */
3577                 if (rc == -EAGAIN)
3578                         goto findFirstRetry;
3579         } else { /* decode response */
3580                 /* BB remember to free buffer if error BB */
3581                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3582                 if (rc == 0) {
3583                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3584                                 psrch_inf->unicode = TRUE;
3585                         else
3586                                 psrch_inf->unicode = FALSE;
3587
3588                         psrch_inf->ntwrk_buf_start = (char *)pSMBr;
3589                         psrch_inf->smallBuf = 0;
3590                         psrch_inf->srch_entries_start =
3591                                 (char *) &pSMBr->hdr.Protocol +
3592                                         le16_to_cpu(pSMBr->t2.DataOffset);
3593                         parms = (T2_FFIRST_RSP_PARMS *)((char *) &pSMBr->hdr.Protocol +
3594                                le16_to_cpu(pSMBr->t2.ParameterOffset));
3595
3596                         if (parms->EndofSearch)
3597                                 psrch_inf->endOfSearch = TRUE;
3598                         else
3599                                 psrch_inf->endOfSearch = FALSE;
3600
3601                         psrch_inf->entries_in_buffer =
3602                                         le16_to_cpu(parms->SearchCount);
3603                         psrch_inf->index_of_last_entry = 2 /* skip . and .. */ +
3604                                 psrch_inf->entries_in_buffer;
3605                         *pnetfid = parms->SearchHandle;
3606                 } else {
3607                         cifs_buf_release(pSMB);
3608                 }
3609         }
3610
3611         return rc;
3612 }
3613
3614 int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
3615                  __u16 searchHandle, struct cifs_search_info *psrch_inf)
3616 {
3617         TRANSACTION2_FNEXT_REQ *pSMB = NULL;
3618         TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
3619         T2_FNEXT_RSP_PARMS *parms;
3620         char *response_data;
3621         int rc = 0;
3622         int bytes_returned, name_len;
3623         __u16 params, byte_count;
3624
3625         cFYI(1, ("In FindNext"));
3626
3627         if (psrch_inf->endOfSearch == TRUE)
3628                 return -ENOENT;
3629
3630         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3631                 (void **) &pSMBr);
3632         if (rc)
3633                 return rc;
3634
3635         params = 14; /* includes 2 bytes of null string, converted to LE below*/
3636         byte_count = 0;
3637         pSMB->TotalDataCount = 0;       /* no EAs */
3638         pSMB->MaxParameterCount = cpu_to_le16(8);
3639         pSMB->MaxDataCount =
3640                 cpu_to_le16((tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) &
3641                                 0xFFFFFF00);
3642         pSMB->MaxSetupCount = 0;
3643         pSMB->Reserved = 0;
3644         pSMB->Flags = 0;
3645         pSMB->Timeout = 0;
3646         pSMB->Reserved2 = 0;
3647         pSMB->ParameterOffset =  cpu_to_le16(
3648               offsetof(struct smb_com_transaction2_fnext_req,SearchHandle) - 4);
3649         pSMB->DataCount = 0;
3650         pSMB->DataOffset = 0;
3651         pSMB->SetupCount = 1;
3652         pSMB->Reserved3 = 0;
3653         pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_NEXT);
3654         pSMB->SearchHandle = searchHandle;      /* always kept as le */
3655         pSMB->SearchCount =
3656                 cpu_to_le16(CIFSMaxBufSize / sizeof(FILE_UNIX_INFO));
3657         pSMB->InformationLevel = cpu_to_le16(psrch_inf->info_level);
3658         pSMB->ResumeKey = psrch_inf->resume_key;
3659         pSMB->SearchFlags =
3660               cpu_to_le16(CIFS_SEARCH_CLOSE_AT_END | CIFS_SEARCH_RETURN_RESUME);
3661
3662         name_len = psrch_inf->resume_name_len;
3663         params += name_len;
3664         if (name_len < PATH_MAX) {
3665                 memcpy(pSMB->ResumeFileName, psrch_inf->presume_name, name_len);
3666                 byte_count += name_len;
3667                 /* 14 byte parm len above enough for 2 byte null terminator */
3668                 pSMB->ResumeFileName[name_len] = 0;
3669                 pSMB->ResumeFileName[name_len+1] = 0;
3670         } else {
3671                 rc = -EINVAL;
3672                 goto FNext2_err_exit;
3673         }
3674         byte_count = params + 1 /* pad */ ;
3675         pSMB->TotalParameterCount = cpu_to_le16(params);
3676         pSMB->ParameterCount = pSMB->TotalParameterCount;
3677         pSMB->hdr.smb_buf_length += byte_count;
3678         pSMB->ByteCount = cpu_to_le16(byte_count);
3679
3680         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3681                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3682         cifs_stats_inc(&tcon->num_fnext);
3683         if (rc) {
3684                 if (rc == -EBADF) {
3685                         psrch_inf->endOfSearch = TRUE;
3686                         rc = 0; /* search probably was closed at end of search*/
3687                 } else
3688                         cFYI(1, ("FindNext returned = %d", rc));
3689         } else {                /* decode response */
3690                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3691
3692                 if (rc == 0) {
3693                         /* BB fixme add lock for file (srch_info) struct here */
3694                         if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE)
3695                                 psrch_inf->unicode = TRUE;
3696                         else
3697                                 psrch_inf->unicode = FALSE;
3698                         response_data = (char *) &pSMBr->hdr.Protocol +
3699                                le16_to_cpu(pSMBr->t2.ParameterOffset);
3700                         parms = (T2_FNEXT_RSP_PARMS *)response_data;
3701                         response_data = (char *)&pSMBr->hdr.Protocol +
3702                                 le16_to_cpu(pSMBr->t2.DataOffset);
3703                         if (psrch_inf->smallBuf)
3704                                 cifs_small_buf_release(
3705                                         psrch_inf->ntwrk_buf_start);
3706                         else
3707                                 cifs_buf_release(psrch_inf->ntwrk_buf_start);
3708                         psrch_inf->srch_entries_start = response_data;
3709                         psrch_inf->ntwrk_buf_start = (char *)pSMB;
3710                         psrch_inf->smallBuf = 0;
3711                         if (parms->EndofSearch)
3712                                 psrch_inf->endOfSearch = TRUE;
3713                         else
3714                                 psrch_inf->endOfSearch = FALSE;
3715                         psrch_inf->entries_in_buffer =
3716                                                 le16_to_cpu(parms->SearchCount);
3717                         psrch_inf->index_of_last_entry +=
3718                                 psrch_inf->entries_in_buffer;
3719 /*  cFYI(1,("fnxt2 entries in buf %d index_of_last %d",
3720             psrch_inf->entries_in_buffer, psrch_inf->index_of_last_entry)); */
3721
3722                         /* BB fixme add unlock here */
3723                 }
3724
3725         }
3726
3727         /* BB On error, should we leave previous search buf (and count and
3728         last entry fields) intact or free the previous one? */
3729
3730         /* Note: On -EAGAIN error only caller can retry on handle based calls
3731         since file handle passed in no longer valid */
3732 FNext2_err_exit:
3733         if (rc != 0)
3734                 cifs_buf_release(pSMB);
3735         return rc;
3736 }
3737
3738 int
3739 CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
3740               const __u16 searchHandle)
3741 {
3742         int rc = 0;
3743         FINDCLOSE_REQ *pSMB = NULL;
3744
3745         cFYI(1, ("In CIFSSMBFindClose"));
3746         rc = small_smb_init(SMB_COM_FIND_CLOSE2, 1, tcon, (void **)&pSMB);
3747
3748         /* no sense returning error if session restarted
3749                 as file handle has been closed */
3750         if (rc == -EAGAIN)
3751                 return 0;
3752         if (rc)
3753                 return rc;
3754
3755         pSMB->FileID = searchHandle;
3756         pSMB->ByteCount = 0;
3757         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
3758         if (rc)
3759                 cERROR(1, ("Send error in FindClose = %d", rc));
3760
3761         cifs_stats_inc(&tcon->num_fclose);
3762
3763         /* Since session is dead, search handle closed on server already */
3764         if (rc == -EAGAIN)
3765                 rc = 0;
3766
3767         return rc;
3768 }
3769
3770 int
3771 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
3772                       const unsigned char *searchName,
3773                       __u64 *inode_number,
3774                       const struct nls_table *nls_codepage, int remap)
3775 {
3776         int rc = 0;
3777         TRANSACTION2_QPI_REQ *pSMB = NULL;
3778         TRANSACTION2_QPI_RSP *pSMBr = NULL;
3779         int name_len, bytes_returned;
3780         __u16 params, byte_count;
3781
3782         cFYI(1, ("In GetSrvInodeNum for %s", searchName));
3783         if (tcon == NULL)
3784                 return -ENODEV;
3785
3786 GetInodeNumberRetry:
3787         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
3788                       (void **) &pSMBr);
3789         if (rc)
3790                 return rc;
3791
3792         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
3793                 name_len =
3794                         cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
3795                                          PATH_MAX, nls_codepage, remap);
3796                 name_len++;     /* trailing null */
3797                 name_len *= 2;
3798         } else {        /* BB improve the check for buffer overruns BB */
3799                 name_len = strnlen(searchName, PATH_MAX);
3800                 name_len++;     /* trailing null */
3801                 strncpy(pSMB->FileName, searchName, name_len);
3802         }
3803
3804         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
3805         pSMB->TotalDataCount = 0;
3806         pSMB->MaxParameterCount = cpu_to_le16(2);
3807         /* BB find exact max data count below from sess structure BB */
3808         pSMB->MaxDataCount = cpu_to_le16(4000);
3809         pSMB->MaxSetupCount = 0;
3810         pSMB->Reserved = 0;
3811         pSMB->Flags = 0;
3812         pSMB->Timeout = 0;
3813         pSMB->Reserved2 = 0;
3814         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3815                 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
3816         pSMB->DataCount = 0;
3817         pSMB->DataOffset = 0;
3818         pSMB->SetupCount = 1;
3819         pSMB->Reserved3 = 0;
3820         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
3821         byte_count = params + 1 /* pad */ ;
3822         pSMB->TotalParameterCount = cpu_to_le16(params);
3823         pSMB->ParameterCount = pSMB->TotalParameterCount;
3824         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FILE_INTERNAL_INFO);
3825         pSMB->Reserved4 = 0;
3826         pSMB->hdr.smb_buf_length += byte_count;
3827         pSMB->ByteCount = cpu_to_le16(byte_count);
3828
3829         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
3830                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3831         if (rc) {
3832                 cFYI(1, ("error %d in QueryInternalInfo", rc));
3833         } else {
3834                 /* decode response */
3835                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3836                 if (rc || (pSMBr->ByteCount < 2))
3837                 /* BB also check enough total bytes returned */
3838                         /* If rc should we check for EOPNOSUPP and
3839                         disable the srvino flag? or in caller? */
3840                         rc = -EIO;      /* bad smb */
3841                 else {
3842                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3843                         __u16 count = le16_to_cpu(pSMBr->t2.DataCount);
3844                         struct file_internal_info *pfinfo;
3845                         /* BB Do we need a cast or hash here ? */
3846                         if (count < 8) {
3847                                 cFYI(1, ("Illegal size ret in QryIntrnlInf"));
3848                                 rc = -EIO;
3849                                 goto GetInodeNumOut;
3850                         }
3851                         pfinfo = (struct file_internal_info *)
3852                                 (data_offset + (char *) &pSMBr->hdr.Protocol);
3853                         *inode_number = pfinfo->UniqueId;
3854                 }
3855         }
3856 GetInodeNumOut:
3857         cifs_buf_release(pSMB);
3858         if (rc == -EAGAIN)
3859                 goto GetInodeNumberRetry;
3860         return rc;
3861 }
3862
3863 int
3864 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
3865                 const unsigned char *searchName,
3866                 unsigned char **targetUNCs,
3867                 unsigned int *number_of_UNC_in_array,
3868                 const struct nls_table *nls_codepage, int remap)
3869 {
3870 /* TRANS2_GET_DFS_REFERRAL */
3871         TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
3872         TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
3873         struct dfs_referral_level_3 *referrals = NULL;
3874         int rc = 0;
3875         int bytes_returned;
3876         int name_len;
3877         unsigned int i;
3878         char *temp;
3879         __u16 params, byte_count;
3880         *number_of_UNC_in_array = 0;
3881         *targetUNCs = NULL;
3882
3883         cFYI(1, ("In GetDFSRefer the path %s", searchName));
3884         if (ses == NULL)
3885                 return -ENODEV;
3886 getDFSRetry:
3887         rc = smb_init(SMB_COM_TRANSACTION2, 15, NULL, (void **) &pSMB,
3888                       (void **) &pSMBr);
3889         if (rc)
3890                 return rc;
3891
3892         /* server pointer checked in called function,
3893         but should never be null here anyway */
3894         pSMB->hdr.Mid = GetNextMid(ses->server);
3895         pSMB->hdr.Tid = ses->ipc_tid;
3896         pSMB->hdr.Uid = ses->Suid;
3897         if (ses->capabilities & CAP_STATUS32)
3898                 pSMB->hdr.Flags2 |= SMBFLG2_ERR_STATUS;
3899         if (ses->capabilities & CAP_DFS)
3900                 pSMB->hdr.Flags2 |= SMBFLG2_DFS;
3901
3902         if (ses->capabilities & CAP_UNICODE) {
3903                 pSMB->hdr.Flags2 |= SMBFLG2_UNICODE;
3904                 name_len =
3905                     cifsConvertToUCS((__le16 *) pSMB->RequestFileName,
3906                                      searchName, PATH_MAX, nls_codepage, remap);
3907                 name_len++;     /* trailing null */
3908                 name_len *= 2;
3909         } else {        /* BB improve the check for buffer overruns BB */
3910                 name_len = strnlen(searchName, PATH_MAX);
3911                 name_len++;     /* trailing null */
3912                 strncpy(pSMB->RequestFileName, searchName, name_len);
3913         }
3914
3915         if (ses->server) {
3916                 if (ses->server->secMode &
3917                    (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3918                         pSMB->hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3919         }
3920
3921         pSMB->hdr.Uid = ses->Suid;
3922
3923         params = 2 /* level */  + name_len /*includes null */ ;
3924         pSMB->TotalDataCount = 0;
3925         pSMB->DataCount = 0;
3926         pSMB->DataOffset = 0;
3927         pSMB->MaxParameterCount = 0;
3928         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
3929         pSMB->MaxSetupCount = 0;
3930         pSMB->Reserved = 0;
3931         pSMB->Flags = 0;
3932         pSMB->Timeout = 0;
3933         pSMB->Reserved2 = 0;
3934         pSMB->ParameterOffset = cpu_to_le16(offsetof(
3935           struct smb_com_transaction2_get_dfs_refer_req, MaxReferralLevel) - 4);
3936         pSMB->SetupCount = 1;
3937         pSMB->Reserved3 = 0;
3938         pSMB->SubCommand = cpu_to_le16(TRANS2_GET_DFS_REFERRAL);
3939         byte_count = params + 3 /* pad */ ;
3940         pSMB->ParameterCount = cpu_to_le16(params);
3941         pSMB->TotalParameterCount = pSMB->ParameterCount;
3942         pSMB->MaxReferralLevel = cpu_to_le16(3);
3943         pSMB->hdr.smb_buf_length += byte_count;
3944         pSMB->ByteCount = cpu_to_le16(byte_count);
3945
3946         rc = SendReceive(xid, ses, (struct smb_hdr *) pSMB,
3947                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
3948         if (rc) {
3949                 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
3950         } else {                /* decode response */
3951 /* BB Add logic to parse referrals here */
3952                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
3953
3954                 /* BB Also check if enough total bytes returned? */
3955                 if (rc || (pSMBr->ByteCount < 17))
3956                         rc = -EIO;      /* bad smb */
3957                 else {
3958                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
3959                         __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
3960
3961                         cFYI(1,
3962                             ("Decoding GetDFSRefer response BCC: %d  Offset %d",
3963                               pSMBr->ByteCount, data_offset));
3964                         referrals =
3965                             (struct dfs_referral_level_3 *)
3966                                         (8 /* sizeof start of data block */ +
3967                                         data_offset +
3968                                         (char *) &pSMBr->hdr.Protocol);
3969                         cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n"
3970                                 "for referral one refer size: 0x%x srv "
3971                                 "type: 0x%x refer flags: 0x%x ttl: 0x%x",
3972                                 le16_to_cpu(pSMBr->NumberOfReferrals),
3973                                 le16_to_cpu(pSMBr->DFSFlags),
3974                                 le16_to_cpu(referrals->ReferralSize),
3975                                 le16_to_cpu(referrals->ServerType),
3976                                 le16_to_cpu(referrals->ReferralFlags),
3977                                 le16_to_cpu(referrals->TimeToLive)));
3978                         /* BB This field is actually two bytes in from start of
3979                            data block so we could do safety check that DataBlock
3980                            begins at address of pSMBr->NumberOfReferrals */
3981                         *number_of_UNC_in_array =
3982                                         le16_to_cpu(pSMBr->NumberOfReferrals);
3983
3984                         /* BB Fix below so can return more than one referral */
3985                         if (*number_of_UNC_in_array > 1)
3986                                 *number_of_UNC_in_array = 1;
3987
3988                         /* get the length of the strings describing refs */
3989                         name_len = 0;
3990                         for (i = 0; i < *number_of_UNC_in_array; i++) {
3991                                 /* make sure that DfsPathOffset not past end */
3992                                 __u16 offset =
3993                                         le16_to_cpu(referrals->DfsPathOffset);
3994                                 if (offset > data_count) {
3995                                         /* if invalid referral, stop here and do
3996                                         not try to copy any more */
3997                                         *number_of_UNC_in_array = i;
3998                                         break;
3999                                 }
4000                                 temp = ((char *)referrals) + offset;
4001
4002                                 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
4003                                         name_len += UniStrnlen((wchar_t *)temp,
4004                                                                 data_count);
4005                                 } else {
4006                                         name_len += strnlen(temp, data_count);
4007                                 }
4008                                 referrals++;
4009                                 /* BB add check that referral pointer does
4010                                    not fall off end PDU */
4011                         }
4012                         /* BB add check for name_len bigger than bcc */
4013                         *targetUNCs =
4014                                 kmalloc(name_len+1+(*number_of_UNC_in_array),
4015                                         GFP_KERNEL);
4016                         if (*targetUNCs == NULL) {
4017                                 rc = -ENOMEM;
4018                                 goto GetDFSRefExit;
4019                         }
4020                         /* copy the ref strings */
4021                         referrals = (struct dfs_referral_level_3 *)
4022                                         (8 /* sizeof data hdr */ + data_offset +
4023                                         (char *) &pSMBr->hdr.Protocol);
4024
4025                         for (i = 0; i < *number_of_UNC_in_array; i++) {
4026                                 temp = ((char *)referrals) +
4027                                           le16_to_cpu(referrals->DfsPathOffset);
4028                                 if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
4029                                         cifs_strfromUCS_le(*targetUNCs,
4030                                                           (__le16 *) temp,
4031                                                           name_len,
4032                                                           nls_codepage);
4033                                 } else {
4034                                         strncpy(*targetUNCs, temp, name_len);
4035                                 }
4036                                 /*  BB update target_uncs pointers */
4037                                 referrals++;
4038                         }
4039                         temp = *targetUNCs;
4040                         temp[name_len] = 0;
4041                 }
4042
4043         }
4044 GetDFSRefExit:
4045         if (pSMB)
4046                 cifs_buf_release(pSMB);
4047
4048         if (rc == -EAGAIN)
4049                 goto getDFSRetry;
4050
4051         return rc;
4052 }
4053
4054 /* Query File System Info such as free space to old servers such as Win 9x */
4055 int
4056 SMBOldQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4057 {
4058 /* level 0x01 SMB_QUERY_FILE_SYSTEM_INFO */
4059         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4060         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4061         FILE_SYSTEM_ALLOC_INFO *response_data;
4062         int rc = 0;
4063         int bytes_returned = 0;
4064         __u16 params, byte_count;
4065
4066         cFYI(1, ("OldQFSInfo"));
4067 oldQFSInfoRetry:
4068         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4069                 (void **) &pSMBr);
4070         if (rc)
4071                 return rc;
4072
4073         params = 2;     /* level */
4074         pSMB->TotalDataCount = 0;
4075         pSMB->MaxParameterCount = cpu_to_le16(2);
4076         pSMB->MaxDataCount = cpu_to_le16(1000);
4077         pSMB->MaxSetupCount = 0;
4078         pSMB->Reserved = 0;
4079         pSMB->Flags = 0;
4080         pSMB->Timeout = 0;
4081         pSMB->Reserved2 = 0;
4082         byte_count = params + 1 /* pad */ ;
4083         pSMB->TotalParameterCount = cpu_to_le16(params);
4084         pSMB->ParameterCount = pSMB->TotalParameterCount;
4085         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4086         struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4087         pSMB->DataCount = 0;
4088         pSMB->DataOffset = 0;
4089         pSMB->SetupCount = 1;
4090         pSMB->Reserved3 = 0;
4091         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4092         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_ALLOCATION);
4093         pSMB->hdr.smb_buf_length += byte_count;
4094         pSMB->ByteCount = cpu_to_le16(byte_count);
4095
4096         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4097                 (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4098         if (rc) {
4099                 cFYI(1, ("Send error in QFSInfo = %d", rc));
4100         } else {                /* decode response */
4101                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4102
4103                 if (rc || (pSMBr->ByteCount < 18))
4104                         rc = -EIO;      /* bad smb */
4105                 else {
4106                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4107                         cFYI(1, ("qfsinf resp BCC: %d  Offset %d",
4108                                  pSMBr->ByteCount, data_offset));
4109
4110                         response_data = (FILE_SYSTEM_ALLOC_INFO *)
4111                                 (((char *) &pSMBr->hdr.Protocol) + data_offset);
4112                         FSData->f_bsize =
4113                                 le16_to_cpu(response_data->BytesPerSector) *
4114                                 le32_to_cpu(response_data->
4115                                         SectorsPerAllocationUnit);
4116                         FSData->f_blocks =
4117                                le32_to_cpu(response_data->TotalAllocationUnits);
4118                         FSData->f_bfree = FSData->f_bavail =
4119                                 le32_to_cpu(response_data->FreeAllocationUnits);
4120                         cFYI(1,
4121                              ("Blocks: %lld  Free: %lld Block size %ld",
4122                               (unsigned long long)FSData->f_blocks,
4123                               (unsigned long long)FSData->f_bfree,
4124                               FSData->f_bsize));
4125                 }
4126         }
4127         cifs_buf_release(pSMB);
4128
4129         if (rc == -EAGAIN)
4130                 goto oldQFSInfoRetry;
4131
4132         return rc;
4133 }
4134
4135 int
4136 CIFSSMBQFSInfo(const int xid, struct cifsTconInfo *tcon, struct kstatfs *FSData)
4137 {
4138 /* level 0x103 SMB_QUERY_FILE_SYSTEM_INFO */
4139         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4140         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4141         FILE_SYSTEM_INFO *response_data;
4142         int rc = 0;
4143         int bytes_returned = 0;
4144         __u16 params, byte_count;
4145
4146         cFYI(1, ("In QFSInfo"));
4147 QFSInfoRetry:
4148         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4149                       (void **) &pSMBr);
4150         if (rc)
4151                 return rc;
4152
4153         params = 2;     /* level */
4154         pSMB->TotalDataCount = 0;
4155         pSMB->MaxParameterCount = cpu_to_le16(2);
4156         pSMB->MaxDataCount = cpu_to_le16(1000);
4157         pSMB->MaxSetupCount = 0;
4158         pSMB->Reserved = 0;
4159         pSMB->Flags = 0;
4160         pSMB->Timeout = 0;
4161         pSMB->Reserved2 = 0;
4162         byte_count = params + 1 /* pad */ ;
4163         pSMB->TotalParameterCount = cpu_to_le16(params);
4164         pSMB->ParameterCount = pSMB->TotalParameterCount;
4165         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4166                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4167         pSMB->DataCount = 0;
4168         pSMB->DataOffset = 0;
4169         pSMB->SetupCount = 1;
4170         pSMB->Reserved3 = 0;
4171         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4172         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_SIZE_INFO);
4173         pSMB->hdr.smb_buf_length += byte_count;
4174         pSMB->ByteCount = cpu_to_le16(byte_count);
4175
4176         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4177                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4178         if (rc) {
4179                 cFYI(1, ("Send error in QFSInfo = %d", rc));
4180         } else {                /* decode response */
4181                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4182
4183                 if (rc || (pSMBr->ByteCount < 24))
4184                         rc = -EIO;      /* bad smb */
4185                 else {
4186                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4187
4188                         response_data =
4189                             (FILE_SYSTEM_INFO
4190                              *) (((char *) &pSMBr->hdr.Protocol) +
4191                                  data_offset);
4192                         FSData->f_bsize =
4193                             le32_to_cpu(response_data->BytesPerSector) *
4194                             le32_to_cpu(response_data->
4195                                         SectorsPerAllocationUnit);
4196                         FSData->f_blocks =
4197                             le64_to_cpu(response_data->TotalAllocationUnits);
4198                         FSData->f_bfree = FSData->f_bavail =
4199                             le64_to_cpu(response_data->FreeAllocationUnits);
4200                         cFYI(1,
4201                              ("Blocks: %lld  Free: %lld Block size %ld",
4202                               (unsigned long long)FSData->f_blocks,
4203                               (unsigned long long)FSData->f_bfree,
4204                               FSData->f_bsize));
4205                 }
4206         }
4207         cifs_buf_release(pSMB);
4208
4209         if (rc == -EAGAIN)
4210                 goto QFSInfoRetry;
4211
4212         return rc;
4213 }
4214
4215 int
4216 CIFSSMBQFSAttributeInfo(const int xid, struct cifsTconInfo *tcon)
4217 {
4218 /* level 0x105  SMB_QUERY_FILE_SYSTEM_INFO */
4219         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4220         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4221         FILE_SYSTEM_ATTRIBUTE_INFO *response_data;
4222         int rc = 0;
4223         int bytes_returned = 0;
4224         __u16 params, byte_count;
4225
4226         cFYI(1, ("In QFSAttributeInfo"));
4227 QFSAttributeRetry:
4228         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4229                       (void **) &pSMBr);
4230         if (rc)
4231                 return rc;
4232
4233         params = 2;     /* level */
4234         pSMB->TotalDataCount = 0;
4235         pSMB->MaxParameterCount = cpu_to_le16(2);
4236         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4237         pSMB->MaxSetupCount = 0;
4238         pSMB->Reserved = 0;
4239         pSMB->Flags = 0;
4240         pSMB->Timeout = 0;
4241         pSMB->Reserved2 = 0;
4242         byte_count = params + 1 /* pad */ ;
4243         pSMB->TotalParameterCount = cpu_to_le16(params);
4244         pSMB->ParameterCount = pSMB->TotalParameterCount;
4245         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4246                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4247         pSMB->DataCount = 0;
4248         pSMB->DataOffset = 0;
4249         pSMB->SetupCount = 1;
4250         pSMB->Reserved3 = 0;
4251         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4252         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_ATTRIBUTE_INFO);
4253         pSMB->hdr.smb_buf_length += byte_count;
4254         pSMB->ByteCount = cpu_to_le16(byte_count);
4255
4256         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4257                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4258         if (rc) {
4259                 cERROR(1, ("Send error in QFSAttributeInfo = %d", rc));
4260         } else {                /* decode response */
4261                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4262
4263                 if (rc || (pSMBr->ByteCount < 13)) {
4264                         /* BB also check if enough bytes returned */
4265                         rc = -EIO;      /* bad smb */
4266                 } else {
4267                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4268                         response_data =
4269                             (FILE_SYSTEM_ATTRIBUTE_INFO
4270                              *) (((char *) &pSMBr->hdr.Protocol) +
4271                                  data_offset);
4272                         memcpy(&tcon->fsAttrInfo, response_data,
4273                                sizeof(FILE_SYSTEM_ATTRIBUTE_INFO));
4274                 }
4275         }
4276         cifs_buf_release(pSMB);
4277
4278         if (rc == -EAGAIN)
4279                 goto QFSAttributeRetry;
4280
4281         return rc;
4282 }
4283
4284 int
4285 CIFSSMBQFSDeviceInfo(const int xid, struct cifsTconInfo *tcon)
4286 {
4287 /* level 0x104 SMB_QUERY_FILE_SYSTEM_INFO */
4288         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4289         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4290         FILE_SYSTEM_DEVICE_INFO *response_data;
4291         int rc = 0;
4292         int bytes_returned = 0;
4293         __u16 params, byte_count;
4294
4295         cFYI(1, ("In QFSDeviceInfo"));
4296 QFSDeviceRetry:
4297         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4298                       (void **) &pSMBr);
4299         if (rc)
4300                 return rc;
4301
4302         params = 2;     /* level */
4303         pSMB->TotalDataCount = 0;
4304         pSMB->MaxParameterCount = cpu_to_le16(2);
4305         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4306         pSMB->MaxSetupCount = 0;
4307         pSMB->Reserved = 0;
4308         pSMB->Flags = 0;
4309         pSMB->Timeout = 0;
4310         pSMB->Reserved2 = 0;
4311         byte_count = params + 1 /* pad */ ;
4312         pSMB->TotalParameterCount = cpu_to_le16(params);
4313         pSMB->ParameterCount = pSMB->TotalParameterCount;
4314         pSMB->ParameterOffset = cpu_to_le16(offsetof(
4315                 struct smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4316
4317         pSMB->DataCount = 0;
4318         pSMB->DataOffset = 0;
4319         pSMB->SetupCount = 1;
4320         pSMB->Reserved3 = 0;
4321         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4322         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_FS_DEVICE_INFO);
4323         pSMB->hdr.smb_buf_length += byte_count;
4324         pSMB->ByteCount = cpu_to_le16(byte_count);
4325
4326         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4327                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4328         if (rc) {
4329                 cFYI(1, ("Send error in QFSDeviceInfo = %d", rc));
4330         } else {                /* decode response */
4331                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4332
4333                 if (rc || (pSMBr->ByteCount < sizeof(FILE_SYSTEM_DEVICE_INFO)))
4334                         rc = -EIO;      /* bad smb */
4335                 else {
4336                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4337                         response_data =
4338                             (FILE_SYSTEM_DEVICE_INFO *)
4339                                 (((char *) &pSMBr->hdr.Protocol) +
4340                                  data_offset);
4341                         memcpy(&tcon->fsDevInfo, response_data,
4342                                sizeof(FILE_SYSTEM_DEVICE_INFO));
4343                 }
4344         }
4345         cifs_buf_release(pSMB);
4346
4347         if (rc == -EAGAIN)
4348                 goto QFSDeviceRetry;
4349
4350         return rc;
4351 }
4352
4353 int
4354 CIFSSMBQFSUnixInfo(const int xid, struct cifsTconInfo *tcon)
4355 {
4356 /* level 0x200  SMB_QUERY_CIFS_UNIX_INFO */
4357         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4358         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4359         FILE_SYSTEM_UNIX_INFO *response_data;
4360         int rc = 0;
4361         int bytes_returned = 0;
4362         __u16 params, byte_count;
4363
4364         cFYI(1, ("In QFSUnixInfo"));
4365 QFSUnixRetry:
4366         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4367                       (void **) &pSMBr);
4368         if (rc)
4369                 return rc;
4370
4371         params = 2;     /* level */
4372         pSMB->TotalDataCount = 0;
4373         pSMB->DataCount = 0;
4374         pSMB->DataOffset = 0;
4375         pSMB->MaxParameterCount = cpu_to_le16(2);
4376         pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
4377         pSMB->MaxSetupCount = 0;
4378         pSMB->Reserved = 0;
4379         pSMB->Flags = 0;
4380         pSMB->Timeout = 0;
4381         pSMB->Reserved2 = 0;
4382         byte_count = params + 1 /* pad */ ;
4383         pSMB->ParameterCount = cpu_to_le16(params);
4384         pSMB->TotalParameterCount = pSMB->ParameterCount;
4385         pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4386                         smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4387         pSMB->SetupCount = 1;
4388         pSMB->Reserved3 = 0;
4389         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4390         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_CIFS_UNIX_INFO);
4391         pSMB->hdr.smb_buf_length += byte_count;
4392         pSMB->ByteCount = cpu_to_le16(byte_count);
4393
4394         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4395                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4396         if (rc) {
4397                 cERROR(1, ("Send error in QFSUnixInfo = %d", rc));
4398         } else {                /* decode response */
4399                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4400
4401                 if (rc || (pSMBr->ByteCount < 13)) {
4402                         rc = -EIO;      /* bad smb */
4403                 } else {
4404                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4405                         response_data =
4406                             (FILE_SYSTEM_UNIX_INFO
4407                              *) (((char *) &pSMBr->hdr.Protocol) +
4408                                  data_offset);
4409                         memcpy(&tcon->fsUnixInfo, response_data,
4410                                sizeof(FILE_SYSTEM_UNIX_INFO));
4411                 }
4412         }
4413         cifs_buf_release(pSMB);
4414
4415         if (rc == -EAGAIN)
4416                 goto QFSUnixRetry;
4417
4418
4419         return rc;
4420 }
4421
4422 int
4423 CIFSSMBSetFSUnixInfo(const int xid, struct cifsTconInfo *tcon, __u64 cap)
4424 {
4425 /* level 0x200  SMB_SET_CIFS_UNIX_INFO */
4426         TRANSACTION2_SETFSI_REQ *pSMB = NULL;
4427         TRANSACTION2_SETFSI_RSP *pSMBr = NULL;
4428         int rc = 0;
4429         int bytes_returned = 0;
4430         __u16 params, param_offset, offset, byte_count;
4431
4432         cFYI(1, ("In SETFSUnixInfo"));
4433 SETFSUnixRetry:
4434         /* BB switch to small buf init to save memory */
4435         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4436                       (void **) &pSMBr);
4437         if (rc)
4438                 return rc;
4439
4440         params = 4;     /* 2 bytes zero followed by info level. */
4441         pSMB->MaxSetupCount = 0;
4442         pSMB->Reserved = 0;
4443         pSMB->Flags = 0;
4444         pSMB->Timeout = 0;
4445         pSMB->Reserved2 = 0;
4446         param_offset = offsetof(struct smb_com_transaction2_setfsi_req, FileNum)
4447                                 - 4;
4448         offset = param_offset + params;
4449
4450         pSMB->MaxParameterCount = cpu_to_le16(4);
4451         pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
4452         pSMB->SetupCount = 1;
4453         pSMB->Reserved3 = 0;
4454         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
4455         byte_count = 1 /* pad */ + params + 12;
4456
4457         pSMB->DataCount = cpu_to_le16(12);
4458         pSMB->ParameterCount = cpu_to_le16(params);
4459         pSMB->TotalDataCount = pSMB->DataCount;
4460         pSMB->TotalParameterCount = pSMB->ParameterCount;
4461         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4462         pSMB->DataOffset = cpu_to_le16(offset);
4463
4464         /* Params. */
4465         pSMB->FileNum = 0;
4466         pSMB->InformationLevel = cpu_to_le16(SMB_SET_CIFS_UNIX_INFO);
4467
4468         /* Data. */
4469         pSMB->ClientUnixMajor = cpu_to_le16(CIFS_UNIX_MAJOR_VERSION);
4470         pSMB->ClientUnixMinor = cpu_to_le16(CIFS_UNIX_MINOR_VERSION);
4471         pSMB->ClientUnixCap = cpu_to_le64(cap);
4472
4473         pSMB->hdr.smb_buf_length += byte_count;
4474         pSMB->ByteCount = cpu_to_le16(byte_count);
4475
4476         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4477                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4478         if (rc) {
4479                 cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
4480         } else {                /* decode response */
4481                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4482                 if (rc)
4483                         rc = -EIO;      /* bad smb */
4484         }
4485         cifs_buf_release(pSMB);
4486
4487         if (rc == -EAGAIN)
4488                 goto SETFSUnixRetry;
4489
4490         return rc;
4491 }
4492
4493
4494
4495 int
4496 CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
4497                    struct kstatfs *FSData)
4498 {
4499 /* level 0x201  SMB_QUERY_CIFS_POSIX_INFO */
4500         TRANSACTION2_QFSI_REQ *pSMB = NULL;
4501         TRANSACTION2_QFSI_RSP *pSMBr = NULL;
4502         FILE_SYSTEM_POSIX_INFO *response_data;
4503         int rc = 0;
4504         int bytes_returned = 0;
4505         __u16 params, byte_count;
4506
4507         cFYI(1, ("In QFSPosixInfo"));
4508 QFSPosixRetry:
4509         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4510                       (void **) &pSMBr);
4511         if (rc)
4512                 return rc;
4513
4514         params = 2;     /* level */
4515         pSMB->TotalDataCount = 0;
4516         pSMB->DataCount = 0;
4517         pSMB->DataOffset = 0;
4518         pSMB->MaxParameterCount = cpu_to_le16(2);
4519         pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
4520         pSMB->MaxSetupCount = 0;
4521         pSMB->Reserved = 0;
4522         pSMB->Flags = 0;
4523         pSMB->Timeout = 0;
4524         pSMB->Reserved2 = 0;
4525         byte_count = params + 1 /* pad */ ;
4526         pSMB->ParameterCount = cpu_to_le16(params);
4527         pSMB->TotalParameterCount = pSMB->ParameterCount;
4528         pSMB->ParameterOffset = cpu_to_le16(offsetof(struct
4529                         smb_com_transaction2_qfsi_req, InformationLevel) - 4);
4530         pSMB->SetupCount = 1;
4531         pSMB->Reserved3 = 0;
4532         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_FS_INFORMATION);
4533         pSMB->InformationLevel = cpu_to_le16(SMB_QUERY_POSIX_FS_INFO);
4534         pSMB->hdr.smb_buf_length += byte_count;
4535         pSMB->ByteCount = cpu_to_le16(byte_count);
4536
4537         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4538                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4539         if (rc) {
4540                 cFYI(1, ("Send error in QFSUnixInfo = %d", rc));
4541         } else {                /* decode response */
4542                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
4543
4544                 if (rc || (pSMBr->ByteCount < 13)) {
4545                         rc = -EIO;      /* bad smb */
4546                 } else {
4547                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
4548                         response_data =
4549                             (FILE_SYSTEM_POSIX_INFO
4550                              *) (((char *) &pSMBr->hdr.Protocol) +
4551                                  data_offset);
4552                         FSData->f_bsize =
4553                                         le32_to_cpu(response_data->BlockSize);
4554                         FSData->f_blocks =
4555                                         le64_to_cpu(response_data->TotalBlocks);
4556                         FSData->f_bfree =
4557                             le64_to_cpu(response_data->BlocksAvail);
4558                         if (response_data->UserBlocksAvail == cpu_to_le64(-1)) {
4559                                 FSData->f_bavail = FSData->f_bfree;
4560                         } else {
4561                                 FSData->f_bavail =
4562                                     le64_to_cpu(response_data->UserBlocksAvail);
4563                         }
4564                         if (response_data->TotalFileNodes != cpu_to_le64(-1))
4565                                 FSData->f_files =
4566                                      le64_to_cpu(response_data->TotalFileNodes);
4567                         if (response_data->FreeFileNodes != cpu_to_le64(-1))
4568                                 FSData->f_ffree =
4569                                       le64_to_cpu(response_data->FreeFileNodes);
4570                 }
4571         }
4572         cifs_buf_release(pSMB);
4573
4574         if (rc == -EAGAIN)
4575                 goto QFSPosixRetry;
4576
4577         return rc;
4578 }
4579
4580
4581 /* We can not use write of zero bytes trick to
4582    set file size due to need for large file support.  Also note that
4583    this SetPathInfo is preferred to SetFileInfo based method in next
4584    routine which is only needed to work around a sharing violation bug
4585    in Samba which this routine can run into */
4586
4587 int
4588 CIFSSMBSetEOF(const int xid, struct cifsTconInfo *tcon, const char *fileName,
4589               __u64 size, int SetAllocation,
4590               const struct nls_table *nls_codepage, int remap)
4591 {
4592         struct smb_com_transaction2_spi_req *pSMB = NULL;
4593         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
4594         struct file_end_of_file_info *parm_data;
4595         int name_len;
4596         int rc = 0;
4597         int bytes_returned = 0;
4598         __u16 params, byte_count, data_count, param_offset, offset;
4599
4600         cFYI(1, ("In SetEOF"));
4601 SetEOFRetry:
4602         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4603                       (void **) &pSMBr);
4604         if (rc)
4605                 return rc;
4606
4607         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4608                 name_len =
4609                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4610                                      PATH_MAX, nls_codepage, remap);
4611                 name_len++;     /* trailing null */
4612                 name_len *= 2;
4613         } else {        /* BB improve the check for buffer overruns BB */
4614                 name_len = strnlen(fileName, PATH_MAX);
4615                 name_len++;     /* trailing null */
4616                 strncpy(pSMB->FileName, fileName, name_len);
4617         }
4618         params = 6 + name_len;
4619         data_count = sizeof(struct file_end_of_file_info);
4620         pSMB->MaxParameterCount = cpu_to_le16(2);
4621         pSMB->MaxDataCount = cpu_to_le16(4100);
4622         pSMB->MaxSetupCount = 0;
4623         pSMB->Reserved = 0;
4624         pSMB->Flags = 0;
4625         pSMB->Timeout = 0;
4626         pSMB->Reserved2 = 0;
4627         param_offset = offsetof(struct smb_com_transaction2_spi_req,
4628                                 InformationLevel) - 4;
4629         offset = param_offset + params;
4630         if (SetAllocation) {
4631                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4632                         pSMB->InformationLevel =
4633                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4634                 else
4635                         pSMB->InformationLevel =
4636                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4637         } else /* Set File Size */  {
4638             if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4639                     pSMB->InformationLevel =
4640                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4641             else
4642                     pSMB->InformationLevel =
4643                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4644         }
4645
4646         parm_data =
4647             (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol) +
4648                                        offset);
4649         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4650         pSMB->DataOffset = cpu_to_le16(offset);
4651         pSMB->SetupCount = 1;
4652         pSMB->Reserved3 = 0;
4653         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4654         byte_count = 3 /* pad */  + params + data_count;
4655         pSMB->DataCount = cpu_to_le16(data_count);
4656         pSMB->TotalDataCount = pSMB->DataCount;
4657         pSMB->ParameterCount = cpu_to_le16(params);
4658         pSMB->TotalParameterCount = pSMB->ParameterCount;
4659         pSMB->Reserved4 = 0;
4660         pSMB->hdr.smb_buf_length += byte_count;
4661         parm_data->FileSize = cpu_to_le64(size);
4662         pSMB->ByteCount = cpu_to_le16(byte_count);
4663         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4664                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4665         if (rc)
4666                 cFYI(1, ("SetPathInfo (file size) returned %d", rc));
4667
4668         cifs_buf_release(pSMB);
4669
4670         if (rc == -EAGAIN)
4671                 goto SetEOFRetry;
4672
4673         return rc;
4674 }
4675
4676 int
4677 CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
4678                    __u16 fid, __u32 pid_of_opener, int SetAllocation)
4679 {
4680         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
4681         char *data_offset;
4682         struct file_end_of_file_info *parm_data;
4683         int rc = 0;
4684         __u16 params, param_offset, offset, byte_count, count;
4685
4686         cFYI(1, ("SetFileSize (via SetFileInfo) %lld",
4687                         (long long)size));
4688         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4689
4690         if (rc)
4691                 return rc;
4692
4693         pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4694         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));
4695
4696         params = 6;
4697         pSMB->MaxSetupCount = 0;
4698         pSMB->Reserved = 0;
4699         pSMB->Flags = 0;
4700         pSMB->Timeout = 0;
4701         pSMB->Reserved2 = 0;
4702         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4703         offset = param_offset + params;
4704
4705         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4706
4707         count = sizeof(struct file_end_of_file_info);
4708         pSMB->MaxParameterCount = cpu_to_le16(2);
4709         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
4710         pSMB->SetupCount = 1;
4711         pSMB->Reserved3 = 0;
4712         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
4713         byte_count = 3 /* pad */  + params + count;
4714         pSMB->DataCount = cpu_to_le16(count);
4715         pSMB->ParameterCount = cpu_to_le16(params);
4716         pSMB->TotalDataCount = pSMB->DataCount;
4717         pSMB->TotalParameterCount = pSMB->ParameterCount;
4718         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4719         parm_data =
4720                 (struct file_end_of_file_info *) (((char *) &pSMB->hdr.Protocol)
4721                                 + offset);
4722         pSMB->DataOffset = cpu_to_le16(offset);
4723         parm_data->FileSize = cpu_to_le64(size);
4724         pSMB->Fid = fid;
4725         if (SetAllocation) {
4726                 if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4727                         pSMB->InformationLevel =
4728                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO2);
4729                 else
4730                         pSMB->InformationLevel =
4731                                 cpu_to_le16(SMB_SET_FILE_ALLOCATION_INFO);
4732         } else /* Set File Size */  {
4733             if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4734                     pSMB->InformationLevel =
4735                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO2);
4736             else
4737                     pSMB->InformationLevel =
4738                                 cpu_to_le16(SMB_SET_FILE_END_OF_FILE_INFO);
4739         }
4740         pSMB->Reserved4 = 0;
4741         pSMB->hdr.smb_buf_length += byte_count;
4742         pSMB->ByteCount = cpu_to_le16(byte_count);
4743         rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
4744         if (rc) {
4745                 cFYI(1,
4746                      ("Send error in SetFileInfo (SetFileSize) = %d",
4747                       rc));
4748         }
4749
4750         /* Note: On -EAGAIN error only caller can retry on handle based calls
4751                 since file handle passed in no longer valid */
4752
4753         return rc;
4754 }
4755
4756 /* Some legacy servers such as NT4 require that the file times be set on
4757    an open handle, rather than by pathname - this is awkward due to
4758    potential access conflicts on the open, but it is unavoidable for these
4759    old servers since the only other choice is to go from 100 nanosecond DCE
4760    time and resort to the original setpathinfo level which takes the ancient
4761    DOS time format with 2 second granularity */
4762 int
4763 CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
4764                     const FILE_BASIC_INFO *data, __u16 fid)
4765 {
4766         struct smb_com_transaction2_sfi_req *pSMB  = NULL;
4767         char *data_offset;
4768         int rc = 0;
4769         __u16 params, param_offset, offset, byte_count, count;
4770
4771         cFYI(1, ("Set Times (via SetFileInfo)"));
4772         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
4773
4774         if (rc)
4775                 return rc;
4776
4777         /* At this point there is no need to override the current pid
4778         with the pid of the opener, but that could change if we someday
4779         use an existing handle (rather than opening one on the fly) */
4780         /* pSMB->hdr.Pid = cpu_to_le16((__u16)pid_of_opener);
4781         pSMB->hdr.PidHigh = cpu_to_le16((__u16)(pid_of_opener >> 16));*/
4782
4783         params = 6;
4784         pSMB->MaxSetupCount = 0;
4785         pSMB->Reserved = 0;
4786         pSMB->Flags = 0;
4787         pSMB->Timeout = 0;
4788         pSMB->Reserved2 = 0;
4789         param_offset = offsetof(struct smb_com_transaction2_sfi_req, Fid) - 4;
4790         offset = param_offset + params;
4791
4792         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4793
4794         count = sizeof(FILE_BASIC_INFO);
4795         pSMB->MaxParameterCount = cpu_to_le16(2);
4796         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
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         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4864         pSMB->MaxSetupCount = 0;
4865         pSMB->Reserved = 0;
4866         pSMB->Flags = 0;
4867         pSMB->Timeout = 0;
4868         pSMB->Reserved2 = 0;
4869         param_offset = offsetof(struct smb_com_transaction2_spi_req,
4870                                 InformationLevel) - 4;
4871         offset = param_offset + params;
4872         data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
4873         pSMB->ParameterOffset = cpu_to_le16(param_offset);
4874         pSMB->DataOffset = cpu_to_le16(offset);
4875         pSMB->SetupCount = 1;
4876         pSMB->Reserved3 = 0;
4877         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
4878         byte_count = 3 /* pad */  + params + count;
4879
4880         pSMB->DataCount = cpu_to_le16(count);
4881         pSMB->ParameterCount = cpu_to_le16(params);
4882         pSMB->TotalDataCount = pSMB->DataCount;
4883         pSMB->TotalParameterCount = pSMB->ParameterCount;
4884         if (tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)
4885                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO2);
4886         else
4887                 pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_BASIC_INFO);
4888         pSMB->Reserved4 = 0;
4889         pSMB->hdr.smb_buf_length += byte_count;
4890         memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
4891         pSMB->ByteCount = cpu_to_le16(byte_count);
4892         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4893                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4894         if (rc)
4895                 cFYI(1, ("SetPathInfo (times) returned %d", rc));
4896
4897         cifs_buf_release(pSMB);
4898
4899         if (rc == -EAGAIN)
4900                 goto SetTimesRetry;
4901
4902         return rc;
4903 }
4904
4905 /* Can not be used to set time stamps yet (due to old DOS time format) */
4906 /* Can be used to set attributes */
4907 #if 0  /* Possibly not needed - since it turns out that strangely NT4 has a bug
4908           handling it anyway and NT4 was what we thought it would be needed for
4909           Do not delete it until we prove whether needed for Win9x though */
4910 int
4911 CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon, char *fileName,
4912                 __u16 dos_attrs, const struct nls_table *nls_codepage)
4913 {
4914         SETATTR_REQ *pSMB = NULL;
4915         SETATTR_RSP *pSMBr = NULL;
4916         int rc = 0;
4917         int bytes_returned;
4918         int name_len;
4919
4920         cFYI(1, ("In SetAttrLegacy"));
4921
4922 SetAttrLgcyRetry:
4923         rc = smb_init(SMB_COM_SETATTR, 8, tcon, (void **) &pSMB,
4924                       (void **) &pSMBr);
4925         if (rc)
4926                 return rc;
4927
4928         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4929                 name_len =
4930                         ConvertToUCS((__le16 *) pSMB->fileName, fileName,
4931                                 PATH_MAX, nls_codepage);
4932                 name_len++;     /* trailing null */
4933                 name_len *= 2;
4934         } else {        /* BB improve the check for buffer overruns BB */
4935                 name_len = strnlen(fileName, PATH_MAX);
4936                 name_len++;     /* trailing null */
4937                 strncpy(pSMB->fileName, fileName, name_len);
4938         }
4939         pSMB->attr = cpu_to_le16(dos_attrs);
4940         pSMB->BufferFormat = 0x04;
4941         pSMB->hdr.smb_buf_length += name_len + 1;
4942         pSMB->ByteCount = cpu_to_le16(name_len + 1);
4943         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
4944                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
4945         if (rc)
4946                 cFYI(1, ("Error in LegacySetAttr = %d", rc));
4947
4948         cifs_buf_release(pSMB);
4949
4950         if (rc == -EAGAIN)
4951                 goto SetAttrLgcyRetry;
4952
4953         return rc;
4954 }
4955 #endif /* temporarily unneeded SetAttr legacy function */
4956
4957 int
4958 CIFSSMBUnixSetPerms(const int xid, struct cifsTconInfo *tcon,
4959                     char *fileName, __u64 mode, __u64 uid, __u64 gid,
4960                     dev_t device, const struct nls_table *nls_codepage,
4961                     int remap)
4962 {
4963         TRANSACTION2_SPI_REQ *pSMB = NULL;
4964         TRANSACTION2_SPI_RSP *pSMBr = NULL;
4965         int name_len;
4966         int rc = 0;
4967         int bytes_returned = 0;
4968         FILE_UNIX_BASIC_INFO *data_offset;
4969         __u16 params, param_offset, offset, count, byte_count;
4970
4971         cFYI(1, ("In SetUID/GID/Mode"));
4972 setPermsRetry:
4973         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
4974                       (void **) &pSMBr);
4975         if (rc)
4976                 return rc;
4977
4978         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
4979                 name_len =
4980                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
4981                                      PATH_MAX, nls_codepage, remap);
4982                 name_len++;     /* trailing null */
4983                 name_len *= 2;
4984         } else {        /* BB improve the check for buffer overruns BB */
4985                 name_len = strnlen(fileName, PATH_MAX);
4986                 name_len++;     /* trailing null */
4987                 strncpy(pSMB->FileName, fileName, name_len);
4988         }
4989
4990         params = 6 + name_len;
4991         count = sizeof(FILE_UNIX_BASIC_INFO);
4992         pSMB->MaxParameterCount = cpu_to_le16(2);
4993         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
4994         pSMB->MaxSetupCount = 0;
4995         pSMB->Reserved = 0;
4996         pSMB->Flags = 0;
4997         pSMB->Timeout = 0;
4998         pSMB->Reserved2 = 0;
4999         param_offset = offsetof(struct smb_com_transaction2_spi_req,
5000                                 InformationLevel) - 4;
5001         offset = param_offset + params;
5002         data_offset =
5003             (FILE_UNIX_BASIC_INFO *) ((char *) &pSMB->hdr.Protocol +
5004                                       offset);
5005         memset(data_offset, 0, count);
5006         pSMB->DataOffset = cpu_to_le16(offset);
5007         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5008         pSMB->SetupCount = 1;
5009         pSMB->Reserved3 = 0;
5010         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5011         byte_count = 3 /* pad */  + params + count;
5012         pSMB->ParameterCount = cpu_to_le16(params);
5013         pSMB->DataCount = cpu_to_le16(count);
5014         pSMB->TotalParameterCount = pSMB->ParameterCount;
5015         pSMB->TotalDataCount = pSMB->DataCount;
5016         pSMB->InformationLevel = cpu_to_le16(SMB_SET_FILE_UNIX_BASIC);
5017         pSMB->Reserved4 = 0;
5018         pSMB->hdr.smb_buf_length += byte_count;
5019         /* Samba server ignores set of file size to zero due to bugs in some
5020         older clients, but we should be precise - we use SetFileSize to
5021         set file size and do not want to truncate file size to zero
5022         accidently as happened on one Samba server beta by putting
5023         zero instead of -1 here */
5024         data_offset->EndOfFile = NO_CHANGE_64;
5025         data_offset->NumOfBytes = NO_CHANGE_64;
5026         data_offset->LastStatusChange = NO_CHANGE_64;
5027         data_offset->LastAccessTime = NO_CHANGE_64;
5028         data_offset->LastModificationTime = NO_CHANGE_64;
5029         data_offset->Uid = cpu_to_le64(uid);
5030         data_offset->Gid = cpu_to_le64(gid);
5031         /* better to leave device as zero when it is  */
5032         data_offset->DevMajor = cpu_to_le64(MAJOR(device));
5033         data_offset->DevMinor = cpu_to_le64(MINOR(device));
5034         data_offset->Permissions = cpu_to_le64(mode);
5035
5036         if (S_ISREG(mode))
5037                 data_offset->Type = cpu_to_le32(UNIX_FILE);
5038         else if (S_ISDIR(mode))
5039                 data_offset->Type = cpu_to_le32(UNIX_DIR);
5040         else if (S_ISLNK(mode))
5041                 data_offset->Type = cpu_to_le32(UNIX_SYMLINK);
5042         else if (S_ISCHR(mode))
5043                 data_offset->Type = cpu_to_le32(UNIX_CHARDEV);
5044         else if (S_ISBLK(mode))
5045                 data_offset->Type = cpu_to_le32(UNIX_BLOCKDEV);
5046         else if (S_ISFIFO(mode))
5047                 data_offset->Type = cpu_to_le32(UNIX_FIFO);
5048         else if (S_ISSOCK(mode))
5049                 data_offset->Type = cpu_to_le32(UNIX_SOCKET);
5050
5051
5052         pSMB->ByteCount = cpu_to_le16(byte_count);
5053         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5054                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5055         if (rc)
5056                 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
5057
5058         if (pSMB)
5059                 cifs_buf_release(pSMB);
5060         if (rc == -EAGAIN)
5061                 goto setPermsRetry;
5062         return rc;
5063 }
5064
5065 int CIFSSMBNotify(const int xid, struct cifsTconInfo *tcon,
5066                   const int notify_subdirs, const __u16 netfid,
5067                   __u32 filter, struct file *pfile, int multishot,
5068                   const struct nls_table *nls_codepage)
5069 {
5070         int rc = 0;
5071         struct smb_com_transaction_change_notify_req *pSMB = NULL;
5072         struct smb_com_ntransaction_change_notify_rsp *pSMBr = NULL;
5073         struct dir_notify_req *dnotify_req;
5074         int bytes_returned;
5075
5076         cFYI(1, ("In CIFSSMBNotify for file handle %d", (int)netfid));
5077         rc = smb_init(SMB_COM_NT_TRANSACT, 23, tcon, (void **) &pSMB,
5078                       (void **) &pSMBr);
5079         if (rc)
5080                 return rc;
5081
5082         pSMB->TotalParameterCount = 0 ;
5083         pSMB->TotalDataCount = 0;
5084         pSMB->MaxParameterCount = cpu_to_le32(2);
5085         /* BB find exact data count max from sess structure BB */
5086         pSMB->MaxDataCount = 0; /* same in little endian or be */
5087 /* BB VERIFY verify which is correct for above BB */
5088         pSMB->MaxDataCount = cpu_to_le32((tcon->ses->server->maxBuf -
5089                                              MAX_CIFS_HDR_SIZE) & 0xFFFFFF00);
5090
5091         pSMB->MaxSetupCount = 4;
5092         pSMB->Reserved = 0;
5093         pSMB->ParameterOffset = 0;
5094         pSMB->DataCount = 0;
5095         pSMB->DataOffset = 0;
5096         pSMB->SetupCount = 4; /* single byte does not need le conversion */
5097         pSMB->SubCommand = cpu_to_le16(NT_TRANSACT_NOTIFY_CHANGE);
5098         pSMB->ParameterCount = pSMB->TotalParameterCount;
5099         if (notify_subdirs)
5100                 pSMB->WatchTree = 1; /* one byte - no le conversion needed */
5101         pSMB->Reserved2 = 0;
5102         pSMB->CompletionFilter = cpu_to_le32(filter);
5103         pSMB->Fid = netfid; /* file handle always le */
5104         pSMB->ByteCount = 0;
5105
5106         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5107                          (struct smb_hdr *)pSMBr, &bytes_returned,
5108                          CIFS_ASYNC_OP);
5109         if (rc) {
5110                 cFYI(1, ("Error in Notify = %d", rc));
5111         } else {
5112                 /* Add file to outstanding requests */
5113                 /* BB change to kmem cache alloc */
5114                 dnotify_req = kmalloc(
5115                                                 sizeof(struct dir_notify_req),
5116                                                  GFP_KERNEL);
5117                 if (dnotify_req) {
5118                         dnotify_req->Pid = pSMB->hdr.Pid;
5119                         dnotify_req->PidHigh = pSMB->hdr.PidHigh;
5120                         dnotify_req->Mid = pSMB->hdr.Mid;
5121                         dnotify_req->Tid = pSMB->hdr.Tid;
5122                         dnotify_req->Uid = pSMB->hdr.Uid;
5123                         dnotify_req->netfid = netfid;
5124                         dnotify_req->pfile = pfile;
5125                         dnotify_req->filter = filter;
5126                         dnotify_req->multishot = multishot;
5127                         spin_lock(&GlobalMid_Lock);
5128                         list_add_tail(&dnotify_req->lhead,
5129                                         &GlobalDnotifyReqList);
5130                         spin_unlock(&GlobalMid_Lock);
5131                 } else
5132                         rc = -ENOMEM;
5133         }
5134         cifs_buf_release(pSMB);
5135         return rc;
5136 }
5137 #ifdef CONFIG_CIFS_XATTR
5138 ssize_t
5139 CIFSSMBQAllEAs(const int xid, struct cifsTconInfo *tcon,
5140                  const unsigned char *searchName,
5141                  char *EAData, size_t buf_size,
5142                  const struct nls_table *nls_codepage, int remap)
5143 {
5144                 /* BB assumes one setup word */
5145         TRANSACTION2_QPI_REQ *pSMB = NULL;
5146         TRANSACTION2_QPI_RSP *pSMBr = NULL;
5147         int rc = 0;
5148         int bytes_returned;
5149         int name_len;
5150         struct fea *temp_fea;
5151         char *temp_ptr;
5152         __u16 params, byte_count;
5153
5154         cFYI(1, ("In Query All EAs path %s", searchName));
5155 QAllEAsRetry:
5156         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5157                       (void **) &pSMBr);
5158         if (rc)
5159                 return rc;
5160
5161         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5162                 name_len =
5163                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5164                                      PATH_MAX, nls_codepage, remap);
5165                 name_len++;     /* trailing null */
5166                 name_len *= 2;
5167         } else {        /* BB improve the check for buffer overruns BB */
5168                 name_len = strnlen(searchName, PATH_MAX);
5169                 name_len++;     /* trailing null */
5170                 strncpy(pSMB->FileName, searchName, name_len);
5171         }
5172
5173         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5174         pSMB->TotalDataCount = 0;
5175         pSMB->MaxParameterCount = cpu_to_le16(2);
5176         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
5177         pSMB->MaxSetupCount = 0;
5178         pSMB->Reserved = 0;
5179         pSMB->Flags = 0;
5180         pSMB->Timeout = 0;
5181         pSMB->Reserved2 = 0;
5182         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5183         struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5184         pSMB->DataCount = 0;
5185         pSMB->DataOffset = 0;
5186         pSMB->SetupCount = 1;
5187         pSMB->Reserved3 = 0;
5188         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5189         byte_count = params + 1 /* pad */ ;
5190         pSMB->TotalParameterCount = cpu_to_le16(params);
5191         pSMB->ParameterCount = pSMB->TotalParameterCount;
5192         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5193         pSMB->Reserved4 = 0;
5194         pSMB->hdr.smb_buf_length += byte_count;
5195         pSMB->ByteCount = cpu_to_le16(byte_count);
5196
5197         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5198                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5199         if (rc) {
5200                 cFYI(1, ("Send error in QueryAllEAs = %d", rc));
5201         } else {                /* decode response */
5202                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5203
5204                 /* BB also check enough total bytes returned */
5205                 /* BB we need to improve the validity checking
5206                 of these trans2 responses */
5207                 if (rc || (pSMBr->ByteCount < 4))
5208                         rc = -EIO;      /* bad smb */
5209            /* else if (pFindData){
5210                         memcpy((char *) pFindData,
5211                                (char *) &pSMBr->hdr.Protocol +
5212                                data_offset, kl);
5213                 }*/ else {
5214                         /* check that length of list is not more than bcc */
5215                         /* check that each entry does not go beyond length
5216                            of list */
5217                         /* check that each element of each entry does not
5218                            go beyond end of list */
5219                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5220                         struct fealist *ea_response_data;
5221                         rc = 0;
5222                         /* validate_trans2_offsets() */
5223                         /* BB check if start of smb + data_offset > &bcc+ bcc */
5224                         ea_response_data = (struct fealist *)
5225                                 (((char *) &pSMBr->hdr.Protocol) +
5226                                 data_offset);
5227                         name_len = le32_to_cpu(ea_response_data->list_len);
5228                         cFYI(1, ("ea length %d", name_len));
5229                         if (name_len <= 8) {
5230                         /* returned EA size zeroed at top of function */
5231                                 cFYI(1, ("empty EA list returned from server"));
5232                         } else {
5233                                 /* account for ea list len */
5234                                 name_len -= 4;
5235                                 temp_fea = ea_response_data->list;
5236                                 temp_ptr = (char *)temp_fea;
5237                                 while (name_len > 0) {
5238                                         __u16 value_len;
5239                                         name_len -= 4;
5240                                         temp_ptr += 4;
5241                                         rc += temp_fea->name_len;
5242                                 /* account for prefix user. and trailing null */
5243                                         rc = rc + 5 + 1;
5244                                         if (rc < (int)buf_size) {
5245                                                 memcpy(EAData, "user.", 5);
5246                                                 EAData += 5;
5247                                                 memcpy(EAData, temp_ptr,
5248                                                        temp_fea->name_len);
5249                                                 EAData += temp_fea->name_len;
5250                                                 /* null terminate name */
5251                                                 *EAData = 0;
5252                                                 EAData = EAData + 1;
5253                                         } else if (buf_size == 0) {
5254                                                 /* skip copy - calc size only */
5255                                         } else {
5256                                                 /* stop before overrun buffer */
5257                                                 rc = -ERANGE;
5258                                                 break;
5259                                         }
5260                                         name_len -= temp_fea->name_len;
5261                                         temp_ptr += temp_fea->name_len;
5262                                         /* account for trailing null */
5263                                         name_len--;
5264                                         temp_ptr++;
5265                                         value_len =
5266                                               le16_to_cpu(temp_fea->value_len);
5267                                         name_len -= value_len;
5268                                         temp_ptr += value_len;
5269                                         /* BB check that temp_ptr is still
5270                                               within the SMB BB*/
5271
5272                                         /* no trailing null to account for
5273                                            in value len */
5274                                         /* go on to next EA */
5275                                         temp_fea = (struct fea *)temp_ptr;
5276                                 }
5277                         }
5278                 }
5279         }
5280         if (pSMB)
5281                 cifs_buf_release(pSMB);
5282         if (rc == -EAGAIN)
5283                 goto QAllEAsRetry;
5284
5285         return (ssize_t)rc;
5286 }
5287
5288 ssize_t CIFSSMBQueryEA(const int xid, struct cifsTconInfo *tcon,
5289                 const unsigned char *searchName, const unsigned char *ea_name,
5290                 unsigned char *ea_value, size_t buf_size,
5291                 const struct nls_table *nls_codepage, int remap)
5292 {
5293         TRANSACTION2_QPI_REQ *pSMB = NULL;
5294         TRANSACTION2_QPI_RSP *pSMBr = NULL;
5295         int rc = 0;
5296         int bytes_returned;
5297         int name_len;
5298         struct fea *temp_fea;
5299         char *temp_ptr;
5300         __u16 params, byte_count;
5301
5302         cFYI(1, ("In Query EA path %s", searchName));
5303 QEARetry:
5304         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5305                       (void **) &pSMBr);
5306         if (rc)
5307                 return rc;
5308
5309         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5310                 name_len =
5311                     cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
5312                                      PATH_MAX, nls_codepage, remap);
5313                 name_len++;     /* trailing null */
5314                 name_len *= 2;
5315         } else {        /* BB improve the check for buffer overruns BB */
5316                 name_len = strnlen(searchName, PATH_MAX);
5317                 name_len++;     /* trailing null */
5318                 strncpy(pSMB->FileName, searchName, name_len);
5319         }
5320
5321         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
5322         pSMB->TotalDataCount = 0;
5323         pSMB->MaxParameterCount = cpu_to_le16(2);
5324         pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
5325         pSMB->MaxSetupCount = 0;
5326         pSMB->Reserved = 0;
5327         pSMB->Flags = 0;
5328         pSMB->Timeout = 0;
5329         pSMB->Reserved2 = 0;
5330         pSMB->ParameterOffset = cpu_to_le16(offsetof(
5331                 struct smb_com_transaction2_qpi_req, InformationLevel) - 4);
5332         pSMB->DataCount = 0;
5333         pSMB->DataOffset = 0;
5334         pSMB->SetupCount = 1;
5335         pSMB->Reserved3 = 0;
5336         pSMB->SubCommand = cpu_to_le16(TRANS2_QUERY_PATH_INFORMATION);
5337         byte_count = params + 1 /* pad */ ;
5338         pSMB->TotalParameterCount = cpu_to_le16(params);
5339         pSMB->ParameterCount = pSMB->TotalParameterCount;
5340         pSMB->InformationLevel = cpu_to_le16(SMB_INFO_QUERY_ALL_EAS);
5341         pSMB->Reserved4 = 0;
5342         pSMB->hdr.smb_buf_length += byte_count;
5343         pSMB->ByteCount = cpu_to_le16(byte_count);
5344
5345         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5346                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5347         if (rc) {
5348                 cFYI(1, ("Send error in Query EA = %d", rc));
5349         } else {                /* decode response */
5350                 rc = validate_t2((struct smb_t2_rsp *)pSMBr);
5351
5352                 /* BB also check enough total bytes returned */
5353                 /* BB we need to improve the validity checking
5354                 of these trans2 responses */
5355                 if (rc || (pSMBr->ByteCount < 4))
5356                         rc = -EIO;      /* bad smb */
5357            /* else if (pFindData){
5358                         memcpy((char *) pFindData,
5359                                (char *) &pSMBr->hdr.Protocol +
5360                                data_offset, kl);
5361                 }*/ else {
5362                         /* check that length of list is not more than bcc */
5363                         /* check that each entry does not go beyond length
5364                            of list */
5365                         /* check that each element of each entry does not
5366                            go beyond end of list */
5367                         __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
5368                         struct fealist *ea_response_data;
5369                         rc = -ENODATA;
5370                         /* validate_trans2_offsets() */
5371                         /* BB check if start of smb + data_offset > &bcc+ bcc*/
5372                         ea_response_data = (struct fealist *)
5373                                 (((char *) &pSMBr->hdr.Protocol) +
5374                                 data_offset);
5375                         name_len = le32_to_cpu(ea_response_data->list_len);
5376                         cFYI(1, ("ea length %d", name_len));
5377                         if (name_len <= 8) {
5378                         /* returned EA size zeroed at top of function */
5379                                 cFYI(1, ("empty EA list returned from server"));
5380                         } else {
5381                                 /* account for ea list len */
5382                                 name_len -= 4;
5383                                 temp_fea = ea_response_data->list;
5384                                 temp_ptr = (char *)temp_fea;
5385                                 /* loop through checking if we have a matching
5386                                 name and then return the associated value */
5387                                 while (name_len > 0) {
5388                                         __u16 value_len;
5389                                         name_len -= 4;
5390                                         temp_ptr += 4;
5391                                         value_len =
5392                                               le16_to_cpu(temp_fea->value_len);
5393                                 /* BB validate that value_len falls within SMB,
5394                                 even though maximum for name_len is 255 */
5395                                         if (memcmp(temp_fea->name, ea_name,
5396                                                   temp_fea->name_len) == 0) {
5397                                                 /* found a match */
5398                                                 rc = value_len;
5399                                 /* account for prefix user. and trailing null */
5400                                                 if (rc <= (int)buf_size) {
5401                                                         memcpy(ea_value,
5402                                                                 temp_fea->name+temp_fea->name_len+1,
5403                                                                 rc);
5404                                                         /* ea values, unlike ea
5405                                                            names, are not null
5406                                                            terminated */
5407                                                 } else if (buf_size == 0) {
5408                                                 /* skip copy - calc size only */
5409                                                 } else {
5410                                                 /* stop before overrun buffer */
5411                                                         rc = -ERANGE;
5412                                                 }
5413                                                 break;
5414                                         }
5415                                         name_len -= temp_fea->name_len;
5416                                         temp_ptr += temp_fea->name_len;
5417                                         /* account for trailing null */
5418                                         name_len--;
5419                                         temp_ptr++;
5420                                         name_len -= value_len;
5421                                         temp_ptr += value_len;
5422                                         /* No trailing null to account for in
5423                                            value_len.  Go on to next EA */
5424                                         temp_fea = (struct fea *)temp_ptr;
5425                                 }
5426                         }
5427                 }
5428         }
5429         if (pSMB)
5430                 cifs_buf_release(pSMB);
5431         if (rc == -EAGAIN)
5432                 goto QEARetry;
5433
5434         return (ssize_t)rc;
5435 }
5436
5437 int
5438 CIFSSMBSetEA(const int xid, struct cifsTconInfo *tcon, const char *fileName,
5439              const char *ea_name, const void *ea_value,
5440              const __u16 ea_value_len, const struct nls_table *nls_codepage,
5441              int remap)
5442 {
5443         struct smb_com_transaction2_spi_req *pSMB = NULL;
5444         struct smb_com_transaction2_spi_rsp *pSMBr = NULL;
5445         struct fealist *parm_data;
5446         int name_len;
5447         int rc = 0;
5448         int bytes_returned = 0;
5449         __u16 params, param_offset, byte_count, offset, count;
5450
5451         cFYI(1, ("In SetEA"));
5452 SetEARetry:
5453         rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
5454                       (void **) &pSMBr);
5455         if (rc)
5456                 return rc;
5457
5458         if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
5459                 name_len =
5460                     cifsConvertToUCS((__le16 *) pSMB->FileName, fileName,
5461                                      PATH_MAX, nls_codepage, remap);
5462                 name_len++;     /* trailing null */
5463                 name_len *= 2;
5464         } else {        /* BB improve the check for buffer overruns BB */
5465                 name_len = strnlen(fileName, PATH_MAX);
5466                 name_len++;     /* trailing null */
5467                 strncpy(pSMB->FileName, fileName, name_len);
5468         }
5469
5470         params = 6 + name_len;
5471
5472         /* done calculating parms using name_len of file name,
5473         now use name_len to calculate length of ea name
5474         we are going to create in the inode xattrs */
5475         if (ea_name == NULL)
5476                 name_len = 0;
5477         else
5478                 name_len = strnlen(ea_name, 255);
5479
5480         count = sizeof(*parm_data) + ea_value_len + name_len;
5481         pSMB->MaxParameterCount = cpu_to_le16(2);
5482         pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
5483         pSMB->MaxSetupCount = 0;
5484         pSMB->Reserved = 0;
5485         pSMB->Flags = 0;
5486         pSMB->Timeout = 0;
5487         pSMB->Reserved2 = 0;
5488         param_offset = offsetof(struct smb_com_transaction2_spi_req,
5489                                 InformationLevel) - 4;
5490         offset = param_offset + params;
5491         pSMB->InformationLevel =
5492                 cpu_to_le16(SMB_SET_FILE_EA);
5493
5494         parm_data =
5495                 (struct fealist *) (((char *) &pSMB->hdr.Protocol) +
5496                                        offset);
5497         pSMB->ParameterOffset = cpu_to_le16(param_offset);
5498         pSMB->DataOffset = cpu_to_le16(offset);
5499         pSMB->SetupCount = 1;
5500         pSMB->Reserved3 = 0;
5501         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_PATH_INFORMATION);
5502         byte_count = 3 /* pad */  + params + count;
5503         pSMB->DataCount = cpu_to_le16(count);
5504         parm_data->list_len = cpu_to_le32(count);
5505         parm_data->list[0].EA_flags = 0;
5506         /* we checked above that name len is less than 255 */
5507         parm_data->list[0].name_len = (__u8)name_len;
5508         /* EA names are always ASCII */
5509         if (ea_name)
5510                 strncpy(parm_data->list[0].name, ea_name, name_len);
5511         parm_data->list[0].name[name_len] = 0;
5512         parm_data->list[0].value_len = cpu_to_le16(ea_value_len);
5513         /* caller ensures that ea_value_len is less than 64K but
5514         we need to ensure that it fits within the smb */
5515
5516         /*BB add length check to see if it would fit in
5517              negotiated SMB buffer size BB */
5518         /* if (ea_value_len > buffer_size - 512 (enough for header)) */
5519         if (ea_value_len)
5520                 memcpy(parm_data->list[0].name+name_len+1,
5521                        ea_value, ea_value_len);
5522
5523         pSMB->TotalDataCount = pSMB->DataCount;
5524         pSMB->ParameterCount = cpu_to_le16(params);
5525         pSMB->TotalParameterCount = pSMB->ParameterCount;
5526         pSMB->Reserved4 = 0;
5527         pSMB->hdr.smb_buf_length += byte_count;
5528         pSMB->ByteCount = cpu_to_le16(byte_count);
5529         rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
5530                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
5531         if (rc)
5532                 cFYI(1, ("SetPathInfo (EA) returned %d", rc));
5533
5534         cifs_buf_release(pSMB);
5535
5536         if (rc == -EAGAIN)
5537                 goto SetEARetry;
5538
5539         return rc;
5540 }
5541
5542 #endif