Added ssize_t to configure code.

Got 'religion' about using size_t and ssize_t for read/write stuff
as part of the code to expose 64 bits to the client.

This checkin does all the 'easy' stuff - such as all the read/write/lock
calls - but now comes the harder parts (open & friends) and all the
file enquiry functions.....

Jeremy.

7 files changed, 295 insertions, 294 deletions

diff --git a/source/smbd/blocking.c b/source/smbd/blocking.c
index 2241b7aa8d2..051e276ca76 100644
--- a/source/smbd/blocking.c
+++ b/source/smbd/blocking.c
@@ -195,11 +195,13 @@ static void reply_lockingX_error(blocking_lock_record *blr, int eclass, int32 ec
   files_struct *fsp = blr->fsp;
   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
   uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
-  uint32 count, offset;
+  SMB_OFF_T count, offset;
+  unsigned char locktype = CVAL(inbuf,smb_vwv3);
+  BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
   char *data;
   int i;
 
-  data = smb_buf(inbuf) + 10*num_ulocks;
+  data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
 
   /* 
    * Data now points at the beginning of the list
@@ -209,8 +211,18 @@ static void reply_lockingX_error(blocking_lock_record *blr, int eclass, int32 ec
   for(i = blr->lock_num; i >= 0; i--) {
     int dummy1;
     uint32 dummy2;
-    count = IVAL(data,SMB_LKLEN_OFFSET(i));
-    offset = IVAL(data,SMB_LKOFF_OFFSET(i));
+    if(!large_file_format) {
+      count = IVAL(data,SMB_LKLEN_OFFSET(i));
+      offset = IVAL(data,SMB_LKOFF_OFFSET(i));
+    }
+#ifdef LARGE_SMB_OFF_T
+    else {
+      count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
+              ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
+      offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
+               ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
+    }
+#endif
     do_unlock(fsp,conn,count,offset,&dummy1,&dummy2);
   }
 
@@ -248,10 +260,11 @@ static BOOL process_lockread(blocking_lock_record *blr)
 {
   char *outbuf = OutBuffer;
   char *inbuf = blr->inbuf;
-  int nread = -1;
+  ssize_t nread = -1;
   char *data;
   int outsize = 0;
-  uint32 startpos, numtoread;
+  SMB_OFF_T startpos;
+  size_t numtoread;
   int eclass;
   uint32 ecode;
   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
@@ -316,7 +329,7 @@ static BOOL process_lock(blocking_lock_record *blr)
   char *outbuf = OutBuffer;
   char *inbuf = blr->inbuf;
   int outsize;
-  uint32 count,offset;
+  SMB_OFF_T count,offset;
   int eclass;
   uint32 ecode;
   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
@@ -352,8 +365,8 @@ static BOOL process_lock(blocking_lock_record *blr)
    * Success - we got the lock.
    */
 
-  DEBUG(3,("process_lock : file=%s fnum=%d ofs=%d cnt=%d\n",
-       fsp->fsp_name, fsp->fnum, (int)offset, (int)count));
+  DEBUG(3,("process_lock : file=%s fnum=%d offset=%.0f count=%.0f\n",
+       fsp->fsp_name, fsp->fnum, (double)offset, (double)count));
 
   construct_reply_common(inbuf, outbuf);
   outsize = set_message(outbuf,0,0,True);
@@ -374,12 +387,13 @@ static BOOL process_lockingX(blocking_lock_record *blr)
   connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
   uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
   uint16 num_locks = SVAL(inbuf,smb_vwv7);
-  uint32 count, offset;
+  SMB_OFF_T count, offset;
+  BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
   char *data;
   int eclass=0;
   uint32 ecode=0;
 
-  data = smb_buf(inbuf) + 10*num_ulocks;
+  data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
 
   /* 
    * Data now points at the beginning of the list
@@ -387,8 +401,18 @@ static BOOL process_lockingX(blocking_lock_record *blr)
    */
 
   for(; blr->lock_num < num_locks; blr->lock_num++) {
-    count = IVAL(data,SMB_LKLEN_OFFSET(blr->lock_num));
-    offset = IVAL(data,SMB_LKOFF_OFFSET(blr->lock_num));
+    if(!large_file_format) {
+      count = IVAL(data,SMB_LKLEN_OFFSET(blr->lock_num));
+      offset = IVAL(data,SMB_LKOFF_OFFSET(blr->lock_num));
+    }
+#ifdef LARGE_SMB_OFF_T
+    else {
+      count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(blr->lock_num))) << 32) |
+              ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(blr->lock_num)));
+      offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(blr->lock_num))) << 32) |
+               ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(blr->lock_num)));
+    }
+#endif
     errno = 0;
     if(!do_lock(fsp,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK),
                 &eclass, &ecode))
diff --git a/source/smbd/fileio.c b/source/smbd/fileio.c
index 6d6edf9d371..f0bb5e45ac4 100644
--- a/source/smbd/fileio.c
+++ b/source/smbd/fileio.c
@@ -27,6 +27,7 @@ extern int DEBUGLEVEL;
 /****************************************************************************
 seek a file. Try to avoid the seek if possible
 ****************************************************************************/
+
 SMB_OFF_T seek_file(files_struct *fsp,SMB_OFF_T pos)
 {
   SMB_OFF_T offset = 0;
@@ -41,45 +42,43 @@ SMB_OFF_T seek_file(files_struct *fsp,SMB_OFF_T pos)
 /****************************************************************************
 read from a file
 ****************************************************************************/
-int read_file(files_struct *fsp,char *data,uint32 pos,int n)
+
+ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
 {
-  int ret=0,readret;
+  ssize_t ret=0,readret;
 
 #if USE_READ_PREDICTION
-  if (!fsp->can_write)
-    {
-      ret = read_predict(fsp->fd_ptr->fd,pos,data,NULL,n);
+  if (!fsp->can_write) {
+    ret = read_predict(fsp->fd_ptr->fd,pos,data,NULL,n);
 
-      data += ret;
-      n -= ret;
-      pos += ret;
-    }
+    data += ret;
+    n -= ret;
+    pos += ret;
+  }
 #endif
 
 #if WITH_MMAP
-  if (fsp->mmap_ptr)
-    {
-      int num = (fsp->mmap_size > pos) ? (fsp->mmap_size - pos) : -1;
-      num = MIN(n,num);
-      if (num > 0)
-	{
-	  memcpy(data,fsp->mmap_ptr+pos,num);
-	  data += num;
-	  pos += num;
-	  n -= num;
-	  ret += num;
-	}
+  if (fsp->mmap_ptr) {
+    SMB_OFF_T num = (fsp->mmap_size > pos) ? (fsp->mmap_size - pos) : -1;
+    num = MIN(n,num);
+#ifdef LARGE_SMB_OFF_T
+    if ((num > 0) && (num < (1<<(sizeof(size_t)*8))) {
+#else /* LARGE_SMB_OFF_T */
+    if (num > 0) {
+#endif /* LARGE_SMB_OFF_T */
+      memcpy(data,fsp->mmap_ptr+pos,num);
+      data += num;
+      pos += num;
+      n -= num;
+      ret += num;
     }
+  }
 #endif
 
-  if (n <= 0)
+  if (seek_file(fsp,pos) != pos) {
+    DEBUG(3,("Failed to seek to %.0f\n",(double)pos));
     return(ret);
-
-  if (seek_file(fsp,pos) != pos)
-    {
-      DEBUG(3,("Failed to seek to %d\n",pos));
-      return(ret);
-    }
+  }
   
   if (n > 0) {
     readret = read(fsp->fd_ptr->fd,data,n);
@@ -93,7 +92,8 @@ int read_file(files_struct *fsp,char *data,uint32 pos,int n)
 /****************************************************************************
 write to a file
 ****************************************************************************/
-int write_file(files_struct *fsp,char *data,int n)
+
+ssize_t write_file(files_struct *fsp,char *data,size_t n)
 {
 
   if (!fsp->can_write) {
@@ -119,6 +119,7 @@ int write_file(files_struct *fsp,char *data,int n)
 /*******************************************************************
 sync a file
 ********************************************************************/
+
 void sync_file(connection_struct *conn, files_struct *fsp)
 {
 #ifdef HAVE_FSYNC
@@ -126,4 +127,3 @@ void sync_file(connection_struct *conn, files_struct *fsp)
       fsync(fsp->fd_ptr->fd);
 #endif
 }
-
diff --git a/source/smbd/nttrans.c b/source/smbd/nttrans.c
index 0f50145d7fa..81b3ff26d52 100644
--- a/source/smbd/nttrans.c
+++ b/source/smbd/nttrans.c
@@ -890,12 +890,12 @@ static int call_nt_transact_create(connection_struct *conn,
     p += 8;
     SIVAL(p,0,fmode); /* File Attributes. */
     p += 12;
-#if OFF_T_IS_64_BITS
-      SIVAL(p,0, file_len & 0xFFFFFFFF);
-      SIVAL(p,4, (file_len >> 32));
-#else /* OFF_T_IS_64_BITS */
-      SIVAL(p,0,file_len);
-#endif /* OFF_T_IS_64_BITS */
+#ifdef LARGE_SMB_OFF_T
+    SIVAL(p,0, file_len & 0xFFFFFFFF);
+    SIVAL(p,4, (file_len >> 32));
+#else /* LARGE_SMB_OFF_T */
+    SIVAL(p,0,file_len);
+#endif /* LARGE_SMB_OFF_T */
   }
 
   /* Send the required number of replies */
diff --git a/source/smbd/open.c b/source/smbd/open.c
index bd1ead69218..bdd4816aa71 100644
--- a/source/smbd/open.c
+++ b/source/smbd/open.c
@@ -815,13 +815,8 @@ void open_file_shared(files_struct *fsp,connection_struct *conn,char *fname,int
           if(share_entry->op_type & (EXCLUSIVE_OPLOCK|BATCH_OPLOCK))
           {
 
-#ifdef LARGE_SMB_INO_T
             DEBUG(5,("open_file_shared: breaking oplock (%x) on file %s, \
 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-            DEBUG(5,("open_file_shared: breaking oplock (%x) on file %s, \
-dev = %x, inode = %lx\n", share_entry->op_type, fname, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
             /* Oplock break.... */
             unlock_share_entry(conn, dev, inode, token);
@@ -829,13 +824,8 @@ dev = %x, inode = %lx\n", share_entry->op_type, fname, (unsigned int)dev, (unsig
             {
               free((char *)old_shares);
 
-#ifdef LARGE_SMB_INO_T
               DEBUG(0,("open_file_shared: FAILED when breaking oplock (%x) on file %s, \
 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-              DEBUG(0,("open_file_shared: FAILED when breaking oplock (%x) on file %s, \
-dev = %x, inode = %lx\n", old_shares[i].op_type, fname, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
               errno = EACCES;
               unix_ERR_class = ERRDOS;
@@ -940,13 +930,8 @@ dev = %x, inode = %lx\n", old_shares[i].op_type, fname, (unsigned int)dev, (unsi
         global_oplocks_open++;
         port = oplock_port;
 
-#ifdef LARGE_SMB_INO_T
         DEBUG(5,("open_file_shared: granted oplock (%x) on file %s, \
 dev = %x, inode = %.0f\n", oplock_request, fname, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-        DEBUG(5,("open_file_shared: granted oplock (%x) on file %s, \
-dev = %x, inode = %lx\n", oplock_request, fname, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
       }
       else
@@ -1114,13 +1099,8 @@ BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
           if(rename_op && (share_entry->pid == pid))
           {
 
-#ifdef LARGE_SMB_INO_T
             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-            DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
-batch oplocked file %s, dev = %x, inode = %lx\n", fname, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
             /* 
              * This next line is a test that allows the deny-mode
@@ -1135,13 +1115,8 @@ batch oplocked file %s, dev = %x, inode = %lx\n", fname, (unsigned int)dev, (uns
           else
           {
 
-#ifdef LARGE_SMB_INO_T
             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-            DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
-dev = %x, inode = %lx\n", share_entry->op_type, fname, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
             /* Oplock break.... */
             unlock_share_entry(conn, dev, inode, token);
@@ -1149,13 +1124,8 @@ dev = %x, inode = %lx\n", share_entry->op_type, fname, (unsigned int)dev, (unsig
             {
               free((char *)old_shares);
 
-#ifdef LARGE_SMB_INO_T
               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-              DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
-dev = %x, inode = %lx\n", old_shares[i].op_type, fname, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
               return False;
             }
diff --git a/source/smbd/oplock.c b/source/smbd/oplock.c
index dd882d08cc6..348e29dbe23 100644
--- a/source/smbd/oplock.c
+++ b/source/smbd/oplock.c
@@ -124,13 +124,8 @@ should be %d).\n", msg_len, OPLOCK_BREAK_MSG_LEN));
         tval.tv_sec = IVAL(msg_start, OPLOCK_BREAK_SEC_OFFSET);
         tval.tv_usec = IVAL(msg_start, OPLOCK_BREAK_USEC_OFFSET);
 
-#ifdef LARGE_SMB_INO_T
         DEBUG(5,("process_local_message: oplock break request from \
 pid %d, port %d, dev = %x, inode = %.0f\n", remotepid, from_port, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-        DEBUG(5,("process_local_message: oplock break request from \
-pid %d, port %d, dev = %x, inode = %lx\n", remotepid, from_port, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
         /*
          * If we have no record of any currently open oplocks,
@@ -170,15 +165,9 @@ oplocks. Returning success.\n"));
           return False;
         }
 
-#ifdef LARGE_SMB_INO_T
         DEBUG(5,("process_local_message: oplock break reply sent to \
 pid %d, port %d, for file dev = %x, inode = %.0f\n",
               remotepid, from_port, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-        DEBUG(5,("process_local_message: oplock break reply sent to \
-pid %d, port %d, for file dev = %x, inode = %lx\n",
-              remotepid, from_port, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
       }
       break;
@@ -210,13 +199,8 @@ reply - dumping info.\n"));
         SMB_INO_T inode = IVAL(msg_start, OPLOCK_BREAK_INODE_OFFSET);
 #endif /* LARGE_SMB_INO_T */
 
-#ifdef LARGE_SMB_INO_T
         DEBUG(0,("process_local_message: unsolicited oplock break reply from \
 pid %d, port %d, dev = %x, inode = %.0f\n", remotepid, from_port, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-        DEBUG(0,("process_local_message: unsolicited oplock break reply from \
-pid %d, port %d, dev = %x, inode = %lx\n", remotepid, from_port, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
        }
        return False;
@@ -247,11 +231,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
 
   if( DEBUGLVL( 3 ) )
     {
-#ifdef LARGE_SMB_INO_T
     dbgtext( "oplock_break: called for dev = %x, inode = %.0f.\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-    dbgtext( "oplock_break: called for dev = %x, inode = %lx.\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
     dbgtext( "Current global_oplocks_open = %d\n", global_oplocks_open );
     }
 
@@ -266,11 +246,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
     if( DEBUGLVL( 0 ) )
       {
       dbgtext( "oplock_break: cannot find open file with " );
-#ifdef LARGE_SMB_INO_T
       dbgtext( "dev = %x, inode = %.0f ", (unsigned int)dev, (double)inode);
-#else /* LARGE_SMB_INO_T */
-      dbgtext( "dev = %x, inode = %lx ", (unsigned int)dev, (unsigned long)inode);
-#endif /* LARGE_SMB_INO_T */
       dbgtext( "allowing break to succeed.\n" );
       }
     return True;
@@ -290,11 +266,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
     if( DEBUGLVL( 0 ) )
       {
       dbgtext( "oplock_break: file %s ", fsp->fsp_name );
-#ifdef LARGE_SMB_INO_T
       dbgtext( "(dev = %x, inode = %.0f) has no oplock.\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-      dbgtext( "(dev = %x, inode = %lx) has no oplock.\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
       dbgtext( "Allowing break to succeed regardless.\n" );
       }
     return True;
@@ -307,11 +279,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
       {
       dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
       dbgtext( "file %s ", fsp->fsp_name);
-#ifdef LARGE_SMB_INO_T
       dbgtext( "(dev = %x, inode = %.0f)\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-      dbgtext( "(dev = %x, inode = %lx)\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
       }
 
     /* We have to fail the open here as we cannot send another oplock break on
@@ -403,11 +371,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
                      OPLOCK_BREAK_TIMEOUT ) );
 
       DEBUGADD( 0, ( "oplock_break failed for file %s ", fsp->fsp_name ) );
-#ifdef LARGE_SMB_INO_T
       DEBUGADD( 0, ( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-      DEBUGADD( 0, ( "(dev = %x, inode = %lx).\n", (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
       shutdown_server = True;
       break;
@@ -435,11 +399,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
         dbgtext( "oplock_break: no break received from client " );
         dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
         dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
-#ifdef LARGE_SMB_INO_T
         dbgtext( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-        dbgtext( "(dev = %x, inode = %lx).\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
 
         }
       shutdown_server = True;
@@ -507,11 +467,7 @@ static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
   if( DEBUGLVL( 3 ) )
     {
     dbgtext( "oplock_break: returning success for " );
-#ifdef LARGE_SMB_INO_T
     dbgtext( "dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-    dbgtext( "dev = %x, inode = %lx\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
     dbgtext( "Current global_oplocks_open = %d\n", global_oplocks_open );
     }
 
@@ -576,11 +532,7 @@ should be %d\n", pid, share_entry->op_port, oplock_port));
     {
     dbgtext( "request_oplock_break: sending a oplock break message to " );
     dbgtext( "pid %d on port %d ", share_entry->pid, share_entry->op_port );
-#ifdef LARGE_SMB_INO_T
     dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-    dbgtext( "for dev = %x, inode = %lx\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
 
     }
 
@@ -592,11 +544,7 @@ should be %d\n", pid, share_entry->op_port, oplock_port));
       dbgtext( "request_oplock_break: failed when sending a oplock " );
       dbgtext( "break message to pid %d ", share_entry->pid );
       dbgtext( "on port %d ", share_entry->op_port );
-#ifdef LARGE_SMB_INO_T
       dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-      dbgtext( "for dev = %x, inode = %lx\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
       dbgtext( "Error was %s\n", strerror(errno) );
       }
     return False;
@@ -629,11 +577,7 @@ should be %d\n", pid, share_entry->op_port, oplock_port));
           dbgtext( "request_oplock_break: no response received to oplock " );
           dbgtext( "break request to pid %d ", share_entry->pid );
           dbgtext( "on port %d ", share_entry->op_port );
-#ifdef LARGE_SMB_INO_T
           dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-          dbgtext( "for dev = %x, inode = %lx\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
 
           }
         /*
@@ -651,11 +595,7 @@ should be %d\n", pid, share_entry->op_port, oplock_port));
           dbgtext( "request_oplock_break: error in response received " );
           dbgtext( "to oplock break request to pid %d ", share_entry->pid );
           dbgtext( "on port %d ", share_entry->op_port );
-#ifdef LARGE_SMB_INO_T
           dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-#else /* LARGE_SMB_INO_T */
-          dbgtext( "for dev = %x, inode = %lx\n", (unsigned int)dev, (unsigned long)inode );
-#endif /* LARGE_SMB_INO_T */
           dbgtext( "Error was (%s).\n", strerror(errno) );
           }
       return False;
diff --git a/source/smbd/predict.c b/source/smbd/predict.c
index 0deda0c0b63..5f015139cf3 100644
--- a/source/smbd/predict.c
+++ b/source/smbd/predict.c
@@ -28,11 +28,11 @@ extern int DEBUGLEVEL;
 /* variables used by the read prediction module */
 static int rp_fd = -1;
 static SMB_OFF_T rp_offset = 0;
-static int rp_length = 0;
-static int rp_alloced = 0;
+static ssize_t rp_length = 0;
+static ssize_t rp_alloced = 0;
 static int rp_predict_fd = -1;
 static SMB_OFF_T rp_predict_offset = 0;
-static int rp_predict_length = 0;
+static size_t rp_predict_length = 0;
 static int rp_timeout = 5;
 static time_t rp_time = 0;
 static char *rp_buffer = NULL;
@@ -42,10 +42,10 @@ extern time_t smb_last_time;
 /****************************************************************************
 handle read prediction on a file
 ****************************************************************************/
-int read_predict(int fd,SMB_OFF_T offset,char *buf,char **ptr,int num)
+ssize_t read_predict(int fd,SMB_OFF_T offset,char *buf,char **ptr,size_t num)
 {
-  int ret = 0;
-  int possible = rp_length - (offset - rp_offset);
+  ssize_t ret = 0;
+  ssize_t possible = rp_length - (offset - rp_offset);
 
   possible = MIN(possible,num);
 
@@ -97,7 +97,7 @@ pre-read some data
 ****************************************************************************/
 void do_read_prediction(void)
 {
-  static int readsize = 0;
+  static size_t readsize = 0;
 
   if (predict_skip) return;
 
diff --git a/source/smbd/reply.c b/source/smbd/reply.c
index 3d537d88681..8ec2715d0da 100644
--- a/source/smbd/reply.c
+++ b/source/smbd/reply.c
@@ -1765,11 +1765,11 @@ int reply_unlink(connection_struct *conn, char *inbuf,char *outbuf, int dum_size
 ****************************************************************************/
 int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_size, int dum_buffsize)
 {
-  int maxcount,mincount;
-  int nread = 0;
-  uint32 startpos;
+  size_t maxcount,mincount;
+  size_t nread = 0;
+  SMB_OFF_T startpos;
   char *header = outbuf;
-  SMB_OFF_T ret=0;
+  ssize_t ret=0;
   int fd;
   char *fname;
   files_struct *fsp;
@@ -1791,8 +1791,23 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
   fsp = file_fsp(inbuf,smb_vwv0);
 
   startpos = IVAL(inbuf,smb_vwv1);
-  maxcount = SVAL(inbuf,smb_vwv3);
-  mincount = SVAL(inbuf,smb_vwv4);
+#ifdef LARGE_SMB_OFF_T
+  if(SVAL(inbuf,smb_wct) == 10) {
+    /*
+     * This is a large offset (64 bit) read.
+     */
+    startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv8)) << 32);
+    if(startpos < 0) {
+      DEBUG(0,("readbraw - negative 64 bit readraw offset (%.0f) !\n",
+            (double)startpos ));
+	  _smb_setlen(header,0);
+	  transfer_file(0,Client,(SMB_OFF_T)0,header,4,0);
+	  return(-1);
+    }      
+  }
+#endif /* LARGE_SMB_OFF_T */
+  maxcount = (SVAL(inbuf,smb_vwv3) & 0xFFFF);
+  mincount = (SVAL(inbuf,smb_vwv4) & 0xFFFF);
 
   /* ensure we don't overrun the packet size */
   maxcount = MIN(65535,maxcount);
@@ -1812,9 +1827,10 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
   if (!is_locked(fsp,conn,maxcount,startpos, F_RDLCK))
   {
     SMB_OFF_T size = fsp->size;
-    int sizeneeded = startpos + maxcount;
+    SMB_OFF_T sizeneeded = startpos + maxcount;
 	    
-    if (size < sizeneeded) {
+    if (size < sizeneeded)
+    {
       SMB_STRUCT_STAT st;
       if (sys_fstat(fsp->fd_ptr->fd,&st) == 0)
         size = st.st_size;
@@ -1822,14 +1838,14 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
         fsp->size = size;
     }
 
-    nread = MIN(maxcount,(int)(size - startpos));	  
+    nread = MIN(maxcount,(size - startpos));	  
   }
 
   if (nread < mincount)
     nread = 0;
   
-  DEBUG( 3, ( "readbraw fnum=%d start=%d max=%d min=%d nread=%d\n",
-	      fsp->fnum, startpos,
+  DEBUG( 3, ( "readbraw fnum=%d start=%.0f max=%d min=%d nread=%d\n",
+	      fsp->fnum, (double)startpos,
 	      maxcount, mincount, nread ) );
   
 #if UNSAFE_READRAW
@@ -1840,12 +1856,12 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
 #if USE_READ_PREDICTION
     if (!fsp->can_write)
       predict = read_predict(fd,startpos,header+4,NULL,nread);
-#endif
+#endif /* USE_READ_PREDICTION */
 
     if ((nread-predict) > 0)
       seek_file(fsp,startpos + predict);
     
-    ret = transfer_file(fd,Client,(SMB_OFF_T)(nread-predict),header,4+predict,
+    ret = (ssize_t)transfer_file(fd,Client,(SMB_OFF_T)(nread-predict),header,4+predict,
 			startpos+predict);
   }
 
@@ -1853,13 +1869,13 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
     DEBUG(0,("ERROR: file read failure on %s at %d for %d bytes (%d)\n",
 	     fname,startpos,nread,ret));
 
-#else
+#else /* UNSAFE_READRAW */
   ret = read_file(fsp,header+4,startpos,nread);
   if (ret < mincount) ret = 0;
 
   _smb_setlen(header,ret);
   transfer_file(0,Client,0,header,4+ret,0);
-#endif
+#endif /* UNSAFE_READRAW */
 
   DEBUG(5,("readbraw finished\n"));
   return -1;
@@ -1871,10 +1887,11 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
 ****************************************************************************/
 int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int length, int dum_buffsiz)
 {
-  int nread = -1;
+  ssize_t nread = -1;
   char *data;
   int outsize = 0;
-  uint32 startpos, numtoread;
+  SMB_OFF_T startpos;
+  size_t numtoread;
   int eclass;
   uint32 ecode;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
@@ -1925,10 +1942,10 @@ int reply_lockread(connection_struct *conn, char *inbuf,char *outbuf, int length
 ****************************************************************************/
 int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-  int numtoread;
-  int nread = 0;
+  size_t numtoread;
+  ssize_t nread = 0;
   char *data;
-  uint32 startpos;
+  SMB_OFF_T startpos;
   int outsize = 0;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
 
@@ -1971,10 +1988,10 @@ int reply_read(connection_struct *conn, char *inbuf,char *outbuf, int dum_size,
 int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
 {
   files_struct *fsp = file_fsp(inbuf,smb_vwv2);
-  uint32 smb_offs = IVAL(inbuf,smb_vwv3);
-  int smb_maxcnt = SVAL(inbuf,smb_vwv5);
-  int smb_mincnt = SVAL(inbuf,smb_vwv6);
-  int nread = -1;
+  SMB_OFF_T startpos = IVAL(inbuf,smb_vwv3);
+  size_t smb_maxcnt = SVAL(inbuf,smb_vwv5);
+  size_t smb_mincnt = SVAL(inbuf,smb_vwv6);
+  ssize_t nread = -1;
   char *data;
   BOOL ok = False;
 
@@ -1989,9 +2006,18 @@ int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt
   set_message(outbuf,12,0,True);
   data = smb_buf(outbuf);
 
-  if (is_locked(fsp,conn,smb_maxcnt,smb_offs, F_RDLCK))
+#ifdef LARGE_SMB_INO_T
+  if(SVAL(inbuf,smb_wct) == 12) {
+    /*
+     * This is a large offset (64 bit) read.
+     */
+    startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv10)) << 32);
+  }
+#endif /* LARGE_SMB_INO_T */
+
+  if (is_locked(fsp,conn,smb_maxcnt,startpos, F_RDLCK))
     return(ERROR(ERRDOS,ERRlock));
-  nread = read_file(fsp,data,smb_offs,smb_maxcnt);
+  nread = read_file(fsp,data,startpos,smb_maxcnt);
   ok = True;
   
   if (nread < 0)
@@ -2007,21 +2033,20 @@ int reply_read_and_X(connection_struct *conn, char *inbuf,char *outbuf,int lengt
   return chain_reply(inbuf,outbuf,length,bufsize);
 }
 
-
 /****************************************************************************
   reply to a writebraw (core+ or LANMAN1.0 protocol)
 ****************************************************************************/
 int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-  int nwritten=0;
-  int total_written=0;
-  int numtowrite=0;
-  int outsize = 0;
-  long startpos;
+  ssize_t nwritten=0;
+  ssize_t total_written=0;
+  size_t numtowrite=0;
+  size_t tcount;
+  SMB_OFF_T startpos;
   char *data=NULL;
   BOOL write_through;
-  int tcount;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
+  int outsize = 0;
 
   CHECK_FSP(fsp,conn);
   CHECK_WRITE(fsp);
@@ -2049,13 +2074,13 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s
     return(ERROR(ERRDOS,ERRlock));
 
   if (seek_file(fsp,startpos) != startpos)
-    DEBUG(0,("couldn't seek to %ld in writebraw\n",startpos));
+    DEBUG(0,("couldn't seek to %.0f in writebraw\n",(double)startpos));
 
   if (numtowrite>0)
     nwritten = write_file(fsp,data,numtowrite);
   
-  DEBUG(3,("writebraw1 fnum=%d start=%ld num=%d wrote=%d sync=%d\n",
-	   fsp->fnum, startpos, numtowrite, nwritten, write_through));
+  DEBUG(3,("writebraw1 fnum=%d start=%.0f num=%d wrote=%d sync=%d\n",
+	   fsp->fnum, (double)startpos, numtowrite, nwritten, write_through));
 
   if (nwritten < numtowrite) 
     return(UNIXERROR(ERRHRD,ERRdiskfull));
@@ -2092,7 +2117,7 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s
   CVAL(outbuf,smb_com) = SMBwritec;
   SSVAL(outbuf,smb_vwv0,total_written);
 
-  if (nwritten < numtowrite) {
+  if (nwritten < (ssize_t)numtowrite) {
     CVAL(outbuf,smb_rcls) = ERRHRD;
     SSVAL(outbuf,smb_err,ERRdiskfull);      
   }
@@ -2100,8 +2125,8 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s
   if (lp_syncalways(SNUM(conn)) || write_through)
     sync_file(conn,fsp);
 
-  DEBUG(3,("writebraw2 fnum=%d start=%ld num=%d wrote=%d\n",
-	   fsp->fnum, startpos, numtowrite, total_written));
+  DEBUG(3,("writebraw2 fnum=%d start=%.0f num=%d wrote=%d\n",
+	   fsp->fnum, (double)startpos, numtowrite, total_written));
 
   /* we won't return a status if write through is not selected - this 
      follows what WfWg does */
@@ -2111,19 +2136,19 @@ int reply_writebraw(connection_struct *conn, char *inbuf,char *outbuf, int dum_s
   return(outsize);
 }
 
-
 /****************************************************************************
   reply to a writeunlock (core+)
 ****************************************************************************/
 int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-  int nwritten = -1;
-  int outsize = 0;
+  ssize_t nwritten = -1;
+  size_t numtowrite;
+  SMB_OFF_T startpos;
   char *data;
-  uint32 numtowrite,startpos;
   int eclass;
   uint32 ecode;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
+  int outsize = 0;
 
   CHECK_FSP(fsp,conn);
   CHECK_WRITE(fsp);
@@ -2165,18 +2190,17 @@ int reply_writeunlock(connection_struct *conn, char *inbuf,char *outbuf, int dum
   return(outsize);
 }
 
-
 /****************************************************************************
   reply to a write
 ****************************************************************************/
 int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,int dum_buffsize)
 {
-  int numtowrite;
-  int nwritten = -1;
-  int outsize = 0;
-  int startpos;
+  size_t numtowrite;
+  ssize_t nwritten = -1;
+  SMB_OFF_T startpos;
   char *data;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
+  int outsize = 0;
 
   CHECK_FSP(fsp,conn);
   CHECK_WRITE(fsp);
@@ -2209,7 +2233,7 @@ int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,i
   
   SSVAL(outbuf,smb_vwv0,nwritten);
 
-  if (nwritten < numtowrite) {
+  if (nwritten < (ssize_t)numtowrite) {
     CVAL(outbuf,smb_rcls) = ERRHRD;
     SSVAL(outbuf,smb_err,ERRdiskfull);      
   }
@@ -2227,11 +2251,11 @@ int reply_write(connection_struct *conn, char *inbuf,char *outbuf,int dum_size,i
 int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
 {
   files_struct *fsp = file_fsp(inbuf,smb_vwv2);
-  uint32 smb_offs = IVAL(inbuf,smb_vwv3);
-  int smb_dsize = SVAL(inbuf,smb_vwv10);
-  int smb_doff = SVAL(inbuf,smb_vwv11);
+  SMB_OFF_T startpos = IVAL(inbuf,smb_vwv3);
+  size_t numtowrite = SVAL(inbuf,smb_vwv10);
   BOOL write_through = BITSETW(inbuf+smb_vwv7,0);
-  int nwritten = -1;
+  ssize_t nwritten = -1;
+  int smb_doff = SVAL(inbuf,smb_vwv11);
   char *data;
 
   CHECK_FSP(fsp,conn);
@@ -2240,34 +2264,43 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng
 
   data = smb_base(inbuf) + smb_doff;
 
-  if (is_locked(fsp,conn,smb_dsize,smb_offs, F_WRLCK))
+#ifdef LLARGE_SMB_INO_T
+  if(SVAL(inbuf,smb_wct) == 14) {
+    /*
+     * This is a large offset (64 bit) write.
+     */
+    startpos |= (((SMB_OFF_T)IVAL(inbuf,smb_vwv12)) << 32);
+  }
+#endif /* LARGE_SMB_INO_T */
+
+  if (is_locked(fsp,conn,numtowrite,startpos, F_WRLCK))
     return(ERROR(ERRDOS,ERRlock));
 
-  seek_file(fsp,smb_offs);
+  seek_file(fsp,startpos);
   
   /* X/Open SMB protocol says that, unlike SMBwrite
      if the length is zero then NO truncation is
      done, just a write of zero. To truncate a file,
      use SMBwrite. */
-  if(smb_dsize == 0)
+  if(numtowrite == 0)
     nwritten = 0;
   else
-    nwritten = write_file(fsp,data,smb_dsize);
+    nwritten = write_file(fsp,data,numtowrite);
   
-  if(((nwritten == 0) && (smb_dsize != 0))||(nwritten < 0))
+  if(((nwritten == 0) && (numtowrite != 0))||(nwritten < 0))
     return(UNIXERROR(ERRDOS,ERRnoaccess));
 
   set_message(outbuf,6,0,True);
   
   SSVAL(outbuf,smb_vwv2,nwritten);
   
-  if (nwritten < smb_dsize) {
+  if (nwritten < (ssize_t)numtowrite) {
     CVAL(outbuf,smb_rcls) = ERRHRD;
     SSVAL(outbuf,smb_err,ERRdiskfull);      
   }
 
   DEBUG(3,("writeX fnum=%d num=%d wrote=%d\n",
-	   fsp->fnum, smb_dsize, nwritten));
+	   fsp->fnum, numtowrite, nwritten));
 
   if (lp_syncalways(SNUM(conn)) || write_through)
     sync_file(conn,fsp);
@@ -2281,7 +2314,7 @@ int reply_write_and_X(connection_struct *conn, char *inbuf,char *outbuf,int leng
 ****************************************************************************/
 int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-  uint32 startpos;
+  SMB_OFF_T startpos;
   SMB_OFF_T res= -1;
   int mode,umode;
   int outsize = 0;
@@ -2302,19 +2335,18 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int dum_size,
       umode = SEEK_SET; break;
   }
 
-  res = sys_lseek(fsp->fd_ptr->fd,(SMB_OFF_T)startpos,umode);
+  res = sys_lseek(fsp->fd_ptr->fd,startpos,umode);
   fsp->pos = res;
   
   outsize = set_message(outbuf,2,0,True);
-  SIVALS(outbuf,smb_vwv0,(uint32)res);
+  SIVALS(outbuf,smb_vwv0,res);
   
-  DEBUG(3,("lseek fnum=%d ofs=%d mode=%d\n",
-	   fsp->fnum, startpos, mode));
+  DEBUG(3,("lseek fnum=%d ofs=%.0f mode=%d\n",
+	   fsp->fnum, (double)startpos, mode));
 
   return(outsize);
 }
 
-
 /****************************************************************************
   reply to a flush
 ****************************************************************************/
@@ -2421,10 +2453,10 @@ int reply_close(connection_struct *conn,
 int reply_writeclose(connection_struct *conn,
 		     char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-	int numtowrite;
-	int nwritten = -1;
+	size_t numtowrite;
+	ssize_t nwritten = -1;
 	int outsize = 0;
-	int startpos;
+	SMB_OFF_T startpos;
 	char *data;
 	time_t mtime;
 	files_struct *fsp = file_fsp(inbuf,smb_vwv0);
@@ -2470,7 +2502,7 @@ int reply_lock(connection_struct *conn,
 	       char *inbuf,char *outbuf, int length, int dum_buffsize)
 {
 	int outsize = set_message(outbuf,0,0,True);
-	uint32 count,offset;
+	SMB_OFF_T count,offset;
 	int eclass;
 	uint32 ecode;
 	files_struct *fsp = file_fsp(inbuf,smb_vwv0);
@@ -2481,8 +2513,8 @@ int reply_lock(connection_struct *conn,
 	count = IVAL(inbuf,smb_vwv1);
 	offset = IVAL(inbuf,smb_vwv3);
 
-	DEBUG(3,("lock fd=%d fnum=%d ofs=%d cnt=%d\n",
-		 fsp->fd_ptr->fd, fsp->fnum, offset, count));
+	DEBUG(3,("lock fd=%d fnum=%d offset=%.0f count=%.0f\n",
+		 fsp->fd_ptr->fd, fsp->fnum, (double)offset, (double)count));
 
 	if (!do_lock(fsp, conn, count, offset, F_WRLCK, &eclass, &ecode)) {
       if((ecode == ERRlock) && lp_blocking_locks(SNUM(conn))) {
@@ -2507,7 +2539,7 @@ int reply_lock(connection_struct *conn,
 int reply_unlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
   int outsize = set_message(outbuf,0,0,True);
-  uint32 count,offset;
+  SMB_OFF_T count,offset;
   int eclass;
   uint32 ecode;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
@@ -2521,8 +2553,8 @@ int reply_unlock(connection_struct *conn, char *inbuf,char *outbuf, int dum_size
   if(!do_unlock(fsp, conn, count, offset, &eclass, &ecode))
     return (ERROR(eclass,ecode));
 
-  DEBUG( 3, ( "unlock fd=%d fnum=%d ofs=%d cnt=%d\n",
-        fsp->fd_ptr->fd, fsp->fnum, offset, count ) );
+  DEBUG( 3, ( "unlock fd=%d fnum=%d offset=%.0f count=%.0f\n",
+        fsp->fd_ptr->fd, fsp->fnum, (double)offset, (double)count ) );
   
   return(outsize);
 }
@@ -3476,8 +3508,6 @@ int reply_copy(connection_struct *conn, char *inbuf,char *outbuf, int dum_size,
   return(outsize);
 }
 
-
-
 /****************************************************************************
   reply to a setdir
 ****************************************************************************/
@@ -3515,7 +3545,6 @@ int reply_setdir(connection_struct *conn, char *inbuf,char *outbuf, int dum_size
   return(outsize);
 }
 
-
 /****************************************************************************
   reply to a lockingX request
 ****************************************************************************/
@@ -3528,13 +3557,13 @@ int reply_lockingX(connection_struct *conn, char *inbuf,char *outbuf,int length,
 #endif
   uint16 num_ulocks = SVAL(inbuf,smb_vwv6);
   uint16 num_locks = SVAL(inbuf,smb_vwv7);
-  uint32 count, offset;
+  SMB_OFF_T count, offset;
   int32 lock_timeout = IVAL(inbuf,smb_vwv4);
   int i;
   char *data;
   uint32 ecode=0, dummy2;
   int eclass=0, dummy1;
-
+  BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
   CHECK_FSP(fsp,conn);
   CHECK_ERROR(fsp);
 
@@ -3565,13 +3594,8 @@ no oplock granted on this file.\n", fsp->fnum));
     lock_share_entry(fsp->conn, dev, inode, &token);
     if(remove_share_oplock(fsp, token)==False) {
 
-#ifdef LARGE_SMB_INO_T
 	    DEBUG(0,("reply_lockingX: failed to remove share oplock for fnum %d, \
 dev = %x, inode = %.0f\n", fsp->fnum, (unsigned int)dev, (double)inode));
-#else /* LARGE_SMB_INO_T */
-	    DEBUG(0,("reply_lockingX: failed to remove share oplock for fnum %d, \
-dev = %x, inode = %lx\n", fsp->fnum, (unsigned int)dev, (unsigned long)inode));
-#endif /* LARGE_SMB_INO_T */
 
 	    unlock_share_entry(fsp->conn, dev, inode, token);
     } else {
@@ -3596,10 +3620,22 @@ dev = %x, inode = %lx\n", fsp->fnum, (unsigned int)dev, (unsigned long)inode));
   /* Data now points at the beginning of the list
      of smb_unlkrng structs */
   for(i = 0; i < (int)num_ulocks; i++) {
-    count = IVAL(data,SMB_LKLEN_OFFSET(i));
-    offset = IVAL(data,SMB_LKOFF_OFFSET(i));
-    DEBUG(10,("reply_lockingX: unlock start=%d, len=%d for file %s\n",
-          (int)offset, (int)count, fsp->fsp_name ));
+    if(!large_file_format) {
+      count = IVAL(data,SMB_LKLEN_OFFSET(i));
+      offset = IVAL(data,SMB_LKOFF_OFFSET(i));
+    }
+#ifdef LARGE_SMB_OFF_T
+    else {
+      count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
+              ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
+      offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
+               ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
+    }
+#endif
+
+    DEBUG(10,("reply_lockingX: unlock start=%.0f, len=%.0f for file %s\n",
+          (double)offset, (double)count, fsp->fsp_name ));
+
     if(!do_unlock(fsp,conn,count,offset,&eclass, &ecode))
       return ERROR(eclass,ecode);
   }
@@ -3608,14 +3644,28 @@ dev = %x, inode = %lx\n", fsp->fnum, (unsigned int)dev, (unsigned long)inode));
   lock_timeout = ((lock_timeout == -1) ? -1 : lock_timeout/1000);
 
   /* Now do any requested locks */
-  data += 10*num_ulocks;
+  data += ((large_file_format ? 20 : 10)*num_ulocks);
+
   /* Data now points at the beginning of the list
      of smb_lkrng structs */
+
   for(i = 0; i < (int)num_locks; i++) {
-    count = IVAL(data,SMB_LKLEN_OFFSET(i)); 
-    offset = IVAL(data,SMB_LKOFF_OFFSET(i)); 
-    DEBUG(10,("reply_lockingX: lock start=%d, len=%d for file %s\n",
-          (int)offset, (int)count, fsp->fsp_name ));
+    if(!large_file_format) {
+      count = IVAL(data,SMB_LKLEN_OFFSET(i)); 
+      offset = IVAL(data,SMB_LKOFF_OFFSET(i)); 
+    }
+#ifdef LARGE_SMB_OFF_T
+    else {
+      count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
+              ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
+      offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
+               ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
+    }
+#endif
+
+    DEBUG(10,("reply_lockingX: lock start=%.0f, len=%.0f for file %s\n",
+          (double)offset, (double)count, fsp->fsp_name ));
+
     if(!do_lock(fsp,conn,count,offset, ((locktype & 1) ? F_RDLCK : F_WRLCK),
                 &eclass, &ecode)) {
       if((ecode == ERRlock) && (lock_timeout != 0) && lp_blocking_locks(SNUM(conn))) {
@@ -3635,8 +3685,19 @@ dev = %x, inode = %lx\n", fsp->fnum, (unsigned int)dev, (unsigned long)inode));
      all of the previous locks (X/Open spec). */
   if(i != num_locks && num_locks != 0) {
     for(; i >= 0; i--) {
-      count = IVAL(data,SMB_LKLEN_OFFSET(i));  
-      offset = IVAL(data,SMB_LKOFF_OFFSET(i)); 
+      if(!large_file_format) {
+        count = IVAL(data,SMB_LKLEN_OFFSET(i));  
+        offset = IVAL(data,SMB_LKOFF_OFFSET(i)); 
+      }
+#ifdef LARGE_SMB_OFF_T
+      else {
+        count = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_HIGH(i))) << 32) |
+                ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKLEN_OFFSET_LOW(i)));
+        offset = (((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_HIGH(i))) << 32) |
+                 ((SMB_OFF_T) IVAL(data,SMB_LARGE_LKOFF_OFFSET_LOW(i)));
+      }
+#endif
+
       do_unlock(fsp,conn,count,offset,&dummy1,&dummy2);
     }
     return ERROR(eclass,ecode);
@@ -3656,13 +3717,14 @@ dev = %x, inode = %lx\n", fsp->fnum, (unsigned int)dev, (unsigned long)inode));
 ****************************************************************************/
 int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,int bufsize)
 {
-  int nread = -1;
-  int total_read;
+  ssize_t nread = -1;
+  ssize_t total_read;
   char *data;
-  uint32 startpos;
-  int outsize, mincount, maxcount;
+  SMB_OFF_T startpos;
+  int outsize;
+  size_t mincount, maxcount;
   int max_per_packet;
-  int tcount;
+  size_t tcount;
   int pad;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
 
@@ -3694,14 +3756,14 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,
 	
   do
     {
-      int N = MIN(max_per_packet,tcount-total_read);
+      size_t N = MIN(max_per_packet,tcount-total_read);
   
       nread = read_file(fsp,data,startpos,N);
 
       if (nread <= 0) nread = 0;
 
-      if (nread < N)
-	tcount = total_read + nread;
+      if (nread < (ssize_t)N)
+        tcount = total_read + nread;
 
       set_message(outbuf,8,nread,False);
       SIVAL(outbuf,smb_vwv0,startpos);
@@ -3714,22 +3776,23 @@ int reply_readbmpx(connection_struct *conn, char *inbuf,char *outbuf,int length,
       total_read += nread;
       startpos += nread;
     }
-  while (total_read < tcount);
+  while (total_read < (ssize_t)tcount);
 
   return(-1);
 }
 
-
 /****************************************************************************
   reply to a SMBwritebmpx (write block multiplex primary) request
 ****************************************************************************/
 int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-  int numtowrite;
-  int nwritten = -1;
+  size_t numtowrite;
+  ssize_t nwritten = -1;
   int outsize = 0;
-  uint32 startpos;
-  int tcount, write_through, smb_doff;
+  SMB_OFF_T startpos;
+  size_t tcount;
+  BOOL write_through;
+  int smb_doff;
   char *data;
   files_struct *fsp = file_fsp(inbuf,smb_vwv0);
 
@@ -3758,32 +3821,32 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s
   if(lp_syncalways(SNUM(conn)) || write_through)
     sync_file(conn,fsp);
   
-  if(nwritten < numtowrite)
+  if(nwritten < (ssize_t)numtowrite)
     return(UNIXERROR(ERRHRD,ERRdiskfull));
 
   /* If the maximum to be written to this file
      is greater than what we just wrote then set
      up a secondary struct to be attached to this
      fd, we will use this to cache error messages etc. */
-  if(tcount > nwritten) 
+  if((ssize_t)tcount > nwritten) 
+  {
+    write_bmpx_struct *wbms;
+    if(fsp->wbmpx_ptr != NULL)
+      wbms = fsp->wbmpx_ptr; /* Use an existing struct */
+    else
+      wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct));
+    if(!wbms)
     {
-      write_bmpx_struct *wbms;
-      if(fsp->wbmpx_ptr != NULL)
-	wbms = fsp->wbmpx_ptr; /* Use an existing struct */
-      else
-	wbms = (write_bmpx_struct *)malloc(sizeof(write_bmpx_struct));
-      if(!wbms)
-	{
-	  DEBUG(0,("Out of memory in reply_readmpx\n"));
-	  return(ERROR(ERRSRV,ERRnoresource));
-	}
-      wbms->wr_mode = write_through;
-      wbms->wr_discard = False; /* No errors yet */
-      wbms->wr_total_written = nwritten;
-      wbms->wr_errclass = 0;
-      wbms->wr_error = 0;
-      fsp->wbmpx_ptr = wbms;
+      DEBUG(0,("Out of memory in reply_readmpx\n"));
+      return(ERROR(ERRSRV,ERRnoresource));
     }
+    wbms->wr_mode = write_through;
+    wbms->wr_discard = False; /* No errors yet */
+    wbms->wr_total_written = nwritten;
+    wbms->wr_errclass = 0;
+    wbms->wr_error = 0;
+    fsp->wbmpx_ptr = wbms;
+  }
 
   /* We are returning successfully, set the message type back to
      SMBwritebmpx */
@@ -3816,11 +3879,13 @@ int reply_writebmpx(connection_struct *conn, char *inbuf,char *outbuf, int dum_s
 ****************************************************************************/
 int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize)
 {
-  int numtowrite;
-  int nwritten = -1;
+  size_t numtowrite;
+  ssize_t nwritten = -1;
   int outsize = 0;
-  int32 startpos;
-  int tcount, write_through, smb_doff;
+  SMB_OFF_T startpos;
+  size_t tcount;
+  BOOL write_through;
+  int smb_doff;
   char *data;
   write_bmpx_struct *wbms;
   BOOL send_response = False; 
@@ -3858,32 +3923,34 @@ int reply_writebs(connection_struct *conn, char *inbuf,char *outbuf, int dum_siz
   if(lp_syncalways(SNUM(conn)) || write_through)
     sync_file(conn,fsp);
   
-  if (nwritten < numtowrite)
+  if (nwritten < (ssize_t)numtowrite)
+  {
+    if(write_through)
     {
-      if(write_through)	{
-	/* We are returning an error - we can delete the aux struct */
-	if (wbms) free((char *)wbms);
-	fsp->wbmpx_ptr = NULL;
-	return(ERROR(ERRHRD,ERRdiskfull));
-      }
-      return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull));
+      /* We are returning an error - we can delete the aux struct */
+      if (wbms) free((char *)wbms);
+      fsp->wbmpx_ptr = NULL;
+      return(ERROR(ERRHRD,ERRdiskfull));
     }
+    return(CACHE_ERROR(wbms,ERRHRD,ERRdiskfull));
+  }
 
   /* Increment the total written, if this matches tcount
      we can discard the auxiliary struct (hurrah !) and return a writeC */
   wbms->wr_total_written += nwritten;
   if(wbms->wr_total_written >= tcount)
+  {
+    if (write_through)
     {
-      if (write_through) {
-	outsize = set_message(outbuf,1,0,True);
-	SSVAL(outbuf,smb_vwv0,wbms->wr_total_written);    
-	send_response = True;
-      }
-
-      free((char *)wbms);
-      fsp->wbmpx_ptr = NULL;
+      outsize = set_message(outbuf,1,0,True);
+      SSVAL(outbuf,smb_vwv0,wbms->wr_total_written);    
+      send_response = True;
     }
 
+    free((char *)wbms);
+    fsp->wbmpx_ptr = NULL;
+  }
+
   if(send_response)
     return(outsize);