r15162: Patch for bug #3668. Windows has a bug with LARGE_READX

[ira/wip.git] / source3 / libsmb / clireadwrite.c

diff --git a/source3/libsmb/clireadwrite.c b/source3/libsmb/clireadwrite.c
index 875df11dca46387dd37557506cc0d072deea9c13..883bc1260d6c492dcfb4efb5f1146ccbdfde0cd6 100644 (file)
--- a/source3/libsmb/clireadwrite.c
+++ b/source3/libsmb/clireadwrite.c
@@ -18,8 +18,6 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-#define NO_SYSLOG
-
 #include "includes.h"
 
 /****************************************************************************
@@ -29,10 +27,15 @@ Issue a single SMBread and don't wait for a reply.
 static BOOL cli_issue_read(struct cli_state *cli, int fnum, off_t offset, 
                           size_t size, int i)
 {
+       BOOL bigoffset = False;
+
        memset(cli->outbuf,'\0',smb_size);
        memset(cli->inbuf,'\0',smb_size);
 
-       set_message(cli->outbuf,10,0,True);
+       if ((SMB_BIG_UINT)offset >> 32) 
+               bigoffset = True;
+
+       set_message(cli->outbuf,bigoffset ? 12 : 10,0,True);
                
        SCVAL(cli->outbuf,smb_com,SMBreadX);
        SSVAL(cli->outbuf,smb_tid,cli->cnum);
@@ -43,8 +46,13 @@ static BOOL cli_issue_read(struct cli_state *cli, int fnum, off_t offset,
        SIVAL(cli->outbuf,smb_vwv3,offset);
        SSVAL(cli->outbuf,smb_vwv5,size);
        SSVAL(cli->outbuf,smb_vwv6,size);
+       SSVAL(cli->outbuf,smb_vwv7,((size >> 16) & 1));
        SSVAL(cli->outbuf,smb_mid,cli->mid + i);
 
+       if (bigoffset) {
+               SIVAL(cli->outbuf,smb_vwv10,(((SMB_BIG_UINT)offset)>>32) & 0xffffffff);
+       }
+
        return cli_send_smb(cli);
 }
 
@@ -67,7 +75,15 @@ ssize_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_
         * rounded down to a multiple of 1024.
         */
 
-       readsize = (cli->max_xmit - (smb_size+32)) & ~1023;
+       if (cli->capabilities & CAP_LARGE_READX) {
+               if (cli->is_samba) {
+                       readsize = CLI_SAMBA_MAX_LARGE_READX_SIZE;
+               } else {
+                       readsize = CLI_WINDOWS_MAX_LARGE_READX_SIZE;
+               }
+       } else {
+               readsize = (cli->max_xmit - (smb_size+32)) & ~1023;
+       }
 
        while (total < size) {
                readsize = MIN(readsize, size-total);
@@ -84,6 +100,7 @@ ssize_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_
                    errors. */
 
                 if (cli_is_error(cli)) {
+                       BOOL recoverable_error = False;
                         NTSTATUS status = NT_STATUS_OK;
                         uint8 eclass = 0;
                        uint32 ecode = 0;
@@ -93,12 +110,22 @@ ssize_t cli_read(struct cli_state *cli, int fnum, char *buf, off_t offset, size_
                         else
                                 cli_dos_error(cli, &eclass, &ecode);
 
+                       /*
+                        * ERRDOS ERRmoredata or STATUS_MORE_ENRTIES is a
+                        * recoverable error, plus we have valid data in the
+                        * packet so don't error out here.
+                        */
+
                         if ((eclass == ERRDOS && ecode == ERRmoredata) ||
                             NT_STATUS_V(status) == NT_STATUS_V(STATUS_MORE_ENTRIES))
+                               recoverable_error = True;
+
+                       if (!recoverable_error)
                                 return -1;
                }
 
                size2 = SVAL(cli->inbuf, smb_vwv5);
+               size2 |= (((unsigned int)(SVAL(cli->inbuf, smb_vwv7) & 1)) << 16);
 
                if (size2 > readsize) {
                        DEBUG(5,("server returned more than we wanted!\n"));
@@ -230,23 +257,34 @@ ssize_t cli_readraw(struct cli_state *cli, int fnum, char *buf, off_t offset, si
 issue a single SMBwrite and don't wait for a reply
 ****************************************************************************/
 
-static BOOL cli_issue_write(struct cli_state *cli, int fnum, off_t offset, uint16 mode, char *buf,
+static BOOL cli_issue_write(struct cli_state *cli, int fnum, off_t offset, 
+                           uint16 mode, const char *buf,
                            size_t size, int i)
 {
        char *p;
+       BOOL large_writex = False;
 
        if (size > cli->bufsize) {
-               cli->outbuf = realloc(cli->outbuf, size + 1024);
-               cli->inbuf = realloc(cli->inbuf, size + 1024);
-               if (cli->outbuf == NULL || cli->inbuf == NULL)
+               cli->outbuf = SMB_REALLOC(cli->outbuf, size + 1024);
+               if (!cli->outbuf) {
                        return False;
+               }
+               cli->inbuf = SMB_REALLOC(cli->inbuf, size + 1024);
+               if (cli->inbuf == NULL) {
+                       SAFE_FREE(cli->outbuf);
+                       return False;
+               }
                cli->bufsize = size + 1024;
        }
 
        memset(cli->outbuf,'\0',smb_size);
        memset(cli->inbuf,'\0',smb_size);
 
-       if (size > 0xFFFF)
+       if (((SMB_BIG_UINT)offset >> 32) || (size > 0xFFFF)) {
+               large_writex = True;
+       }
+
+       if (large_writex)
                set_message(cli->outbuf,14,0,True);
        else
                set_message(cli->outbuf,12,0,True);
@@ -259,14 +297,24 @@ static BOOL cli_issue_write(struct cli_state *cli, int fnum, off_t offset, uint1
        SSVAL(cli->outbuf,smb_vwv2,fnum);
 
        SIVAL(cli->outbuf,smb_vwv3,offset);
-       SIVAL(cli->outbuf,smb_vwv5,(mode & 0x0008) ? 0xFFFFFFFF : 0);
+       SIVAL(cli->outbuf,smb_vwv5,0);
        SSVAL(cli->outbuf,smb_vwv7,mode);
 
        SSVAL(cli->outbuf,smb_vwv8,(mode & 0x0008) ? size : 0);
+       /*
+        * According to CIFS-TR-1p00, this following field should only
+        * be set if CAP_LARGE_WRITEX is set. We should check this
+        * locally. However, this check might already have been
+        * done by our callers.
+        */
        SSVAL(cli->outbuf,smb_vwv9,((size>>16)&1));
        SSVAL(cli->outbuf,smb_vwv10,size);
        SSVAL(cli->outbuf,smb_vwv11,
              smb_buf(cli->outbuf) - smb_base(cli->outbuf));
+
+       if (large_writex) {
+               SIVAL(cli->outbuf,smb_vwv12,(((SMB_BIG_UINT)offset)>>32) & 0xffffffff);
+       }
        
        p = smb_base(cli->outbuf) + SVAL(cli->outbuf,smb_vwv11);
        memcpy(p, buf, size);
@@ -287,21 +335,27 @@ static BOOL cli_issue_write(struct cli_state *cli, int fnum, off_t offset, uint1
 ****************************************************************************/
 
 ssize_t cli_write(struct cli_state *cli,
-                 int fnum, uint16 write_mode,
-                 char *buf, off_t offset, size_t size)
+                int fnum, uint16 write_mode,
+                const char *buf, off_t offset, size_t size)
 {
-       int bwritten = 0;
-       int issued = 0;
-       int received = 0;
-       int mpx = MAX(cli->max_mux-1, 1);
-       int block = (cli->max_xmit - (smb_size+32)) & ~1023;
+       ssize_t bwritten = 0;
+       unsigned int issued = 0;
+       unsigned int received = 0;
+       int mpx = 1;
+       int block = cli->max_xmit - (smb_size+32);
        int blocks = (size + (block-1)) / block;
 
+       if(cli->max_mux > 1) {
+               mpx = cli->max_mux-1;
+       } else {
+               mpx = 1;
+       }
+
        while (received < blocks) {
 
                while ((issued - received < mpx) && (issued < blocks)) {
-                       int bsent = issued * block;
-                       int size1 = MIN(block, size - bsent);
+                       ssize_t bsent = issued * block;
+                       ssize_t size1 = MIN(block, size - bsent);
 
                        if (!cli_issue_write(cli, fnum, offset + bsent,
                                        write_mode,
@@ -320,7 +374,7 @@ ssize_t cli_write(struct cli_state *cli,
                        break;
 
                bwritten += SVAL(cli->inbuf, smb_vwv2);
-               bwritten += (((int)(SVAL(cli->inbuf, smb_vwv4)))>>16);
+               bwritten += (((int)(SVAL(cli->inbuf, smb_vwv4)))<<16);
        }
 
        while (received < issued && cli_receive_smb(cli))