fs/cifs/cifssmb.c

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