From ef2e26c91b80556af033d3335e55f5dfa6fff31d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 13 Aug 2003 01:53:07 +0000
Subject: first public release of samba4 code

(This used to be commit b0510b5428b3461aeb9bbe3cc95f62fc73e2b97f)
---
 source4/libcli/raw/rawreadwrite.c | 321 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 321 insertions(+)
 create mode 100644 source4/libcli/raw/rawreadwrite.c

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
new file mode 100644
index 0000000000..84c7e3c00f
--- /dev/null
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -0,0 +1,321 @@
+/* 
+   Unix SMB/CIFS implementation.
+   client file read/write routines
+   Copyright (C) Andrew Tridgell 1994-1998
+   Copyright (C) James Myers 2003
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+
+#define SETUP_REQUEST(cmd, wct, buflen) do { \
+	req = cli_request_setup(tree, cmd, wct, buflen); \
+	if (!req) return NULL; \
+} while (0)
+
+
+/****************************************************************************
+ low level read operation (async send)
+****************************************************************************/
+struct cli_request *smb_raw_read_send(struct cli_tree *tree, union smb_read *parms)
+{
+	BOOL bigoffset = False;
+	struct cli_request *req; 
+
+	switch (parms->generic.level) {
+	case RAW_READ_GENERIC:
+		return NULL;
+		
+	case RAW_READ_READBRAW:
+		if (parms->readbraw.in.offset >= 0x80000000) {
+			bigoffset = True;
+		}
+		SETUP_REQUEST(SMBreadbraw, bigoffset? 10:8, 0);
+		SSVAL(req->out.vwv, VWV(0), parms->readbraw.in.fnum);
+		SIVAL(req->out.vwv, VWV(1), parms->readbraw.in.offset);
+		SSVAL(req->out.vwv, VWV(3), parms->readbraw.in.maxcnt);
+		SSVAL(req->out.vwv, VWV(4), parms->readbraw.in.mincnt);
+		SIVAL(req->out.vwv, VWV(5), parms->readbraw.in.timeout);
+		SSVAL(req->out.vwv, VWV(7), 0); /* reserved */
+		if (bigoffset) {
+			SIVAL(req->out.vwv, VWV(8),parms->readbraw.in.offset>>32);
+		}
+		break;
+
+	case RAW_READ_LOCKREAD:
+		SETUP_REQUEST(SMBlockread, 5, 0);
+		SSVAL(req->out.vwv, VWV(0), parms->lockread.in.fnum);
+		SSVAL(req->out.vwv, VWV(1), parms->lockread.in.count);
+		SIVAL(req->out.vwv, VWV(2), parms->lockread.in.offset);
+		SSVAL(req->out.vwv, VWV(4), parms->lockread.in.remaining);
+		break;
+
+	case RAW_READ_READ:
+		SETUP_REQUEST(SMBread, 5, 0);
+		SSVAL(req->out.vwv, VWV(0), parms->read.in.fnum);
+		SSVAL(req->out.vwv, VWV(1), parms->read.in.count);
+		SIVAL(req->out.vwv, VWV(2), parms->read.in.offset);
+		SSVAL(req->out.vwv, VWV(4), parms->read.in.remaining);
+		break;
+
+	case RAW_READ_READX:
+		if (parms->readx.in.offset >= 0x80000000) {
+			bigoffset = True;
+		}
+		SETUP_REQUEST(SMBreadX, bigoffset ? 12 : 10, 0);
+		SSVAL(req->out.vwv, VWV(0), 0xFF);
+		SSVAL(req->out.vwv, VWV(1), 0);
+		SSVAL(req->out.vwv, VWV(2), parms->readx.in.fnum);
+		SIVAL(req->out.vwv, VWV(3), parms->readx.in.offset);
+		SSVAL(req->out.vwv, VWV(5), parms->readx.in.maxcnt);
+		SSVAL(req->out.vwv, VWV(6), parms->readx.in.mincnt);
+		SIVAL(req->out.vwv, VWV(7), 0); /* reserved */
+		SSVAL(req->out.vwv, VWV(9), parms->readx.in.remaining);
+		if (bigoffset) {
+			SIVAL(req->out.vwv, VWV(10),parms->readx.in.offset>>32);
+		}
+		break;
+	}
+
+	if (!cli_request_send(req)) {
+		cli_request_destroy(req);
+		return NULL;
+	}
+
+	/* the transport layer needs to know that a readbraw is pending
+	   and handle receives a little differently */
+	if (parms->generic.level == RAW_READ_READBRAW) {
+		tree->session->transport->readbraw_pending = 1;
+	}
+
+	return req;
+}
+
+/****************************************************************************
+ low level read operation (async recv)
+****************************************************************************/
+NTSTATUS smb_raw_read_recv(struct cli_request *req, union smb_read *parms)
+{
+	if (!cli_request_receive(req) ||
+	    cli_request_is_error(req)) {
+		goto failed;
+	}
+
+	switch (parms->generic.level) {
+	case RAW_READ_GENERIC:
+		/* handled in _send() */
+		break;
+
+	case RAW_READ_READBRAW:
+		parms->readbraw.out.nread = req->in.size - NBT_HDR_SIZE;
+		if (parms->readbraw.out.nread > 
+		    MAX(parms->readx.in.mincnt, parms->readx.in.maxcnt)) {
+			req->status = NT_STATUS_BUFFER_TOO_SMALL;
+			goto failed;
+		}
+		memcpy(parms->readbraw.out.data, req->in.buffer + NBT_HDR_SIZE, parms->readbraw.out.nread);
+		break;
+		
+	case RAW_READ_LOCKREAD:
+		CLI_CHECK_WCT(req, 5);
+		parms->lockread.out.nread = SVAL(req->in.vwv, VWV(0));
+		if (parms->lockread.out.nread > parms->lockread.in.count ||
+		    !cli_raw_pull_data(req, req->in.data+3, 
+				       parms->lockread.out.nread, parms->lockread.out.data)) {
+			req->status = NT_STATUS_BUFFER_TOO_SMALL;
+		}
+		break;
+
+	case RAW_READ_READ:
+		/* there are 4 reserved words in the reply */
+		CLI_CHECK_WCT(req, 5);
+		parms->read.out.nread = SVAL(req->in.vwv, VWV(0));
+		if (parms->read.out.nread > parms->read.in.count ||
+		    !cli_raw_pull_data(req, req->in.data+3, 
+				       parms->read.out.nread, parms->read.out.data)) {
+			req->status = NT_STATUS_BUFFER_TOO_SMALL;
+		}
+		break;
+
+	case RAW_READ_READX:
+		/* there are 5 reserved words in the reply */
+		CLI_CHECK_WCT(req, 12);
+		parms->readx.out.remaining       = SVAL(req->in.vwv, VWV(2));
+		parms->readx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
+		parms->readx.out.nread = SVAL(req->in.vwv, VWV(5));
+		if (parms->readx.out.nread > MAX(parms->readx.in.mincnt, parms->readx.in.maxcnt) ||
+		    !cli_raw_pull_data(req, req->in.hdr + SVAL(req->in.vwv, VWV(6)), 
+				       parms->readx.out.nread, 
+				       parms->readx.out.data)) {
+			req->status = NT_STATUS_BUFFER_TOO_SMALL;
+		}
+		break;
+	}
+
+failed:
+	return cli_request_destroy(req);
+}
+
+/****************************************************************************
+ low level read operation (sync interface)
+****************************************************************************/
+NTSTATUS smb_raw_read(struct cli_tree *tree, union smb_read *parms)
+{
+	struct cli_request *req = smb_raw_read_send(tree, parms);
+	return smb_raw_read_recv(req, parms);
+}
+
+
+/****************************************************************************
+ raw write interface (async send)
+****************************************************************************/
+struct cli_request *smb_raw_write_send(struct cli_tree *tree, union smb_write *parms)
+{
+	BOOL bigoffset = False;
+	struct cli_request *req; 
+
+	switch (parms->generic.level) {
+	case RAW_WRITE_GENERIC:
+		return NULL;
+		
+	case RAW_WRITE_WRITEUNLOCK:
+		SETUP_REQUEST(SMBwriteunlock, 5, 3 + parms->writeunlock.in.count);
+		SSVAL(req->out.vwv, VWV(0), parms->writeunlock.in.fnum);
+		SSVAL(req->out.vwv, VWV(1), parms->writeunlock.in.count);
+		SIVAL(req->out.vwv, VWV(2), parms->writeunlock.in.offset);
+		SSVAL(req->out.vwv, VWV(4), parms->writeunlock.in.remaining);
+		SCVAL(req->out.data, 0, SMB_DATA_BLOCK);
+		SSVAL(req->out.data, 1, parms->writeunlock.in.count);
+		if (parms->writeunlock.in.count > 0) {
+			memcpy(req->out.data+3, parms->writeunlock.in.data, 
+			       parms->writeunlock.in.count);
+		}
+		break;
+
+	case RAW_WRITE_WRITE:
+		SETUP_REQUEST(SMBwrite, 5,  3 + parms->write.in.count);
+		SSVAL(req->out.vwv, VWV(0), parms->write.in.fnum);
+		SSVAL(req->out.vwv, VWV(1), parms->write.in.count);
+		SIVAL(req->out.vwv, VWV(2), parms->write.in.offset);
+		SSVAL(req->out.vwv, VWV(4), parms->write.in.remaining);
+		SCVAL(req->out.data, 0, SMB_DATA_BLOCK);
+		SSVAL(req->out.data, 1, parms->write.in.count);
+		if (parms->write.in.count > 0) {
+			memcpy(req->out.data+3, parms->write.in.data, parms->write.in.count);
+		}
+		break;
+
+	case RAW_WRITE_WRITECLOSE:
+		SETUP_REQUEST(SMBwriteclose, 6, 1 + parms->writeclose.in.count);
+		SSVAL(req->out.vwv, VWV(0), parms->writeclose.in.fnum);
+		SSVAL(req->out.vwv, VWV(1), parms->writeclose.in.count);
+		SIVAL(req->out.vwv, VWV(2), parms->writeclose.in.offset);
+		put_dos_date3(req->out.vwv, VWV(4), parms->writeclose.in.mtime);
+		SCVAL(req->out.data, 0, 0);
+		if (parms->writeclose.in.count > 0) {
+			memcpy(req->out.data+1, parms->writeclose.in.data, 
+			       parms->writeclose.in.count);
+		}
+		break;
+
+	case RAW_WRITE_WRITEX:
+		if (parms->writex.in.offset >= 0x80000000) {
+			bigoffset = True;
+		}
+		SETUP_REQUEST(SMBwriteX, bigoffset ? 14 : 12, parms->writex.in.count);
+		SSVAL(req->out.vwv, VWV(0), 0xFF);
+		SSVAL(req->out.vwv, VWV(1), 0);
+		SSVAL(req->out.vwv, VWV(2), parms->writex.in.fnum);
+		SIVAL(req->out.vwv, VWV(3), parms->writex.in.offset);
+		SIVAL(req->out.vwv, VWV(5), 0); /* reserved */
+		SSVAL(req->out.vwv, VWV(7), parms->writex.in.wmode);
+		SSVAL(req->out.vwv, VWV(8), parms->writex.in.remaining);
+		SSVAL(req->out.vwv, VWV(9), 0); /* reserved */
+		SSVAL(req->out.vwv, VWV(10), parms->writex.in.count);
+		SSVAL(req->out.vwv, VWV(11), PTR_DIFF(req->out.data, req->out.hdr));
+		if (bigoffset) {
+	      		SIVAL(req->out.vwv,VWV(12),parms->writex.in.offset>>32);
+		}
+	      	if (parms->writex.in.count > 0) {
+			memcpy(req->out.data, parms->writex.in.data, parms->writex.in.count);
+		}
+		break;
+
+	case RAW_WRITE_SPLWRITE:
+		SETUP_REQUEST(SMBsplwr, 1, parms->splwrite.in.count);
+		SSVAL(req->out.vwv, VWV(0), parms->splwrite.in.fnum);
+		if (parms->splwrite.in.count > 0) {
+			memcpy(req->out.data, parms->splwrite.in.data, parms->splwrite.in.count);
+		}
+		break;
+	}
+
+	if (!cli_request_send(req)) {
+cli_request_destroy(req);
+		return NULL;
+	}
+
+	return req;
+}
+
+
+/****************************************************************************
+ raw write interface (async recv)
+****************************************************************************/
+NTSTATUS smb_raw_write_recv(struct cli_request *req, union smb_write *parms)
+{
+	if (!cli_request_receive(req) ||
+	    cli_request_is_error(req)) {
+		goto failed;
+	}
+
+	switch (parms->generic.level) {
+	case RAW_WRITE_GENERIC:
+		break;
+	case RAW_WRITE_WRITEUNLOCK:
+		CLI_CHECK_WCT(req, 1);		
+		parms->writeunlock.out.nwritten = SVAL(req->in.vwv, VWV(0));
+		break;
+	case RAW_WRITE_WRITE:
+		CLI_CHECK_WCT(req, 1);
+		parms->write.out.nwritten = SVAL(req->in.vwv, VWV(0));
+		break;
+	case RAW_WRITE_WRITECLOSE:
+		CLI_CHECK_WCT(req, 1);
+		parms->writeclose.out.nwritten = SVAL(req->in.vwv, VWV(0));
+		break;
+	case RAW_WRITE_WRITEX:
+		CLI_CHECK_WCT(req, 6);
+		parms->writex.out.nwritten  = SVAL(req->in.vwv, VWV(2));
+		parms->writex.out.nwritten += (CVAL(req->in.vwv, VWV(4)) << 16);
+		parms->writex.out.remaining = SVAL(req->in.vwv, VWV(3));
+		break;
+	case RAW_WRITE_SPLWRITE:
+		break;
+	}
+
+failed:
+	return cli_request_destroy(req);
+}
+
+/****************************************************************************
+ raw write interface (sync interface)
+****************************************************************************/
+NTSTATUS smb_raw_write(struct cli_tree *tree, union smb_write *parms)
+{
+	struct cli_request *req = smb_raw_write_send(tree, parms);
+	return smb_raw_write_recv(req, parms);
+}
-- 
cgit 


From 14591dc0eaa8751e8eb982d4157862e8ab8f2841 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 8 Mar 2004 07:11:13 +0000
Subject: fixed two writex client bugs

 - always use the 14 word writex varient even for small transfers as
   long as large offsets are negotiated (this matches windows
   behaviour)

 - make sure we fill in the top 16 bits of the count for large writex
   calls
(This used to be commit 9ea20d0c9a1cb4800f3f54195cbbe70c98c8e423)
---
 source4/libcli/raw/rawreadwrite.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 84c7e3c00f..3aa95c35aa 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -40,7 +40,7 @@ struct cli_request *smb_raw_read_send(struct cli_tree *tree, union smb_read *par
 		return NULL;
 		
 	case RAW_READ_READBRAW:
-		if (parms->readbraw.in.offset >= 0x80000000) {
+		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBreadbraw, bigoffset? 10:8, 0);
@@ -72,7 +72,7 @@ struct cli_request *smb_raw_read_send(struct cli_tree *tree, union smb_read *par
 		break;
 
 	case RAW_READ_READX:
-		if (parms->readx.in.offset >= 0x80000000) {
+		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBreadX, bigoffset ? 12 : 10, 0);
@@ -232,7 +232,7 @@ struct cli_request *smb_raw_write_send(struct cli_tree *tree, union smb_write *p
 		break;
 
 	case RAW_WRITE_WRITEX:
-		if (parms->writex.in.offset >= 0x80000000) {
+		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBwriteX, bigoffset ? 14 : 12, parms->writex.in.count);
@@ -243,7 +243,7 @@ struct cli_request *smb_raw_write_send(struct cli_tree *tree, union smb_write *p
 		SIVAL(req->out.vwv, VWV(5), 0); /* reserved */
 		SSVAL(req->out.vwv, VWV(7), parms->writex.in.wmode);
 		SSVAL(req->out.vwv, VWV(8), parms->writex.in.remaining);
-		SSVAL(req->out.vwv, VWV(9), 0); /* reserved */
+		SSVAL(req->out.vwv, VWV(9), parms->writex.in.count>>16);
 		SSVAL(req->out.vwv, VWV(10), parms->writex.in.count);
 		SSVAL(req->out.vwv, VWV(11), PTR_DIFF(req->out.data, req->out.hdr));
 		if (bigoffset) {
-- 
cgit 


From ac193579e7db00c7a2ea0aadaaf0d34c10dcf1a5 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 10 Apr 2004 20:18:22 +0000
Subject: r152: a quick airport commit ....

added ldbedit, a _really_ useful command

added ldbadd, ldbdel, ldbsearch and ldbmodify to build

solved lots of timezone issues, we now pass the torture tests with
client and server in different zones

fixed several build issues

I know this breaks the no-LDAP build. Wait till I arrive in San Jose for that
fix.
(This used to be commit af34710d4da1841653624fe304b1c8d812c0fdd9)
---
 source4/libcli/raw/rawreadwrite.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 3aa95c35aa..3e3b29d252 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -223,7 +223,8 @@ struct cli_request *smb_raw_write_send(struct cli_tree *tree, union smb_write *p
 		SSVAL(req->out.vwv, VWV(0), parms->writeclose.in.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->writeclose.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->writeclose.in.offset);
-		put_dos_date3(req->out.vwv, VWV(4), parms->writeclose.in.mtime);
+		raw_push_dos_date3(tree->session->transport,
+				  req->out.vwv, VWV(4), parms->writeclose.in.mtime);
 		SCVAL(req->out.data, 0, 0);
 		if (parms->writeclose.in.count > 0) {
 			memcpy(req->out.data+1, parms->writeclose.in.data, 
-- 
cgit 


From c5fbb6f23c2d399c7510bc552cdb1a27b1ef66a8 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 4 Aug 2004 13:23:35 +0000
Subject: r1654: rename cli_ -> smbcli_ rename CLI_ -> SMBCLI_

metze
(This used to be commit 8441750fd9427dd6fe477f27e603821b4026f038)
---
 source4/libcli/raw/rawreadwrite.c | 62 +++++++++++++++++++--------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 3e3b29d252..f0a9a063ed 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -22,7 +22,7 @@
 #include "includes.h"
 
 #define SETUP_REQUEST(cmd, wct, buflen) do { \
-	req = cli_request_setup(tree, cmd, wct, buflen); \
+	req = smbcli_request_setup(tree, cmd, wct, buflen); \
 	if (!req) return NULL; \
 } while (0)
 
@@ -30,10 +30,10 @@
 /****************************************************************************
  low level read operation (async send)
 ****************************************************************************/
-struct cli_request *smb_raw_read_send(struct cli_tree *tree, union smb_read *parms)
+struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_read *parms)
 {
 	BOOL bigoffset = False;
-	struct cli_request *req; 
+	struct smbcli_request *req; 
 
 	switch (parms->generic.level) {
 	case RAW_READ_GENERIC:
@@ -90,8 +90,8 @@ struct cli_request *smb_raw_read_send(struct cli_tree *tree, union smb_read *par
 		break;
 	}
 
-	if (!cli_request_send(req)) {
-		cli_request_destroy(req);
+	if (!smbcli_request_send(req)) {
+		smbcli_request_destroy(req);
 		return NULL;
 	}
 
@@ -107,10 +107,10 @@ struct cli_request *smb_raw_read_send(struct cli_tree *tree, union smb_read *par
 /****************************************************************************
  low level read operation (async recv)
 ****************************************************************************/
-NTSTATUS smb_raw_read_recv(struct cli_request *req, union smb_read *parms)
+NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 {
-	if (!cli_request_receive(req) ||
-	    cli_request_is_error(req)) {
+	if (!smbcli_request_receive(req) ||
+	    smbcli_request_is_error(req)) {
 		goto failed;
 	}
 
@@ -130,10 +130,10 @@ NTSTATUS smb_raw_read_recv(struct cli_request *req, union smb_read *parms)
 		break;
 		
 	case RAW_READ_LOCKREAD:
-		CLI_CHECK_WCT(req, 5);
+		SMBCLI_CHECK_WCT(req, 5);
 		parms->lockread.out.nread = SVAL(req->in.vwv, VWV(0));
 		if (parms->lockread.out.nread > parms->lockread.in.count ||
-		    !cli_raw_pull_data(req, req->in.data+3, 
+		    !smbcli_raw_pull_data(req, req->in.data+3, 
 				       parms->lockread.out.nread, parms->lockread.out.data)) {
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
 		}
@@ -141,10 +141,10 @@ NTSTATUS smb_raw_read_recv(struct cli_request *req, union smb_read *parms)
 
 	case RAW_READ_READ:
 		/* there are 4 reserved words in the reply */
-		CLI_CHECK_WCT(req, 5);
+		SMBCLI_CHECK_WCT(req, 5);
 		parms->read.out.nread = SVAL(req->in.vwv, VWV(0));
 		if (parms->read.out.nread > parms->read.in.count ||
-		    !cli_raw_pull_data(req, req->in.data+3, 
+		    !smbcli_raw_pull_data(req, req->in.data+3, 
 				       parms->read.out.nread, parms->read.out.data)) {
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
 		}
@@ -152,12 +152,12 @@ NTSTATUS smb_raw_read_recv(struct cli_request *req, union smb_read *parms)
 
 	case RAW_READ_READX:
 		/* there are 5 reserved words in the reply */
-		CLI_CHECK_WCT(req, 12);
+		SMBCLI_CHECK_WCT(req, 12);
 		parms->readx.out.remaining       = SVAL(req->in.vwv, VWV(2));
 		parms->readx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
 		parms->readx.out.nread = SVAL(req->in.vwv, VWV(5));
 		if (parms->readx.out.nread > MAX(parms->readx.in.mincnt, parms->readx.in.maxcnt) ||
-		    !cli_raw_pull_data(req, req->in.hdr + SVAL(req->in.vwv, VWV(6)), 
+		    !smbcli_raw_pull_data(req, req->in.hdr + SVAL(req->in.vwv, VWV(6)), 
 				       parms->readx.out.nread, 
 				       parms->readx.out.data)) {
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
@@ -166,15 +166,15 @@ NTSTATUS smb_raw_read_recv(struct cli_request *req, union smb_read *parms)
 	}
 
 failed:
-	return cli_request_destroy(req);
+	return smbcli_request_destroy(req);
 }
 
 /****************************************************************************
  low level read operation (sync interface)
 ****************************************************************************/
-NTSTATUS smb_raw_read(struct cli_tree *tree, union smb_read *parms)
+NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
 {
-	struct cli_request *req = smb_raw_read_send(tree, parms);
+	struct smbcli_request *req = smb_raw_read_send(tree, parms);
 	return smb_raw_read_recv(req, parms);
 }
 
@@ -182,10 +182,10 @@ NTSTATUS smb_raw_read(struct cli_tree *tree, union smb_read *parms)
 /****************************************************************************
  raw write interface (async send)
 ****************************************************************************/
-struct cli_request *smb_raw_write_send(struct cli_tree *tree, union smb_write *parms)
+struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms)
 {
 	BOOL bigoffset = False;
-	struct cli_request *req; 
+	struct smbcli_request *req; 
 
 	switch (parms->generic.level) {
 	case RAW_WRITE_GENERIC:
@@ -264,8 +264,8 @@ struct cli_request *smb_raw_write_send(struct cli_tree *tree, union smb_write *p
 		break;
 	}
 
-	if (!cli_request_send(req)) {
-cli_request_destroy(req);
+	if (!smbcli_request_send(req)) {
+smbcli_request_destroy(req);
 		return NULL;
 	}
 
@@ -276,10 +276,10 @@ cli_request_destroy(req);
 /****************************************************************************
  raw write interface (async recv)
 ****************************************************************************/
-NTSTATUS smb_raw_write_recv(struct cli_request *req, union smb_write *parms)
+NTSTATUS smb_raw_write_recv(struct smbcli_request *req, union smb_write *parms)
 {
-	if (!cli_request_receive(req) ||
-	    cli_request_is_error(req)) {
+	if (!smbcli_request_receive(req) ||
+	    smbcli_request_is_error(req)) {
 		goto failed;
 	}
 
@@ -287,19 +287,19 @@ NTSTATUS smb_raw_write_recv(struct cli_request *req, union smb_write *parms)
 	case RAW_WRITE_GENERIC:
 		break;
 	case RAW_WRITE_WRITEUNLOCK:
-		CLI_CHECK_WCT(req, 1);		
+		SMBCLI_CHECK_WCT(req, 1);		
 		parms->writeunlock.out.nwritten = SVAL(req->in.vwv, VWV(0));
 		break;
 	case RAW_WRITE_WRITE:
-		CLI_CHECK_WCT(req, 1);
+		SMBCLI_CHECK_WCT(req, 1);
 		parms->write.out.nwritten = SVAL(req->in.vwv, VWV(0));
 		break;
 	case RAW_WRITE_WRITECLOSE:
-		CLI_CHECK_WCT(req, 1);
+		SMBCLI_CHECK_WCT(req, 1);
 		parms->writeclose.out.nwritten = SVAL(req->in.vwv, VWV(0));
 		break;
 	case RAW_WRITE_WRITEX:
-		CLI_CHECK_WCT(req, 6);
+		SMBCLI_CHECK_WCT(req, 6);
 		parms->writex.out.nwritten  = SVAL(req->in.vwv, VWV(2));
 		parms->writex.out.nwritten += (CVAL(req->in.vwv, VWV(4)) << 16);
 		parms->writex.out.remaining = SVAL(req->in.vwv, VWV(3));
@@ -309,14 +309,14 @@ NTSTATUS smb_raw_write_recv(struct cli_request *req, union smb_write *parms)
 	}
 
 failed:
-	return cli_request_destroy(req);
+	return smbcli_request_destroy(req);
 }
 
 /****************************************************************************
  raw write interface (sync interface)
 ****************************************************************************/
-NTSTATUS smb_raw_write(struct cli_tree *tree, union smb_write *parms)
+NTSTATUS smb_raw_write(struct smbcli_tree *tree, union smb_write *parms)
 {
-	struct cli_request *req = smb_raw_write_send(tree, parms);
+	struct smbcli_request *req = smb_raw_write_send(tree, parms);
 	return smb_raw_write_recv(req, parms);
 }
-- 
cgit 


From b83ba93eaeb2dcb0bf11615591d886fda84e4162 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 21 Aug 2004 01:54:46 +0000
Subject: r1983: a completely new implementation of talloc

This version does the following:

  1) talloc_free(), talloc_realloc() and talloc_steal() lose their
     (redundent) first arguments

  2) you can use _any_ talloc pointer as a talloc context to allocate
     more memory. This allows you to create complex data structures
     where the top level structure is the logical parent of the next
     level down, and those are the parents of the level below
     that. Then destroy either the lot with a single talloc_free() or
     destroy any sub-part with a talloc_free() of that part

  3) you can name any pointer. Use talloc_named() which is just like
     talloc() but takes the printf style name argument as well as the
     parent context and the size.

The whole thing ends up being a very simple piece of code, although
some of the pointer walking gets hairy.

So far, I'm just using the new talloc() like the old one. The next
step is to actually take advantage of the new interface
properly. Expect some new commits soon that simplify some common
coding styles in samba4 by using the new talloc().
(This used to be commit e35bb094c52e550b3105dd1638d8d90de71d854f)
---
 source4/libcli/raw/rawreadwrite.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index f0a9a063ed..dbca6fb7a5 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -33,7 +33,7 @@
 struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_read *parms)
 {
 	BOOL bigoffset = False;
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_READ_GENERIC:
@@ -185,7 +185,7 @@ NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
 struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms)
 {
 	BOOL bigoffset = False;
-	struct smbcli_request *req; 
+	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_WRITE_GENERIC:
-- 
cgit 


From 20d17b80571f0d0265c99c1ccdc21910c2eed043 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Wed, 20 Oct 2004 08:28:31 +0000
Subject: r3081: several updates to ntvfs and server side async request
 handling in preparation for the full share modes and ntcreatex code that I am
 working on.

highlights include:

 - changed the way a backend determines if it is allowed to process a
   request asynchronously. The previous method of looking at the
   send_fn caused problems when an intermediate ntvfs module disabled
   it, and the caller then wanted to finished processing using this
   function. The new method is a REQ_CONTROL_MAY_ASYNC flag in
   req->control_flags, which is also a bit easier to read

 - fixed 2 bugs in the readbraw server code. One related to trying to
   answer a readbraw with smb signing (which can't work, and crashed
   our signing code), the second related to error handling, which
   attempted to send a normal SMB error packet, when readbraw must
   send a 0 read reply (as it has no header)

 - added several more ntvfs_generic.c generic mapping functions. This
   means that backends no longer need to implement such esoteric
   functions as SMBwriteunlock() if they don't want to. The backend
   can just request the mapping layer turn it into a write followed by
   an unlock. This makes the backends considerably simpler as they
   only need to implement one style of each function for lock, read,
   write, open etc, rather than the full host of functions that SMB
   provides. A backend can still choose to implement them
   individually, of course, and the CIFS backend does that.

 - simplified the generic structures to make them identical to the
   principal call for several common SMB calls (such as
   RAW_WRITE_GENERIC now being an alias for RAW_WRITE_WRITEX).

 - started rewriting the pvfs_open() code in preparation for the full
   ntcreatex semantics.

 - in pvfs_open and ipc_open, initially allocate the open file
   structure as a child of the request, so on error we don't need to
   clean up. Then when we are going to succeed the open steal the
   pointer into the long term backend context. This makes for much
   simpler error handling (and fixes some bugs)

 - use a destructor in the ipc backend to make sure that everthing is
   cleaned up on receive error conditions.

 - switched the ipc backend to using idtree for fnum allocation

 - in the ntvfs_generic mapping routines, use a allocated secondary
   structure not a stack structure to ensure the request pointer
   remains valid even if the backend replies async.
(This used to be commit 3457c1836c09c82956697eb21627dfa2ed37682e)
---
 source4/libcli/raw/rawreadwrite.c | 12 ------------
 1 file changed, 12 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index dbca6fb7a5..e145ff9c10 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -36,9 +36,6 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
-	case RAW_READ_GENERIC:
-		return NULL;
-		
 	case RAW_READ_READBRAW:
 		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
 			bigoffset = True;
@@ -115,10 +112,6 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 	}
 
 	switch (parms->generic.level) {
-	case RAW_READ_GENERIC:
-		/* handled in _send() */
-		break;
-
 	case RAW_READ_READBRAW:
 		parms->readbraw.out.nread = req->in.size - NBT_HDR_SIZE;
 		if (parms->readbraw.out.nread > 
@@ -188,9 +181,6 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
-	case RAW_WRITE_GENERIC:
-		return NULL;
-		
 	case RAW_WRITE_WRITEUNLOCK:
 		SETUP_REQUEST(SMBwriteunlock, 5, 3 + parms->writeunlock.in.count);
 		SSVAL(req->out.vwv, VWV(0), parms->writeunlock.in.fnum);
@@ -284,8 +274,6 @@ NTSTATUS smb_raw_write_recv(struct smbcli_request *req, union smb_write *parms)
 	}
 
 	switch (parms->generic.level) {
-	case RAW_WRITE_GENERIC:
-		break;
 	case RAW_WRITE_WRITEUNLOCK:
 		SMBCLI_CHECK_WCT(req, 1);		
 		parms->writeunlock.out.nwritten = SVAL(req->in.vwv, VWV(0));
-- 
cgit 


From fef66179dd5a7c3498f23a79a43de9632f02648b Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 26 Oct 2004 05:34:35 +0000
Subject: r3237: - allow for readx calls larger than 64k

- combine setattre and standard levels in setfileinfo, as they use the
  same structure
(This used to be commit e9aa1f789955533aca4fe43d5d74ffa1e8d1300b)
---
 source4/libcli/raw/rawreadwrite.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index e145ff9c10..bc9730f33d 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -77,9 +77,9 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 		SSVAL(req->out.vwv, VWV(1), 0);
 		SSVAL(req->out.vwv, VWV(2), parms->readx.in.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->readx.in.offset);
-		SSVAL(req->out.vwv, VWV(5), parms->readx.in.maxcnt);
+		SSVAL(req->out.vwv, VWV(5), parms->readx.in.maxcnt & 0xFFFF);
 		SSVAL(req->out.vwv, VWV(6), parms->readx.in.mincnt);
-		SIVAL(req->out.vwv, VWV(7), 0); /* reserved */
+		SIVAL(req->out.vwv, VWV(7), parms->readx.in.maxcnt >> 16);
 		SSVAL(req->out.vwv, VWV(9), parms->readx.in.remaining);
 		if (bigoffset) {
 			SIVAL(req->out.vwv, VWV(10),parms->readx.in.offset>>32);
-- 
cgit 


From 9f1210a243654fd6d94acdef83f468a33c1b3b3f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 1 Nov 2004 01:03:22 +0000
Subject: r3419: moved the libcli/raw structures into libcli/raw/libcliraw.h
 and made them private (This used to be commit
 386ac565c452ede1d74e06acb401ca9db99d3ff3)

---
 source4/libcli/raw/rawreadwrite.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index bc9730f33d..4978514d26 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -20,6 +20,7 @@
 */
 
 #include "includes.h"
+#include "libcli/raw/libcliraw.h"
 
 #define SETUP_REQUEST(cmd, wct, buflen) do { \
 	req = smbcli_request_setup(tree, cmd, wct, buflen); \
-- 
cgit 


From cb700e90c22d9e301a05142699df7b64402a08d8 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 10 Nov 2004 10:56:43 +0000
Subject: r3654: Add static and fix indentation.

Andrew Bartlett
(This used to be commit cef31134ec4cd09eafd4f9f8f64e5fe3d68f19de)
---
 source4/libcli/raw/rawreadwrite.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 4978514d26..8381c7b2b0 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -256,7 +256,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 	}
 
 	if (!smbcli_request_send(req)) {
-smbcli_request_destroy(req);
+		smbcli_request_destroy(req);
 		return NULL;
 	}
 
-- 
cgit 


From 5e4e61c8276d5f0a4a2d4c6cbc20047554096227 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sun, 26 Dec 2004 08:13:01 +0000
Subject: r4364: - added support for testing of chained SMB operations in
 smbtorture

- added test for chained OpenX/ReadX, simulating the OS/2 workplace shell

- fixed a bug in handling chained fnum in openx and ntcreatex in the server

(yes, I'm on holiday, but this bug was annoying me ....)
(This used to be commit b3b8958a18e302b815d98c0e3879e404bced6a08)
---
 source4/libcli/raw/rawreadwrite.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 8381c7b2b0..d9fe3fdce0 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -27,7 +27,6 @@
 	if (!req) return NULL; \
 } while (0)
 
-
 /****************************************************************************
  low level read operation (async send)
 ****************************************************************************/
@@ -74,7 +73,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBreadX, bigoffset ? 12 : 10, 0);
-		SSVAL(req->out.vwv, VWV(0), 0xFF);
+		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 		SSVAL(req->out.vwv, VWV(1), 0);
 		SSVAL(req->out.vwv, VWV(2), parms->readx.in.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->readx.in.offset);
@@ -228,7 +227,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBwriteX, bigoffset ? 14 : 12, parms->writex.in.count);
-		SSVAL(req->out.vwv, VWV(0), 0xFF);
+		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 		SSVAL(req->out.vwv, VWV(1), 0);
 		SSVAL(req->out.vwv, VWV(2), parms->writex.in.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->writex.in.offset);
-- 
cgit 


From 307e43bb5628e8b53a930c2928279af994281ba5 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Fri, 10 Mar 2006 20:49:20 +0000
Subject: r14173: change smb interface structures to always use a union
 smb_file, to abtract - const char *path fot qpathinfo and setpathinfo -
 uint16_t fnum for SMB - smb2_handle handle for SMB2

the idea is to later add a struct ntvfs_handle *ntvfs
so that the ntvfs subsystem don't need to know the difference between SMB and SMB2

metze
(This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f)
---
 source4/libcli/raw/rawreadwrite.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index d9fe3fdce0..00dc71971e 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -41,7 +41,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBreadbraw, bigoffset? 10:8, 0);
-		SSVAL(req->out.vwv, VWV(0), parms->readbraw.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->readbraw.file.fnum);
 		SIVAL(req->out.vwv, VWV(1), parms->readbraw.in.offset);
 		SSVAL(req->out.vwv, VWV(3), parms->readbraw.in.maxcnt);
 		SSVAL(req->out.vwv, VWV(4), parms->readbraw.in.mincnt);
@@ -54,7 +54,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 
 	case RAW_READ_LOCKREAD:
 		SETUP_REQUEST(SMBlockread, 5, 0);
-		SSVAL(req->out.vwv, VWV(0), parms->lockread.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->lockread.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->lockread.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->lockread.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->lockread.in.remaining);
@@ -62,7 +62,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 
 	case RAW_READ_READ:
 		SETUP_REQUEST(SMBread, 5, 0);
-		SSVAL(req->out.vwv, VWV(0), parms->read.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->read.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->read.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->read.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->read.in.remaining);
@@ -75,7 +75,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 		SETUP_REQUEST(SMBreadX, bigoffset ? 12 : 10, 0);
 		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 		SSVAL(req->out.vwv, VWV(1), 0);
-		SSVAL(req->out.vwv, VWV(2), parms->readx.in.fnum);
+		SSVAL(req->out.vwv, VWV(2), parms->readx.file.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->readx.in.offset);
 		SSVAL(req->out.vwv, VWV(5), parms->readx.in.maxcnt & 0xFFFF);
 		SSVAL(req->out.vwv, VWV(6), parms->readx.in.mincnt);
@@ -183,7 +183,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 	switch (parms->generic.level) {
 	case RAW_WRITE_WRITEUNLOCK:
 		SETUP_REQUEST(SMBwriteunlock, 5, 3 + parms->writeunlock.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->writeunlock.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->writeunlock.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->writeunlock.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->writeunlock.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->writeunlock.in.remaining);
@@ -197,7 +197,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_WRITE:
 		SETUP_REQUEST(SMBwrite, 5,  3 + parms->write.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->write.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->write.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->write.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->write.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->write.in.remaining);
@@ -210,7 +210,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_WRITECLOSE:
 		SETUP_REQUEST(SMBwriteclose, 6, 1 + parms->writeclose.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->writeclose.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->writeclose.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->writeclose.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->writeclose.in.offset);
 		raw_push_dos_date3(tree->session->transport,
@@ -229,7 +229,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 		SETUP_REQUEST(SMBwriteX, bigoffset ? 14 : 12, parms->writex.in.count);
 		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 		SSVAL(req->out.vwv, VWV(1), 0);
-		SSVAL(req->out.vwv, VWV(2), parms->writex.in.fnum);
+		SSVAL(req->out.vwv, VWV(2), parms->writex.file.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->writex.in.offset);
 		SIVAL(req->out.vwv, VWV(5), 0); /* reserved */
 		SSVAL(req->out.vwv, VWV(7), parms->writex.in.wmode);
@@ -247,7 +247,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_SPLWRITE:
 		SETUP_REQUEST(SMBsplwr, 1, parms->splwrite.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->splwrite.in.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->splwrite.file.fnum);
 		if (parms->splwrite.in.count > 0) {
 			memcpy(req->out.data, parms->splwrite.in.data, parms->splwrite.in.count);
 		}
-- 
cgit 


From 7f0c7702f6b9db216fcd6c29165b2a11ea1f24a9 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 11 Mar 2006 12:58:36 +0000
Subject: r14208: removed use of req->flags2 inside the ntvfs layer. This
 should help metze on his quest to unify the ntvfs strucures for the smb and
 smb2 servers. The only place we needed flags2 inside ntvfs was for the
 FLAGS2_READ_PERMIT_EXECUTE bit, which only affects readx, so I added a
 readx.in.read_for_execute flag instead. (This used to be commit
 b78abbbce60ab0009da19a72dd769800c44298a2)

---
 source4/libcli/raw/rawreadwrite.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 00dc71971e..c4e2ab2498 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -84,6 +84,9 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 		if (bigoffset) {
 			SIVAL(req->out.vwv, VWV(10),parms->readx.in.offset>>32);
 		}
+		if (parms->readx.in.read_for_execute) {
+			req->flags2 |= FLAGS2_READ_PERMIT_EXECUTE;
+		}
 		break;
 	}
 
-- 
cgit 


From a1b295ed4823ce8d06f830b8db9a5d965c934b54 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sun, 12 Mar 2006 22:48:25 +0000
Subject: r14256: - rename smb_file -> smb_handle - move it into the in/out
 substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo

metze
(This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963)
---
 source4/libcli/raw/rawreadwrite.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index c4e2ab2498..7f1aaf26d4 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -41,7 +41,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 			bigoffset = True;
 		}
 		SETUP_REQUEST(SMBreadbraw, bigoffset? 10:8, 0);
-		SSVAL(req->out.vwv, VWV(0), parms->readbraw.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->readbraw.in.file.fnum);
 		SIVAL(req->out.vwv, VWV(1), parms->readbraw.in.offset);
 		SSVAL(req->out.vwv, VWV(3), parms->readbraw.in.maxcnt);
 		SSVAL(req->out.vwv, VWV(4), parms->readbraw.in.mincnt);
@@ -54,7 +54,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 
 	case RAW_READ_LOCKREAD:
 		SETUP_REQUEST(SMBlockread, 5, 0);
-		SSVAL(req->out.vwv, VWV(0), parms->lockread.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->lockread.in.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->lockread.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->lockread.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->lockread.in.remaining);
@@ -62,7 +62,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 
 	case RAW_READ_READ:
 		SETUP_REQUEST(SMBread, 5, 0);
-		SSVAL(req->out.vwv, VWV(0), parms->read.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->read.in.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->read.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->read.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->read.in.remaining);
@@ -75,7 +75,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 		SETUP_REQUEST(SMBreadX, bigoffset ? 12 : 10, 0);
 		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 		SSVAL(req->out.vwv, VWV(1), 0);
-		SSVAL(req->out.vwv, VWV(2), parms->readx.file.fnum);
+		SSVAL(req->out.vwv, VWV(2), parms->readx.in.file.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->readx.in.offset);
 		SSVAL(req->out.vwv, VWV(5), parms->readx.in.maxcnt & 0xFFFF);
 		SSVAL(req->out.vwv, VWV(6), parms->readx.in.mincnt);
@@ -186,7 +186,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 	switch (parms->generic.level) {
 	case RAW_WRITE_WRITEUNLOCK:
 		SETUP_REQUEST(SMBwriteunlock, 5, 3 + parms->writeunlock.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->writeunlock.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->writeunlock.in.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->writeunlock.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->writeunlock.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->writeunlock.in.remaining);
@@ -200,7 +200,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_WRITE:
 		SETUP_REQUEST(SMBwrite, 5,  3 + parms->write.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->write.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->write.in.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->write.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->write.in.offset);
 		SSVAL(req->out.vwv, VWV(4), parms->write.in.remaining);
@@ -213,7 +213,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_WRITECLOSE:
 		SETUP_REQUEST(SMBwriteclose, 6, 1 + parms->writeclose.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->writeclose.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->writeclose.in.file.fnum);
 		SSVAL(req->out.vwv, VWV(1), parms->writeclose.in.count);
 		SIVAL(req->out.vwv, VWV(2), parms->writeclose.in.offset);
 		raw_push_dos_date3(tree->session->transport,
@@ -232,7 +232,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 		SETUP_REQUEST(SMBwriteX, bigoffset ? 14 : 12, parms->writex.in.count);
 		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
 		SSVAL(req->out.vwv, VWV(1), 0);
-		SSVAL(req->out.vwv, VWV(2), parms->writex.file.fnum);
+		SSVAL(req->out.vwv, VWV(2), parms->writex.in.file.fnum);
 		SIVAL(req->out.vwv, VWV(3), parms->writex.in.offset);
 		SIVAL(req->out.vwv, VWV(5), 0); /* reserved */
 		SSVAL(req->out.vwv, VWV(7), parms->writex.in.wmode);
@@ -250,7 +250,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_SPLWRITE:
 		SETUP_REQUEST(SMBsplwr, 1, parms->splwrite.in.count);
-		SSVAL(req->out.vwv, VWV(0), parms->splwrite.file.fnum);
+		SSVAL(req->out.vwv, VWV(0), parms->splwrite.in.file.fnum);
 		if (parms->splwrite.in.count > 0) {
 			memcpy(req->out.data, parms->splwrite.in.data, parms->splwrite.in.count);
 		}
-- 
cgit 


From acc051674226d60a4d9739d883b2261ce98d651c Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 18 Apr 2006 13:05:24 +0000
Subject: r15121: fix pushing of the FLAGS2_READ_PERMIT_EXECUTE flag in the
 "readx.read_for_execute = True" case.

metze
(This used to be commit f30f9cd3285f75ac8cbbe8dc5a476fe6a714a2e3)
---
 source4/libcli/raw/rawreadwrite.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 7f1aaf26d4..7b424df6df 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -85,7 +85,9 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 			SIVAL(req->out.vwv, VWV(10),parms->readx.in.offset>>32);
 		}
 		if (parms->readx.in.read_for_execute) {
-			req->flags2 |= FLAGS2_READ_PERMIT_EXECUTE;
+			uint16_t flags2 = SVAL(req->out.hdr, HDR_FLG2);
+			flags2 |= FLAGS2_READ_PERMIT_EXECUTE;
+			SSVAL(req->out.hdr, HDR_FLG2, flags2);
 		}
 		break;
 	}
-- 
cgit 


From 2de1d5f7a8c2a3a815d81c217c274d2d5f1768cb Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 20 May 2006 10:40:10 +0000
Subject: r15740: add TODO, that we should check if the server supports large
 offsets, before sending large offset requests

metze
(This used to be commit b9ba2b8c5a314ba9e559e50bea4deb692dc0f3ec)
---
 source4/libcli/raw/rawreadwrite.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 7b424df6df..63a60ad545 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -81,6 +81,10 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 		SSVAL(req->out.vwv, VWV(6), parms->readx.in.mincnt);
 		SIVAL(req->out.vwv, VWV(7), parms->readx.in.maxcnt >> 16);
 		SSVAL(req->out.vwv, VWV(9), parms->readx.in.remaining);
+		/*
+		 * TODO: give an error when the offset is 64 bit
+		 *       and the server doesn't support it
+		 */
 		if (bigoffset) {
 			SIVAL(req->out.vwv, VWV(10),parms->readx.in.offset>>32);
 		}
-- 
cgit 


From e306c5bf129a981693bd251d45597f1e584ee850 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Sat, 20 May 2006 10:46:38 +0000
Subject: r15741: move smb2 request structures into the main smb request
 structs as new levels

metze
(This used to be commit 91806353174704857dfcc15a730af7232cfde660)
---
 source4/libcli/raw/rawreadwrite.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 63a60ad545..7a47ce66f4 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -94,6 +94,9 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 			SSVAL(req->out.hdr, HDR_FLG2, flags2);
 		}
 		break;
+
+	case RAW_READ_SMB2:
+		return NULL;
 	}
 
 	if (!smbcli_request_send(req)) {
@@ -165,6 +168,10 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
 		}
 		break;
+
+	case RAW_READ_SMB2:
+		req->status = NT_STATUS_INTERNAL_ERROR;
+		break;
 	}
 
 failed:
@@ -261,6 +268,9 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 			memcpy(req->out.data, parms->splwrite.in.data, parms->splwrite.in.count);
 		}
 		break;
+
+	case RAW_WRITE_SMB2:
+		return NULL;
 	}
 
 	if (!smbcli_request_send(req)) {
@@ -303,6 +313,9 @@ NTSTATUS smb_raw_write_recv(struct smbcli_request *req, union smb_write *parms)
 		break;
 	case RAW_WRITE_SPLWRITE:
 		break;
+	case RAW_WRITE_SMB2:
+		req->status = NT_STATUS_INTERNAL_ERROR;
+		break;
 	}
 
 failed:
-- 
cgit 


From c72c3e983468bdee33e4482e7b7ccb45cb7c9ddb Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 8 Dec 2006 03:47:02 +0000
Subject: r20077: support large readx replies, as done by samba3 (and the snia
 spec), but not done by windows servers (This used to be commit
 e5dbbe177c13b2788b4b4765b3b37cc918b3405c)

---
 source4/libcli/raw/rawreadwrite.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 7a47ce66f4..e7a3209d07 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -161,6 +161,20 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 		parms->readx.out.remaining       = SVAL(req->in.vwv, VWV(2));
 		parms->readx.out.compaction_mode = SVAL(req->in.vwv, VWV(3));
 		parms->readx.out.nread = SVAL(req->in.vwv, VWV(5));
+
+		/* handle oversize replies for non-chained readx replies with
+		   CAP_LARGE_READX. The snia spec has must to answer for. */
+		if ((req->tree->session->transport->negotiate.capabilities & CAP_LARGE_READX)
+		    && CVAL(req->in.vwv, VWV(0)) == SMB_CHAIN_NONE &&
+		    req->in.size >= 0x10000) {
+			parms->readx.out.nread += (SVAL(req->in.vwv, VWV(7)) << 16);
+			if (req->in.hdr + SVAL(req->in.vwv, VWV(6)) +
+			    parms->readx.out.nread <= 
+			    req->in.buffer + req->in.size) {
+				req->in.data_size += (SVAL(req->in.vwv, VWV(7)) << 16);
+			}
+		}
+
 		if (parms->readx.out.nread > MAX(parms->readx.in.mincnt, parms->readx.in.maxcnt) ||
 		    !smbcli_raw_pull_data(req, req->in.hdr + SVAL(req->in.vwv, VWV(6)), 
 				       parms->readx.out.nread, 
-- 
cgit 


From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:07:03 +0000
Subject: r23792: convert Samba4 to GPLv3

There are still a few tidyups of old FSF addresses to come (in both s3
and s4). More commits soon.
(This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa)
---
 source4/libcli/raw/rawreadwrite.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index e7a3209d07..a288b7ec54 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -6,7 +6,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -15,8 +15,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-- 
cgit 


From 2151cde58014ea2e822c13d2f8a369b45dc19ca8 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 6 Oct 2007 22:28:14 +0000
Subject: r25554: Convert last instances of BOOL, True and False to the
 standard types. (This used to be commit
 566aa14139510788548a874e9213d91317f83ca9)

---
 source4/libcli/raw/rawreadwrite.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index a288b7ec54..b0c49ddab7 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -31,13 +31,13 @@
 ****************************************************************************/
 struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_read *parms)
 {
-	BOOL bigoffset = False;
+	bool bigoffset = false;
 	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
 	case RAW_READ_READBRAW:
 		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
-			bigoffset = True;
+			bigoffset = true;
 		}
 		SETUP_REQUEST(SMBreadbraw, bigoffset? 10:8, 0);
 		SSVAL(req->out.vwv, VWV(0), parms->readbraw.in.file.fnum);
@@ -69,7 +69,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 
 	case RAW_READ_READX:
 		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
-			bigoffset = True;
+			bigoffset = true;
 		}
 		SETUP_REQUEST(SMBreadX, bigoffset ? 12 : 10, 0);
 		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
@@ -206,7 +206,7 @@ NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
 ****************************************************************************/
 struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms)
 {
-	BOOL bigoffset = False;
+	bool bigoffset = false;
 	struct smbcli_request *req = NULL; 
 
 	switch (parms->generic.level) {
@@ -253,7 +253,7 @@ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_wr
 
 	case RAW_WRITE_WRITEX:
 		if (tree->session->transport->negotiate.capabilities & CAP_LARGE_FILES) {
-			bigoffset = True;
+			bigoffset = true;
 		}
 		SETUP_REQUEST(SMBwriteX, bigoffset ? 14 : 12, parms->writex.in.count);
 		SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
-- 
cgit 


From e870cfec9f3512b0f1bd3110d7b975652525e28a Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Thu, 14 Feb 2008 10:12:33 +1100
Subject: Convert SMB and SMB2 code to use a common buffer handling structure

This converts our SMB and SMB2 code to use a common structure "struct
request_bufinfo" for information on the buffer bounds of a packet,
alignment information and string handling. This allows us to use a
common backend for SMB and SMB2 code, while still using all the same
string and blob handling functions.

Up to now we had been passing a NULL req handle into these common
routines from the SMB2 side of the server, which meant that we failed
any operation which did a bounds checked string extraction (such as a
RenameInformation setinfo call, which is what Vista uses for renaming
files)

There is still some more work to be done on this - for example we can
now remove many of the SMB2 specific buffer handling functions that we
had, and use the SMB ones.
(This used to be commit ca6d9be6cb6a403a81b18fa6e9a6a0518d7f0f68)
---
 source4/libcli/raw/rawreadwrite.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index b0c49ddab7..2005e36e04 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -137,7 +137,7 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 		SMBCLI_CHECK_WCT(req, 5);
 		parms->lockread.out.nread = SVAL(req->in.vwv, VWV(0));
 		if (parms->lockread.out.nread > parms->lockread.in.count ||
-		    !smbcli_raw_pull_data(req, req->in.data+3, 
+		    !smbcli_raw_pull_data(&req->in.bufinfo, req->in.data+3, 
 				       parms->lockread.out.nread, parms->lockread.out.data)) {
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
 		}
@@ -148,7 +148,7 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 		SMBCLI_CHECK_WCT(req, 5);
 		parms->read.out.nread = SVAL(req->in.vwv, VWV(0));
 		if (parms->read.out.nread > parms->read.in.count ||
-		    !smbcli_raw_pull_data(req, req->in.data+3, 
+		    !smbcli_raw_pull_data(&req->in.bufinfo, req->in.data+3, 
 				       parms->read.out.nread, parms->read.out.data)) {
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
 		}
@@ -175,7 +175,7 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 		}
 
 		if (parms->readx.out.nread > MAX(parms->readx.in.mincnt, parms->readx.in.maxcnt) ||
-		    !smbcli_raw_pull_data(req, req->in.hdr + SVAL(req->in.vwv, VWV(6)), 
+		    !smbcli_raw_pull_data(&req->in.bufinfo, req->in.hdr + SVAL(req->in.vwv, VWV(6)), 
 				       parms->readx.out.nread, 
 				       parms->readx.out.data)) {
 			req->status = NT_STATUS_BUFFER_TOO_SMALL;
-- 
cgit 


From afe8e5551e41550f40271f49ab4ded5e5f0def9c Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 16 Feb 2008 13:28:37 +1100
Subject: fixed RAW-READ after the bufinfo changes. Thanks to Metze for
 spotting this. (This used to be commit
 3c9973b695a0b5c30d3a5bfabecf62dd1a25ebc1)

---
 source4/libcli/raw/rawreadwrite.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 2005e36e04..9e4edaf99c 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -171,6 +171,9 @@ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 			    parms->readx.out.nread <= 
 			    req->in.buffer + req->in.size) {
 				req->in.data_size += (SVAL(req->in.vwv, VWV(7)) << 16);
+
+				/* update the bufinfo with the new size */
+				smb_setup_bufinfo(req);
 			}
 		}
 
-- 
cgit 


From afe3e8172ddaa5e4aa811faceecda4f943d6e2ef Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 2 Apr 2008 04:53:27 +0200
Subject: Install public header files again and include required prototypes.
 (This used to be commit 47ffbbf67435904754469544390b67d34c958343)

---
 source4/libcli/raw/rawreadwrite.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'source4/libcli/raw/rawreadwrite.c')

diff --git a/source4/libcli/raw/rawreadwrite.c b/source4/libcli/raw/rawreadwrite.c
index 9e4edaf99c..a8c7996310 100644
--- a/source4/libcli/raw/rawreadwrite.c
+++ b/source4/libcli/raw/rawreadwrite.c
@@ -20,6 +20,7 @@
 
 #include "includes.h"
 #include "libcli/raw/libcliraw.h"
+#include "libcli/raw/raw_proto.h"
 
 #define SETUP_REQUEST(cmd, wct, buflen) do { \
 	req = smbcli_request_setup(tree, cmd, wct, buflen); \
@@ -29,7 +30,7 @@
 /****************************************************************************
  low level read operation (async send)
 ****************************************************************************/
-struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_read *parms)
+_PUBLIC_ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_read *parms)
 {
 	bool bigoffset = false;
 	struct smbcli_request *req = NULL; 
@@ -115,7 +116,7 @@ struct smbcli_request *smb_raw_read_send(struct smbcli_tree *tree, union smb_rea
 /****************************************************************************
  low level read operation (async recv)
 ****************************************************************************/
-NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
+_PUBLIC_ NTSTATUS smb_raw_read_recv(struct smbcli_request *req, union smb_read *parms)
 {
 	if (!smbcli_request_receive(req) ||
 	    smbcli_request_is_error(req)) {
@@ -197,7 +198,7 @@ failed:
 /****************************************************************************
  low level read operation (sync interface)
 ****************************************************************************/
-NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
+_PUBLIC_ NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
 {
 	struct smbcli_request *req = smb_raw_read_send(tree, parms);
 	return smb_raw_read_recv(req, parms);
@@ -207,7 +208,7 @@ NTSTATUS smb_raw_read(struct smbcli_tree *tree, union smb_read *parms)
 /****************************************************************************
  raw write interface (async send)
 ****************************************************************************/
-struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms)
+_PUBLIC_ struct smbcli_request *smb_raw_write_send(struct smbcli_tree *tree, union smb_write *parms)
 {
 	bool bigoffset = false;
 	struct smbcli_request *req = NULL; 
@@ -341,7 +342,7 @@ failed:
 /****************************************************************************
  raw write interface (sync interface)
 ****************************************************************************/
-NTSTATUS smb_raw_write(struct smbcli_tree *tree, union smb_write *parms)
+_PUBLIC_ NTSTATUS smb_raw_write(struct smbcli_tree *tree, union smb_write *parms)
 {
 	struct smbcli_request *req = smb_raw_write_send(tree, parms);
 	return smb_raw_write_recv(req, parms);
-- 
cgit