SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/cifs/cifssmb.c

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