From fdeea341ed1bae670382e45eb731db1b5838ad21 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 11 Mar 1998 21:11:04 +0000
Subject: "For I have laboured mightily on Luke's code, and hath broken all I
 saw" - the book of Jeremy, chapter 1 :-).

So here is the mega-merge of the NTDOM branch server code.
It doesn't include the new client side pieces, we'll look
at that later.

This should give the same functionality, server wise, as
the NTDOM branch does, only merged into the main branch.

Any fixes to domain controler functionality should be
added to the main branch, not the NTDOM branch.

This code compiles without warnings on gcc2.8, but will
need further testing before we are sure all the working
functionality of the NTDOM server branch has been
correctly carried over.

I hereby declare the server side of the NTDOM branch
dead (and all who sail in her :-).

Jeremy.
(This used to be commit 118ba4d77a33248e762a2cf843fb7cbc906ee6e7)
---
 source3/rpc_parse/parse_prs.c | 290 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 290 insertions(+)
 create mode 100644 source3/rpc_parse/parse_prs.c

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
new file mode 100644
index 0000000000..799bd1cc94
--- /dev/null
+++ b/source3/rpc_parse/parse_prs.c
@@ -0,0 +1,290 @@
+/* 
+   Unix SMB/Netbios implementation.
+   Version 1.9.
+   Samba memory buffer functions
+   Copyright (C) Andrew Tridgell              1992-1997
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1997
+   
+   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.
+*/
+
+extern int DEBUGLEVEL;
+
+#include "includes.h"
+
+
+/*******************************************************************
+ debug output for parsing info.
+
+ XXXX side-effect of this function is to increase the debug depth XXXX
+
+ ********************************************************************/
+void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
+{
+	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->offset, fn_name, desc));
+}
+
+/*******************************************************************
+ initialise a parse structure
+ ********************************************************************/
+void prs_init(prs_struct *ps, uint32 size,
+				uint8 align, uint32 margin,
+				BOOL io)
+{
+	ps->io = io;
+	ps->align = align;
+	ps->offset = 0;
+
+	ps->data = NULL;
+	mem_buf_init(&(ps->data), margin);
+
+	if (size != 0)
+	{
+		mem_alloc_data(ps->data, size);
+		ps->data->offset.start = 0;
+		ps->data->offset.end   = 0xffffffff;
+	}
+}
+
+/*******************************************************************
+ initialise a parse structure
+ ********************************************************************/
+void prs_mem_free(prs_struct *ps)
+{
+	mem_buf_free(&(ps->data));
+}
+
+/*******************************************************************
+ align a pointer to a multiple of align_offset bytes.  looks like it
+ will work for offsets of 0, 2 and 4...
+ ********************************************************************/
+void prs_align(prs_struct *ps)
+{
+	int mod = ps->offset & (ps->align-1);
+	if (ps->align != 0 && mod != 0)
+	{
+		ps->offset += ps->align - mod;
+	}
+}
+
+/*******************************************************************
+ attempt, if appropriate, to grow a data buffer.
+
+ depends on the data stream mode (io)
+ ********************************************************************/
+BOOL prs_grow(prs_struct *ps)
+{
+	return mem_grow_data(&(ps->data), ps->io, ps->offset);
+}
+
+
+/*******************************************************************
+ stream a uint8
+ ********************************************************************/
+BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_CVAL(name, depth, ps->offset, ps->io, q, *data8)
+	ps->offset += 1;
+
+	return True;
+}
+
+/*******************************************************************
+ stream a uint16
+ ********************************************************************/
+BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_SVAL(name, depth, ps->offset, ps->io, q, *data16)
+	ps->offset += 2;
+
+	return True;
+}
+
+/*******************************************************************
+ stream a uint32
+ ********************************************************************/
+BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_IVAL(name, depth, ps->offset, ps->io, q, *data32)
+	ps->offset += 4;
+
+	return True;
+}
+
+
+/******************************************************************
+ stream an array of uint8s.  length is number of uint8s
+ ********************************************************************/
+BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s, len)
+	ps->offset += len;
+
+	return True;
+}
+
+/******************************************************************
+ stream an array of uint16s.  length is number of uint16s
+ ********************************************************************/
+BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, data16s, len)
+	ps->offset += len * sizeof(uint16);
+
+	return True;
+}
+
+/******************************************************************
+ stream an array of uint32s.  length is number of uint32s
+ ********************************************************************/
+BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, q, data32s, len)
+	ps->offset += len * sizeof(uint32);
+
+	return True;
+}
+
+/******************************************************************
+ stream a "not" unicode string, length/buffer specified separately,
+ in byte chars
+ ********************************************************************/
+BOOL prs_uninotstr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNINOTSTR2 *str)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_max_len)
+	ps->offset += str->uni_buf_len;
+
+	return True;
+}
+
+/******************************************************************
+ stream a string, length/buffer specified separately,
+ in uint8 chars.
+ ********************************************************************/
+BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->str_max_len)
+	ps->offset += str->str_str_len * sizeof(uint8);
+
+	return True;
+}
+
+/******************************************************************
+ stream a unicode string, length/buffer specified separately,
+ in uint16 chars.
+ ********************************************************************/
+BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_max_len)
+	ps->offset += str->uni_str_len * sizeof(uint16);
+
+	return True;
+}
+
+/*******************************************************************
+ stream a unicode  null-terminated string
+ ********************************************************************/
+BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	int i = 0;
+	uint8 *start = (uint8*)q;
+
+	if (q == NULL) return False;
+
+	do 
+	{
+		RW_SVAL(ps->io, q, str->buffer[i],0);
+		q += 2;
+		i++;
+
+	} while ((i < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+		     (str->buffer[i] != 0));
+
+	ps->offset += i*2;
+
+	dump_data(5+depth, start, ps->offset);
+
+	return True;
+}
+
+/*******************************************************************
+ stream a null-terminated string.  len is strlen, and therefore does
+ not include the null-termination character.
+
+ len == 0 indicates variable length string
+ (up to max size of pstring - 1024 chars).
+
+ ********************************************************************/
+BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	uint8 *start = (uint8*)q;
+	int i = -1; /* start off at zero after 1st i++ */
+
+	if (q == NULL) return False;
+
+	do
+	{
+		i++;
+
+		if (i < len || len == 0)
+		{
+			RW_CVAL(ps->io, q, str[i],0);
+		}
+		else
+		{
+			uint8 dummy = 0;
+			RW_CVAL(ps->io, q, dummy,0);
+		}
+
+		q++;
+
+	} while (i < sizeof(pstring) && (len == 0 ? str[i] != 0 : i < len) );
+
+	ps->offset += i+1;
+
+	dump_data(5+depth, start, ps->offset);
+
+	return True;
+}
+
-- 
cgit 


From e300c0346ff92035ff9568b55b34469193e29769 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 10 Apr 1998 18:21:16 +0000
Subject: includes.h: Moved HPUX undefine of SEMMSL to where it actually does
 something. ipc.c: Added Luke's debug statement. locking_slow.c: Added
 FTRUNCATE_NEEDS_ROOT code for broken systems that need it (not sure what
 these are yet).

membuffer.c ntdomain.h proto.h
lib/rpc/include/rpc_dce.h lib/rpc/include/rpc_srvsvc.h
lib/rpc/parse/parse_prs.c lib/rpc/parse/parse_rpc.c
lib/rpc/server/srv_pipe_hnd.c lib/rpc/server/srv_util.c:
   Re-merge of Luke's NTDOM changes 'cos he's a lazy git with
   carpel tunnel syndrome :-).

Jeremy.
(This used to be commit 52e3966fbcf7b5fbdbc7cbe9ac0b453ab5bf3217)
---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 799bd1cc94..0baf05597c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -86,7 +86,7 @@ void prs_align(prs_struct *ps)
  ********************************************************************/
 BOOL prs_grow(prs_struct *ps)
 {
-	return mem_grow_data(&(ps->data), ps->io, ps->offset);
+	return mem_grow_data(&(ps->data), ps->io, ps->offset, False);
 }
 
 
-- 
cgit 


From 3dfc0c847240ac7e12c39f4ed9c31a888949ade1 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 11 May 1998 06:38:36 +0000
Subject: changed to use slprintf() instead of sprintf() just about everywhere.
 I've implemented slprintf() as a bounds checked sprintf() using mprotect()
 and a non-writeable page.

This should prevent any sprintf based security holes.
(This used to be commit ee09e9dadb69aaba5a751dd20ccc6d587d841bd6)
---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 0baf05597c..ad05831229 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -242,7 +242,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 
 	ps->offset += i*2;
 
-	dump_data(5+depth, start, ps->offset);
+	dump_data(5+depth, (char *)start, ps->offset);
 
 	return True;
 }
@@ -283,7 +283,7 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len)
 
 	ps->offset += i+1;
 
-	dump_data(5+depth, start, ps->offset);
+	dump_data(5+depth, (char *)start, ps->offset);
 
 	return True;
 }
-- 
cgit 


From e9ea36e4d2270bd7d32da12ef6d6e2299641582d Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Sat, 5 Sep 1998 05:07:05 +0000
Subject: tridge the destroyer returns!

prompted by the interpret_security() dead code that Jean-Francois
pointed out I added a make target "finddead" that finds potentially
dead (ie. unused) code. It spat out 304 function names ...

I went through these are deleted many of them, making others static
(finddead also reports functions that are used only in the local
file).

in doing this I have almost certainly deleted some useful code. I may
have even prevented compilation with some compile options. I
apologise. I decided it was better to get rid of this code now and add
back the one or two functions that are needed than to keep all this
baggage.

So, if I have done a bit too much "destroying" then let me know. Keep
the swearing to a minimum :)

One bit I didn't do is the ubibt code. Chris, can you look at that?
Heaps of unused functions there. Can they be made static?
(This used to be commit 2204475c87f3024ea8fd1fbd7385b2def617a46f)
---
 source3/rpc_parse/parse_prs.c | 14 --------------
 1 file changed, 14 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index ad05831229..024ac88b18 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -147,20 +147,6 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
 	return True;
 }
 
-/******************************************************************
- stream an array of uint16s.  length is number of uint16s
- ********************************************************************/
-BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
-{
-	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
-
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, data16s, len)
-	ps->offset += len * sizeof(uint16);
-
-	return True;
-}
-
 /******************************************************************
  stream an array of uint32s.  length is number of uint32s
  ********************************************************************/
-- 
cgit 


From c07b2bdf9032c870f7f50a9671e8d9fb0a56739a Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Tue, 6 Oct 1998 22:03:04 +0000
Subject: dce/rpc (This used to be commit
 eb279cabd059603b6c8d9b74e4fd31c4ffe87593)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 024ac88b18..f166bbd704 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -241,7 +241,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
  (up to max size of pstring - 1024 chars).
 
  ********************************************************************/
-BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len)
+BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	uint8 *start = (uint8*)q;
@@ -265,7 +265,7 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len)
 
 		q++;
 
-	} while (i < sizeof(pstring) && (len == 0 ? str[i] != 0 : i < len) );
+	} while (i < max_buf_size && (len == 0 ? str[i] != 0 : i < len) );
 
 	ps->offset += i+1;
 
-- 
cgit 


From 2fef8f2e87f61043e3f1a2cf7d1f2a4ff9f119ff Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Wed, 7 Oct 1998 15:22:49 +0000
Subject: dce/rpc (This used to be commit
 34afa638f6f7bb145ec094510ac58f7a22dfc3aa)

---
 source3/rpc_parse/parse_prs.c | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f166bbd704..34f72596ce 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -66,6 +66,14 @@ void prs_mem_free(prs_struct *ps)
 	mem_buf_free(&(ps->data));
 }
 
+/*******************************************************************
+ link one parsing structure to another
+ ********************************************************************/
+void prs_link(prs_struct *ps, prs_struct const *const to)
+{
+	DEBUG(0,("NOT IMPLEMENTED\n"));
+}
+
 /*******************************************************************
  align a pointer to a multiple of align_offset bytes.  looks like it
  will work for offsets of 0, 2 and 4...
-- 
cgit 


From 48b31ae44fb2a1961bd738b0b3e7a986259168a2 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Wed, 7 Oct 1998 21:42:24 +0000
Subject: dce/rpc (This used to be commit
 6677b888bdb45df00646eb7cc13005b9465ff971)

---
 source3/rpc_parse/parse_prs.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 34f72596ce..d031a828f1 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -69,9 +69,11 @@ void prs_mem_free(prs_struct *ps)
 /*******************************************************************
  link one parsing structure to another
  ********************************************************************/
-void prs_link(prs_struct *ps, prs_struct const *const to)
+void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
 {
-	DEBUG(0,("NOT IMPLEMENTED\n"));
+	ps->data->offset.start = prev != NULL ? prev->data->offset.end : 0;
+	ps->data->offset.end   = ps->data->offset.start + ps->offset;
+	ps->data->next         = next != NULL ? next->data : NULL;
 }
 
 /*******************************************************************
@@ -236,7 +238,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 
 	ps->offset += i*2;
 
-	dump_data(5+depth, (char *)start, ps->offset);
+	dump_data(5+depth, (char *)start, i * 2);
 
 	return True;
 }
@@ -277,7 +279,7 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, ui
 
 	ps->offset += i+1;
 
-	dump_data(5+depth, (char *)start, ps->offset);
+	dump_data(5+depth, (char *)start, i);
 
 	return True;
 }
-- 
cgit 


From 1e1c2ec93c204e6fd3ebba6dfb11e4fbc136e10c Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Tue, 10 Nov 1998 19:05:00 +0000
Subject: rpcclient registry commands. (This used to be commit
 36fcb4a6e643a05d06a2a273d74318fee7f2c647)

---
 source3/rpc_parse/parse_prs.c | 58 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 54 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d031a828f1..873a689792 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -175,13 +175,13 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
  stream a "not" unicode string, length/buffer specified separately,
  in byte chars
  ********************************************************************/
-BOOL prs_uninotstr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNINOTSTR2 *str)
+BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL) return False;
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_max_len)
-	ps->offset += str->uni_buf_len;
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len/2)
+	ps->offset += str->buf_len;
 
 	return True;
 }
@@ -210,7 +210,22 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 	char *q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL) return False;
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_max_len)
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_str_len)
+	ps->offset += str->uni_str_len * sizeof(uint16);
+
+	return True;
+}
+
+/******************************************************************
+ stream a unicode string, length/buffer specified separately,
+ in uint16 chars.
+ ********************************************************************/
+BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->str.buffer, str->uni_str_len)
 	ps->offset += str->uni_str_len * sizeof(uint16);
 
 	return True;
@@ -284,3 +299,38 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, ui
 	return True;
 }
 
+/*******************************************************************
+ prs_uint16 wrapper.  call this and it sets up a pointer to where the
+ uint16 should be stored, or gets the size if reading
+ ********************************************************************/
+BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *off_ptr)
+{
+	(*off_ptr) = ps->offset;
+	if (ps->io)
+	{
+		/* reading. */
+		return prs_uint16(name, ps, depth, data16);
+	}
+	return True;
+}
+
+/*******************************************************************
+ prs_uint16 wrapper.  call this and it retrospectively stores the size.
+ does nothing on reading, as that is already handled by ...._pre()
+ ********************************************************************/
+BOOL prs_uint16_post(char *name, prs_struct *ps, int depth,
+				uint32 ptr_uint16, uint32 start_offset)
+{
+	if (!ps->io)
+	{
+		/* storing: go back and do a retrospective job.  i hate this */
+		uint16 data_size = ps->offset - start_offset;
+		uint32 old_offset = ps->offset;
+
+		ps->offset = ptr_uint16;
+		prs_uint16(name, ps, depth, &data_size);
+		ps->offset = old_offset;
+	}
+	return True;
+}
+
-- 
cgit 


From 60a91a1dca12e675e4498062f33ed773ddd5600a Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Wed, 11 Nov 1998 19:22:08 +0000
Subject: clearing up security descriptor (This used to be commit
 abdc9d790b7d27b70aaf88451f5c82c99c94ca6e)

---
 source3/rpc_parse/parse_prs.c | 57 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 54 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 873a689792..cc068778ac 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -303,14 +303,18 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, ui
  prs_uint16 wrapper.  call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading
  ********************************************************************/
-BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *off_ptr)
+BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
-	(*off_ptr) = ps->offset;
+	(*offset) = ps->io;
 	if (ps->io)
 	{
 		/* reading. */
 		return prs_uint16(name, ps, depth, data16);
 	}
+	else
+	{
+		ps->offset += sizeof(uint16);
+	}
 	return True;
 }
 
@@ -318,7 +322,7 @@ BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint3
  prs_uint16 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL prs_uint16_post(char *name, prs_struct *ps, int depth,
+BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 				uint32 ptr_uint16, uint32 start_offset)
 {
 	if (!ps->io)
@@ -331,6 +335,53 @@ BOOL prs_uint16_post(char *name, prs_struct *ps, int depth,
 		prs_uint16(name, ps, depth, &data_size);
 		ps->offset = old_offset;
 	}
+	else
+	{
+		ps->offset = start_offset + (*data16);
+	}
+	return True;
+}
+
+/*******************************************************************
+ prs_uint32 wrapper.  call this and it sets up a pointer to where the
+ uint32 should be stored, or gets the size if reading
+ ********************************************************************/
+BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+{
+	(*offset) = ps->io;
+	if (ps->io)
+	{
+		/* reading. */
+		return prs_uint32(name, ps, depth, data32);
+	}
+	else
+	{
+		ps->offset += sizeof(uint32);
+	}
+	return True;
+}
+
+/*******************************************************************
+ prs_uint32 wrapper.  call this and it retrospectively stores the size.
+ does nothing on reading, as that is already handled by ...._pre()
+ ********************************************************************/
+BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
+				uint32 ptr_uint32, uint32 start_offset)
+{
+	if (!ps->io)
+	{
+		/* storing: go back and do a retrospective job.  i hate this */
+		uint32 data_size = ps->offset - start_offset;
+		uint32 old_offset = ps->offset;
+
+		ps->offset = ptr_uint32;
+		prs_uint32(name, ps, depth, &data_size);
+		ps->offset = old_offset;
+	}
+	else
+	{
+		ps->offset = start_offset + (*data32);
+	}
 	return True;
 }
 
-- 
cgit 


From 1ab463a79575316612097445ea40b9dd7bcb84bd Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Thu, 12 Nov 1998 16:03:35 +0000
Subject: security descriptors and registry. (This used to be commit
 9814ac8a65f4d8333527976f1d227e8cd3c2c8ce)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index cc068778ac..8df7d06a39 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -305,7 +305,7 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, ui
  ********************************************************************/
 BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
-	(*offset) = ps->io;
+	(*offset) = ps->offset;
 	if (ps->io)
 	{
 		/* reading. */
@@ -348,7 +348,7 @@ BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
  ********************************************************************/
 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
-	(*offset) = ps->io;
+	(*offset) = ps->offset;
 	if (ps->io)
 	{
 		/* reading. */
-- 
cgit 


From 597c5a6caa871b724ee1337f14467950b0707b34 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Thu, 12 Nov 1998 19:21:20 +0000
Subject: jean-f. sent me some S-1-3-0,1,2,3 SIDs and names.  S-1-3 doesn't
 exist.

security descriptor testing.  hey wow, you can get a SD then send it back!
(This used to be commit 7466c3113ef8f8a89b8496efadfeb611c9f3e069)
---
 source3/rpc_parse/parse_prs.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 8df7d06a39..75432627ab 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -366,22 +366,16 @@ BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint3
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
-				uint32 ptr_uint32, uint32 start_offset)
+				uint32 ptr_uint32, uint32 data_size)
 {
 	if (!ps->io)
 	{
 		/* storing: go back and do a retrospective job.  i hate this */
-		uint32 data_size = ps->offset - start_offset;
 		uint32 old_offset = ps->offset;
-
 		ps->offset = ptr_uint32;
 		prs_uint32(name, ps, depth, &data_size);
 		ps->offset = old_offset;
 	}
-	else
-	{
-		ps->offset = start_offset + (*data32);
-	}
 	return True;
 }
 
-- 
cgit 


From 74576a48fdf71e4264a892fda58302053f809670 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Wed, 9 Dec 1998 16:28:04 +0000
Subject: adding some enumerate services code, client and server. (This used to
 be commit dacf5b152bf74cc3ee9a816911384a5eb0e77afa)

---
 source3/rpc_parse/parse_prs.c | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 75432627ab..ef327f01a1 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -237,21 +237,22 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	int i = 0;
+	int i = -1;
 	uint8 *start = (uint8*)q;
 
 	if (q == NULL) return False;
 
-	do 
+	do
 	{
+		i++;
 		RW_SVAL(ps->io, q, str->buffer[i],0);
 		q += 2;
-		i++;
-
-	} while ((i < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+	}
+	while ((i < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
 		     (str->buffer[i] != 0));
 
-	ps->offset += i*2;
+
+	ps->offset += (i+1)*2;
 
 	dump_data(5+depth, (char *)start, i * 2);
 
-- 
cgit 


From 373ea639e03e72bef8242133abbf678cf90ed0d9 Mon Sep 17 00:00:00 2001
From: Matthew Chapman <matty@samba.org>
Date: Thu, 8 Apr 1999 05:36:15 +0000
Subject: Mainly BDC-related changes.

* Added SEC_CHAN_BDC
* Propagate sec_chan into the various functions which change trust account
  passwords, so they can be used for domain control and inter-domain
  trusts.
* Fix for endianness problem reported by Edan Idzerda <edan@mtu.edu>. A
  BUFFER2 is really a "unibuf" in my terminology and we should treat it as
  such.
* Added some more common NT structures (BIGINT, BUFHDR2, BUFFER4).
* Added NET_SAM_SYNC (-> NetDatabaseSync2) RPC for account replication.
  Still experimental and incomplete, with a few too many NULL security
  descriptors lying around (must go look at Jeremy's SD code). Haven't
  worked out password encryption yet either.
  However, the XXX_INFO structures I've added to rpc_netlogon.h are quite
  nice as they give some insight into how these objects are stored in the
  SAM.
(This used to be commit 7b830350eb54dc9d357c115e12ddf9a0633527ac)
---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index ef327f01a1..23a9d5bfdf 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -180,7 +180,7 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
 	char *q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL) return False;
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len/2)
+	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len)
 	ps->offset += str->buf_len;
 
 	return True;
-- 
cgit 


From be552ca3504ebd98da37e70bac1f10b248cf860b Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Tue, 27 Apr 1999 10:43:32 +0000
Subject: rpc_parse/parse_misc.c : defined a new BUFFER5 struct
 include/ntdomain.h     : added rpc_spoolss.h include statement
 include/proto.h include/rpc_dce.h      : added definition of
 RPC_ALTER_CONTEXT request &                          reply param/loadparm.c  
     : 2 new options for NT printing support and some                         
 changes to initial values in the LPRNG case. rpc_parse/parse_prs.c  : added
 prs_uint16s() rpc_parse/parse_rpc.c  : added SYNT_SPOOLSS_V1 and code for the
                          alter-context support. rpc_server/srv_pipe.c  :
 alter-context support smbd/nttrans.c smbd/server.c include/rpc_misc.h
 Makefile.in include/smb.h

Jean Francois
(This used to be commit 4c515804b70254248e378a3f90f47e4c32639d29)
---
 source3/rpc_parse/parse_prs.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 23a9d5bfdf..a231fb57cf 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -157,6 +157,20 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
 	return True;
 }
 
+/******************************************************************
+ stream an array of uint16s.  length is number of uint16s
+ ********************************************************************/
+BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+{
+	char *q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL) return False;
+
+	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, data16s, len)
+	ps->offset += len * sizeof(uint16);
+
+	return True;
+}
+
 /******************************************************************
  stream an array of uint32s.  length is number of uint32s
  ********************************************************************/
-- 
cgit 


From 6a5a4e818684a616306d2954d1a2612113b314a6 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Wed, 21 Jul 1999 00:32:09 +0000
Subject: BDC support. (This used to be commit
 2331aa32ab36c3ee5fd8cfbe972e57299939e33d)

---
 source3/rpc_parse/parse_prs.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index a231fb57cf..c55ec9c225 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -128,6 +128,27 @@ BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 	return True;
 }
 
+/*******************************************************************
+ hash a stream.
+ ********************************************************************/
+BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
+{
+	char *q = mem_data(&(ps->data), offset);
+	if (q == NULL) return False;
+
+#ifdef DEBUG_PASSWORD
+	DEBUG(100,("prs_hash1\n"));
+	dump_data(100, sess_key, 16);
+	dump_data(100, q, 68);
+#endif
+	SamOEMhash(q, sess_key, 2);
+#ifdef DEBUG_PASSWORD
+	dump_data(100, q, 68);
+#endif
+
+	return True;
+}
+
 /*******************************************************************
  stream a uint32
  ********************************************************************/
-- 
cgit 


From dcea4bfd0fce7bced156f859c792ac51a7c0ad0b Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Thu, 14 Oct 1999 19:21:23 +0000
Subject: stop over-runs in reading / writing data stream. (This used to be
 commit 144fd01f37bde420234ca474014b0f378d9f8975)

---
 source3/rpc_parse/parse_prs.c | 69 +++++++++++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 25 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c55ec9c225..4e007ce07c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -170,10 +170,13 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + len * sizeof(uint8);
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s, len)
-	ps->offset += len;
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -184,10 +187,13 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
 BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + len * sizeof(uint16);
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, data16s, len)
-	ps->offset += len * sizeof(uint16);
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -198,10 +204,13 @@ BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *d
 BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + len * sizeof(uint32);
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, q, data32s, len)
-	ps->offset += len * sizeof(uint32);
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -213,10 +222,13 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
 BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + str->buf_len;
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len)
-	ps->offset += str->buf_len;
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -228,10 +240,13 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + str->str_str_len * sizeof(uint8);
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->str_max_len)
-	ps->offset += str->str_str_len * sizeof(uint8);
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -243,10 +258,13 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_str_len)
-	ps->offset += str->uni_str_len * sizeof(uint16);
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -258,10 +276,13 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	int end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
+	char *e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) return False;
 
 	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->str.buffer, str->uni_str_len)
-	ps->offset += str->uni_str_len * sizeof(uint16);
+	ps->offset = end_offset;
 
 	return True;
 }
@@ -271,17 +292,16 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
  ********************************************************************/
 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
 	int i = -1;
-	uint8 *start = (uint8*)q;
-
-	if (q == NULL) return False;
+	uint8 *start = (uint8*)mem_data(&(ps->data), ps->offset);
 
 	do
 	{
+		char *q;
 		i++;
+		q = mem_data(&(ps->data), ps->offset + i*2);
+		if (q == NULL) return False;
 		RW_SVAL(ps->io, q, str->buffer[i],0);
-		q += 2;
 	}
 	while ((i < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
 		     (str->buffer[i] != 0));
@@ -304,16 +324,17 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
  ********************************************************************/
 BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	uint8 *start = (uint8*)q;
+	uint8 *start = (uint8*)mem_data(&(ps->data), ps->offset);
 	int i = -1; /* start off at zero after 1st i++ */
 
-	if (q == NULL) return False;
-
 	do
 	{
+		char *q;
 		i++;
 
+		q = mem_data(&(ps->data), ps->offset + i);
+		if (q == NULL) return False;
+
 		if (i < len || len == 0)
 		{
 			RW_CVAL(ps->io, q, str[i],0);
@@ -324,8 +345,6 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, ui
 			RW_CVAL(ps->io, q, dummy,0);
 		}
 
-		q++;
-
 	} while (i < max_buf_size && (len == 0 ? str[i] != 0 : i < len) );
 
 	ps->offset += i+1;
-- 
cgit 


From 896ecb48cab1d928224387f06ec63584bc6c6e99 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Fri, 15 Oct 1999 18:46:22 +0000
Subject: return results on prs_xxxxx() and all xxx_io_xxx() routines. the
 whole task is not complete, yet.  xxx_io_xxx() routines that _call_
 xxx_io_xxx() routines not done.

prs_xxxx() covered by macros.  considering doing xxx_io_xxxx in the same way.
(This used to be commit 3b583f7be51434af98bc52b48dfa42c4602a3094)
---
 source3/rpc_parse/parse_prs.c | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4e007ce07c..f30a05e346 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -2,8 +2,8 @@
    Unix SMB/Netbios implementation.
    Version 1.9.
    Samba memory buffer functions
-   Copyright (C) Andrew Tridgell              1992-1997
-   Copyright (C) Luke Kenneth Casson Leighton 1996-1997
+   Copyright (C) Andrew Tridgell              1992-1999
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1999
    
    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
@@ -103,7 +103,7 @@ BOOL prs_grow(prs_struct *ps)
 /*******************************************************************
  stream a uint8
  ********************************************************************/
-BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
+BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL) return False;
@@ -117,7 +117,7 @@ BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 /*******************************************************************
  stream a uint16
  ********************************************************************/
-BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
+BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL) return False;
@@ -131,7 +131,7 @@ BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 /*******************************************************************
  hash a stream.
  ********************************************************************/
-BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
+BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 {
 	char *q = mem_data(&(ps->data), offset);
 	if (q == NULL) return False;
@@ -152,7 +152,7 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 /*******************************************************************
  stream a uint32
  ********************************************************************/
-BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
+BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL) return False;
@@ -167,7 +167,7 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 /******************************************************************
  stream an array of uint8s.  length is number of uint8s
  ********************************************************************/
-BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + len * sizeof(uint8);
@@ -184,7 +184,7 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
 /******************************************************************
  stream an array of uint16s.  length is number of uint16s
  ********************************************************************/
-BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + len * sizeof(uint16);
@@ -201,7 +201,7 @@ BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *d
 /******************************************************************
  stream an array of uint32s.  length is number of uint32s
  ********************************************************************/
-BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
+BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + len * sizeof(uint32);
@@ -219,7 +219,7 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
  stream a "not" unicode string, length/buffer specified separately,
  in byte chars
  ********************************************************************/
-BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
+BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + str->buf_len;
@@ -237,7 +237,7 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
  stream a string, length/buffer specified separately,
  in uint8 chars.
  ********************************************************************/
-BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
+BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + str->str_str_len * sizeof(uint8);
@@ -255,7 +255,7 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
  stream a unicode string, length/buffer specified separately,
  in uint16 chars.
  ********************************************************************/
-BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
+BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
@@ -273,7 +273,7 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
  stream a unicode string, length/buffer specified separately,
  in uint16 chars.
  ********************************************************************/
-BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
+BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
@@ -290,7 +290,7 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
 /*******************************************************************
  stream a unicode  null-terminated string
  ********************************************************************/
-BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
+BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	int i = -1;
 	uint8 *start = (uint8*)mem_data(&(ps->data), ps->offset);
@@ -322,7 +322,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
  (up to max size of pstring - 1024 chars).
 
  ********************************************************************/
-BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
+BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
 {
 	uint8 *start = (uint8*)mem_data(&(ps->data), ps->offset);
 	int i = -1; /* start off at zero after 1st i++ */
@@ -358,13 +358,13 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, ui
  prs_uint16 wrapper.  call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading
  ********************************************************************/
-BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
+BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
 	(*offset) = ps->offset;
 	if (ps->io)
 	{
 		/* reading. */
-		return prs_uint16(name, ps, depth, data16);
+		return _prs_uint16(name, ps, depth, data16);
 	}
 	else
 	{
@@ -377,7 +377,7 @@ BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint3
  prs_uint16 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
+BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 				uint32 ptr_uint16, uint32 start_offset)
 {
 	if (!ps->io)
@@ -401,13 +401,13 @@ BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
  prs_uint32 wrapper.  call this and it sets up a pointer to where the
  uint32 should be stored, or gets the size if reading
  ********************************************************************/
-BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
 	(*offset) = ps->offset;
 	if (ps->io)
 	{
 		/* reading. */
-		return prs_uint32(name, ps, depth, data32);
+		return _prs_uint32(name, ps, depth, data32);
 	}
 	else
 	{
@@ -420,7 +420,7 @@ BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint3
  prs_uint32 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
+BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 				uint32 ptr_uint32, uint32 data_size)
 {
 	if (!ps->io)
-- 
cgit 


From 003f7364fd54ccdd190d447e275b70b0f76e95f7 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Fri, 15 Oct 1999 20:00:30 +0000
Subject: adding error checking in parsing code (This used to be commit
 4c98d71ebd3f1cdaef664d46c998c864af34632a)

---
 source3/rpc_parse/parse_prs.c | 191 ++++++++++++++++++++++++++++++++----------
 1 file changed, 147 insertions(+), 44 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f30a05e346..80e7eecf13 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -46,6 +46,7 @@ void prs_init(prs_struct *ps, uint32 size,
 	ps->io = io;
 	ps->align = align;
 	ps->offset = 0;
+	ps->error = False;
 
 	ps->data = NULL;
 	mem_buf_init(&(ps->data), margin);
@@ -82,7 +83,9 @@ void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
  ********************************************************************/
 void prs_align(prs_struct *ps)
 {
-	int mod = ps->offset & (ps->align-1);
+	int mod;
+	if (ps->error) return;
+	mod = ps->offset & (ps->align-1);
 	if (ps->align != 0 && mod != 0)
 	{
 		ps->offset += ps->align - mod;
@@ -96,6 +99,7 @@ void prs_align(prs_struct *ps)
  ********************************************************************/
 BOOL prs_grow(prs_struct *ps)
 {
+	if (ps->error) return False;
 	return mem_grow_data(&(ps->data), ps->io, ps->offset, False);
 }
 
@@ -105,8 +109,14 @@ BOOL prs_grow(prs_struct *ps)
  ********************************************************************/
 BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	char *q;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_CVAL(name, depth, ps->offset, ps->io, q, *data8)
 	ps->offset += 1;
@@ -119,8 +129,14 @@ BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
  ********************************************************************/
 BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	char *q;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_SVAL(name, depth, ps->offset, ps->io, q, *data16)
 	ps->offset += 2;
@@ -133,8 +149,14 @@ BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
  ********************************************************************/
 BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 {
-	char *q = mem_data(&(ps->data), offset);
-	if (q == NULL) return False;
+	char *q;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 #ifdef DEBUG_PASSWORD
 	DEBUG(100,("prs_hash1\n"));
@@ -154,8 +176,14 @@ BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
  ********************************************************************/
 BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL) return False;
+	char *q;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	if (q == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_IVAL(name, depth, ps->offset, ps->io, q, *data32)
 	ps->offset += 4;
@@ -169,11 +197,19 @@ BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
  ********************************************************************/
 BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + len * sizeof(uint8);
-	char *e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) return False;
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL) 
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s, len)
 	ps->offset = end_offset;
@@ -186,11 +222,22 @@ BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *da
  ********************************************************************/
 BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
 	char *q = mem_data(&(ps->data), ps->offset);
 	int end_offset = ps->offset + len * sizeof(uint16);
 	char *e = mem_data(&(ps->data), end_offset-1);
 
-	if (q == NULL || e == NULL) return False;
+	if (q == NULL || e == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, data16s, len)
 	ps->offset = end_offset;
@@ -203,11 +250,19 @@ BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *
  ********************************************************************/
 BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + len * sizeof(uint32);
-	char *e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) return False;
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, q, data32s, len)
 	ps->offset = end_offset;
@@ -221,11 +276,19 @@ BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *
  ********************************************************************/
 BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + str->buf_len;
-	char *e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) return False;
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len)
 	ps->offset = end_offset;
@@ -239,11 +302,19 @@ BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2
  ********************************************************************/
 BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + str->str_str_len * sizeof(uint8);
-	char *e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) return False;
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->str_max_len)
 	ps->offset = end_offset;
@@ -257,11 +328,19 @@ BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2
  ********************************************************************/
 BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
-	char *e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) return False;
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_str_len)
 	ps->offset = end_offset;
@@ -275,11 +354,19 @@ BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2
  ********************************************************************/
 BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
-	char *e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) return False;
+	char *q;
+	int end_offset;
+	char *e;
+	if (ps->error) return False;
+	q = mem_data(&(ps->data), ps->offset);
+	end_offset = ps->offset + len * sizeof(uint8);
+	e = mem_data(&(ps->data), end_offset-1);
+
+	if (q == NULL || e == NULL)
+	{
+		ps->error = True;
+		return False;
+	}
 
 	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->str.buffer, str->uni_str_len)
 	ps->offset = end_offset;
@@ -293,14 +380,20 @@ BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int d
 BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	int i = -1;
-	uint8 *start = (uint8*)mem_data(&(ps->data), ps->offset);
+	uint8 *start;
+	if (ps->error) return False;
+	start = (uint8*)mem_data(&(ps->data), ps->offset);
 
 	do
 	{
 		char *q;
 		i++;
 		q = mem_data(&(ps->data), ps->offset + i*2);
-		if (q == NULL) return False;
+		if (q == NULL) 
+		{
+			ps->error = True;
+			return False;
+		}
 		RW_SVAL(ps->io, q, str->buffer[i],0);
 	}
 	while ((i < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
@@ -324,8 +417,10 @@ BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
  ********************************************************************/
 BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
 {
-	uint8 *start = (uint8*)mem_data(&(ps->data), ps->offset);
 	int i = -1; /* start off at zero after 1st i++ */
+	uint8 *start;
+	if (ps->error) return False;
+	start = (uint8*)mem_data(&(ps->data), ps->offset);
 
 	do
 	{
@@ -333,7 +428,11 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
 		i++;
 
 		q = mem_data(&(ps->data), ps->offset + i);
-		if (q == NULL) return False;
+		if (q == NULL)
+		{
+			ps->error = True;
+			return False;
+		}
 
 		if (i < len || len == 0)
 		{
@@ -360,6 +459,7 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
  ********************************************************************/
 BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
+	if (ps->error) return False;
 	(*offset) = ps->offset;
 	if (ps->io)
 	{
@@ -380,6 +480,7 @@ BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint
 BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 				uint32 ptr_uint16, uint32 start_offset)
 {
+	if (ps->error) return False;
 	if (!ps->io)
 	{
 		/* storing: go back and do a retrospective job.  i hate this */
@@ -403,6 +504,7 @@ BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
  ********************************************************************/
 BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
+	if (ps->error) return False;
 	(*offset) = ps->offset;
 	if (ps->io)
 	{
@@ -423,6 +525,7 @@ BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint
 BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 				uint32 ptr_uint32, uint32 data_size)
 {
+	if (ps->error) return False;
 	if (!ps->io)
 	{
 		/* storing: go back and do a retrospective job.  i hate this */
-- 
cgit 


From 63fa96e2168a98ead5e595134346650eece1c94e Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Fri, 15 Oct 1999 20:10:46 +0000
Subject: added prs_struct "error" member, set and checked when prs_struct data
 is handled. (This used to be commit b4ba49c5c114764247802bd8b0a6dbc0a7f5c2a1)

---
 source3/rpc_parse/parse_prs.c | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 80e7eecf13..c50b1d1567 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -227,11 +227,8 @@ BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *
 	char *e;
 	if (ps->error) return False;
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + len * sizeof(uint8);
+	end_offset = ps->offset + len * sizeof(uint16);
 	e = mem_data(&(ps->data), end_offset-1);
-	char *q = mem_data(&(ps->data), ps->offset);
-	int end_offset = ps->offset + len * sizeof(uint16);
-	char *e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
@@ -255,7 +252,7 @@ BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *
 	char *e;
 	if (ps->error) return False;
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + len * sizeof(uint8);
+	end_offset = ps->offset + len * sizeof(uint32);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
@@ -281,7 +278,7 @@ BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2
 	char *e;
 	if (ps->error) return False;
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + len * sizeof(uint8);
+	end_offset = ps->offset + str->buf_len;
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
@@ -307,7 +304,7 @@ BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2
 	char *e;
 	if (ps->error) return False;
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + len * sizeof(uint8);
+	end_offset = ps->offset + str->str_str_len * sizeof(uint8);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
@@ -333,7 +330,7 @@ BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2
 	char *e;
 	if (ps->error) return False;
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + len * sizeof(uint8);
+	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
@@ -359,7 +356,7 @@ BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int d
 	char *e;
 	if (ps->error) return False;
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + len * sizeof(uint8);
+	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
-- 
cgit 


From 56128244261f8e4c6e1144da66c736fbc2104665 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Mon, 25 Oct 1999 19:03:27 +0000
Subject: - typecast malloc / Realloc issues.

- signed / unsigned issues.
(This used to be commit c8fd555179314baf1672a23db34dc8ad9f2d02bf)
---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c50b1d1567..bf4efbe527 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -163,7 +163,7 @@ BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 	dump_data(100, sess_key, 16);
 	dump_data(100, q, 68);
 #endif
-	SamOEMhash(q, sess_key, 2);
+	SamOEMhash((uchar*)q, sess_key, 2);
 #ifdef DEBUG_PASSWORD
 	dump_data(100, q, 68);
 #endif
@@ -393,7 +393,7 @@ BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 		}
 		RW_SVAL(ps->io, q, str->buffer[i],0);
 	}
-	while ((i < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+	while ((((size_t)i) < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
 		     (str->buffer[i] != 0));
 
 
-- 
cgit 


From a0ba234cf9b40adf6b5390e4e67730163a42883f Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Mon, 6 Dec 1999 00:44:32 +0000
Subject: the first independent msrpc daemon - lsarpcd.

one horrible cut / paste job from smbd, plus a code split of shared
components between the two.

the job is not _yet_ complete, as i need to be able to do a become_user()
call for security reasons.  i picked lsarpcd first because you don't
_need_ security on it (microsoft botched so badly on this one, it's not
real.  at least they fixed this in nt5 with restrictanonymous=0x2).
fixing this involves sending the current smb and unix credentials down
the unix pipe so that the daemon it eventually goes to can pick them
up at the other end.

i can't believe this all worked!!!
(This used to be commit 2245b0c6d13c7c5886e81f9137b05df883598c26)
---
 source3/rpc_parse/parse_prs.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index bf4efbe527..f53b2da955 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -36,6 +36,16 @@ void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->offset, fn_name, desc));
 }
 
+/*******************************************************************
+ debug a parse structure
+ ********************************************************************/
+void prs_debug_out(prs_struct *ps, int level)
+{
+	DEBUG(level,("ps: io %s align %d offset %d err %d data %p len %d\n",
+		BOOLSTR(ps->io), ps->align, ps->offset, ps->error, ps->data,
+		ps->data != NULL ? mem_buf_len(ps->data) : 0));
+}
+
 /*******************************************************************
  initialise a parse structure
  ********************************************************************/
-- 
cgit 


From 4ab9d91428b66bd2fe407b0dba94f4130160b576 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Wed, 8 Dec 1999 21:43:03 +0000
Subject: ABOUT TIME!!!!!!!!

damn, this one is bad.

started, at least two days ago, to add an authentication mechanism to
the smbd<->msrpc redirector/relay, such that sufficient unix / nt
information could be transferred across the unix socket to do a
become_user() on the other side of the socket.

it is necessary that the msrpc daemon inherit the same unix and nt
credentials as the smbd process from which it was spawned, until
such time as the msrpc daemon receives an authentication request
of its own, whereupon the msrpc daemon is responsible for authenticating
the new credentials and doing yet another become_user() etc sequence.
(This used to be commit 30c7fdd6ef10ecd35594311c1b250b95ff895489)
---
 source3/rpc_parse/parse_prs.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f53b2da955..4c52e15769 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -429,6 +429,9 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
 	if (ps->error) return False;
 	start = (uint8*)mem_data(&(ps->data), ps->offset);
 
+	DEBUG(120,("_prs_string: string %s len %d max %d\n",
+			str, len, max_buf_size));
+
 	do
 	{
 		char *q;
@@ -443,7 +446,7 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
 
 		if (i < len || len == 0)
 		{
-			RW_CVAL(ps->io, q, str[i],0);
+			RW_CVAL(ps->io, q, str[i], 0);
 		}
 		else
 		{
@@ -453,6 +456,9 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
 
 	} while (i < max_buf_size && (len == 0 ? str[i] != 0 : i < len) );
 
+	DEBUG(120,("_prs_string: string %s len %d max %d\n",
+			str, len, max_buf_size));
+
 	ps->offset += i+1;
 
 	dump_data(5+depth, (char *)start, i);
-- 
cgit 


From 0ce128e3550794d4dbbd1def00e87c020f72c992 Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Sun, 12 Dec 1999 01:25:49 +0000
Subject: delineation between smb and msrpc more marked.  smbd now constructs
 pdus, and then feeds them over either a "local" function call or a "remote"
 function call to an msrpc service.  the "remote" msrpc daemon, on the other
 side of a unix socket, then calls the same "local" function that smbd would,
 if the msrpc service were being run from inside smbd.

this allows a transition from local msrpc services (inside the same smbd
process) to remote (over a unix socket).

removed reference to pipes_struct in msrpc services.  all msrpc processing
functions take rpcsrv_struct which is a structure containing state info
for the msrpc functions to decode and create pdus.

created become_vuser() which does everything not related to connection_struct
that become_user() does.

removed, as best i could, connection_struct dependencies from the nt spoolss
printing code.

todo: remove dcinfo from rpcsrv_struct because this stores NETLOGON-specific
info on a per-connection basis, and if the connection dies then so does
the info, and that's a fairly serious problem.

had to put pretty much everything that is in user_struct into parse_creds.c
to feed unix user info over to the msrpc daemons.  why?  because it's
expensive to do unix password/group database lookups, and it's definitely
expensive to do nt user profile lookups, not to mention pretty difficult
and if you did either of these it would introduce a complication /
unnecessary interdependency.  so, send uid/gid/num_groups/gid_t* +
SID+num_rids+domain_group_rids* + unix username + nt username + nt domain
+ user session key etc.  this is the MINIMUM info identified so far that's
actually implemented.  missing bits include the called and calling
netbios names etc.  (basically, anything that can be loaded into
standard_sub() and standard_sub_basic()...)
(This used to be commit aa3c659a8dba0437c17c60055a6ed30fdfecdb6d)
---
 source3/rpc_parse/parse_prs.c | 92 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 80 insertions(+), 12 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4c52e15769..d9c07e3885 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -39,10 +39,11 @@ void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 /*******************************************************************
  debug a parse structure
  ********************************************************************/
-void prs_debug_out(prs_struct *ps, int level)
+void prs_debug_out(prs_struct *ps, char *msg, int level)
 {
-	DEBUG(level,("ps: io %s align %d offset %d err %d data %p len %d\n",
-		BOOLSTR(ps->io), ps->align, ps->offset, ps->error, ps->data,
+	DEBUG(level,("%s ps: io %s align %d offset %d err %d data %p len %d\n",
+		msg, BOOLSTR(ps->io), ps->align, ps->offset, ps->error,
+		ps->data,
 		ps->data != NULL ? mem_buf_len(ps->data) : 0));
 }
 
@@ -69,6 +70,22 @@ void prs_init(prs_struct *ps, uint32 size,
 	}
 }
 
+/*******************************************************************
+ copy a parse structure
+ ********************************************************************/
+BOOL prs_copy(prs_struct *ps, const prs_struct *from)
+{
+	int len = mem_buf_len(from->data);
+	prs_init(ps, len, from->align, from->data->margin, from->io);
+	if (!mem_buf_copy(mem_data(&ps->data, 0), from->data, 0, len))
+	{
+		return False;
+	}
+	ps->offset = len;
+	prs_link(NULL, ps, NULL);
+	return True;
+}
+
 /*******************************************************************
  initialise a parse structure
  ********************************************************************/
@@ -85,6 +102,10 @@ void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
 	ps->data->offset.start = prev != NULL ? prev->data->offset.end : 0;
 	ps->data->offset.end   = ps->data->offset.start + ps->offset;
 	ps->data->next         = next != NULL ? next->data : NULL;
+
+	DEBUG(150,("prs_link: start %d end %d\n",
+		ps->data->offset.start,
+		ps->data->offset.end));
 }
 
 /*******************************************************************
@@ -107,12 +128,31 @@ void prs_align(prs_struct *ps)
 
  depends on the data stream mode (io)
  ********************************************************************/
-BOOL prs_grow(prs_struct *ps)
+BOOL prs_grow(prs_struct *ps, uint32 new_size)
 {
 	if (ps->error) return False;
-	return mem_grow_data(&(ps->data), ps->io, ps->offset, False);
+	return mem_grow_data(&(ps->data), ps->io, new_size, False);
 }
 
+/*******************************************************************
+ lengthens a buffer by len bytes and copies data into it.
+ ********************************************************************/
+BOOL prs_append_data(prs_struct *ps, const char *data, int len)
+{
+	int prev_size = ps->data->data_used;
+	int new_size  = prev_size + len;
+	char *to;
+
+	mem_realloc_data(ps->data, new_size);
+	to = mem_data(&ps->data, prev_size);
+	if (to == NULL || ps->data->data_used != new_size)
+	{
+		return False;
+	}
+	memcpy(to, data, len);
+
+	return True;
+}
 
 /*******************************************************************
  stream a uint8
@@ -121,16 +161,19 @@ BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 {
 	char *q;
 	if (ps->error) return False;
+	prs_grow(ps, ps->offset + 1);
 	q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_uint8 error", 5);
 		return False;
 	}
 
 	DBG_RW_CVAL(name, depth, ps->offset, ps->io, q, *data8)
 	ps->offset += 1;
 
+
 	return True;
 }
 
@@ -141,10 +184,12 @@ BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 {
 	char *q;
 	if (ps->error) return False;
+	prs_grow(ps, ps->offset + 2);
 	q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_uint16 error", 5);
 		return False;
 	}
 
@@ -165,6 +210,7 @@ BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 	if (q == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_hash1 error", 5);
 		return False;
 	}
 
@@ -188,10 +234,12 @@ BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 {
 	char *q;
 	if (ps->error) return False;
+	prs_grow(ps, ps->offset + 4);
 	q = mem_data(&(ps->data), ps->offset);
 	if (q == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_uint32 error", 5);
 		return False;
 	}
 
@@ -211,13 +259,15 @@ BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *da
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
 	end_offset = ps->offset + len * sizeof(uint8);
+	prs_grow(ps, end_offset);
+	q = mem_data(&(ps->data), ps->offset);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL) 
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_uint8s error", 5);
 		return False;
 	}
 
@@ -236,13 +286,15 @@ BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
 	end_offset = ps->offset + len * sizeof(uint16);
+	prs_grow(ps, end_offset);
+	q = mem_data(&(ps->data), ps->offset);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_uint16s error", 5);
 		return False;
 	}
 
@@ -261,13 +313,15 @@ BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
 	end_offset = ps->offset + len * sizeof(uint32);
+	prs_grow(ps, end_offset);
+	q = mem_data(&(ps->data), ps->offset);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_uint32s error", 5);
 		return False;
 	}
 
@@ -287,13 +341,15 @@ BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
+	end_offset = ps->offset + str->buf_len * sizeof(uint8);
+	prs_grow(ps, end_offset);
 	q = mem_data(&(ps->data), ps->offset);
-	end_offset = ps->offset + str->buf_len;
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_buffer2 error", 5);
 		return False;
 	}
 
@@ -313,13 +369,15 @@ BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
 	end_offset = ps->offset + str->str_str_len * sizeof(uint8);
+	prs_grow(ps, end_offset);
+	q = mem_data(&(ps->data), ps->offset);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_string2 error", 5);
 		return False;
 	}
 
@@ -339,13 +397,15 @@ BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
 	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
+	prs_grow(ps, end_offset);
+	q = mem_data(&(ps->data), ps->offset);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_unistr2 error", 5);
 		return False;
 	}
 
@@ -365,13 +425,15 @@ BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int d
 	int end_offset;
 	char *e;
 	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
 	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
+	prs_grow(ps, end_offset);
+	q = mem_data(&(ps->data), ps->offset);
 	e = mem_data(&(ps->data), end_offset-1);
 
 	if (q == NULL || e == NULL)
 	{
 		ps->error = True;
+		prs_debug_out(ps, "_prs_unistr3 error", 5);
 		return False;
 	}
 
@@ -395,10 +457,12 @@ BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	{
 		char *q;
 		i++;
+		prs_grow(ps, ps->offset + i*2);
 		q = mem_data(&(ps->data), ps->offset + i*2);
 		if (q == NULL) 
 		{
 			ps->error = True;
+			prs_debug_out(ps, "_prs_unistr error", 5);
 			return False;
 		}
 		RW_SVAL(ps->io, q, str->buffer[i],0);
@@ -432,15 +496,19 @@ BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, u
 	DEBUG(120,("_prs_string: string %s len %d max %d\n",
 			str, len, max_buf_size));
 
+	DEBUG(10,("%s%04x %s: ", tab_depth(depth), ps->offset, name != NULL ? name : ""));
+
 	do
 	{
 		char *q;
 		i++;
 
+		prs_grow(ps, ps->offset + i);
 		q = mem_data(&(ps->data), ps->offset + i);
 		if (q == NULL)
 		{
 			ps->error = True;
+			prs_debug_out(ps, "_prs_string error", 5);
 			return False;
 		}
 
-- 
cgit 


From 3db52feb1f3b2c07ce0b06ad4a7099fa6efe3fc7 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 13 Dec 1999 13:27:58 +0000
Subject: first pass at updating head branch to be to be the same as the
 SAMBA_2_0 branch (This used to be commit
 453a822a76780063dff23526c35408866d0c0154)

---
 source3/rpc_parse/parse_prs.c | 787 ++++++++++++++++++++++--------------------
 1 file changed, 417 insertions(+), 370 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d9c07e3885..f5f4eb67b8 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -2,8 +2,9 @@
    Unix SMB/Netbios implementation.
    Version 1.9.
    Samba memory buffer functions
-   Copyright (C) Andrew Tridgell              1992-1999
-   Copyright (C) Luke Kenneth Casson Leighton 1996-1999
+   Copyright (C) Andrew Tridgell              1992-1997
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1997
+   Copyright (C) Jeremy Allison 1999.
    
    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
@@ -33,523 +34,567 @@ extern int DEBUGLEVEL;
  ********************************************************************/
 void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 {
-	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->offset, fn_name, desc));
+	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
 }
 
 /*******************************************************************
- debug a parse structure
+ Initialise a parse structure - malloc the data if requested.
  ********************************************************************/
-void prs_debug_out(prs_struct *ps, char *msg, int level)
+
+BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, BOOL io)
 {
-	DEBUG(level,("%s ps: io %s align %d offset %d err %d data %p len %d\n",
-		msg, BOOLSTR(ps->io), ps->align, ps->offset, ps->error,
-		ps->data,
-		ps->data != NULL ? mem_buf_len(ps->data) : 0));
+	ZERO_STRUCTP(ps);
+	ps->io = io;
+	ps->bigendian_data = False;
+	ps->align = align;
+	ps->is_dynamic = False;
+	ps->data_offset = 0;
+	ps->buffer_size = 0;
+	ps->data_p = NULL;
+
+	if (size != 0) {
+		ps->buffer_size = size;
+		if((ps->data_p = (char *)malloc((size_t)size)) == NULL) {
+			DEBUG(0,("prs_init: malloc fail for %u bytes.\n", (unsigned int)size));
+			return False;
+		}
+		ps->is_dynamic = True; /* We own this memory. */
+	}
+
+	return True;
 }
 
 /*******************************************************************
- initialise a parse structure
+ Delete the memory in a parse structure - if we own it.
  ********************************************************************/
-void prs_init(prs_struct *ps, uint32 size,
-				uint8 align, uint32 margin,
-				BOOL io)
+
+void prs_mem_free(prs_struct *ps)
 {
-	ps->io = io;
-	ps->align = align;
-	ps->offset = 0;
-	ps->error = False;
+	if(ps->is_dynamic && (ps->data_p != NULL))
+		free(ps->data_p);
+	ps->is_dynamic = False;
+	ps->data_p = NULL;
+	ps->buffer_size = 0;
+	ps->data_offset = 0;
+}
 
-	ps->data = NULL;
-	mem_buf_init(&(ps->data), margin);
+/*******************************************************************
+ Hand some already allocated memory to a prs_struct.
+ ********************************************************************/
 
-	if (size != 0)
-	{
-		mem_alloc_data(ps->data, size);
-		ps->data->offset.start = 0;
-		ps->data->offset.end   = 0xffffffff;
-	}
+void prs_give_memory(prs_struct *ps, char *buf, uint32 size, BOOL is_dynamic)
+{
+	ps->is_dynamic = is_dynamic;
+	ps->data_p = buf;
+	ps->buffer_size = size;
 }
 
 /*******************************************************************
- copy a parse structure
+ Take some memory back from a prs_struct.
  ********************************************************************/
-BOOL prs_copy(prs_struct *ps, const prs_struct *from)
+
+char *prs_take_memory(prs_struct *ps, uint32 *psize)
 {
-	int len = mem_buf_len(from->data);
-	prs_init(ps, len, from->align, from->data->margin, from->io);
-	if (!mem_buf_copy(mem_data(&ps->data, 0), from->data, 0, len))
-	{
+	char *ret = ps->data_p;
+	if(psize)
+		*psize = ps->buffer_size;
+	ps->is_dynamic = False;
+	prs_mem_free(ps);
+	return ret;
+}
+
+/*******************************************************************
+ Attempt, if needed, to grow a data buffer.
+ Also depends on the data stream mode (io).
+ ********************************************************************/
+
+BOOL prs_grow(prs_struct *ps, uint32 extra_space)
+{
+	uint32 new_size;
+	char *new_data;
+
+	if(ps->data_offset + extra_space <= ps->buffer_size)
+		return True;
+
+	/*
+	 * We cannot grow the buffer if we're not reading
+	 * into the prs_struct, or if we don't own the memory.
+	 */
+
+	if(UNMARSHALLING(ps) || !ps->is_dynamic) {
+		DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
+				(unsigned int)extra_space));
 		return False;
 	}
-	ps->offset = len;
-	prs_link(NULL, ps, NULL);
+
+	/*
+	 * Decide how much extra space we really need.
+	 */
+
+	extra_space -= (ps->buffer_size - ps->data_offset);
+
+	if(ps->buffer_size == 0) {
+
+		/*
+		 * Ensure we have at least a PDU's length, or extra_space, whichever
+		 * is greater.
+		 */
+
+		new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);
+
+		if((new_data = malloc(new_size)) == NULL) {
+			DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
+			return False;
+		}
+		memset(new_data, '\0', new_size );
+	} else {
+
+		/*
+		 * If the current buffer size is bigger than the space needed, just 
+		 * double it, else add extra_space.
+		 */
+
+		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);
+
+		if((new_data = Realloc(ps->data_p, new_size)) == NULL) {
+			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
+				(unsigned int)new_size));
+			return False;
+		}
+	}
+
+	ps->buffer_size = new_size;
+	ps->data_p = new_data;
+
 	return True;
 }
 
 /*******************************************************************
- initialise a parse structure
+ Attempt to force a data buffer to grow by len bytes.
+ This is only used when appending more data onto a prs_struct
+ when reading an rpc reply, before unmarshalling it.
  ********************************************************************/
-void prs_mem_free(prs_struct *ps)
+
+BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 {
-	mem_buf_free(&(ps->data));
+	uint32 new_size = ps->buffer_size + extra_space;
+	char *new_data;
+
+	if(!UNMARSHALLING(ps) || !ps->is_dynamic) {
+		DEBUG(0,("prs_force_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
+				(unsigned int)extra_space));
+		return False;
+	}
+
+	if((new_data = Realloc(ps->data_p, new_size)) == NULL) {
+		DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
+			(unsigned int)new_size));
+		return False;
+	}
+
+	ps->buffer_size = new_size;
+	ps->data_p = new_data;
+
+	return True;
 }
 
 /*******************************************************************
- link one parsing structure to another
+ Get the data pointer (external interface).
  ********************************************************************/
-void prs_link(prs_struct *prev, prs_struct *ps, prs_struct *next)
-{
-	ps->data->offset.start = prev != NULL ? prev->data->offset.end : 0;
-	ps->data->offset.end   = ps->data->offset.start + ps->offset;
-	ps->data->next         = next != NULL ? next->data : NULL;
 
-	DEBUG(150,("prs_link: start %d end %d\n",
-		ps->data->offset.start,
-		ps->data->offset.end));
+char *prs_data_p(prs_struct *ps)
+{
+	return ps->data_p;
 }
 
 /*******************************************************************
- align a pointer to a multiple of align_offset bytes.  looks like it
- will work for offsets of 0, 2 and 4...
+ Get the current data size (external interface).
  ********************************************************************/
-void prs_align(prs_struct *ps)
+
+uint32 prs_data_size(prs_struct *ps)
 {
-	int mod;
-	if (ps->error) return;
-	mod = ps->offset & (ps->align-1);
-	if (ps->align != 0 && mod != 0)
-	{
-		ps->offset += ps->align - mod;
-	}
+	return ps->buffer_size;
 }
 
 /*******************************************************************
- attempt, if appropriate, to grow a data buffer.
-
- depends on the data stream mode (io)
+ Fetch the current offset (external interface).
  ********************************************************************/
-BOOL prs_grow(prs_struct *ps, uint32 new_size)
+
+uint32 prs_offset(prs_struct *ps)
 {
-	if (ps->error) return False;
-	return mem_grow_data(&(ps->data), ps->io, new_size, False);
+	return ps->data_offset;
 }
 
 /*******************************************************************
- lengthens a buffer by len bytes and copies data into it.
+ Set the current offset (external interface).
  ********************************************************************/
-BOOL prs_append_data(prs_struct *ps, const char *data, int len)
+
+BOOL prs_set_offset(prs_struct *ps, uint32 offset)
 {
-	int prev_size = ps->data->data_used;
-	int new_size  = prev_size + len;
-	char *to;
+	if(offset <= ps->data_offset) {
+		ps->data_offset = offset;
+		return True;
+	}
 
-	mem_realloc_data(ps->data, new_size);
-	to = mem_data(&ps->data, prev_size);
-	if (to == NULL || ps->data->data_used != new_size)
-	{
+	if(!prs_grow(ps, offset - ps->data_offset))
 		return False;
-	}
-	memcpy(to, data, len);
 
+	ps->data_offset = offset;
 	return True;
 }
 
 /*******************************************************************
- stream a uint8
+ Append the data from one parse_struct into another.
  ********************************************************************/
-BOOL _prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
+
+BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 {
-	char *q;
-	if (ps->error) return False;
-	prs_grow(ps, ps->offset + 1);
-	q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_uint8 error", 5);
+	if(!prs_grow(dst, prs_offset(src)))
 		return False;
-	}
-
-	DBG_RW_CVAL(name, depth, ps->offset, ps->io, q, *data8)
-	ps->offset += 1;
 
+	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
+	dst->data_offset += prs_offset(src);
 
 	return True;
 }
 
 /*******************************************************************
- stream a uint16
+ Append the data from a buffer into a parse_struct.
  ********************************************************************/
-BOOL _prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
+
+BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 {
-	char *q;
-	if (ps->error) return False;
-	prs_grow(ps, ps->offset + 2);
-	q = mem_data(&(ps->data), ps->offset);
-	if (q == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_uint16 error", 5);
+	if(!prs_grow(dst, len))
 		return False;
-	}
 
-	DBG_RW_SVAL(name, depth, ps->offset, ps->io, q, *data16)
-	ps->offset += 2;
+	memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
+	dst->data_offset += len;
 
 	return True;
 }
 
 /*******************************************************************
- hash a stream.
+ Set the data as big-endian (external interface).
  ********************************************************************/
-BOOL _prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
+
+void prs_set_bigendian_data(prs_struct *ps)
 {
-	char *q;
-	if (ps->error) return False;
-	q = mem_data(&(ps->data), ps->offset);
+	ps->bigendian_data = True;
+}
+
+/*******************************************************************
+ Align a the data_len to a multiple of align bytes - filling with
+ zeros.
+ ********************************************************************/
+
+BOOL prs_align(prs_struct *ps)
+{
+	uint32 mod = ps->data_offset & (ps->align-1);
+
+	if (ps->align != 0 && mod != 0) {
+		uint32 extra_space = (ps->align - mod);
+		if(!prs_grow(ps, extra_space))
+			return False;
+		memset(&ps->data_p[ps->data_offset], '\0', (size_t)extra_space);
+		ps->data_offset += extra_space;
+	}
+
+	return True;
+}
+
+/*******************************************************************
+ Ensure we can read/write to a given offset.
+ ********************************************************************/
+
+char *prs_mem_get(prs_struct *ps, uint32 extra_size)
+{
+	if(UNMARSHALLING(ps)) {
+		/*
+		 * If reading, ensure that we can read the requested size item.
+		 */
+		if (ps->data_offset + extra_size > ps->buffer_size) {
+			DEBUG(0,("prs_mem_get: reading data of size %u would overrun buffer.\n",
+					(unsigned int)extra_size ));
+			return NULL;
+		}
+	} else {
+		/*
+		 * Writing - grow the buffer if needed.
+		 */
+		if(!prs_grow(ps, extra_size))
+			return False;
+	}
+	return &ps->data_p[ps->data_offset];
+}
+
+/*******************************************************************
+ Stream a uint8.
+ ********************************************************************/
+
+BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
+{
+	char *q = prs_mem_get(ps, sizeof(uint8));
 	if (q == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_hash1 error", 5);
 		return False;
-	}
 
-#ifdef DEBUG_PASSWORD
-	DEBUG(100,("prs_hash1\n"));
-	dump_data(100, sess_key, 16);
-	dump_data(100, q, 68);
-#endif
-	SamOEMhash((uchar*)q, sess_key, 2);
-#ifdef DEBUG_PASSWORD
-	dump_data(100, q, 68);
-#endif
+	DBG_RW_CVAL(name, depth, ps->data_offset, ps->io, q, *data8)
+	ps->data_offset += sizeof(uint8);
 
 	return True;
 }
 
 /*******************************************************************
- stream a uint32
+ Stream a uint16.
  ********************************************************************/
-BOOL _prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
+
+BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 {
-	char *q;
-	if (ps->error) return False;
-	prs_grow(ps, ps->offset + 4);
-	q = mem_data(&(ps->data), ps->offset);
+	char *q = prs_mem_get(ps, sizeof(uint16));
 	if (q == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_uint32 error", 5);
 		return False;
-	}
 
-	DBG_RW_IVAL(name, depth, ps->offset, ps->io, q, *data32)
-	ps->offset += 4;
+	DBG_RW_SVAL(name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, *data16)
+	ps->data_offset += sizeof(uint16);
 
 	return True;
 }
 
-
-/******************************************************************
- stream an array of uint8s.  length is number of uint8s
+/*******************************************************************
+ Stream a uint32.
  ********************************************************************/
-BOOL _prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+
+BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + len * sizeof(uint8);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL) 
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_uint8s error", 5);
+	char *q = prs_mem_get(ps, sizeof(uint32));
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, data8s, len)
-	ps->offset = end_offset;
+	DBG_RW_IVAL(name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, *data32)
+	ps->data_offset += sizeof(uint32);
 
 	return True;
 }
 
+
 /******************************************************************
- stream an array of uint16s.  length is number of uint16s
+ Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
-BOOL _prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+
+BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + len * sizeof(uint16);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_uint16s error", 5);
+	char *q = prs_mem_get(ps, len * sizeof(uint8));
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, data16s, len)
-	ps->offset = end_offset;
+	DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, data8s, len)
+	ps->data_offset += (len * sizeof(uint8));
 
 	return True;
 }
 
 /******************************************************************
- stream an array of uint32s.  length is number of uint32s
+ Stream an array of uint32s. Length is number of uint32s.
  ********************************************************************/
-BOOL _prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
+
+BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + len * sizeof(uint32);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_uint32s error", 5);
+	char *q = prs_mem_get(ps, len * sizeof(uint32));
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PIVAL(charmode, name, depth, ps->offset, ps->io, q, data32s, len)
-	ps->offset = end_offset;
+	DBG_RW_PIVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, data32s, len)
+	ps->data_offset += (len * sizeof(uint32));
 
 	return True;
 }
 
 /******************************************************************
- stream a "not" unicode string, length/buffer specified separately,
- in byte chars
+ Stream a "not" unicode string, length/buffer specified separately,
+ in byte chars. String is in little-endian format.
  ********************************************************************/
-BOOL _prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
+
+BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + str->buf_len * sizeof(uint8);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_buffer2 error", 5);
+	char *p = (char *)str->buffer;
+	char *q = prs_mem_get(ps, str->buf_len);
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->buf_len)
-	ps->offset = end_offset;
+	/* If we're using big-endian, reverse to get little-endian. */
+	if(ps->bigendian_data)
+		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->buf_len/2)
+	else
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->buf_len)
+	ps->data_offset += str->buf_len;
 
 	return True;
 }
 
 /******************************************************************
- stream a string, length/buffer specified separately,
+ Stream a string, length/buffer specified separately,
  in uint8 chars.
  ********************************************************************/
-BOOL _prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
+
+BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + str->str_str_len * sizeof(uint8);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_string2 error", 5);
+	char *q = prs_mem_get(ps, str->str_str_len * sizeof(uint8));
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->str_max_len)
-	ps->offset = end_offset;
+	DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, str->buffer, str->str_max_len)
+	ps->data_offset += (str->str_str_len * sizeof(uint8));
 
 	return True;
 }
 
 /******************************************************************
- stream a unicode string, length/buffer specified separately,
- in uint16 chars.
+ Stream a unicode string, length/buffer specified separately,
+ in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
+ as the unicode string is already in little-endian format.
  ********************************************************************/
-BOOL _prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
+
+BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_unistr2 error", 5);
+	char *p = (char *)str->buffer;
+	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->buffer, str->uni_str_len)
-	ps->offset = end_offset;
+	/* If we're using big-endian, reverse to get little-endian. */
+	if(ps->bigendian_data)
+		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
+	else
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * 2)
+	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
 }
 
 /******************************************************************
- stream a unicode string, length/buffer specified separately,
- in uint16 chars.
+ Stream a unicode string, length/buffer specified separately,
+ in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
+ as the unicode string is already in little-endian format.
  ********************************************************************/
-BOOL _prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
+
+BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
-	char *q;
-	int end_offset;
-	char *e;
-	if (ps->error) return False;
-	end_offset = ps->offset + str->uni_str_len * sizeof(uint16);
-	prs_grow(ps, end_offset);
-	q = mem_data(&(ps->data), ps->offset);
-	e = mem_data(&(ps->data), end_offset-1);
-
-	if (q == NULL || e == NULL)
-	{
-		ps->error = True;
-		prs_debug_out(ps, "_prs_unistr3 error", 5);
+	char *p = (char *)str->str.buffer;
+	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
+	if (q == NULL)
 		return False;
-	}
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->offset, ps->io, q, str->str.buffer, str->uni_str_len)
-	ps->offset = end_offset;
+	/* If we're using big-endian, reverse to get little-endian. */
+	if(ps->bigendian_data)
+		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
+	else
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * 2)
+	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
 }
 
 /*******************************************************************
- stream a unicode  null-terminated string
+ Stream a unicode  null-terminated string. As the string is already
+ in little-endian format then do it as a stream of bytes.
  ********************************************************************/
-BOOL _prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
+
+BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
-	int i = -1;
+	int len = 0;
+	unsigned char *p = (unsigned char *)str->buffer;
 	uint8 *start;
-	if (ps->error) return False;
-	start = (uint8*)mem_data(&(ps->data), ps->offset);
+	char *q;
+
+	for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+			   str->buffer[len] != 0; len++)
+		;
 
-	do
+	q = prs_mem_get(ps, len*2);
+	if (q == NULL)
+		return False;
+
+	start = (uint8*)q;
+
+	len = 0;
+	do 
 	{
-		char *q;
-		i++;
-		prs_grow(ps, ps->offset + i*2);
-		q = mem_data(&(ps->data), ps->offset + i*2);
-		if (q == NULL) 
-		{
-			ps->error = True;
-			prs_debug_out(ps, "_prs_unistr error", 5);
-			return False;
+		if(ps->bigendian_data) {
+			RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0)
+			p += 2;
+			q += 2;
+		} else {
+			RW_CVAL(ps->io, q, *p, 0);
+			p++;
+			q++;
+			RW_CVAL(ps->io, q, *p, 0);
+			p++;
+			q++;
 		}
-		RW_SVAL(ps->io, q, str->buffer[i],0);
-	}
-	while ((((size_t)i) < sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-		     (str->buffer[i] != 0));
-
+		len++;
+	} while ((len < (sizeof(str->buffer) / sizeof(str->buffer[0]))) &&
+		     (str->buffer[len] != 0));
 
-	ps->offset += (i+1)*2;
+	ps->data_offset += len*2;
 
-	dump_data(5+depth, (char *)start, i * 2);
+	dump_data(5+depth, (char *)start, len * 2);
 
 	return True;
 }
 
 /*******************************************************************
- stream a null-terminated string.  len is strlen, and therefore does
+ Stream a null-terminated string.  len is strlen, and therefore does
  not include the null-termination character.
-
- len == 0 indicates variable length string
- (up to max size of pstring - 1024 chars).
-
  ********************************************************************/
-BOOL _prs_string(char *name, prs_struct *ps, int depth, char *str, uint16 len, uint16 max_buf_size)
+
+BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
 {
-	int i = -1; /* start off at zero after 1st i++ */
+	char *q;
 	uint8 *start;
-	if (ps->error) return False;
-	start = (uint8*)mem_data(&(ps->data), ps->offset);
+	int i;
 
-	DEBUG(120,("_prs_string: string %s len %d max %d\n",
-			str, len, max_buf_size));
+	len = MIN(len, (max_buf_size-1));
 
-	DEBUG(10,("%s%04x %s: ", tab_depth(depth), ps->offset, name != NULL ? name : ""));
+	q = prs_mem_get(ps, len+1);
+	if (q == NULL)
+		return False;
 
-	do
-	{
-		char *q;
-		i++;
-
-		prs_grow(ps, ps->offset + i);
-		q = mem_data(&(ps->data), ps->offset + i);
-		if (q == NULL)
-		{
-			ps->error = True;
-			prs_debug_out(ps, "_prs_string error", 5);
-			return False;
-		}
+	start = (uint8*)q;
 
-		if (i < len || len == 0)
-		{
-			RW_CVAL(ps->io, q, str[i], 0);
-		}
-		else
-		{
-			uint8 dummy = 0;
-			RW_CVAL(ps->io, q, dummy,0);
-		}
+	for(i = 0; i < len; i++) {
+		RW_CVAL(ps->io, q, str[i],0);
+		q++;
+	}
 
-	} while (i < max_buf_size && (len == 0 ? str[i] != 0 : i < len) );
+	/* The terminating null. */
+	str[i] = '\0';
 
-	DEBUG(120,("_prs_string: string %s len %d max %d\n",
-			str, len, max_buf_size));
+	if (MARSHALLING(ps)) {
+		RW_CVAL(ps->io, q, str[i], 0);
+	}
 
-	ps->offset += i+1;
+	ps->data_offset += len+1;
 
-	dump_data(5+depth, (char *)start, i);
+	dump_data(5+depth, (char *)start, len);
 
 	return True;
 }
 
 /*******************************************************************
- prs_uint16 wrapper.  call this and it sets up a pointer to where the
- uint16 should be stored, or gets the size if reading
+ prs_uint16 wrapper. Call this and it sets up a pointer to where the
+ uint16 should be stored, or gets the size if reading.
  ********************************************************************/
-BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
+
+BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
-	if (ps->error) return False;
-	(*offset) = ps->offset;
-	if (ps->io)
-	{
+	(*offset) = ps->data_offset;
+	if (UNMARSHALLING(ps)) {
 		/* reading. */
-		return _prs_uint16(name, ps, depth, data16);
-	}
-	else
-	{
-		ps->offset += sizeof(uint16);
+		return prs_uint16(name, ps, depth, data16);
+	} else {
+		char *q = prs_mem_get(ps, sizeof(uint16));
+		if(q ==NULL)
+			return False;
+		ps->data_offset += sizeof(uint16);
 	}
 	return True;
 }
@@ -558,43 +603,42 @@ BOOL _prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint
  prs_uint16 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL _prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
+
+BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 				uint32 ptr_uint16, uint32 start_offset)
 {
-	if (ps->error) return False;
-	if (!ps->io)
-	{
-		/* storing: go back and do a retrospective job.  i hate this */
-		uint16 data_size = ps->offset - start_offset;
-		uint32 old_offset = ps->offset;
-
-		ps->offset = ptr_uint16;
-		prs_uint16(name, ps, depth, &data_size);
-		ps->offset = old_offset;
-	}
-	else
-	{
-		ps->offset = start_offset + (*data16);
+	if (MARSHALLING(ps)) {
+		/* 
+		 * Writing - temporarily move the offset pointer.
+		 */
+		uint16 data_size = ps->data_offset - start_offset;
+		uint32 old_offset = ps->data_offset;
+
+		ps->data_offset = ptr_uint16;
+		if(!prs_uint16(name, ps, depth, &data_size)) {
+			ps->data_offset = old_offset;
+			return False;
+		}
+		ps->data_offset = old_offset;
+	} else {
+		ps->data_offset = start_offset + (uint32)(*data16);
 	}
 	return True;
 }
 
 /*******************************************************************
- prs_uint32 wrapper.  call this and it sets up a pointer to where the
- uint32 should be stored, or gets the size if reading
+ prs_uint32 wrapper. Call this and it sets up a pointer to where the
+ uint32 should be stored, or gets the size if reading.
  ********************************************************************/
-BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+
+BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
-	if (ps->error) return False;
-	(*offset) = ps->offset;
-	if (ps->io)
-	{
+	(*offset) = ps->data_offset;
+	if (UNMARSHALLING(ps)) {
 		/* reading. */
-		return _prs_uint32(name, ps, depth, data32);
-	}
-	else
-	{
-		ps->offset += sizeof(uint32);
+		return prs_uint32(name, ps, depth, data32);
+	} else {
+		ps->data_offset += sizeof(uint32);
 	}
 	return True;
 }
@@ -603,18 +647,21 @@ BOOL _prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint
  prs_uint32 wrapper.  call this and it retrospectively stores the size.
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
-BOOL _prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
+
+BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 				uint32 ptr_uint32, uint32 data_size)
 {
-	if (ps->error) return False;
-	if (!ps->io)
-	{
-		/* storing: go back and do a retrospective job.  i hate this */
-		uint32 old_offset = ps->offset;
-		ps->offset = ptr_uint32;
-		prs_uint32(name, ps, depth, &data_size);
-		ps->offset = old_offset;
+	if (MARSHALLING(ps)) {
+		/* 
+		 * Writing - temporarily move the offset pointer.
+		 */
+		uint32 old_offset = ps->data_offset;
+		ps->data_offset = ptr_uint32;
+		if(!prs_uint32(name, ps, depth, &data_size)) {
+			ps->data_offset = old_offset;
+			return False;
+		}
+		ps->data_offset = old_offset;
 	}
 	return True;
 }
-
-- 
cgit 


From fbd17c8dafeefac788f4bc1c41045726825f513f Mon Sep 17 00:00:00 2001
From: Luke Leighton <lkcl@samba.org>
Date: Mon, 3 Jan 2000 19:19:48 +0000
Subject: simple mods to add msrpc pipe redirection.  default behaviour: fall
 back to using internal msrpc code in smbd. (This used to be commit
 8976e26d46cb991710bc77463f7f928ac00dd4d8)

---
 source3/rpc_parse/parse_prs.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f5f4eb67b8..6bb07c5f64 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -64,6 +64,30 @@ BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, BOOL io)
 	return True;
 }
 
+/*******************************************************************
+ read from a socket into memory.
+ ********************************************************************/
+BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
+{
+	BOOL ok;
+	size_t prev_size = ps->buffer_size;
+	if (!prs_grow(ps, len))
+	{
+		return False;
+	}
+
+	if (timeout > 0)
+	{
+		ok = (read_with_timeout(fd, &ps->data_p[prev_size],
+		                            len, len,timeout) == len);
+	}
+	else 
+	{
+		ok = (read_data(fd, &ps->data_p[prev_size], len) == len);
+	}
+	return ok;
+}
+
 /*******************************************************************
  Delete the memory in a parse structure - if we own it.
  ********************************************************************/
-- 
cgit 


From 195e3d44daccc3b6457486018ba0322ac9d44566 Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Mon, 7 Feb 2000 16:25:15 +0000
Subject: spoolss definitions.

also added some prs_struct functions, 'cause I'm handling buffers as
prs_struct.

	J.F.
(This used to be commit 81e375bbbe0fb022a44a2aaaa3729a9518b7a854)
---
 source3/rpc_parse/parse_prs.c | 50 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 6bb07c5f64..24eff1b779 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -282,6 +282,21 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 	return True;
 }
 
+/*******************************************************************
+ Append some data from one parse_struct into another.
+ ********************************************************************/
+
+BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, uint32 len)
+{
+	if(!prs_grow(dst, len))
+		return False;
+
+	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)len);
+	dst->data_offset += len;
+
+	return True;
+}
+
 /*******************************************************************
  Append the data from a buffer into a parse_struct.
  ********************************************************************/
@@ -351,6 +366,25 @@ char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 	return &ps->data_p[ps->data_offset];
 }
 
+/*******************************************************************
+ Change the struct type.
+ ********************************************************************/
+
+BOOL prs_switch_type(prs_struct *ps, BOOL io)
+{
+	if ((ps->io ^ io) == True)
+		ps->io=io;
+}
+
+/*******************************************************************
+ Force a prs_struct to be dynamic even when it's size is 0.
+ ********************************************************************/
+
+void prs_force_dynamic(prs_struct *ps)
+{
+	ps->is_dynamic=True;
+}
+
 /*******************************************************************
  Stream a uint8.
  ********************************************************************/
@@ -416,6 +450,22 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
 	return True;
 }
 
+/******************************************************************
+ Stream an array of uint16s. Length is number of uint16s.
+ ********************************************************************/
+
+BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+{
+	char *q = prs_mem_get(ps, len * sizeof(uint16));
+	if (q == NULL)
+		return False;
+
+	DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, data16s, len)
+	ps->data_offset += (len * sizeof(uint16));
+
+	return True;
+}
+
 /******************************************************************
  Stream an array of uint32s. Length is number of uint32s.
  ********************************************************************/
-- 
cgit 


From 8688933c7feb87179c178a30e4fc42970fe1da8f Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Tue, 15 Feb 2000 18:07:45 +0000
Subject: fix the reply of rpc_alter_context OpenPrinterEx is now decoding
 correctly the query most of the EnumXXX use the new_buffer struct. check the
 (un)marshalling return code.

conclusion: still a long way to go. all the client code has to be
rewritten, and I still wonder how to implement correctly the notify stuff.
(This used to be commit 3d6d3863751787b08d40268c83221add1487a5c9)
---
 source3/rpc_parse/parse_prs.c | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 24eff1b779..5d0ea832c8 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -150,15 +150,13 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 				(unsigned int)extra_space));
 		return False;
 	}
-
+	
 	/*
 	 * Decide how much extra space we really need.
 	 */
 
 	extra_space -= (ps->buffer_size - ps->data_offset);
-
 	if(ps->buffer_size == 0) {
-
 		/*
 		 * Ensure we have at least a PDU's length, or extra_space, whichever
 		 * is greater.
@@ -172,21 +170,18 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		}
 		memset(new_data, '\0', new_size );
 	} else {
-
 		/*
 		 * If the current buffer size is bigger than the space needed, just 
 		 * double it, else add extra_space.
 		 */
+		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);		
 
-		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);
-
-		if((new_data = Realloc(ps->data_p, new_size)) == NULL) {
+		if ((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 				(unsigned int)new_size));
 			return False;
 		}
 	}
-
 	ps->buffer_size = new_size;
 	ps->data_p = new_data;
 
@@ -286,12 +281,12 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
  Append some data from one parse_struct into another.
  ********************************************************************/
 
-BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, uint32 len)
-{
+BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
+{	
 	if(!prs_grow(dst, len))
 		return False;
-
-	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)len);
+	
+	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
 	dst->data_offset += len;
 
 	return True;
-- 
cgit 


From 78d7ba5ca021518ec5c088eb492b36710e556c31 Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Mon, 6 Mar 2000 11:13:40 +0000
Subject: changed prs_unistr to parse empty and non-empty strings the same way.
 fixed typo in SPOOLSS_SYNT some cleanup of unused functions wrote
 make_spoolss_enumprinter and make_spoolss_openprinterex for rpcclient as I'm
 trying to keep in sync the parsing code between HEAD and TNG.

Will commit changes to TNG after lunch.

	J.F.
(This used to be commit 025cdb345f6de287a41d4449b2662dbc5e762bf2)
---
 source3/rpc_parse/parse_prs.c | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 5d0ea832c8..64c1590b7d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -365,7 +365,7 @@ char *prs_mem_get(prs_struct *ps, uint32 extra_size)
  Change the struct type.
  ********************************************************************/
 
-BOOL prs_switch_type(prs_struct *ps, BOOL io)
+void prs_switch_type(prs_struct *ps, BOOL io)
 {
 	if ((ps->io ^ io) == True)
 		ps->io=io;
@@ -573,22 +573,22 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	unsigned char *p = (unsigned char *)str->buffer;
 	uint8 *start;
 	char *q;
+	char zero=0;
 
 	for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
 			   str->buffer[len] != 0; len++)
 		;
 
-	q = prs_mem_get(ps, len*2);
+	q = prs_mem_get(ps, (len+1)*2);
 	if (q == NULL)
 		return False;
 
 	start = (uint8*)q;
 
-	len = 0;
-	do 
-	{
+	for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+			   str->buffer[len] != 0; len++) {
 		if(ps->bigendian_data) {
-			RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0)
+			RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
 			p += 2;
 			q += 2;
 		} else {
@@ -599,10 +599,21 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 			p++;
 			q++;
 		}
-		len++;
-	} while ((len < (sizeof(str->buffer) / sizeof(str->buffer[0]))) &&
-		     (str->buffer[len] != 0));
+	}
+	
+	/*
+	 * even if the string is 'empty' (only an \0 char)
+	 * at this point the leading \0 hasn't been parsed.
+	 * so parse it now
+	 */
+
+	RW_CVAL(ps->io, q, zero, 0);
+	q++;
+	RW_CVAL(ps->io, q, zero, 0);
+	q++;
 
+	len++;
+		
 	ps->data_offset += len*2;
 
 	dump_data(5+depth, (char *)start, len * 2);
-- 
cgit 


From 0806cf75ff96dee6715610bd61e21cde08fa1c61 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Fri, 12 May 2000 14:28:46 +0000
Subject: added spool_io_printer_driver_info_level_6()

thsi function and the associated header structure were autogenerated
using a little awk based code geerator I wroe ths evening. I'll commit
that next ...
(This used to be commit 974813f0d4afb6c14ed27c48ab24b19932557f9f)
---
 source3/rpc_parse/parse_prs.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 64c1590b7d..2edd080a0e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -26,6 +26,25 @@ extern int DEBUGLEVEL;
 #include "includes.h"
 
 
+/*******************************************************************
+dump a prs to a file
+ ********************************************************************/
+void prs_dump(char *name, int level, prs_struct *ps)
+{
+	int fd;
+	pstring fname;
+	if (DEBUGLEVEL < 50) return;
+	slprintf(fname,sizeof(fname), "/tmp/%s_%d.prs", name, level);
+	fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
+	if (fd != -1) {
+		write(fd, ps->data_p + ps->data_offset, ps->buffer_size - ps->data_offset);
+		close(fd);
+		DEBUG(0,("created %s\n", fname));
+	}
+}
+
+
+
 /*******************************************************************
  debug output for parsing info.
 
@@ -428,7 +447,6 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 	return True;
 }
 
-
 /******************************************************************
  Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
-- 
cgit 


From 414caf80a2705c5953af03db736a0d9774fab9fc Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 15 May 2000 07:17:34 +0000
Subject: make prs_dump() store up to 100 variants of each msg type (This used
 to be commit 0e7819bb4562a840ecb9b7ef12706572b6b60202)

---
 source3/rpc_parse/parse_prs.c | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 2edd080a0e..efcd16470a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -29,13 +29,20 @@ extern int DEBUGLEVEL;
 /*******************************************************************
 dump a prs to a file
  ********************************************************************/
-void prs_dump(char *name, int level, prs_struct *ps)
+void prs_dump(char *name, int v, prs_struct *ps)
 {
-	int fd;
+	int fd, i;
 	pstring fname;
 	if (DEBUGLEVEL < 50) return;
-	slprintf(fname,sizeof(fname), "/tmp/%s_%d.prs", name, level);
-	fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
+	for (i=1;i<100;i++) {
+		if (v != -1) {
+			slprintf(fname,sizeof(fname), "/tmp/%s_%d.%d.prs", name, v, i);
+		} else {
+			slprintf(fname,sizeof(fname), "/tmp/%s.%d.prs", name, i);
+		}
+		fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
+		if (fd != -1 || errno != EEXIST) break;
+	}
 	if (fd != -1) {
 		write(fd, ps->data_p + ps->data_offset, ps->buffer_size - ps->data_offset);
 		close(fd);
-- 
cgit 


From bb01686063812c5cdb206d19dd71bc082008d4ac Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 15 May 2000 09:58:58 +0000
Subject: update grow_size in prs_grow (This used to be commit
 a42da205361bb70778913c8bd9facbb6b9a24937)

---
 source3/rpc_parse/parse_prs.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index efcd16470a..fff1bc27b1 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -44,7 +44,7 @@ void prs_dump(char *name, int v, prs_struct *ps)
 		if (fd != -1 || errno != EEXIST) break;
 	}
 	if (fd != -1) {
-		write(fd, ps->data_p + ps->data_offset, ps->buffer_size - ps->data_offset);
+		write(fd, ps->data_p + ps->data_offset, ps->grow_size - ps->data_offset);
 		close(fd);
 		DEBUG(0,("created %s\n", fname));
 	}
@@ -163,6 +163,8 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 	uint32 new_size;
 	char *new_data;
 
+	ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
+
 	if(ps->data_offset + extra_space <= ps->buffer_size)
 		return True;
 
-- 
cgit 


From c560164030c0b842ee06f651a2b019c5596624a2 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 17 May 2000 03:12:56 +0000
Subject: Fixed bug where mallocd size of prs_struct could be larger than
 incoming packet. Ensure new alloced memory is zeroed before use. Jeremy.
 (This used to be commit 1c3193aa1c1137734dc34ef2e6d62abb0609c30e)

---
 source3/rpc_parse/parse_prs.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index fff1bc27b1..4260b1c8d5 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -209,6 +209,8 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 				(unsigned int)new_size));
 			return False;
 		}
+
+		memset(&new_data[ps->buffer_size], '\0', new_size - ps->buffer_size);
 	}
 	ps->buffer_size = new_size;
 	ps->data_p = new_data;
@@ -239,6 +241,8 @@ BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 		return False;
 	}
 
+	memset(&new_data[ps->buffer_size], '\0', new_size - ps->buffer_size);
+
 	ps->buffer_size = new_size;
 	ps->data_p = new_data;
 
@@ -296,7 +300,7 @@ BOOL prs_set_offset(prs_struct *ps, uint32 offset)
 
 BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 {
-	if(!prs_grow(dst, prs_offset(src)))
+	if(!prs_force_grow(dst, prs_offset(src)))
 		return False;
 
 	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
@@ -311,7 +315,7 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 
 BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 {	
-	if(!prs_grow(dst, len))
+	if(!prs_force_grow(dst, len))
 		return False;
 	
 	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
@@ -326,7 +330,7 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
 
 BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 {
-	if(!prs_grow(dst, len))
+	if(!prs_force_grow(dst, len))
 		return False;
 
 	memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
-- 
cgit 


From 819c15449882a0c08689a4565bf0b31f756f05bd Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 17 May 2000 19:17:16 +0000
Subject: Fixed bug I introduced last night (sorry). Now truncate incoming
 prs_struct buffer size to exact size of incoming data to prevent read
 overruns into slop space. Jeremy. (This used to be commit
 aa1a4f46da9584240cd6cee6fb652aa73e77015c)

---
 source3/rpc_parse/parse_prs.c | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4260b1c8d5..dafff63ad9 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -153,6 +153,29 @@ char *prs_take_memory(prs_struct *ps, uint32 *psize)
 	return ret;
 }
 
+/*******************************************************************
+ Set a prs_struct to exactly a given size. Will grow or tuncate if neccessary.
+ ********************************************************************/
+
+BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
+{
+	if (newsize > ps->buffer_size)
+		return prs_force_grow(ps, newsize - ps->buffer_size);
+
+	if (newsize < ps->buffer_size) {
+		char *new_data_p = Realloc(ps->data_p, newsize);
+		if (new_data_p == NULL) {
+			DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
+				(unsigned int)newsize));
+			return False;
+		}
+		ps->data_p = new_data_p;
+		ps->buffer_size = newsize;
+	}
+
+	return True;
+}
+
 /*******************************************************************
  Attempt, if needed, to grow a data buffer.
  Also depends on the data stream mode (io).
@@ -300,7 +323,7 @@ BOOL prs_set_offset(prs_struct *ps, uint32 offset)
 
 BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 {
-	if(!prs_force_grow(dst, prs_offset(src)))
+	if(!prs_grow(dst, prs_offset(src)))
 		return False;
 
 	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
@@ -315,7 +338,7 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 
 BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 {	
-	if(!prs_force_grow(dst, len))
+	if(!prs_grow(dst, len))
 		return False;
 	
 	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
@@ -330,7 +353,7 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
 
 BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 {
-	if(!prs_force_grow(dst, len))
+	if(!prs_grow(dst, len))
 		return False;
 
 	memcpy(&dst->data_p[dst->data_offset], src, (size_t)len);
-- 
cgit 


From f3c44fba111392a7680e489330f3f69aedbff13d Mon Sep 17 00:00:00 2001
From: Shirish Kalele <kalele@samba.org>
Date: Fri, 26 May 2000 22:37:08 +0000
Subject: Fixed memory leak in RPC parsing code. Problem in
 prs_set_buffer_size() was Realloc returns a NULL when newsize is zero
 (equivalent to a free()). We were returning a failure here without resetting
 the buffer_size or the data_p pointer in the prs_struct. And we weren't
 checking for a failure from prs_set_buffer_size(). So realloc's to zero size
 were not reflected in the prs_struct: memory leak. (This used to be commit
 590d9ece8449b1feecfe1aa13e61bcd8fea4e5bf)

---
 source3/rpc_parse/parse_prs.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index dafff63ad9..422b420a3c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -164,9 +164,11 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 
 	if (newsize < ps->buffer_size) {
 		char *new_data_p = Realloc(ps->data_p, newsize);
-		if (new_data_p == NULL) {
+		/* if newsize is zero, Realloc acts like free() & returns NULL*/
+		if (new_data_p == NULL && newsize != 0) {
 			DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
 				(unsigned int)newsize));
+			DEBUG(0,("prs_set_buffer_size: Reason %s\n",strerror(errno)));
 			return False;
 		}
 		ps->data_p = new_data_p;
-- 
cgit 


From 0cc138993573a8337c335563ba3c5936d260f298 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 2 Jun 2000 21:16:39 +0000
Subject: More memory leak and PANIC action fixes. This is *horrible* code :-(.
 Jeremy. (This used to be commit ac383bb765ea606fc1105aa91470fcdf453d9335)

---
 source3/rpc_parse/parse_prs.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 422b420a3c..0e057e9403 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -232,6 +232,9 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		if ((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 				(unsigned int)new_size));
+			/* JRATEST */
+			smb_panic("prs_grow: ralloc fail\n");
+			/* JRATEST */
 			return False;
 		}
 
-- 
cgit 


From 6d8c131f50e708d4c009355a7c5fe026cf8d350a Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 5 Jun 2000 20:55:57 +0000
Subject: Some tidyup fixes (memory leaks etc.). Still no progress with the "no
 driver" issue. I'm banging my head against comparitive packet dumps right
 now... Jeremy. (This used to be commit
 03cd4aa1443acd958593f37c61ff9c90a43c660b)

---
 source3/rpc_parse/parse_prs.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 0e057e9403..d277182043 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -232,9 +232,6 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		if ((new_data = Realloc(ps->data_p, new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 				(unsigned int)new_size));
-			/* JRATEST */
-			smb_panic("prs_grow: ralloc fail\n");
-			/* JRATEST */
 			return False;
 		}
 
@@ -343,6 +340,9 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 
 BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 {	
+	if (len == 0)
+		return True;
+
 	if(!prs_grow(dst, len))
 		return False;
 	
-- 
cgit 


From 0164047afbd082b0003147845a72ca08b4781b81 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 7 Jun 2000 01:49:23 +0000
Subject: Fixing get/set of security descriptors. Removed ugly hack for NT
 printing. Fixed up tdb parse stuff memory leaks. Jeremy. (This used to be
 commit 8ef41f31c53e14ad057d883810a1cd2301fede2a)

---
 source3/rpc_parse/parse_prs.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d277182043..b7fe19f9ab 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -201,6 +201,9 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 	if(UNMARSHALLING(ps) || !ps->is_dynamic) {
 		DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 				(unsigned int)extra_space));
+		/* JRATEST */
+		smb_panic("prs_grow");
+		/* JRATEST */
 		return False;
 	}
 	
-- 
cgit 


From 6d38ba721ce57a9a574b5f0c24621df3dfcd0738 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Thu, 8 Jun 2000 01:16:42 +0000
Subject: Moved tdb functions that access parse structs into parse_prs.c to
 prevent builkd breaking. Jeremy. (This used to be commit
 6c7adeab0f92844ecefbcb923d0d4763d4c3eaa5)

---
 source3/rpc_parse/parse_prs.c | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b7fe19f9ab..b6bedac536 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -807,3 +807,31 @@ BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 	}
 	return True;
 }
+
+/* useful function to store a structure in rpc wire format */
+int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
+{
+    TDB_DATA kbuf, dbuf;
+    kbuf.dptr = keystr;
+    kbuf.dsize = strlen(keystr)+1;
+    dbuf.dptr = prs_data_p(ps);
+    dbuf.dsize = prs_offset(ps);
+    return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
+}
+
+/* useful function to fetch a structure into rpc wire format */
+int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
+{
+    TDB_DATA kbuf, dbuf;
+    kbuf.dptr = keystr;
+    kbuf.dsize = strlen(keystr)+1;
+
+    dbuf = tdb_fetch(tdb, kbuf);
+    if (!dbuf.dptr) return -1;
+
+    ZERO_STRUCTP(ps);
+    prs_init(ps, 0, 4, UNMARSHALL);
+    prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
+
+    return 0;
+} 
-- 
cgit 


From 36fd3866efa89b5a537d4cb312e6a0d77ca9b89a Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 26 Jun 2000 22:08:20 +0000
Subject: Changing drivers using the properties page works - but only if
 getting/setting security descriptors is disabled (as it is in this code).

If get/set sd's is enabled spooler.exe crashes on NT.

I'll investigate and fix that issue next.

Jeremy.
(This used to be commit 8c9ed874363e6a710bc0fe521bb8c4f7ee219587)
---
 source3/rpc_parse/parse_prs.c | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b6bedac536..94a6100aa1 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -201,9 +201,6 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 	if(UNMARSHALLING(ps) || !ps->is_dynamic) {
 		DEBUG(0,("prs_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
 				(unsigned int)extra_space));
-		/* JRATEST */
-		smb_panic("prs_grow");
-		/* JRATEST */
 		return False;
 	}
 	
-- 
cgit 


From d2b40a7de259377d937492acedd39988ddd108a4 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Fri, 7 Jul 2000 06:20:46 +0000
Subject: More rpcclient merge issues:

        * fixes some readline bugs from the merge
        * first attempt at commands (spoolenum almost works)
        * no changes to existing functions in HEAD; only additions
          of new functions.  I'll weed out what I can as I go.




--jerry
(This used to be commit 61d2aad5dc2b212b11c981f1eca47efa627e9fc8)
---
 source3/rpc_parse/parse_prs.c | 114 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 113 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 94a6100aa1..3b17f51c95 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -26,6 +26,35 @@ extern int DEBUGLEVEL;
 #include "includes.h"
 
 
+/*******************************************************************
+ search for a memory buffer that falls within the specified offset
+ ********************************************************************/
+static const prs_struct *prs_find(const prs_struct *buf, uint32 offset)
+{
+        const prs_struct *f = NULL;
+
+#if 0  	/* comment out by JERRY */
+        if (buf == NULL)
+                return False;
+
+        f = buf;
+
+        while (f != NULL && offset >= f->end)
+        {
+                DEBUG(200, ("prs_find: next[%d..%d]\n", f->start, f->end));
+
+                f = f->next;
+        }
+
+        if (f != NULL)
+        {
+                DEBUG(200, ("prs_find: found [%d..%d]\n", f->start, f->end));
+        }
+
+#endif
+        return f;
+}
+
 /*******************************************************************
 dump a prs to a file
  ********************************************************************/
@@ -63,10 +92,10 @@ void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
 }
 
+
 /*******************************************************************
  Initialise a parse structure - malloc the data if requested.
  ********************************************************************/
-
 BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, BOOL io)
 {
 	ZERO_STRUCTP(ps);
@@ -805,6 +834,89 @@ BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 	return True;
 }
 
+/*******************************************************************
+ frees a memory buffer.
+ ********************************************************************/
+void prs_free_data(prs_struct *buf)
+{
+        if (buf == NULL)
+                return;
+
+        if (buf->data_p != NULL)
+        {
+                free(buf->data_p);
+                buf->data_p = NULL;
+        }
+        buf->buffer_size = 0;
+}
+
+/*******************************************************************
+ reallocate a memory buffer
+********************************************************************/
+BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
+{
+        char *new_data;
+
+        /* prs_sma_init();  JERRY */
+
+        prs_debug(buf, 200, "prs_realloc_data - before", "prs_realloc_data");
+
+        SMB_ASSERT(((ssize_t) new_size) >= 0);
+
+        if (new_size == 0)
+        {
+                prs_free_data(buf);
+                return True;
+        }
+
+        /* new_data = sma_realloc(prs_sma_region, buf->data_p, new_size); */
+        new_data = realloc(buf->data_p, new_size);
+
+        if (new_data != NULL)
+        {
+                if (new_size > buf->buffer_size)
+                {
+                        memset(&new_data[buf->buffer_size], 0,
+                               new_size - buf->buffer_size);
+                }
+                buf->data_p = new_data;
+                buf->buffer_size = new_size;
+        }
+        else if (buf->buffer_size >= new_size)
+        {
+                DEBUG(3, ("prs_realloc_data: warning - "
+                          "could not realloc to %d\n", new_size));
+        }
+        else
+        {
+                DEBUG(3, ("prs_realloc_data: error - "
+                          "could not realloc to %d\n", new_size));
+
+                prs_free_data(buf);
+                return False;
+        }
+
+        prs_debug(buf, 200, "prs_realloc_data - after", "prs_realloc_data");
+        return True;
+}
+
+/*******************************************************************
+ return the memory location specified by   may return NULL.
+ ********************************************************************/
+char *prs_data(const prs_struct *buf, uint32 offset)
+{
+        buf = prs_find(buf, offset);
+        if (buf != NULL)
+        {
+                /* return &(buf->data[offset - buf->start]); */
+                return &(buf->data_p[offset]);
+        }
+        return NULL;
+}
+
+
+
+
 /* useful function to store a structure in rpc wire format */
 int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
 {
-- 
cgit 


From 64db2010fbc3c1eaaa2d9c7de5b56c1c9edb06e1 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Mon, 10 Jul 2000 19:55:39 +0000
Subject: included a a new prs_unistr().  Is currently #if'd out (denoted by
 RPCCLIENT_TEST) in order to not break anything in the smbd code (and to give
 time to review it).  Originally written by JF. In effect, this checkin makes
 no changes to parse_prs.c at all.

jerry
(This used to be commit 4f431ea1f5d1d3b868d0bb56a299070e608c2512)
---
 source3/rpc_parse/parse_prs.c | 92 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 3b17f51c95..8bfc638d5d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -627,6 +627,8 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 	return True;
 }
 
+
+
 /******************************************************************
  Stream a unicode string, length/buffer specified separately,
  in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
@@ -709,6 +711,96 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	return True;
 }
 
+#if 0	/* RPCCLIENT_TEST */
+BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
+{
+	int len = 0;
+	unsigned char *p = (unsigned char *)str->buffer;
+	uint8 *start;
+	char *q;
+	char zero=0;
+
+	if (MARSHALLING(ps)) {
+
+		for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+				   str->buffer[len] != 0; len++)
+			;
+
+		q = prs_mem_get(ps, (len+1)*2);
+		if (q == NULL)
+			return False;
+
+		start = (uint8*)q;
+
+		for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+				   str->buffer[len] != 0; len++) 
+		{
+			if(ps->bigendian_data) 
+			{
+				RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
+				p += 2;
+				q += 2;
+			} 
+			else 
+			{
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q++;
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q++;
+			}
+		}
+
+		/*
+		 * even if the string is 'empty' (only an \0 char)
+		 * at this point the leading \0 hasn't been parsed.
+		 * so parse it now
+		 */
+
+		RW_CVAL(ps->io, q, zero, 0);
+		q++;
+		RW_CVAL(ps->io, q, zero, 0);
+		q++;
+
+		len++;
+
+		dump_data(5+depth, (char *)start, len * 2);
+	}
+	else { /* unmarshalling */
+	
+		len = -1;
+		q = prs_data_p(ps) + prs_offset(ps);
+
+		do 
+		{
+			len++;
+
+			if(ps->bigendian_data) 
+			{
+				RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
+				p += 2;
+				q += 2;
+			} else {
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q++;
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q++;
+			}
+		} while (len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
+				   str->buffer[len] != 0);
+	}
+
+	ps->data_offset += len*2;
+	
+	return True;
+}
+
+#endif	/* RPCCLIENT_TEST */
+
+
 /*******************************************************************
  Stream a null-terminated string.  len is strlen, and therefore does
  not include the null-termination character.
-- 
cgit 


From 9ab8dfa381971df9aa8ba7731fa4b8e95a422a4b Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Tue, 11 Jul 2000 16:28:59 +0000
Subject: #ifndef RPCCLIENT_TEST 	use old prs_unistr() #else 	use
 new prs_unistr() which handles UNMARSHALL #endif /* RPCCLIENT_TEST */

jerry
(This used to be commit fb0e1fb9e31db135eeb8e949a7ad0826906ba1ff)
---
 source3/rpc_parse/parse_prs.c | 51 ++++++++++++++-----------------------------
 1 file changed, 16 insertions(+), 35 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 8bfc638d5d..5b5834084f 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -26,35 +26,6 @@ extern int DEBUGLEVEL;
 #include "includes.h"
 
 
-/*******************************************************************
- search for a memory buffer that falls within the specified offset
- ********************************************************************/
-static const prs_struct *prs_find(const prs_struct *buf, uint32 offset)
-{
-        const prs_struct *f = NULL;
-
-#if 0  	/* comment out by JERRY */
-        if (buf == NULL)
-                return False;
-
-        f = buf;
-
-        while (f != NULL && offset >= f->end)
-        {
-                DEBUG(200, ("prs_find: next[%d..%d]\n", f->start, f->end));
-
-                f = f->next;
-        }
-
-        if (f != NULL)
-        {
-                DEBUG(200, ("prs_find: found [%d..%d]\n", f->start, f->end));
-        }
-
-#endif
-        return f;
-}
-
 /*******************************************************************
 dump a prs to a file
  ********************************************************************/
@@ -657,6 +628,7 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
  in little-endian format then do it as a stream of bytes.
  ********************************************************************/
 
+#ifndef RPCCLIENT_TEST
 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	int len = 0;
@@ -710,8 +682,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 
 	return True;
 }
-
-#if 0	/* RPCCLIENT_TEST */
+#else
 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	int len = 0;
@@ -993,16 +964,26 @@ BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
 }
 
 /*******************************************************************
- return the memory location specified by   may return NULL.
+ return the memory location specified by offset; may return NULL.
  ********************************************************************/
 char *prs_data(const prs_struct *buf, uint32 offset)
 {
-        buf = prs_find(buf, offset);
-        if (buf != NULL)
+
+	/* do we have something to look at? */
+	if (buf == NULL)
+		return NULL;
+
+	/* check to make sure the offset is within range */
+	if ((offset < 0) || (offset >= buf->buffer_size))
+		return NULL;
+
+	/* locate the memory address */
+        if (buf->data_p != NULL)
         {
-                /* return &(buf->data[offset - buf->start]); */
                 return &(buf->data_p[offset]);
         }
+
+	/* default return */
         return NULL;
 }
 
-- 
cgit 


From 2c46a26a8bbc4130a6dc195a77b760d26016d5a1 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Fri, 14 Jul 2000 16:58:03 +0000
Subject: removed prs_data(), prs_free_data(), and prs_realloc_data() as these
 were unneeded and replaced by the real functions already in HEAD.

Added a few more functions to parse_spoolss.c to help with the
rpcclient merge from TNG.
(This used to be commit 3bc9af4c1dbdb664970541f6091982ffccc87b31)
---
 source3/rpc_parse/parse_prs.c | 93 -------------------------------------------
 1 file changed, 93 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 5b5834084f..1bda5ef506 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -897,99 +897,6 @@ BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
 	return True;
 }
 
-/*******************************************************************
- frees a memory buffer.
- ********************************************************************/
-void prs_free_data(prs_struct *buf)
-{
-        if (buf == NULL)
-                return;
-
-        if (buf->data_p != NULL)
-        {
-                free(buf->data_p);
-                buf->data_p = NULL;
-        }
-        buf->buffer_size = 0;
-}
-
-/*******************************************************************
- reallocate a memory buffer
-********************************************************************/
-BOOL prs_realloc_data(prs_struct *buf, size_t new_size)
-{
-        char *new_data;
-
-        /* prs_sma_init();  JERRY */
-
-        prs_debug(buf, 200, "prs_realloc_data - before", "prs_realloc_data");
-
-        SMB_ASSERT(((ssize_t) new_size) >= 0);
-
-        if (new_size == 0)
-        {
-                prs_free_data(buf);
-                return True;
-        }
-
-        /* new_data = sma_realloc(prs_sma_region, buf->data_p, new_size); */
-        new_data = realloc(buf->data_p, new_size);
-
-        if (new_data != NULL)
-        {
-                if (new_size > buf->buffer_size)
-                {
-                        memset(&new_data[buf->buffer_size], 0,
-                               new_size - buf->buffer_size);
-                }
-                buf->data_p = new_data;
-                buf->buffer_size = new_size;
-        }
-        else if (buf->buffer_size >= new_size)
-        {
-                DEBUG(3, ("prs_realloc_data: warning - "
-                          "could not realloc to %d\n", new_size));
-        }
-        else
-        {
-                DEBUG(3, ("prs_realloc_data: error - "
-                          "could not realloc to %d\n", new_size));
-
-                prs_free_data(buf);
-                return False;
-        }
-
-        prs_debug(buf, 200, "prs_realloc_data - after", "prs_realloc_data");
-        return True;
-}
-
-/*******************************************************************
- return the memory location specified by offset; may return NULL.
- ********************************************************************/
-char *prs_data(const prs_struct *buf, uint32 offset)
-{
-
-	/* do we have something to look at? */
-	if (buf == NULL)
-		return NULL;
-
-	/* check to make sure the offset is within range */
-	if ((offset < 0) || (offset >= buf->buffer_size))
-		return NULL;
-
-	/* locate the memory address */
-        if (buf->data_p != NULL)
-        {
-                return &(buf->data_p[offset]);
-        }
-
-	/* default return */
-        return NULL;
-}
-
-
-
-
 /* useful function to store a structure in rpc wire format */
 int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
 {
-- 
cgit 


From 2637bfee06c1fb2d5fcb9345ff56b0883e024f31 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 18 Jul 2000 19:25:32 +0000
Subject: rpc_parse/parse_prs.c: Removed extraneous ()'s.
 rpc_parse/parse_spoolss.c: Fixed the security descriptor marshalling in a
 INFO_2 struct. 							for
 some reason SD's should be done inline after the info2, not 		
 				as the last buffer marshall.
 rpc_server/srv_spoolss_nt.c: Removed extraneous ()'s. Jeremy. (This used to
 be commit f038a24e9f624fdb04cd52769d45783248ce8a38)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 1bda5ef506..5f43e52975 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -817,7 +817,7 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int m
 
 BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
-	(*offset) = ps->data_offset;
+	*offset = ps->data_offset;
 	if (UNMARSHALLING(ps)) {
 		/* reading. */
 		return prs_uint16(name, ps, depth, data16);
@@ -864,7 +864,7 @@ BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 
 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
-	(*offset) = ps->data_offset;
+	*offset = ps->data_offset;
 	if (UNMARSHALLING(ps)) {
 		/* reading. */
 		return prs_uint32(name, ps, depth, data32);
-- 
cgit 


From 5a5ef183799dd84ff453db849e929533e709fd0b Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Tue, 25 Jul 2000 13:15:16 +0000
Subject: A rather big change set ! (listed in no particular order)

- changed the default forms flag to 2
- all short architecture name are uppercased
- get_short_archi() is now case unsensitive
- the drivers TDB is indexed by archi/version/name
- implemented code to move drivers from the upload area to the download
area. Someone else need to look at that code.
- don't return anymore a default driver if it doesn't exist in the TDB.
Instead return an error.
- cleaned prs_unistr.
- #ifdef out jeremy's new SD parsing in printer_info_2
- removed the unused MANGLE_CODE

- #ifdef out the security checking in update_printer() as it doesn't work
for me.

Zap your ntdrivers.tdb, it won't work anymore.

	J.F.
(This used to be commit ac0a145acc0953a6f362497abbf4dfe70aa522a6)
---
 source3/rpc_parse/parse_prs.c | 57 -------------------------------------------
 1 file changed, 57 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 5f43e52975..42a3410752 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -628,61 +628,6 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
  in little-endian format then do it as a stream of bytes.
  ********************************************************************/
 
-#ifndef RPCCLIENT_TEST
-BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
-{
-	int len = 0;
-	unsigned char *p = (unsigned char *)str->buffer;
-	uint8 *start;
-	char *q;
-	char zero=0;
-
-	for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-			   str->buffer[len] != 0; len++)
-		;
-
-	q = prs_mem_get(ps, (len+1)*2);
-	if (q == NULL)
-		return False;
-
-	start = (uint8*)q;
-
-	for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-			   str->buffer[len] != 0; len++) {
-		if(ps->bigendian_data) {
-			RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
-			p += 2;
-			q += 2;
-		} else {
-			RW_CVAL(ps->io, q, *p, 0);
-			p++;
-			q++;
-			RW_CVAL(ps->io, q, *p, 0);
-			p++;
-			q++;
-		}
-	}
-	
-	/*
-	 * even if the string is 'empty' (only an \0 char)
-	 * at this point the leading \0 hasn't been parsed.
-	 * so parse it now
-	 */
-
-	RW_CVAL(ps->io, q, zero, 0);
-	q++;
-	RW_CVAL(ps->io, q, zero, 0);
-	q++;
-
-	len++;
-		
-	ps->data_offset += len*2;
-
-	dump_data(5+depth, (char *)start, len * 2);
-
-	return True;
-}
-#else
 BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	int len = 0;
@@ -769,8 +714,6 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	return True;
 }
 
-#endif	/* RPCCLIENT_TEST */
-
 
 /*******************************************************************
  Stream a null-terminated string.  len is strlen, and therefore does
-- 
cgit 


From 5ec1642809d9de83da8c88c65d6595c6eb0270f5 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Thu, 27 Jul 2000 00:47:19 +0000
Subject: Ok - this is a *BIG* change - but it fixes the problems with static
 strings in the RPC code. This change was prompted by trying to save a long
 (>256) character comment in the printer properties page.

The new system associates a TALLOC_CTX with the pipe struct, and frees
the pool on return of a complete PDU.

A global TALLOC_CTX is used for the odd buffer allocated in the BUFFERxx
code, and is freed in the main loop.

This code works with insure, and seems to be free of memory leaks and
crashes (so far) but there are probably the occasional problem with
code that uses UNISTRxx structs on the stack and expects them to contain
storage without doing a init_unistrXX().

This means that rpcclient will probably be horribly broken.
A TALLOC_CTX also needed associating with the struct cli_state also,
to make the prs_xx code there work.

The main interface change is the addition of a TALLOC_CTX to the
prs_init calls - used for dynamic allocation in the prs_XXX calls.

Now this is in place it should make dynamic allocation of all RPC
memory on unmarshall *much* easier to fix.

Jeremy.
(This used to be commit 0ff2ce543ee54f7364e6d839db6d06e7ef1edcf4)
---
 source3/rpc_parse/parse_prs.c | 101 +++++++++++++++++++++++++++++++++---------
 1 file changed, 80 insertions(+), 21 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 42a3410752..bf36b5b346 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -67,7 +67,7 @@ void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 /*******************************************************************
  Initialise a parse structure - malloc the data if requested.
  ********************************************************************/
-BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, BOOL io)
+BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, TALLOC_CTX *ctx, BOOL io)
 {
 	ZERO_STRUCTP(ps);
 	ps->io = io;
@@ -77,6 +77,7 @@ BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, BOOL io)
 	ps->data_offset = 0;
 	ps->buffer_size = 0;
 	ps->data_p = NULL;
+	ps->mem_ctx = ctx;
 
 	if (size != 0) {
 		ps->buffer_size = size;
@@ -98,17 +99,12 @@ BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
 	BOOL ok;
 	size_t prev_size = ps->buffer_size;
 	if (!prs_grow(ps, len))
-	{
 		return False;
-	}
 
-	if (timeout > 0)
-	{
+	if (timeout > 0) {
 		ok = (read_with_timeout(fd, &ps->data_p[prev_size],
 		                            len, len,timeout) == len);
-	}
-	else 
-	{
+	} else {
 		ok = (read_data(fd, &ps->data_p[prev_size], len) == len);
 	}
 	return ok;
@@ -128,6 +124,24 @@ void prs_mem_free(prs_struct *ps)
 	ps->data_offset = 0;
 }
 
+/*******************************************************************
+ Allocate memory when unmarshalling...
+ ********************************************************************/
+
+char *prs_alloc_mem(prs_struct *ps, size_t size)
+{
+	return talloc(ps->mem_ctx, size);
+}
+
+/*******************************************************************
+ Return the current talloc context we're using.
+ ********************************************************************/
+
+TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
+{
+	return ps->mem_ctx;
+}
+
 /*******************************************************************
  Hand some already allocated memory to a prs_struct.
  ********************************************************************/
@@ -543,11 +557,19 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
 
 BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
-	char *p = (char *)str->buffer;
+	char *p;
 	char *q = prs_mem_get(ps, str->buf_len);
 	if (q == NULL)
 		return False;
 
+	if (UNMARSHALLING(ps)) {
+		str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
+		if (str->buffer == NULL)
+			return False;
+	}
+
+	p = (char *)str->buffer;
+
 	/* If we're using big-endian, reverse to get little-endian. */
 	if(ps->bigendian_data)
 		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->buf_len/2)
@@ -569,6 +591,12 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
 	if (q == NULL)
 		return False;
 
+	if (UNMARSHALLING(ps)) {
+		str->buffer = prs_alloc_mem(ps,str->str_str_len);
+		if (str->buffer == NULL)
+			return False;
+	}
+
 	DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, str->buffer, str->str_max_len)
 	ps->data_offset += (str->str_str_len * sizeof(uint8));
 
@@ -583,16 +611,24 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
 
 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
-	char *p = (char *)str->buffer;
+	char *p;
 	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 	if (q == NULL)
 		return False;
 
+	if (UNMARSHALLING(ps)) {
+		str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
+		if (str->buffer == NULL)
+			return False;
+	}
+
+	p = (char *)str->buffer;
+
 	/* If we're using big-endian, reverse to get little-endian. */
 	if(ps->bigendian_data)
 		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
 	else
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * 2)
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * sizeof(uint16))
 	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
@@ -608,16 +644,24 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 
 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
-	char *p = (char *)str->str.buffer;
+	char *p;
 	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
 	if (q == NULL)
 		return False;
 
+	if (UNMARSHALLING(ps)) {
+		str->str.buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
+		if (str->str.buffer == NULL)
+			return False;
+	}
+
+	p = (char *)str->str.buffer;
+
 	/* If we're using big-endian, reverse to get little-endian. */
 	if(ps->bigendian_data)
 		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
 	else
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * 2)
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * sizeof(uint16))
 	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
@@ -638,8 +682,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 
 	if (MARSHALLING(ps)) {
 
-		for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-				   str->buffer[len] != 0; len++)
+		for(len = 0; str->buffer[len] != 0; len++)
 			;
 
 		q = prs_mem_get(ps, (len+1)*2);
@@ -648,8 +691,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 
 		start = (uint8*)q;
 
-		for(len = 0; len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-				   str->buffer[len] != 0; len++) 
+		for(len = 0; str->buffer[len] != 0; len++) 
 		{
 			if(ps->bigendian_data) 
 			{
@@ -685,9 +727,27 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	}
 	else { /* unmarshalling */
 	
+		uint32 alloc_len = 0;
 		len = -1;
 		q = prs_data_p(ps) + prs_offset(ps);
 
+		/*
+		 * Work out how much space we need and talloc it.
+		 */
+		{
+			uint32 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
+			uint16 *ptr;
+
+			for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
+				;
+
+			str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
+			if (str->buffer == NULL)
+				return False;
+
+			p = (unsigned char *)str->buffer;
+		}
+
 		do 
 		{
 			len++;
@@ -705,8 +765,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 				p++;
 				q++;
 			}
-		} while (len < (sizeof(str->buffer) / sizeof(str->buffer[0])) &&
-				   str->buffer[len] != 0);
+		} while (len < alloc_len && str->buffer[len] != 0);
 	}
 
 	ps->data_offset += len*2;
@@ -852,7 +911,7 @@ int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
 }
 
 /* useful function to fetch a structure into rpc wire format */
-int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
+int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
 {
     TDB_DATA kbuf, dbuf;
     kbuf.dptr = keystr;
@@ -862,7 +921,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
     if (!dbuf.dptr) return -1;
 
     ZERO_STRUCTP(ps);
-    prs_init(ps, 0, 4, UNMARSHALL);
+    prs_init(ps, 0, 4, mem_ctx, UNMARSHALL);
     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
 
     return 0;
-- 
cgit 


From 49fcb300de40d6da8682b485fd2c51236bcbb3dd Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 31 Jul 2000 20:41:51 +0000
Subject: Added John Reilly's enumports/addprinter/delprinter scripting code
 plus the fix for the Win9x printer drivers. Changed command names to add
 "command" string on the end for some consistancy with the other scripting
 commands. Added '%P' option to tdbpack/unpack to store long comment string.
 Made port name be "Samba Printer Port" if no enum port script given. Fixed
 prs_uint32_pre code to cope with null args. Jeremy. (This used to be commit
 902ada63799cf27924c72e24e7593a8c9fb5eba9)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index bf36b5b346..71806e422e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -867,7 +867,7 @@ BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
 BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
 	*offset = ps->data_offset;
-	if (UNMARSHALLING(ps)) {
+	if (UNMARSHALLING(ps) && (data32 != NULL)) {
 		/* reading. */
 		return prs_uint32(name, ps, depth, data32);
 	} else {
-- 
cgit 


From 2f9a0f83fe1029fddf3aae5f35ff3ccdf63f3134 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Thu, 10 Aug 2000 14:00:40 +0000
Subject: deal with allocation size of 0 in prs_unistr when UNMARSHALLING

jerry
(This used to be commit 26a73a70e282a5e46cc2b6fe7bc09b406724c9dd)
---
 source3/rpc_parse/parse_prs.c | 54 ++++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 24 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 71806e422e..7bc9578863 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -679,6 +679,8 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	uint8 *start;
 	char *q;
 	char zero=0;
+	uint32 max_len;
+	uint16* ptr;
 
 	if (MARSHALLING(ps)) {
 
@@ -734,38 +736,42 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 		/*
 		 * Work out how much space we need and talloc it.
 		 */
-		{
-			uint32 max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
-			uint16 *ptr;
-
-			for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
-				;
+		max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
 
+		for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
+			;
+		if (alloc_len > 0)
+		{
 			str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
 			if (str->buffer == NULL)
 				return False;
 
 			p = (unsigned char *)str->buffer;
-		}
 
-		do 
-		{
-			len++;
-
-			if(ps->bigendian_data) 
+			do 
 			{
-				RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
-				p += 2;
-				q += 2;
-			} else {
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q++;
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q++;
-			}
-		} while (len < alloc_len && str->buffer[len] != 0);
+				len++;
+
+				if(ps->bigendian_data) 
+				{
+					RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
+					p += 2;
+					q += 2;
+				} else {
+					RW_CVAL(ps->io, q, *p, 0);
+					p++;
+					q++;
+					RW_CVAL(ps->io, q, *p, 0);
+					p++;
+					q++;
+				}
+			} while (len < alloc_len && str->buffer[len] != 0);
+		}
+		else
+		{
+			len = 0;
+			str->buffer = NULL;
+		}
 	}
 
 	ps->data_offset += len*2;
-- 
cgit 


From 2ca88a0f2d35c8562350597ed4d45b147b3ab438 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Sat, 12 Aug 2000 14:31:29 +0000
Subject: fixes to prs_unistr UNMARSHALLING only.  Problem was due to talloc's
 of 0 bytes.

jerry
(This used to be commit 3fcc59ba928250759bbf3ef46d7c118950a5ba6f)
---
 source3/rpc_parse/parse_prs.c | 66 ++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 29 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 7bc9578863..469de90434 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -730,7 +730,6 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	else { /* unmarshalling */
 	
 		uint32 alloc_len = 0;
-		len = -1;
 		q = prs_data_p(ps) + prs_offset(ps);
 
 		/*
@@ -738,43 +737,52 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 		 */
 		max_len = (ps->buffer_size - ps->data_offset)/sizeof(uint16);
 
+		/* the test of the value of *ptr helps to catch the circumstance
+		   where we have an emtpty (non-existent) string in the buffer */
 		for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
+			/* do nothing */ 
 			;
-		if (alloc_len > 0)
-		{
-			str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
-			if (str->buffer == NULL)
-				return False;
 
-			p = (unsigned char *)str->buffer;
+		/* should we allocate anything at all? */
+		str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
+		if ((str->buffer == NULL) && (alloc_len > 0))
+			return False;
+
+		p = (unsigned char *)str->buffer;
 
-			do 
+		len = 0;
+		/* the (len < alloc_len) test is to prevent us from overwriting
+		   memory that is not ours...if we get that far, we have a non-null
+		   terminated string in the buffer and have messed up somewhere */
+		while ((len < alloc_len) && (*q != '\0'))
+		{
+			if(ps->bigendian_data) 
 			{
-				len++;
-
-				if(ps->bigendian_data) 
-				{
-					RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
-					p += 2;
-					q += 2;
-				} else {
-					RW_CVAL(ps->io, q, *p, 0);
-					p++;
-					q++;
-					RW_CVAL(ps->io, q, *p, 0);
-					p++;
-					q++;
-				}
-			} while (len < alloc_len && str->buffer[len] != 0);
-		}
-		else
+				RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
+				p += 2;
+				q += 2;
+			} else {
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q++;
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q++;
+			}
+
+			len++;
+		} 
+		if (len < alloc_len)
 		{
-			len = 0;
-			str->buffer = NULL;
+			/* NULL terminate the UNISTR */
+			str->buffer[len++] = '\0';
 		}
 	}
 
-	ps->data_offset += len*2;
+	/* set the offset in the prs_struct; 'len' points to the
+	   terminiating NULL in the UNISTR so we need to go one more
+	   uint16 */
+	ps->data_offset += (len)*2;
 	
 	return True;
 }
-- 
cgit 


From a9b2a406826b857f41ea9da0984cb49addb30a2f Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Wed, 16 Aug 2000 03:44:04 +0000
Subject: hack for unmarshalling unistr's on machines with BIG_ENDIAN arch I
 think we have a lot more of these bugs lurking (i'm fairly confident of it).

jerry
(This used to be commit 3b14487c7e5218ff3e0ff3118ca1afd706e05247)
---
 source3/rpc_parse/parse_prs.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 469de90434..f5a0bc642b 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -626,9 +626,17 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 
 	/* If we're using big-endian, reverse to get little-endian. */
 	if(ps->bigendian_data)
-		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
+	{
+		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, 
+			     ps->io, ps->bigendian_data, q, p, 
+			     str->uni_str_len)
+	}
 	else
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * sizeof(uint16))
+	{
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, 
+			     ps->io, q, p, str->uni_str_len * sizeof(uint16))
+	}
+	
 	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
@@ -762,12 +770,21 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 				p += 2;
 				q += 2;
 			} else {
+#if WORDS_BIGENDIAN
+				RW_CVAL(ps->io, q+1, *p, 0);
+				p++;
+				RW_CVAL(ps->io, q, *p, 0);
+				p++;
+				q+=2;
+#else
 				RW_CVAL(ps->io, q, *p, 0);
 				p++;
 				q++;
 				RW_CVAL(ps->io, q, *p, 0);
 				p++;
 				q++;
+#endif	/* WORDS_BIGENDIAN */
+
 			}
 
 			len++;
-- 
cgit 


From b26e3d2525c2ee09df426a9921c8c0337c1e071e Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 30 Aug 2000 22:54:54 +0000
Subject: Fixed overrun write error when using debuglevel > 50. Jeremy. (This
 used to be commit 3d9b163655f684f2b98aa72f976379cee869db05)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f5a0bc642b..b9b52a029d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -44,7 +44,7 @@ void prs_dump(char *name, int v, prs_struct *ps)
 		if (fd != -1 || errno != EEXIST) break;
 	}
 	if (fd != -1) {
-		write(fd, ps->data_p + ps->data_offset, ps->grow_size - ps->data_offset);
+		write(fd, ps->data_p + ps->data_offset, ps->buffer_size - ps->data_offset);
 		close(fd);
 		DEBUG(0,("created %s\n", fname));
 	}
-- 
cgit 


From 23f78fd7b91878176c518471cdca84cad826cba9 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 4 Oct 2000 01:03:23 +0000
Subject: Adding Herb's compile warning fixes to HEAD. Jeremy. (This used to be
 commit d131ad1ce3f6e72e295f865a463f8dcbfa6f8d42)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b9b52a029d..d6e5797aaf 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -592,7 +592,7 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = prs_alloc_mem(ps,str->str_str_len);
+		str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_str_len);
 		if (str->buffer == NULL)
 			return False;
 	}
-- 
cgit 


From a4cd5013f58f5d58ee9ef7fe4366b377904d85e3 Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Thu, 5 Oct 2000 12:41:31 +0000
Subject: fixing prs_unistr2(). For the special case of an empty (but existing)
 string.

	J.F.
(This used to be commit 83bfe94771e0afbffbb4a1a741cd9983ef612362)
---
 source3/rpc_parse/parse_prs.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d6e5797aaf..401efaadc6 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -617,22 +617,24 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
+		str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 		if (str->buffer == NULL)
 			return False;
+		memset(str->buffer, '\0', str->uni_max_len * sizeof(uint16));
 	}
 
+	/* If the string is empty, we don't have anything to stream */
+	if (str->uni_str_len==0)
+		return True;
+
 	p = (char *)str->buffer;
 
 	/* If we're using big-endian, reverse to get little-endian. */
-	if(ps->bigendian_data)
-	{
+	if(ps->bigendian_data) {
 		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, 
 			     ps->io, ps->bigendian_data, q, p, 
 			     str->uni_str_len)
-	}
-	else
-	{
+	} else {
 		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, 
 			     ps->io, q, p, str->uni_str_len * sizeof(uint16))
 	}
-- 
cgit 


From 85643cd72cbc51d163dba98eecd98c7bb029bfc3 Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Fri, 13 Oct 2000 14:02:01 +0000
Subject: last part of W2K support.

the trust domain list reply on netlogon pipe was wrong, interim hack until
we have full trust relationships.

changed some unistr2 to parse the ending NULL char.

added a prs_align_needed() function. much like a prs_align but with a
condition. needed for the unistr2 parsing.

	J.F.
(This used to be commit d8bf81553c17d9ee3419d8150b96119ebb0b8fa9)
---
 source3/rpc_parse/parse_prs.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 401efaadc6..659f8e42bd 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -410,6 +410,18 @@ BOOL prs_align(prs_struct *ps)
 	return True;
 }
 
+/*******************************************************************
+ Align only if required (for the unistr2 string mainly)
+ ********************************************************************/
+
+BOOL prs_align_needed(prs_struct *ps, uint32 needed)
+{
+	if (needed==0)
+		return True;
+	else
+		return prs_align(ps);
+}
+
 /*******************************************************************
  Ensure we can read/write to a given offset.
  ********************************************************************/
-- 
cgit 


From 4d56f4f3103a5cc549504af133d29ebb30fb59c6 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Mon, 11 Dec 2000 06:34:12 +0000
Subject: return NULL instead of return False in char *prs_mem_get(); (This
 used to be commit 71e5e802b78b22af9be7d3e84e869f311937e542)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 659f8e42bd..e800c20290 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -442,7 +442,7 @@ char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 		 * Writing - grow the buffer if needed.
 		 */
 		if(!prs_grow(ps, extra_size))
-			return False;
+			return NULL;
 	}
 	return &ps->data_p[ps->data_offset];
 }
-- 
cgit 


From 89af6fd745a6f49668bae5b5c2d239d3671fb299 Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Fri, 15 Dec 2000 09:31:56 +0000
Subject: lib/util_unistr.c:         rewrote unistr2_to_ascii() to correct a
 bug seen on SGI boxes.

rpc_parse/parse_misc.c:
rpc_parse/parse_prs.c:
        rewrote of BUFFER5 handling to NOT byteswap when it was already in
        network byte order.

rpc_parse/parse_samr.c:
        cleanup of samr_io_q_lookup_domain(), remove the over-parsing by 2
        bytes.

rpc_server/srv_lsa.c:
        UNISTR2 strings need to be NULL terminated to pleased W2K.

rpc_server/srv_spoolss_nt.c:
        use snprintf instead of safe_strcpy as we want the string
        truncated at 32 chars.


That should fix SUN and SGI box not able to act as printserver and the
problem with joining from a W2K wks.

        J.F.
(This used to be commit 69fe739303b105f2c488f266f13977da1b6b201d)
---
 source3/rpc_parse/parse_prs.c | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index e800c20290..5621a2c210 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -562,6 +562,47 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
 	return True;
 }
 
+/******************************************************************
+ Stream an array of unicode string, length/buffer specified separately,
+ in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
+ as the unicode string is already in little-endian format.
+ ********************************************************************/
+
+BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *str)
+{
+	char *p;
+	char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
+	if (q == NULL)
+		return False;
+
+	if (UNMARSHALLING(ps)) {
+		str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len * sizeof(uint16));
+		if (str->buffer == NULL)
+			return False;
+		memset(str->buffer, '\0', str->buf_len * sizeof(uint16));
+	}
+
+	/* If the string is empty, we don't have anything to stream */
+	if (str->buf_len==0)
+		return True;
+
+	p = (char *)str->buffer;
+
+	/* If we're using big-endian, reverse to get little-endian. */
+	if(ps->bigendian_data) {
+		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, 
+			     ps->io, ps->bigendian_data, q, p, 
+			     str->buf_len)
+	} else {
+		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, 
+			     ps->io, q, p, str->buf_len * sizeof(uint16))
+	}
+	
+	ps->data_offset += (str->buf_len * sizeof(uint16));
+
+	return True;
+}
+
 /******************************************************************
  Stream a "not" unicode string, length/buffer specified separately,
  in byte chars. String is in little-endian format.
-- 
cgit 


From ef2de912f2c0b095ea19986b3dce6b1b8a0ea8b5 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 27 Feb 2001 02:09:50 +0000
Subject: Separated dfs pipe into implementation and interface modules.
 rpc_parse/parse_dfs.c: Had to add buffer overrun checking ! HOW DID THIS GET
 IN HERE ! rpc_parse/parse_prs.c: Ensure prs_alloc_mem does a memset of zero
 before returning. Jeremy. (This used to be commit
 c9a6a17025f4a6850cd2b9a9ddb48bdeec8b3ffe)

---
 source3/rpc_parse/parse_prs.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 5621a2c210..6f23058c1d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -125,12 +125,17 @@ void prs_mem_free(prs_struct *ps)
 }
 
 /*******************************************************************
- Allocate memory when unmarshalling...
+ Allocate memory when unmarshalling... Always zero clears.
  ********************************************************************/
 
 char *prs_alloc_mem(prs_struct *ps, size_t size)
 {
-	return talloc(ps->mem_ctx, size);
+	char *ret = talloc(ps->mem_ctx, size);
+
+	if (ret)
+		memset(ret, '\0', size);
+
+	return ret;
 }
 
 /*******************************************************************
-- 
cgit 


From 538fbb7ad0fab7c36259038ab4a7e937b4d85c36 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 27 Feb 2001 02:18:37 +0000
Subject: As prs_alloc_mem now zeros memory, remove superfluous memsets after
 it. Jeremy. (This used to be commit 94fdffb3557fa68d634d6c402751f5bcb1f6a656)

---
 source3/rpc_parse/parse_prs.c | 2 --
 1 file changed, 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 6f23058c1d..56d03daf18 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -584,7 +584,6 @@ BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *
 		str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len * sizeof(uint16));
 		if (str->buffer == NULL)
 			return False;
-		memset(str->buffer, '\0', str->buf_len * sizeof(uint16));
 	}
 
 	/* If the string is empty, we don't have anything to stream */
@@ -678,7 +677,6 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 		str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 		if (str->buffer == NULL)
 			return False;
-		memset(str->buffer, '\0', str->uni_max_len * sizeof(uint16));
 	}
 
 	/* If the string is empty, we don't have anything to stream */
-- 
cgit 


From e9f555e4bd0c778e40f9661562806fb52dc421d9 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 2 Mar 2001 19:29:02 +0000
Subject: Merged JF's fixes into HEAD. These are for string parsing and SAMR
 fixes. Jeremy. (This used to be commit
 c3a1904564175a7a5cf71e88540b96f7daa59730)

---
 source3/rpc_parse/parse_prs.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 56d03daf18..1ec3f72d4c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -673,16 +673,16 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 	if (q == NULL)
 		return False;
 
+	/* If the string is empty, we don't have anything to stream */
+	if (str->uni_str_len==0)
+		return True;
+
 	if (UNMARSHALLING(ps)) {
 		str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
 		if (str->buffer == NULL)
 			return False;
 	}
 
-	/* If the string is empty, we don't have anything to stream */
-	if (str->uni_str_len==0)
-		return True;
-
 	p = (char *)str->buffer;
 
 	/* If we're using big-endian, reverse to get little-endian. */
-- 
cgit 


From 00ab9021b0cc5fe2667d383eb9cc2973072cdaaa Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 9 Mar 2001 23:48:58 +0000
Subject: Serious (and I *mean* serious) attempt to fix little/bigendian RPC
 issues. We were reading the endainness in the RPC header and then never
 propagating it to the internal parse_structs used to parse the data. Also
 removed the "align" argument to prs_init as it was *always* set to 4, and if
 needed can be set differently on a case by case basis. Now ready for AS/U
 testing when Herb gets it set up :-). Jeremy. (This used to be commit
 0cd37c831d79a12a10e479bf4fa89ffe64c1292a)

---
 source3/rpc_parse/parse_prs.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 1ec3f72d4c..84ccbd5db6 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -67,12 +67,12 @@ void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 /*******************************************************************
  Initialise a parse structure - malloc the data if requested.
  ********************************************************************/
-BOOL prs_init(prs_struct *ps, uint32 size, uint8 align, TALLOC_CTX *ctx, BOOL io)
+BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 {
 	ZERO_STRUCTP(ps);
 	ps->io = io;
-	ps->bigendian_data = False;
-	ps->align = align;
+	ps->bigendian_data = RPC_LITTLE_ENDIAN;
+	ps->align = RPC_PARSE_ALIGN;
 	ps->is_dynamic = False;
 	ps->data_offset = 0;
 	ps->buffer_size = 0;
@@ -387,12 +387,12 @@ BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 }
 
 /*******************************************************************
- Set the data as big-endian (external interface).
+ Set the data as X-endian (external interface).
  ********************************************************************/
 
-void prs_set_bigendian_data(prs_struct *ps)
+void prs_set_endian_data(prs_struct *ps, BOOL endian)
 {
-	ps->bigendian_data = True;
+	ps->bigendian_data = endian;
 }
 
 /*******************************************************************
@@ -1010,7 +1010,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
     if (!dbuf.dptr) return -1;
 
     ZERO_STRUCTP(ps);
-    prs_init(ps, 0, 4, mem_ctx, UNMARSHALL);
+    prs_init(ps, 0, mem_ctx, UNMARSHALL);
     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
 
     return 0;
-- 
cgit 


From 92368833faf51fd56e95a2d646eaae1d697f8e81 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sat, 31 Mar 2001 19:06:45 +0000
Subject: configure configure.in include/config.h.in lib/replace.c: Added test
 and replacement for setlinebuf which apparantly doesn't exist on HPUX 11.
 include/byteorder.h: rpc_parse/parse_prs.c: Ding Dong the witch is dead !
 :-). Ok, I'm happy 'cos I've finally deleted all the *HORRIBLE* DBG_RW_XXX
 and RW_XXX macros from include/byteorder.h. They were macros that included
 macros that had conditional macros included. No one understood them (they
 were the cause of most of the bigendian issue bugs). Finally, I went into
 parse_prs.c and inlined all of that stuff with regular function calls.
 They're understandable, they're easy to edit and they don't include macros !
 JF - please look at the one comment I added (JF PLEASE CHECK). I have tested
 this partly with IRIX (a bigendian system) running with AS/U on a Solaris box
 in SGI's lab, and I've also confirmed these new changes work with W2K
 (vmware) but there may be the odd bug lurking. Herb, if you could re-checkout
 and test again with this code that would help.

Extra.  Fixed bug spotted by the sharp eyes of JF - big endian unicode
packet would cause a early truncate of string parsing as we were checking for a char *
0, not a uint16 * 0.

Jeremy.
(This used to be commit 13765eca71e54aa5d048ce36cd8066b8406777c8)
---
 source3/rpc_parse/parse_prs.c | 302 ++++++++++++++++++++++++++++++------------
 1 file changed, 218 insertions(+), 84 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 84ccbd5db6..8311528874 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -477,12 +477,18 @@ void prs_force_dynamic(prs_struct *ps)
 
 BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
 {
-	char *q = prs_mem_get(ps, sizeof(uint8));
+	char *q = prs_mem_get(ps, 1);
 	if (q == NULL)
 		return False;
 
-	DBG_RW_CVAL(name, depth, ps->data_offset, ps->io, q, *data8)
-	ps->data_offset += sizeof(uint8);
+    if (UNMARSHALLING(ps))
+		*data8 = CVAL(q,0);
+	else
+		SCVAL(q,0,*data8);
+
+    DEBUG(5,("%s%04x %s: %02x\n", tab_depth(depth), ps->data_offset, name, *data8));
+
+	ps->data_offset += 1;
 
 	return True;
 }
@@ -497,7 +503,20 @@ BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
 	if (q == NULL)
 		return False;
 
-	DBG_RW_SVAL(name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, *data16)
+    if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data)
+			*data16 = RSVAL(q,0);
+		else
+			*data16 = SVAL(q,0);
+    } else {
+		if (ps->bigendian_data)
+			RSSVAL(q,0,*data16);
+		else
+			SSVAL(q,0,*data16);
+	}
+
+	DEBUG(5,("%s%04x %s: %04x\n", tab_depth(depth), ps->data_offset, name, *data16));
+
 	ps->data_offset += sizeof(uint16);
 
 	return True;
@@ -513,7 +532,20 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 	if (q == NULL)
 		return False;
 
-	DBG_RW_IVAL(name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, *data32)
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data)
+			*data32 = RIVAL(q,0);
+		else
+			*data32 = IVAL(q,0);
+	} else {
+		if (ps->bigendian_data)
+			RSIVAL(q,0,*data32);
+		else
+			SIVAL(q,0,*data32);
+	}
+
+	DEBUG(5,("%s%04x %s: %08x\n", tab_depth(depth), ps->data_offset, name, *data32));
+
 	ps->data_offset += sizeof(uint32);
 
 	return True;
@@ -525,12 +557,29 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 
 BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
-	char *q = prs_mem_get(ps, len * sizeof(uint8));
+	int i;
+	char *q = prs_mem_get(ps, len);
 	if (q == NULL)
 		return False;
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, data8s, len)
-	ps->data_offset += (len * sizeof(uint8));
+	if (UNMARSHALLING(ps)) {
+		for (i = 0; i < len; i++)
+			data8s[i] = CVAL(q,i);
+	} else {
+		for (i = 0; i < len; i++)
+			SCVAL(q, i, data8s[i]);
+	}
+
+    DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset ,name));
+    if (charmode)
+		print_asc(5, (unsigned char*)data8s, len);
+	else {
+    	for (i = 0; i < len; i++)
+			DEBUG(5,("%02x ", data8s[i]));
+	}
+    DEBUG(5,("\n"));
+
+	ps->data_offset += len;
 
 	return True;
 }
@@ -541,11 +590,92 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
 
 BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
+	int i;
 	char *q = prs_mem_get(ps, len * sizeof(uint16));
 	if (q == NULL)
 		return False;
 
-	DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, data16s, len)
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data) {
+			for (i = 0; i < len; i++)
+				data16s[i] = RSVAL(q, 2*i);
+		} else {
+			for (i = 0; i < len; i++)
+				data16s[i] = SVAL(q, 2*i);
+		}
+	} else {
+		if (ps->bigendian_data) {
+			for (i = 0; i < len; i++)
+				RSSVAL(q, 2*i, data16s[i]);
+		} else {
+			for (i = 0; i < len; i++)
+				SSVAL(q, 2*i, data16s[i]);
+		}
+	}
+
+	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	if (charmode)
+		print_asc(5, (unsigned char*)data16s, 2*len);
+	else {
+		for (i = 0; i < len; i++)
+			DEBUG(5,("%04x ", data16s[i]));
+	}
+    DEBUG(5,("\n"));
+
+	ps->data_offset += (len * sizeof(uint16));
+
+	return True;
+}
+
+/******************************************************************
+ Start using a function for streaming unicode chars. If unmarshalling,
+ output must be little-endian, if marshalling, input must be little-endian.
+ ********************************************************************/
+
+static void dbg_rw_punival(BOOL charmode, char *name, int depth, prs_struct *ps,
+							char *in_buf, char *out_buf, int len)
+{
+	int i;
+
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data) {
+			for (i = 0; i < len; i++)
+				SSVAL(out_buf,2*i,RSVAL(in_buf, 2*i));
+		} else {
+			for (i = 0; i < len; i++)
+				SSVAL(out_buf, 2*i, SVAL(in_buf, 2*i));
+		}
+	} else {
+		if (ps->bigendian_data) {
+			for (i = 0; i < len; i++)
+				RSSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
+		} else {
+			for (i = 0; i < len; i++)
+				SSVAL(in_buf, 2*i, SVAL(out_buf,2*i));
+		}
+	}
+
+	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	if (charmode)
+		print_asc(5, (unsigned char*)out_buf, 2*len);
+	else {
+		for (i = 0; i < len; i++)
+			DEBUG(5,("%04x ", out_buf[i]));
+	}
+    DEBUG(5,("\n"));
+}
+
+/******************************************************************
+ Stream a unistr. Always little endian.
+ ********************************************************************/
+
+BOOL prs_uint16uni(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+{
+	char *q = prs_mem_get(ps, len * sizeof(uint16));
+	if (q == NULL)
+		return False;
+
+	dbg_rw_punival(charmode, name, depth, ps, q, (char *)data16s, len);
 	ps->data_offset += (len * sizeof(uint16));
 
 	return True;
@@ -557,11 +687,38 @@ BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *d
 
 BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
+	int i;
 	char *q = prs_mem_get(ps, len * sizeof(uint32));
 	if (q == NULL)
 		return False;
 
-	DBG_RW_PIVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, data32s, len)
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data) {
+			for (i = 0; i < len; i++)
+				data32s[i] = RIVAL(q, 4*i);
+		} else {
+			for (i = 0; i < len; i++)
+				data32s[i] = IVAL(q, 4*i);
+		}
+	} else {
+		if (ps->bigendian_data) {
+			for (i = 0; i < len; i++)
+				RSIVAL(q, 4*i, data32s[i]);
+		} else {
+			for (i = 0; i < len; i++)
+				SIVAL(q, 4*i, data32s[i]);
+		}
+	}
+
+	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	if (charmode)
+		print_asc(5, (unsigned char*)data32s, 4*len);
+	else {
+		for (i = 0; i < len; i++)
+			DEBUG(5,("%08x ", data32s[i]));
+	}
+    DEBUG(5,("\n"));
+
 	ps->data_offset += (len * sizeof(uint32));
 
 	return True;
@@ -569,8 +726,7 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
 
 /******************************************************************
  Stream an array of unicode string, length/buffer specified separately,
- in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
- as the unicode string is already in little-endian format.
+ in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
 BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *str)
@@ -592,15 +748,7 @@ BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *
 
 	p = (char *)str->buffer;
 
-	/* If we're using big-endian, reverse to get little-endian. */
-	if(ps->bigendian_data) {
-		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, 
-			     ps->io, ps->bigendian_data, q, p, 
-			     str->buf_len)
-	} else {
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, 
-			     ps->io, q, p, str->buf_len * sizeof(uint16))
-	}
+	dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len);
 	
 	ps->data_offset += (str->buf_len * sizeof(uint16));
 
@@ -627,11 +775,7 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
 
 	p = (char *)str->buffer;
 
-	/* If we're using big-endian, reverse to get little-endian. */
-	if(ps->bigendian_data)
-		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->buf_len/2)
-	else
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->buf_len)
+	dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len/2);
 	ps->data_offset += str->buf_len;
 
 	return True;
@@ -644,7 +788,8 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
 
 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 {
-	char *q = prs_mem_get(ps, str->str_str_len * sizeof(uint8));
+	int i;
+	char *q = prs_mem_get(ps, str->str_str_len);
 	if (q == NULL)
 		return False;
 
@@ -654,16 +799,31 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
 			return False;
 	}
 
-	DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, str->buffer, str->str_max_len)
-	ps->data_offset += (str->str_str_len * sizeof(uint8));
+	if (UNMARSHALLING(ps)) {
+		for (i = 0; i < str->str_str_len; i++)
+			str->buffer[i] = CVAL(q,i);
+	} else {
+		for (i = 0; i < str->str_str_len; i++)
+			SCVAL(q, i, str->buffer[i]);
+	}
+
+    DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+    if (charmode)
+		print_asc(5, (unsigned char*)str->buffer, str->str_str_len);
+	else {
+    	for (i = 0; i < str->str_str_len; i++)
+			DEBUG(5,("%02x ", str->buffer[i]));
+	}
+    DEBUG(5,("\n"));
+
+	ps->data_offset += str->str_str_len;
 
 	return True;
 }
 
 /******************************************************************
  Stream a unicode string, length/buffer specified separately,
- in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
- as the unicode string is already in little-endian format.
+ in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
 BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
@@ -685,27 +845,16 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
 
 	p = (char *)str->buffer;
 
-	/* If we're using big-endian, reverse to get little-endian. */
-	if(ps->bigendian_data) {
-		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, 
-			     ps->io, ps->bigendian_data, q, p, 
-			     str->uni_str_len)
-	} else {
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, 
-			     ps->io, q, p, str->uni_str_len * sizeof(uint16))
-	}
+	dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
 	
 	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
 }
 
-
-
 /******************************************************************
  Stream a unicode string, length/buffer specified separately,
- in uint16 chars. We use DBG_RW_PCVAL, not DBG_RW_PSVAL here
- as the unicode string is already in little-endian format.
+ in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
 BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
@@ -723,11 +872,7 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
 
 	p = (char *)str->str.buffer;
 
-	/* If we're using big-endian, reverse to get little-endian. */
-	if(ps->bigendian_data)
-		DBG_RW_PSVAL(charmode, name, depth, ps->data_offset, ps->io, ps->bigendian_data, q, p, str->uni_str_len)
-	else
-		DBG_RW_PCVAL(charmode, name, depth, ps->data_offset, ps->io, q, p, str->uni_str_len * sizeof(uint16))
+	dbg_rw_punival(charmode, name, depth, ps, q, p, str->uni_str_len);
 	ps->data_offset += (str->uni_str_len * sizeof(uint16));
 
 	return True;
@@ -744,7 +889,6 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 	unsigned char *p = (unsigned char *)str->buffer;
 	uint8 *start;
 	char *q;
-	char zero=0;
 	uint32 max_len;
 	uint16* ptr;
 
@@ -763,18 +907,18 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 		{
 			if(ps->bigendian_data) 
 			{
-				RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
+				/* swap bytes - p is little endian, q is big endian. */
+				q[0] = (char)p[1];
+				q[1] = (char)p[0];
 				p += 2;
 				q += 2;
 			} 
 			else 
 			{
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q++;
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q++;
+				q[0] = (char)p[0];
+				q[1] = (char)p[1];
+				p += 2;
+				q += 2;
 			}
 		}
 
@@ -784,10 +928,9 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 		 * so parse it now
 		 */
 
-		RW_CVAL(ps->io, q, zero, 0);
-		q++;
-		RW_CVAL(ps->io, q, zero, 0);
-		q++;
+		q[0] = 0;
+		q[1] = 0;
+		q += 2;
 
 		len++;
 
@@ -820,29 +963,21 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 		/* the (len < alloc_len) test is to prevent us from overwriting
 		   memory that is not ours...if we get that far, we have a non-null
 		   terminated string in the buffer and have messed up somewhere */
-		while ((len < alloc_len) && (*q != '\0'))
+		while ((len < alloc_len) && (*(uint16 *)q != 0))
 		{
 			if(ps->bigendian_data) 
 			{
-				RW_SVAL(ps->io, ps->bigendian_data, q, *p, 0);
+				/* swap bytes - q is big endian, p is little endian. */
+				p[0] = (unsigned char)q[1];
+				p[1] = (unsigned char)q[0];
 				p += 2;
 				q += 2;
 			} else {
-#if WORDS_BIGENDIAN
-				RW_CVAL(ps->io, q+1, *p, 0);
-				p++;
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q+=2;
-#else
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q++;
-				RW_CVAL(ps->io, q, *p, 0);
-				p++;
-				q++;
-#endif	/* WORDS_BIGENDIAN */
 
+				p[0] = (unsigned char)q[0];
+				p[1] = (unsigned char)q[1];
+				p += 2;
+				q += 2;
 			}
 
 			len++;
@@ -871,7 +1006,6 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
 {
 	char *q;
-	uint8 *start;
 	int i;
 
 	len = MIN(len, (max_buf_size-1));
@@ -880,23 +1014,23 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int m
 	if (q == NULL)
 		return False;
 
-	start = (uint8*)q;
-
 	for(i = 0; i < len; i++) {
-		RW_CVAL(ps->io, q, str[i],0);
-		q++;
+		if (UNMARSHALLING(ps))
+			str[i] = q[i];
+		else
+			q[i] = str[i];
 	}
 
 	/* The terminating null. */
 	str[i] = '\0';
 
 	if (MARSHALLING(ps)) {
-		RW_CVAL(ps->io, q, str[i], 0);
+		q[i] = '\0';
 	}
 
 	ps->data_offset += len+1;
 
-	dump_data(5+depth, (char *)start, len);
+	dump_data(5+depth, q, len);
 
 	return True;
 }
-- 
cgit 


From f9a15ce1a69f905e94db7650f0a4805720cd9c88 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sun, 8 Apr 2001 20:22:39 +0000
Subject: Got "medieval on our ass" about adding the -1 to slprintf. Jeremy.
 (This used to be commit 94747b4639ed9b19f7d0fb896e43aa392a84989a)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 8311528874..6bab18ba9d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -36,9 +36,9 @@ void prs_dump(char *name, int v, prs_struct *ps)
 	if (DEBUGLEVEL < 50) return;
 	for (i=1;i<100;i++) {
 		if (v != -1) {
-			slprintf(fname,sizeof(fname), "/tmp/%s_%d.%d.prs", name, v, i);
+			slprintf(fname,sizeof(fname)-1, "/tmp/%s_%d.%d.prs", name, v, i);
 		} else {
-			slprintf(fname,sizeof(fname), "/tmp/%s.%d.prs", name, i);
+			slprintf(fname,sizeof(fname)-1, "/tmp/%s.%d.prs", name, i);
 		}
 		fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
 		if (fd != -1 || errno != EEXIST) break;
-- 
cgit 


From 19fea3242cf6234786b6cbb60631e0071f31ff9f Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 4 Sep 2001 07:13:01 +0000
Subject: the next stage in the NTSTATUS/WERROR change. smbd and nmbd now
 compile, but the client code still needs some work (This used to be commit
 dcd6e735f709a9231860ceb9682db40ff26c9a66)

---
 source3/rpc_parse/parse_prs.c | 61 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 6bab18ba9d..11fa46069a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -551,6 +551,67 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
 	return True;
 }
 
+/*******************************************************************
+ Stream a NTSTATUS
+ ********************************************************************/
+
+BOOL prs_ntstatus(char *name, prs_struct *ps, int depth, NTSTATUS *status)
+{
+	char *q = prs_mem_get(ps, sizeof(uint32));
+	if (q == NULL)
+		return False;
+
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data)
+			*status = NT_STATUS(RIVAL(q,0));
+		else
+			*status = NT_STATUS(IVAL(q,0));
+	} else {
+		if (ps->bigendian_data)
+			RSIVAL(q,0,NT_STATUS_V(*status));
+		else
+			SIVAL(q,0,NT_STATUS_V(*status));
+	}
+
+	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
+		 get_nt_error_msg(*status)));
+
+	ps->data_offset += sizeof(uint32);
+
+	return True;
+}
+
+/*******************************************************************
+ Stream a WERROR
+ ********************************************************************/
+
+BOOL prs_werror(char *name, prs_struct *ps, int depth, WERROR *status)
+{
+	char *q = prs_mem_get(ps, sizeof(uint32));
+	if (q == NULL)
+		return False;
+
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data)
+			*status = W_ERROR(RIVAL(q,0));
+		else
+			*status = W_ERROR(IVAL(q,0));
+	} else {
+		if (ps->bigendian_data)
+			RSIVAL(q,0,W_ERROR_V(*status));
+		else
+			SIVAL(q,0,W_ERROR_V(*status));
+	}
+
+	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
+		 werror_str(*status)));
+
+	ps->data_offset += sizeof(uint32);
+
+	return True;
+}
+
+
 /******************************************************************
  Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
-- 
cgit 


From 504eff41b3a357bd500c2faa2a3385584e4949d4 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Fri, 14 Sep 2001 04:36:19 +0000
Subject: Merge prs_hash1() function from tng. (This used to be commit
 3245714243d15160b9e0e27c413fef65ea91f455)

---
 source3/rpc_parse/parse_prs.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 11fa46069a..d34465e8b4 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1210,3 +1210,27 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
 
     return 0;
 } 
+
+/*******************************************************************
+ hash a stream.
+ ********************************************************************/
+BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
+{
+	char *q;
+
+	q = prs_data_p(ps);
+        q = &q[offset];
+
+#ifdef DEBUG_PASSWORD
+	DEBUG(100, ("prs_hash1\n"));
+	dump_data(100, sess_key, 16);
+	dump_data(100, q, 68);
+#endif
+	SamOEMhash((uchar *) q, sess_key, 68);
+
+#ifdef DEBUG_PASSWORD
+	dump_data(100, q, 68);
+#endif
+
+	return True;
+}
-- 
cgit 


From e7db47bffba15bd087c90b3831f05d736b8b20e5 Mon Sep 17 00:00:00 2001
From: Simo Sorce <idra@samba.org>
Date: Mon, 17 Sep 2001 10:00:29 +0000
Subject: move to SAFE_FREE() (This used to be commit
 94b0fde8a8a4e888cee93ebde79390c7942a2785)

---
 source3/rpc_parse/parse_prs.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d34465e8b4..84c9a3abf4 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -116,10 +116,9 @@ BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
 
 void prs_mem_free(prs_struct *ps)
 {
-	if(ps->is_dynamic && (ps->data_p != NULL))
-		free(ps->data_p);
+	if(ps->is_dynamic)
+		SAFE_FREE(ps->data_p);
 	ps->is_dynamic = False;
-	ps->data_p = NULL;
 	ps->buffer_size = 0;
 	ps->data_offset = 0;
 }
-- 
cgit 


From dc1fc3ee8ec2199bc73bb5d7ec711c6800f61d65 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Tue, 2 Oct 2001 04:29:50 +0000
Subject: Removed 'extern int DEBUGLEVEL' as it is now in the smb.h header.
 (This used to be commit 2d0922b0eabfdc0aaf1d0797482fef47ed7fde8e)

---
 source3/rpc_parse/parse_prs.c | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 84c9a3abf4..7b38e82f5a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -21,11 +21,8 @@
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
-extern int DEBUGLEVEL;
-
 #include "includes.h"
 
-
 /*******************************************************************
 dump a prs to a file
  ********************************************************************/
-- 
cgit 


From ea40fa55f0c385dd714300a7dcf89393f831ca79 Mon Sep 17 00:00:00 2001
From: Martin Pool <mbp@samba.org>
Date: Thu, 15 Nov 2001 06:03:22 +0000
Subject: Doxygen demo for Tim. (This used to be commit
 5c892badbcad43b8a2e002d1a42483c402f2d3e9)

---
 source3/rpc_parse/parse_prs.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 7b38e82f5a..89b0db4609 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -61,9 +61,14 @@ void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
 }
 
 
-/*******************************************************************
- Initialise a parse structure - malloc the data if requested.
- ********************************************************************/
+/**
+ * Initialise an expandable parse structure.
+ *
+ * @param size Initial buffer size.  If >0, a new buffer will be
+ * created with malloc().
+ *
+ * @return False if allocation fails, otherwise True.
+ **/
 BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 {
 	ZERO_STRUCTP(ps);
-- 
cgit 


From b03e162127c0420cb2a0e978433d2dd439b0231f Mon Sep 17 00:00:00 2001
From: Jean-François Micouleau <jfm@samba.org>
Date: Wed, 21 Nov 2001 23:25:30 +0000
Subject: samr_querydom_info level 1: found the meaning of the unknow fields.
 And discovered that our reply is short by 4 bytes since day 1 of this code.

Added a decode function to rpcclient too.

splitted the STRING2 fields filling while trying to understand the win9x
userlist bug. (didn't fix the bug, but the reply looks closer to NT).

        J.F.
(This used to be commit bfbe7f377e5fcb09e87bfc866196dfc51a8fe64d)
---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 89b0db4609..f902210b7b 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -851,12 +851,12 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
 BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
 {
 	int i;
-	char *q = prs_mem_get(ps, str->str_str_len);
+	char *q = prs_mem_get(ps, str->str_max_len);
 	if (q == NULL)
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_str_len);
+		str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_max_len);
 		if (str->buffer == NULL)
 			return False;
 	}
-- 
cgit 


From 4f3a2be2b9b566a33c5205142666e7e697d8f93f Mon Sep 17 00:00:00 2001
From: Martin Pool <mbp@samba.org>
Date: Wed, 2 Jan 2002 07:48:07 +0000
Subject: Add prs_dump_before to dump everything from the start of the prs
 buffer up to the current position, and use this to dump pipe buffers just
 before parsing. (This used to be commit
 92a3ab274e6cf09a8ba39b91f8bbacba6de40b37)

---
 source3/rpc_parse/parse_prs.c | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f902210b7b..8bb9f1c70a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -23,10 +23,29 @@
 
 #include "includes.h"
 
-/*******************************************************************
-dump a prs to a file
- ********************************************************************/
+/**
+ * Dump a prs to a file: from the current location through to the end.
+ **/
 void prs_dump(char *name, int v, prs_struct *ps)
+{
+	prs_dump_region(name, v, ps, ps->data_offset, ps->buffer_size);
+}
+
+
+/**
+ * Dump from the start of the prs to the current location.
+ **/
+void prs_dump_before(char *name, int v, prs_struct *ps)
+{
+	prs_dump_region(name, v, ps, 0, ps->data_offset);
+}
+
+
+/**
+ * Dump everything from the start of the prs up to the current location.
+ **/
+void prs_dump_region(char *name, int v, prs_struct *ps,
+		     int from_off, int to_off)
 {
 	int fd, i;
 	pstring fname;
@@ -41,7 +60,7 @@ void prs_dump(char *name, int v, prs_struct *ps)
 		if (fd != -1 || errno != EEXIST) break;
 	}
 	if (fd != -1) {
-		write(fd, ps->data_p + ps->data_offset, ps->buffer_size - ps->data_offset);
+		write(fd, ps->data_p + from_off, to_off - from_off);
 		close(fd);
 		DEBUG(0,("created %s\n", fname));
 	}
-- 
cgit 


From 37834a48e8b944936c9eb067203f457136fb3a2c Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 18 Jan 2002 00:19:45 +0000
Subject: Always clear malloced memory for parse structs. Jeremy. (This used to
 be commit 6deb4caca5b45f87be84032fe0588db8d73b901a)

---
 source3/rpc_parse/parse_prs.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 8bb9f1c70a..7b4a5f3181 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -106,6 +106,7 @@ BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 			DEBUG(0,("prs_init: malloc fail for %u bytes.\n", (unsigned int)size));
 			return False;
 		}
+		memset(ps->data_p, '\0', (size_t)size);
 		ps->is_dynamic = True; /* We own this memory. */
 	}
 
-- 
cgit 


From 2a3673994d9574068b5fce5d694b1183b9c67395 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 18 Jan 2002 00:36:16 +0000
Subject: Added prs_mem_clear(). Clear memory on buffer reallocation. That way
 we're not returning what the client gave us. Jeremy. (This used to be commit
 9a969069f132019cdd8a11be2b00356a3f09b64d)

---
 source3/rpc_parse/parse_prs.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 7b4a5f3181..725e2e01a5 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -145,6 +145,15 @@ void prs_mem_free(prs_struct *ps)
 	ps->data_offset = 0;
 }
 
+/*******************************************************************
+ Clear the memory in a parse structure.
+ ********************************************************************/
+
+void prs_mem_clear(prs_struct *ps)
+{
+	memset(ps->data_p, '\0', (size_t)ps->buffer_size);
+}
+
 /*******************************************************************
  Allocate memory when unmarshalling... Always zero clears.
  ********************************************************************/
@@ -261,7 +270,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 			DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
 			return False;
 		}
-		memset(new_data, '\0', new_size );
+		memset(new_data, '\0', (size_t)new_size );
 	} else {
 		/*
 		 * If the current buffer size is bigger than the space needed, just 
@@ -275,7 +284,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 			return False;
 		}
 
-		memset(&new_data[ps->buffer_size], '\0', new_size - ps->buffer_size);
+		memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 	}
 	ps->buffer_size = new_size;
 	ps->data_p = new_data;
@@ -306,7 +315,7 @@ BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 		return False;
 	}
 
-	memset(&new_data[ps->buffer_size], '\0', new_size - ps->buffer_size);
+	memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 
 	ps->buffer_size = new_size;
 	ps->data_p = new_data;
-- 
cgit 


From cd68afe31256ad60748b34f7318a180cfc2127cc Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Wed, 30 Jan 2002 06:08:46 +0000
Subject: Removed version number from file header.

Changed "SMB/Netbios" to "SMB/CIFS" in file header.
(This used to be commit 6a58c9bd06d0d7502a24bf5ce5a2faf0a146edfa)
---
 source3/rpc_parse/parse_prs.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 725e2e01a5..2deefd362a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1,6 +1,5 @@
 /* 
-   Unix SMB/Netbios implementation.
-   Version 1.9.
+   Unix SMB/CIFS implementation.
    Samba memory buffer functions
    Copyright (C) Andrew Tridgell              1992-1997
    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
-- 
cgit 


From ab13654dc9ac23872e4d1384e1c54e336f113009 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Sun, 17 Mar 2002 04:36:35 +0000
Subject: Renamed get_nt_error_msg() to nt_errstr(). (This used to be commit
 1f007d3ed41c1b71a89fa6be7d173e67e927c302)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 2deefd362a..5d06cf7a7e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -603,7 +603,7 @@ BOOL prs_ntstatus(char *name, prs_struct *ps, int depth, NTSTATUS *status)
 	}
 
 	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
-		 get_nt_error_msg(*status)));
+		 nt_errstr(*status)));
 
 	ps->data_offset += sizeof(uint32);
 
-- 
cgit 


From a4cce223d6873400b053872a6e3b2eb8621eea45 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Sun, 17 Mar 2002 06:04:15 +0000
Subject: Added dos_errstr() function.  Not all errors in list yet. (This used
 to be commit ddb5753e36b8c5efb48ce5c82c16d970fb8e76b6)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 5d06cf7a7e..6d65d5cc7f 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -633,7 +633,7 @@ BOOL prs_werror(char *name, prs_struct *ps, int depth, WERROR *status)
 	}
 
 	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
-		 werror_str(*status)));
+		 dos_errstr(*status)));
 
 	ps->data_offset += sizeof(uint32);
 
-- 
cgit 


From e90b65284812aaa5ff9e9935ce9bbad7791cbbcd Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Mon, 15 Jul 2002 10:35:28 +0000
Subject: updated the 3.0 branch from the head branch - ready for alpha18 (This
 used to be commit 03ac082dcb375b6f3ca3d810a6a6367542bc23ce)

---
 source3/rpc_parse/parse_prs.c | 37 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 6d65d5cc7f..2ab8c7246e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -22,6 +22,9 @@
 
 #include "includes.h"
 
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_RPC_PARSE
+
 /**
  * Dump a prs to a file: from the current location through to the end.
  **/
@@ -73,7 +76,7 @@ void prs_dump_region(char *name, int v, prs_struct *ps,
  XXXX side-effect of this function is to increase the debug depth XXXX
 
  ********************************************************************/
-void prs_debug(prs_struct *ps, int depth, char *desc, char *fn_name)
+void prs_debug(prs_struct *ps, int depth, const char *desc, char *fn_name)
 {
 	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
 }
@@ -444,6 +447,38 @@ BOOL prs_align(prs_struct *ps)
 	return True;
 }
 
+/******************************************************************
+ Align on a 2 byte boundary
+ *****************************************************************/
+ 
+BOOL prs_align_uint16(prs_struct *ps)
+{
+	BOOL ret;
+	uint8 old_align = ps->align;
+
+	ps->align = 2;
+	ret = prs_align(ps);
+	ps->align = old_align;
+	
+	return ret;
+}
+
+/******************************************************************
+ Align on a 8 byte boundary
+ *****************************************************************/
+ 
+BOOL prs_align_uint64(prs_struct *ps)
+{
+	BOOL ret;
+	uint8 old_align = ps->align;
+
+	ps->align = 8;
+	ret = prs_align(ps);
+	ps->align = old_align;
+	
+	return ret;
+}
+
 /*******************************************************************
  Align only if required (for the unistr2 string mainly)
  ********************************************************************/
-- 
cgit 


From b2edf254eda92f775e7d3d9b6793b4d77f9000b6 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 17 Aug 2002 17:00:51 +0000
Subject: sync 3.0 branch with head (This used to be commit
 3928578b52cfc949be5e0ef444fce1558d75f290)

---
 source3/rpc_parse/parse_prs.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 2ab8c7246e..4de6b88e9c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -893,9 +893,11 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
-		if (str->buffer == NULL)
-			return False;
+		if ( str->buf_len ) {
+			str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
+			if ( str->buffer == NULL )
+				return False;
+		}
 	}
 
 	p = (char *)str->buffer;
-- 
cgit 


From a834a73e341059be154426390304a42e4a011f72 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Wed, 25 Sep 2002 15:19:00 +0000
Subject: sync'ing up for 3.0alpha20 release (This used to be commit
 65e7b5273bb58802bf0c389b77f7fcae0a1f6139)

---
 source3/rpc_parse/parse_prs.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4de6b88e9c..843be33187 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1061,7 +1061,9 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 
 		len++;
 
-		dump_data(5+depth, (char *)start, len * 2);
+		DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+		print_asc(5, (unsigned char*)start, 2*len);	
+		DEBUG(5, ("\n"));
 	}
 	else { /* unmarshalling */
 	
@@ -1114,6 +1116,10 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
 			/* NULL terminate the UNISTR */
 			str->buffer[len++] = '\0';
 		}
+
+		DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+		print_asc(5, (unsigned char*)str->buffer, 2*len);	
+		DEBUG(5, ("\n"));
 	}
 
 	/* set the offset in the prs_struct; 'len' points to the
-- 
cgit 


From de474974ea25df7738dd175126e3f1de0df47ea6 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sat, 23 Nov 2002 02:52:36 +0000
Subject: Lots of fixes for error paths where tdb_fetch() data need freeing.
 Found via a post from Arcady Chernyak <Arcady.Chernyak@efi.com>. Jeremy.
 (This used to be commit 5d5762d1787db4392d2dff16024097c638b2d494)

---
 source3/rpc_parse/parse_prs.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 843be33187..d4a9ec3eda 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1274,7 +1274,8 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
     kbuf.dsize = strlen(keystr)+1;
 
     dbuf = tdb_fetch(tdb, kbuf);
-    if (!dbuf.dptr) return -1;
+    if (!dbuf.dptr)
+	    return -1;
 
     ZERO_STRUCTP(ps);
     prs_init(ps, 0, mem_ctx, UNMARSHALL);
-- 
cgit 


From 634c54310c92c48dd4eceec602e230a021bdcfc5 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Fri, 3 Jan 2003 08:28:12 +0000
Subject: Merge from HEAD - make Samba compile with -Wwrite-strings without
 additional warnings.  (Adds a lot of const).

Andrew Bartlett
(This used to be commit 3a7458f9472432ef12c43008414925fd1ce8ea0c)
---
 source3/rpc_parse/parse_prs.c | 44 +++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d4a9ec3eda..63f9527dec 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -76,7 +76,7 @@ void prs_dump_region(char *name, int v, prs_struct *ps,
  XXXX side-effect of this function is to increase the debug depth XXXX
 
  ********************************************************************/
-void prs_debug(prs_struct *ps, int depth, const char *desc, char *fn_name)
+void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
 {
 	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
 }
@@ -539,7 +539,7 @@ void prs_force_dynamic(prs_struct *ps)
  Stream a uint8.
  ********************************************************************/
 
-BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
+BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 {
 	char *q = prs_mem_get(ps, 1);
 	if (q == NULL)
@@ -561,7 +561,7 @@ BOOL prs_uint8(char *name, prs_struct *ps, int depth, uint8 *data8)
  Stream a uint16.
  ********************************************************************/
 
-BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
+BOOL prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
 {
 	char *q = prs_mem_get(ps, sizeof(uint16));
 	if (q == NULL)
@@ -590,7 +590,7 @@ BOOL prs_uint16(char *name, prs_struct *ps, int depth, uint16 *data16)
  Stream a uint32.
  ********************************************************************/
 
-BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
+BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -619,7 +619,7 @@ BOOL prs_uint32(char *name, prs_struct *ps, int depth, uint32 *data32)
  Stream a NTSTATUS
  ********************************************************************/
 
-BOOL prs_ntstatus(char *name, prs_struct *ps, int depth, NTSTATUS *status)
+BOOL prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -649,7 +649,7 @@ BOOL prs_ntstatus(char *name, prs_struct *ps, int depth, NTSTATUS *status)
  Stream a WERROR
  ********************************************************************/
 
-BOOL prs_werror(char *name, prs_struct *ps, int depth, WERROR *status)
+BOOL prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -680,7 +680,7 @@ BOOL prs_werror(char *name, prs_struct *ps, int depth, WERROR *status)
  Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
 
-BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+BOOL prs_uint8s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
 	int i;
 	char *q = prs_mem_get(ps, len);
@@ -713,7 +713,7 @@ BOOL prs_uint8s(BOOL charmode, char *name, prs_struct *ps, int depth, uint8 *dat
  Stream an array of uint16s. Length is number of uint16s.
  ********************************************************************/
 
-BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+BOOL prs_uint16s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
 	int i;
 	char *q = prs_mem_get(ps, len * sizeof(uint16));
@@ -757,7 +757,7 @@ BOOL prs_uint16s(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *d
  output must be little-endian, if marshalling, input must be little-endian.
  ********************************************************************/
 
-static void dbg_rw_punival(BOOL charmode, char *name, int depth, prs_struct *ps,
+static void dbg_rw_punival(BOOL charmode, const char *name, int depth, prs_struct *ps,
 							char *in_buf, char *out_buf, int len)
 {
 	int i;
@@ -794,7 +794,7 @@ static void dbg_rw_punival(BOOL charmode, char *name, int depth, prs_struct *ps,
  Stream a unistr. Always little endian.
  ********************************************************************/
 
-BOOL prs_uint16uni(BOOL charmode, char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+BOOL prs_uint16uni(BOOL charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
 	char *q = prs_mem_get(ps, len * sizeof(uint16));
 	if (q == NULL)
@@ -810,7 +810,7 @@ BOOL prs_uint16uni(BOOL charmode, char *name, prs_struct *ps, int depth, uint16
  Stream an array of uint32s. Length is number of uint32s.
  ********************************************************************/
 
-BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
+BOOL prs_uint32s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
 	int i;
 	char *q = prs_mem_get(ps, len * sizeof(uint32));
@@ -854,7 +854,7 @@ BOOL prs_uint32s(BOOL charmode, char *name, prs_struct *ps, int depth, uint32 *d
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *str)
+BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUFFER5 *str)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
@@ -885,7 +885,7 @@ BOOL prs_buffer5(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER5 *
  in byte chars. String is in little-endian format.
  ********************************************************************/
 
-BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *str)
+BOOL prs_buffer2(BOOL charmode, const char *name, prs_struct *ps, int depth, BUFFER2 *str)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->buf_len);
@@ -913,7 +913,7 @@ BOOL prs_buffer2(BOOL charmode, char *name, prs_struct *ps, int depth, BUFFER2 *
  in uint8 chars.
  ********************************************************************/
 
-BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *str)
+BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
 {
 	int i;
 	char *q = prs_mem_get(ps, str->str_max_len);
@@ -953,7 +953,7 @@ BOOL prs_string2(BOOL charmode, char *name, prs_struct *ps, int depth, STRING2 *
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *str)
+BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
@@ -984,7 +984,7 @@ BOOL prs_unistr2(BOOL charmode, char *name, prs_struct *ps, int depth, UNISTR2 *
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int depth)
+BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
@@ -1010,7 +1010,7 @@ BOOL prs_unistr3(BOOL charmode, char *name, UNISTR3 *str, prs_struct *ps, int de
  in little-endian format then do it as a stream of bytes.
  ********************************************************************/
 
-BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
+BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	int len = 0;
 	unsigned char *p = (unsigned char *)str->buffer;
@@ -1136,7 +1136,7 @@ BOOL prs_unistr(char *name, prs_struct *ps, int depth, UNISTR *str)
  not include the null-termination character.
  ********************************************************************/
 
-BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
+BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
 {
 	char *q;
 	int i;
@@ -1173,7 +1173,7 @@ BOOL prs_string(char *name, prs_struct *ps, int depth, char *str, int len, int m
  uint16 should be stored, or gets the size if reading.
  ********************************************************************/
 
-BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
+BOOL prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
 	*offset = ps->data_offset;
 	if (UNMARSHALLING(ps)) {
@@ -1193,7 +1193,7 @@ BOOL prs_uint16_pre(char *name, prs_struct *ps, int depth, uint16 *data16, uint3
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 
-BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
+BOOL prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16,
 				uint32 ptr_uint16, uint32 start_offset)
 {
 	if (MARSHALLING(ps)) {
@@ -1220,7 +1220,7 @@ BOOL prs_uint16_post(char *name, prs_struct *ps, int depth, uint16 *data16,
  uint32 should be stored, or gets the size if reading.
  ********************************************************************/
 
-BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+BOOL prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
 	*offset = ps->data_offset;
 	if (UNMARSHALLING(ps) && (data32 != NULL)) {
@@ -1237,7 +1237,7 @@ BOOL prs_uint32_pre(char *name, prs_struct *ps, int depth, uint32 *data32, uint3
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 
-BOOL prs_uint32_post(char *name, prs_struct *ps, int depth, uint32 *data32,
+BOOL prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32,
 				uint32 ptr_uint32, uint32 data_size)
 {
 	if (MARSHALLING(ps)) {
-- 
cgit 


From 4242eda183393b0535ac8ef880b4f441c60137af Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Wed, 15 Jan 2003 17:22:48 +0000
Subject: merging some rpcclient and net functionality from HEAD (This used to
 be commit 7a4c87484237308cb3ad0d671687da7e0f6e733b)

---
 source3/rpc_parse/parse_prs.c | 19 -------------------
 1 file changed, 19 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 63f9527dec..6f6117a9e2 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -115,25 +115,6 @@ BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 	return True;
 }
 
-/*******************************************************************
- read from a socket into memory.
- ********************************************************************/
-BOOL prs_read(prs_struct *ps, int fd, size_t len, int timeout)
-{
-	BOOL ok;
-	size_t prev_size = ps->buffer_size;
-	if (!prs_grow(ps, len))
-		return False;
-
-	if (timeout > 0) {
-		ok = (read_with_timeout(fd, &ps->data_p[prev_size],
-		                            len, len,timeout) == len);
-	} else {
-		ok = (read_data(fd, &ps->data_p[prev_size], len) == len);
-	}
-	return ok;
-}
-
 /*******************************************************************
  Delete the memory in a parse structure - if we own it.
  ********************************************************************/
-- 
cgit 


From 8fc1f1aead6db996a6d96efdc5f81779afc9c8d2 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 14 Feb 2003 22:55:46 +0000
Subject: Ensure that only parse_prs.c access internal members of the
 prs_struct. Needed to move to disk based i/o later. Jeremy. (This used to be
 commit a823fee5b41a5b6cd4ef05aa1f85f7725bd272a5)

---
 source3/rpc_parse/parse_prs.c | 66 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 54 insertions(+), 12 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 6f6117a9e2..702375be35 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -134,7 +134,8 @@ void prs_mem_free(prs_struct *ps)
 
 void prs_mem_clear(prs_struct *ps)
 {
-	memset(ps->data_p, '\0', (size_t)ps->buffer_size);
+	if (ps->buffer_size)
+		memset(ps->data_p, '\0', (size_t)ps->buffer_size);
 }
 
 /*******************************************************************
@@ -143,11 +144,13 @@ void prs_mem_clear(prs_struct *ps)
 
 char *prs_alloc_mem(prs_struct *ps, size_t size)
 {
-	char *ret = talloc(ps->mem_ctx, size);
-
-	if (ret)
-		memset(ret, '\0', size);
+	char *ret = NULL;
 
+	if (size) {
+		ret = talloc(ps->mem_ctx, size);
+		if (ret)
+			memset(ret, '\0', size);
+	}
 	return ret;
 }
 
@@ -308,7 +311,7 @@ BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 
 /*******************************************************************
  Get the data pointer (external interface).
- ********************************************************************/
+********************************************************************/
 
 char *prs_data_p(prs_struct *ps)
 {
@@ -357,10 +360,13 @@ BOOL prs_set_offset(prs_struct *ps, uint32 offset)
 
 BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
 {
+	if (prs_offset(src) == 0)
+		return True;
+
 	if(!prs_grow(dst, prs_offset(src)))
 		return False;
 
-	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src), (size_t)prs_offset(src));
+	memcpy(&dst->data_p[dst->data_offset], src->data_p, (size_t)prs_offset(src));
 	dst->data_offset += prs_offset(src);
 
 	return True;
@@ -378,7 +384,7 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
 	if(!prs_grow(dst, len))
 		return False;
 	
-	memcpy(&dst->data_p[dst->data_offset], prs_data_p(src)+start, (size_t)len);
+	memcpy(&dst->data_p[dst->data_offset], src->data_p + start, (size_t)len);
 	dst->data_offset += len;
 
 	return True;
@@ -388,8 +394,11 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
  Append the data from a buffer into a parse_struct.
  ********************************************************************/
 
-BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
+BOOL prs_copy_data_in(prs_struct *dst, char *src, uint32 len)
 {
+	if (len == 0)
+		return True;
+
 	if(!prs_grow(dst, len))
 		return False;
 
@@ -399,6 +408,39 @@ BOOL prs_append_data(prs_struct *dst, char *src, uint32 len)
 	return True;
 }
 
+/*******************************************************************
+ Copy some data from a parse_struct into a buffer.
+ ********************************************************************/
+
+BOOL prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
+{
+	if (len == 0)
+		return True;
+
+	if(!prs_mem_get(src, len))
+		return False;
+
+	memcpy(dst, &src->data_p[src->data_offset], (size_t)len);
+	src->data_offset += len;
+
+	return True;
+}
+
+/*******************************************************************
+ Copy all the data from a parse_struct into a buffer.
+ ********************************************************************/
+
+BOOL prs_copy_all_data_out(char *dst, prs_struct *src)
+{
+	uint32 len = prs_offset(src);
+
+	if (!len)
+		return True;
+
+	prs_set_offset(src, 0);
+	return prs_copy_data_out(dst, src, len);
+}
+
 /*******************************************************************
  Set the data as X-endian (external interface).
  ********************************************************************/
@@ -1049,7 +1091,7 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 	else { /* unmarshalling */
 	
 		uint32 alloc_len = 0;
-		q = prs_data_p(ps) + prs_offset(ps);
+		q = ps->data_p + prs_offset(ps);
 
 		/*
 		 * Work out how much space we need and talloc it.
@@ -1242,7 +1284,7 @@ int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
     TDB_DATA kbuf, dbuf;
     kbuf.dptr = keystr;
     kbuf.dsize = strlen(keystr)+1;
-    dbuf.dptr = prs_data_p(ps);
+    dbuf.dptr = ps->data_p;
     dbuf.dsize = prs_offset(ps);
     return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
 }
@@ -1272,7 +1314,7 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 {
 	char *q;
 
-	q = prs_data_p(ps);
+	q = ps->data_p;
         q = &q[offset];
 
 #ifdef DEBUG_PASSWORD
-- 
cgit 


From e88eab35bc03a2d108b27f2209ec4cfb395dcdba Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 17 Mar 2003 23:04:03 +0000
Subject: Merge from HEAD:

signed/unsigned (mostly i counters)

a little bit of const.

Andrew Bartlett
(This used to be commit 50f0ca752e5058c4051f42a9337361373ba1f727)
---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 702375be35..aeaa42ac92 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -938,7 +938,7 @@ BOOL prs_buffer2(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
 
 BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
 {
-	int i;
+	unsigned int i;
 	char *q = prs_mem_get(ps, str->str_max_len);
 	if (q == NULL)
 		return False;
@@ -1035,7 +1035,7 @@ BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps,
 
 BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 {
-	int len = 0;
+	unsigned int len = 0;
 	unsigned char *p = (unsigned char *)str->buffer;
 	uint8 *start;
 	char *q;
-- 
cgit 


From d3b8ac6f96889c3dc9137a6b24f351e8df9c23cb Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Wed, 9 Apr 2003 09:31:29 +0000
Subject: Put the core schannel functions to parse_prs.c. They are also used by
 schannel clients.

Volker
(This used to be commit 0f348a35d09ff020837119157ef7f4b9e6f07643)
---
 source3/rpc_parse/parse_prs.c | 182 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 182 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index aeaa42ac92..a22ae1bacd 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1330,3 +1330,185 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 
 	return True;
 }
+
+static void netsechash(uchar * key, uchar * data, int data_len)
+{
+	uchar hash[256];
+	uchar index_i = 0;
+	uchar index_j = 0;
+	uchar j = 0;
+	int ind;
+
+	for (ind = 0; ind < 256; ind++)
+	{
+		hash[ind] = (uchar) ind;
+	}
+
+	for (ind = 0; ind < 256; ind++)
+	{
+		uchar tc;
+
+		j += (hash[ind] + key[ind % 16]);
+
+		tc = hash[ind];
+		hash[ind] = hash[j];
+		hash[j] = tc;
+	}
+
+	for (ind = 0; ind < data_len; ind++)
+	{
+		uchar tc;
+		uchar t;
+
+		index_i++;
+		index_j += hash[index_i];
+
+		tc = hash[index_i];
+		hash[index_i] = hash[index_j];
+		hash[index_j] = tc;
+
+		t = hash[index_i] + hash[index_j];
+		data[ind] ^= hash[t];
+	}
+}
+
+void dump_data_pw(const char *msg, const uchar * data, size_t len)
+{
+#ifdef DEBUG_PASSWORD
+	DEBUG(11, ("%s", msg));
+	if (data != NULL && len > 0)
+	{
+		dump_data(11, data, len);
+	}
+#endif
+}
+
+void netsec_encode(struct netsec_auth_struct *a,
+		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
+{
+	uchar dataN[4];
+	uchar digest1[16];
+	struct MD5Context ctx3;
+	uchar sess_kf0[16];
+	int i;
+
+	/* store the sequence number */
+	SIVAL(dataN, 0, a->seq_num);
+
+	for (i = 0; i < sizeof(sess_kf0); i++)
+	{
+		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
+	}
+
+	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
+	dump_data_pw("a->seq_num :\n", dataN, sizeof(dataN));
+
+	MD5Init(&ctx3);
+	MD5Update(&ctx3, dataN, 0x4);
+	MD5Update(&ctx3, verf->sig, 8);
+
+	MD5Update(&ctx3, verf->data8, 8);
+
+	dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
+	dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
+
+	hmac_md5(sess_kf0, dataN, 0x4, digest1);
+	dump_data_pw("digest1 (ebp-8):\n", digest1, sizeof(digest1));
+	hmac_md5(digest1, verf->data3, 8, digest1);
+	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
+	netsechash(digest1, verf->data8, 8);
+
+	dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
+
+	dump_data_pw("data   :\n", data, data_len);
+	MD5Update(&ctx3, data, data_len);
+
+	{
+		char digest_tmp[16];
+		char digest2[16];
+		MD5Final(digest_tmp, &ctx3);
+		hmac_md5(a->sess_key, digest_tmp, 16, digest2);
+		dump_data_pw("digest_tmp:\n", digest_tmp, sizeof(digest_tmp));
+		dump_data_pw("digest:\n", digest2, sizeof(digest2));
+		memcpy(verf->data1, digest2, sizeof(verf->data1));
+	}
+
+	netsechash(digest1, data, data_len);
+	dump_data_pw("data:\n", data, data_len);
+
+	hmac_md5(a->sess_key, dataN, 0x4, digest1);
+	dump_data_pw("ctx:\n", digest1, sizeof(digest1));
+
+	hmac_md5(digest1, verf->data1, 8, digest1);
+
+	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
+
+	dump_data_pw("verf->data3:\n", verf->data3, sizeof(verf->data3));
+	netsechash(digest1, verf->data3, 8);
+	dump_data_pw("verf->data3:\n", verf->data3, sizeof(verf->data3));
+
+	return;
+}
+
+BOOL netsec_decode(struct netsec_auth_struct *a,
+		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
+{
+	uchar dataN[4];
+	uchar digest1[16];
+	struct MD5Context ctx3;
+	uchar sess_kf0[16];
+	int i;
+
+	/* store the sequence number */
+	SIVAL(dataN, 0, a->seq_num);
+
+	for (i = 0; i < sizeof(sess_kf0); i++)
+	{
+		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
+	}
+
+	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
+	dump_data_pw("a->seq_num :\n", dataN, sizeof(dataN));
+	hmac_md5(a->sess_key, dataN, 0x4, digest1);
+	dump_data_pw("ctx:\n", digest1, sizeof(digest1));
+
+	hmac_md5(digest1, verf->data1, 8, digest1);
+
+	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
+	dump_data_pw("verf->data3:\n", verf->data3, sizeof(verf->data3));
+	netsechash(digest1, verf->data3, 8);
+	dump_data_pw("verf->data3_dec:\n", verf->data3, sizeof(verf->data3));
+
+	MD5Init(&ctx3);
+	MD5Update(&ctx3, dataN, 0x4);
+	MD5Update(&ctx3, verf->sig, 8);
+
+	dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
+
+	hmac_md5(sess_kf0, dataN, 0x4, digest1);
+	dump_data_pw("digest1 (ebp-8):\n", digest1, sizeof(digest1));
+	hmac_md5(digest1, verf->data3, 8, digest1);
+	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
+
+	dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
+	netsechash(digest1, verf->data8, 8);
+	dump_data_pw("verf->data8_dec:\n", verf->data8, sizeof(verf->data8));
+	MD5Update(&ctx3, verf->data8, 8);
+
+	dump_data_pw("data   :\n", data, data_len);
+	netsechash(digest1, data, data_len);
+	dump_data_pw("datadec:\n", data, data_len);
+
+	MD5Update(&ctx3, data, data_len);
+	{
+		uchar digest_tmp[16];
+		MD5Final(digest_tmp, &ctx3);
+		hmac_md5(a->sess_key, digest_tmp, 16, digest1);
+		dump_data_pw("digest_tmp:\n", digest_tmp, sizeof(digest_tmp));
+	}
+
+	dump_data_pw("digest:\n", digest1, sizeof(digest1));
+	dump_data_pw("verf->data1:\n", verf->data1, sizeof(verf->data1));
+
+	return memcmp(digest1, verf->data1, sizeof(verf->data1)) == 0;
+}
-- 
cgit 


From 09a50497d1360659eb8bd1b9f4be510680267bd2 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 16 Apr 2003 15:39:57 +0000
Subject: Fixes to make SCHANNEL work in 3.0 against a W2K DC. Still need to
 fix multi-PDU encode/decode with SCHANNEL. Also need to test against WNT DC.
 Jeremy. (This used to be commit ff66d4097088409205b6bad5124a78ef9946010d)

---
 source3/rpc_parse/parse_prs.c | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index a22ae1bacd..696142905b 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1392,14 +1392,13 @@ void netsec_encode(struct netsec_auth_struct *a,
 	uchar sess_kf0[16];
 	int i;
 
-	/* store the sequence number */
-	SIVAL(dataN, 0, a->seq_num);
+	SIVAL(dataN, 0, 0);
 
-	for (i = 0; i < sizeof(sess_kf0); i++)
-	{
+	for (i = 0; i < sizeof(sess_kf0); i++) {
 		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
 	}
 
+	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%d\n", a->seq_num, data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 	dump_data_pw("a->seq_num :\n", dataN, sizeof(dataN));
 
@@ -1459,14 +1458,13 @@ BOOL netsec_decode(struct netsec_auth_struct *a,
 	uchar sess_kf0[16];
 	int i;
 
-	/* store the sequence number */
-	SIVAL(dataN, 0, a->seq_num);
+	SIVAL(dataN, 0, 0);
 
-	for (i = 0; i < sizeof(sess_kf0); i++)
-	{
+	for (i = 0; i < sizeof(sess_kf0); i++) {
 		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
 	}
 
+	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%d\n", a->seq_num, data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 	dump_data_pw("a->seq_num :\n", dataN, sizeof(dataN));
 	hmac_md5(a->sess_key, dataN, 0x4, digest1);
-- 
cgit 


From e15dfd44c912bf9a567a13cbbec63c4ecbabaed4 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Tue, 22 Apr 2003 15:54:36 +0000
Subject: parse_string is only used for the authentication negotiators.

It can itself determine the length of the string it has to
transfer. Andrew B., could you take a look at the length calculation?
Is that safe?

Thanks,

Volker
(This used to be commit 0ef69b586a8f1fa11a41a3900180ea2090b60bfd)
---
 source3/rpc_parse/parse_prs.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 696142905b..e0a75d7382 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1159,10 +1159,16 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
  not include the null-termination character.
  ********************************************************************/
 
-BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int len, int max_buf_size)
+BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
 {
 	char *q;
 	int i;
+	int len;
+
+	if (UNMARSHALLING(ps))
+		len = strlen(&ps->data_p[ps->data_offset]);
+	else
+		len = strlen(str);
 
 	len = MIN(len, (max_buf_size-1));
 
-- 
cgit 


From 0d3097c135e382f3540b2bb0fef0497af16d7344 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Mon, 26 May 2003 06:59:38 +0000
Subject: This fixes net rpc vampire when talking to win2k (<sp3).  win2k sends
 back a different sized blob of encrypted password data then we were
 expecting.  There's an extra 32 bytes of unknown stuff. (This used to be
 commit 285952fd626b02362fb6732f90c5a3ce0d2d5ae0)

---
 source3/rpc_parse/parse_prs.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index e0a75d7382..88150c718b 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1316,7 +1316,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
 /*******************************************************************
  hash a stream.
  ********************************************************************/
-BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
+BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
 {
 	char *q;
 
@@ -1326,12 +1326,12 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16])
 #ifdef DEBUG_PASSWORD
 	DEBUG(100, ("prs_hash1\n"));
 	dump_data(100, sess_key, 16);
-	dump_data(100, q, 68);
+	dump_data(100, q, len);
 #endif
-	SamOEMhash((uchar *) q, sess_key, 68);
+	SamOEMhash((uchar *) q, sess_key, len);
 
 #ifdef DEBUG_PASSWORD
-	dump_data(100, q, 68);
+	dump_data(100, q, len);
 #endif
 
 	return True;
-- 
cgit 


From 456f51bcbe04ccbb37a27b6e115a851cc134adcd Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Mon, 14 Jul 2003 08:46:32 +0000
Subject: Jeremy requested that I get my NTLMSSP patch into CVS.  He didn't
 request the schannel code, but I've included that anyway. :-)

This patch revives the client-side NTLMSSP support for RPC named pipes
in Samba, and cleans up the client and server schannel code.  The use of the
new code is enabled by the 'sign', 'seal' and 'schannel' commands in
rpcclient.

The aim was to prove that our separate NTLMSSP client library actually
implements NTLMSSP signing and sealing as per Microsoft's NTLMv1 implementation,
in the hope that knowing this will assist us in correctly implementing
NTLMSSP signing for SMB packets.  (Still not yet functional)

This patch replaces the NTLMSSP implementation in rpc_client/cli_pipe.c with
calls to libsmb/ntlmssp.c.  In the process, we have gained the ability to
use the more secure NT password, and the ability to sign-only, instead of
having to seal the pipe connection.  (Previously we were limited to sealing,
and could only use the LM-password derived key).

Our new client-side NTLMSSP code also needed alteration to cope with our
comparatively simple server-side implementation.  A future step is to replace
it with calls to the same NTLMSSP library.

Also included in this patch is the schannel 'sign only' patch I submitted to
the team earlier.  While not enabled (and not functional, at this stage) the
work in this patch makes the code paths *much* easier to follow.  I have also
included similar hooks in rpccleint to allow the use of schannel on *any* pipe.

rpcclient now defaults to not using schannel (or any other extra per-pipe
authenticiation) for any connection.  The 'schannel' command enables schannel
for all pipes until disabled.

This code is also much more secure than the previous code, as changes to our
cli_pipe routines ensure that the authentication footer cannot be removed
by an attacker, and more error states are correctly handled.

(The same needs to be done to our server)

Andrew Bartlett
(This used to be commit 5472ddc9eaf4e79c5b2e1c8ee8c7f190dc285f19)
---
 source3/rpc_parse/parse_prs.c | 270 +++++++++++++++++++++++++++---------------
 1 file changed, 175 insertions(+), 95 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 88150c718b..efd4914c66 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1378,141 +1378,221 @@ static void netsechash(uchar * key, uchar * data, int data_len)
 	}
 }
 
-void dump_data_pw(const char *msg, const uchar * data, size_t len)
+
+/*******************************************************************
+ Create a digest over the entire packet (including the data), and 
+ MD5 it with the session key.
+ ********************************************************************/
+static void netsec_digest(struct netsec_auth_struct *a,
+			  int auth_flags,
+			  RPC_AUTH_NETSEC_CHK * verf,
+			  char *data, size_t data_len,
+			  uchar digest_final[16]) 
 {
-#ifdef DEBUG_PASSWORD
-	DEBUG(11, ("%s", msg));
-	if (data != NULL && len > 0)
-	{
-		dump_data(11, data, len);
+	uchar whole_packet_digest[16];
+	static uchar zeros[4];
+	struct MD5Context ctx3;
+	
+	/* verfiy the signature on the packet by MD5 over various bits */
+	MD5Init(&ctx3);
+	/* use our sequence number, which ensures the packet is not
+	   out of order */
+	MD5Update(&ctx3, zeros, sizeof(zeros));
+	MD5Update(&ctx3, verf->sig, sizeof(verf->sig));
+	if (auth_flags & AUTH_PIPE_SEAL) {
+		MD5Update(&ctx3, verf->data8, sizeof(verf->data8));
 	}
-#endif
+	MD5Update(&ctx3, data, data_len);
+	MD5Final(whole_packet_digest, &ctx3);
+	dump_data_pw("whole_packet_digest:\n", whole_packet_digest, sizeof(whole_packet_digest));
+	
+	/* MD5 this result and the session key, to prove that
+	   only a valid client could had produced this */
+	hmac_md5(a->sess_key, whole_packet_digest, sizeof(whole_packet_digest), digest_final);
 }
 
-void netsec_encode(struct netsec_auth_struct *a,
-		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
+/*******************************************************************
+ Calculate the key with which to encode the data payload 
+ ********************************************************************/
+static void netsec_get_sealing_key(struct netsec_auth_struct *a,
+				   RPC_AUTH_NETSEC_CHK *verf,
+				   uchar sealing_key[16]) 
 {
-	uchar dataN[4];
-	uchar digest1[16];
-	struct MD5Context ctx3;
+	static uchar zeros[4];
+	uchar digest2[16];
 	uchar sess_kf0[16];
 	int i;
 
-	SIVAL(dataN, 0, 0);
-
 	for (i = 0; i < sizeof(sess_kf0); i++) {
 		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
 	}
+	
+	dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
+	
+	/* MD5 of sess_kf0 and the high bytes of the sequence number */
+	hmac_md5(sess_kf0, zeros, 0x4, digest2);
+	dump_data_pw("digest2:\n", digest2, sizeof(digest2));
+	
+	/* MD5 of the above result, plus 8 bytes of sequence number */
+	hmac_md5(digest2, verf->seq_num, sizeof(verf->seq_num), sealing_key);
+	dump_data_pw("sealing_key:\n", sealing_key, 16);
+}
 
-	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%d\n", a->seq_num, data_len));
-	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
-	dump_data_pw("a->seq_num :\n", dataN, sizeof(dataN));
+/*******************************************************************
+ Encode or Decode the sequence number (which is symmetric)
+ ********************************************************************/
+static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
+				     RPC_AUTH_NETSEC_CHK *verf)
+{
+	static uchar zeros[4];
+	uchar sequence_key[16];
+	uchar digest1[16];
 
-	MD5Init(&ctx3);
-	MD5Update(&ctx3, dataN, 0x4);
-	MD5Update(&ctx3, verf->sig, 8);
+	hmac_md5(a->sess_key, zeros, sizeof(zeros), digest1);
+	dump_data_pw("(sequence key) digest1:\n", digest1, sizeof(digest1));
 
-	MD5Update(&ctx3, verf->data8, 8);
+	hmac_md5(digest1, verf->packet_digest, 8, sequence_key);
 
-	dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
-	dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
+	dump_data_pw("sequence_key:\n", sequence_key, sizeof(sequence_key));
 
-	hmac_md5(sess_kf0, dataN, 0x4, digest1);
-	dump_data_pw("digest1 (ebp-8):\n", digest1, sizeof(digest1));
-	hmac_md5(digest1, verf->data3, 8, digest1);
-	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
-	netsechash(digest1, verf->data8, 8);
+	dump_data_pw("seq_num (before):\n", verf->seq_num, sizeof(verf->seq_num));
+	netsechash(sequence_key, verf->seq_num, 8);
+	dump_data_pw("seq_num (after):\n", verf->seq_num, sizeof(verf->seq_num));
+}
 
-	dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
 
-	dump_data_pw("data   :\n", data, data_len);
-	MD5Update(&ctx3, data, data_len);
+/*******************************************************************
+ Encode a blob of data using the netsec (schannel) alogrithm, also produceing
+ a checksum over the original data.  We currently only support
+ signing and sealing togeather - the signing-only code is close, but not
+ quite compatible with what MS does.
+ ********************************************************************/
+void netsec_encode(struct netsec_auth_struct *a, int auth_flags, 
+		   enum netsec_direction direction,
+		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
+{
+	uchar digest_final[16];
 
-	{
-		char digest_tmp[16];
-		char digest2[16];
-		MD5Final(digest_tmp, &ctx3);
-		hmac_md5(a->sess_key, digest_tmp, 16, digest2);
-		dump_data_pw("digest_tmp:\n", digest_tmp, sizeof(digest_tmp));
-		dump_data_pw("digest:\n", digest2, sizeof(digest2));
-		memcpy(verf->data1, digest2, sizeof(verf->data1));
+	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%d\n", a->seq_num, data_len));
+	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
+
+	RSIVAL(verf->seq_num, 0, a->seq_num);
+
+	switch (direction) {
+	case SENDER_IS_INITIATOR:
+		SIVAL(verf->seq_num, 4, 0x80);
+		break;
+	case SENDER_IS_ACCEPTOR:
+		SIVAL(verf->seq_num, 4, 0x0);
+		break;
 	}
 
-	netsechash(digest1, data, data_len);
-	dump_data_pw("data:\n", data, data_len);
+	dump_data_pw("verf->seq_num:\n", verf->seq_num, sizeof(verf->seq_num));
 
-	hmac_md5(a->sess_key, dataN, 0x4, digest1);
-	dump_data_pw("ctx:\n", digest1, sizeof(digest1));
+	/* produce a digest of the packet to prove it's legit (before we seal it) */
+	netsec_digest(a, auth_flags, verf, data, data_len, digest_final);
+	memcpy(verf->packet_digest, digest_final, sizeof(verf->packet_digest));
 
-	hmac_md5(digest1, verf->data1, 8, digest1);
+	if (auth_flags & AUTH_PIPE_SEAL) {
+		uchar sealing_key[16];
 
-	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
+		/* get the key to encode the data with */
+		netsec_get_sealing_key(a, verf, sealing_key);
 
-	dump_data_pw("verf->data3:\n", verf->data3, sizeof(verf->data3));
-	netsechash(digest1, verf->data3, 8);
-	dump_data_pw("verf->data3:\n", verf->data3, sizeof(verf->data3));
+		/* encode the verification data */
+		dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
+		netsechash(sealing_key, verf->data8, 8);
+
+		dump_data_pw("verf->data8_enc:\n", verf->data8, sizeof(verf->data8));
+		
+		/* encode the packet payload */
+		dump_data_pw("data:\n", data, data_len);
+		netsechash(sealing_key, data, data_len);
+		dump_data_pw("data_enc:\n", data, data_len);
+	}
+
+	/* encode the sequence number (key based on packet digest) */
+	/* needs to be done after the sealing, as the original version 
+	   is used in the sealing stuff... */
+	netsec_deal_with_seq_num(a, verf);
 
 	return;
 }
 
-BOOL netsec_decode(struct netsec_auth_struct *a,
+/*******************************************************************
+ Decode a blob of data using the netsec (schannel) alogrithm, also verifiying
+ a checksum over the original data.  We currently can verify signed messages,
+ as well as decode sealed messages
+ ********************************************************************/
+
+BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
+		   enum netsec_direction direction, 
 		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
 {
-	uchar dataN[4];
-	uchar digest1[16];
-	struct MD5Context ctx3;
-	uchar sess_kf0[16];
-	int i;
-
-	SIVAL(dataN, 0, 0);
-
-	for (i = 0; i < sizeof(sess_kf0); i++) {
-		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
+	uchar digest_final[16];
+
+	/* Create the expected sequence number for comparison */
+	uchar seq_num[8];
+	RSIVAL(seq_num, 0, a->seq_num);
+
+	switch (direction) {
+	case SENDER_IS_INITIATOR:
+		SIVAL(seq_num, 4, 0x80);
+		break;
+	case SENDER_IS_ACCEPTOR:
+		SIVAL(seq_num, 4, 0x0);
+		break;
 	}
 
 	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%d\n", a->seq_num, data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
-	dump_data_pw("a->seq_num :\n", dataN, sizeof(dataN));
-	hmac_md5(a->sess_key, dataN, 0x4, digest1);
-	dump_data_pw("ctx:\n", digest1, sizeof(digest1));
-
-	hmac_md5(digest1, verf->data1, 8, digest1);
-
-	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
-	dump_data_pw("verf->data3:\n", verf->data3, sizeof(verf->data3));
-	netsechash(digest1, verf->data3, 8);
-	dump_data_pw("verf->data3_dec:\n", verf->data3, sizeof(verf->data3));
-
-	MD5Init(&ctx3);
-	MD5Update(&ctx3, dataN, 0x4);
-	MD5Update(&ctx3, verf->sig, 8);
-
-	dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
 
-	hmac_md5(sess_kf0, dataN, 0x4, digest1);
-	dump_data_pw("digest1 (ebp-8):\n", digest1, sizeof(digest1));
-	hmac_md5(digest1, verf->data3, 8, digest1);
-	dump_data_pw("netsechashkey:\n", digest1, sizeof(digest1));
+	dump_data_pw("seq_num:\n", seq_num, sizeof(seq_num));
 
-	dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
-	netsechash(digest1, verf->data8, 8);
-	dump_data_pw("verf->data8_dec:\n", verf->data8, sizeof(verf->data8));
-	MD5Update(&ctx3, verf->data8, 8);
+	/* extract the sequence number (key based on supplied packet digest) */
+	/* needs to be done before the sealing, as the original version 
+	   is used in the sealing stuff... */
+	netsec_deal_with_seq_num(a, verf);
 
-	dump_data_pw("data   :\n", data, data_len);
-	netsechash(digest1, data, data_len);
-	dump_data_pw("datadec:\n", data, data_len);
+	if (memcmp(verf->seq_num, seq_num, sizeof(seq_num))) {
+		/* don't even bother with the below if the sequence number is out */
+		/* The sequence number is MD5'ed with a key based on the whole-packet
+		   digest, as supplied by the client.  We check that it's a valid 
+		   checksum after the decode, below
+		*/
+		return False;
+	}
 
-	MD5Update(&ctx3, data, data_len);
-	{
-		uchar digest_tmp[16];
-		MD5Final(digest_tmp, &ctx3);
-		hmac_md5(a->sess_key, digest_tmp, 16, digest1);
-		dump_data_pw("digest_tmp:\n", digest_tmp, sizeof(digest_tmp));
+	if (auth_flags & AUTH_PIPE_SEAL) {
+		uchar sealing_key[16];
+		
+		/* get the key to extract the data with */
+		netsec_get_sealing_key(a, verf, sealing_key);
+
+		/* extract the verification data */
+		dump_data_pw("verf->data8:\n", verf->data8, 
+			     sizeof(verf->data8));
+		netsechash(sealing_key, verf->data8, 8);
+
+		dump_data_pw("verf->data8_dec:\n", verf->data8, 
+			     sizeof(verf->data8));
+		
+		/* extract the packet payload */
+		dump_data_pw("data   :\n", data, data_len);
+		netsechash(sealing_key, data, data_len);
+		dump_data_pw("datadec:\n", data, data_len);	
 	}
 
-	dump_data_pw("digest:\n", digest1, sizeof(digest1));
-	dump_data_pw("verf->data1:\n", verf->data1, sizeof(verf->data1));
+	/* digest includes 'data' after unsealing */
+	netsec_digest(a, auth_flags, verf, data, data_len, digest_final);
 
-	return memcmp(digest1, verf->data1, sizeof(verf->data1)) == 0;
+	dump_data_pw("Calculated digest:\n", digest_final, 
+		     sizeof(digest_final));
+	dump_data_pw("verf->packet_digest:\n", verf->packet_digest, 
+		     sizeof(verf->packet_digest));
+	
+	/* compare - if the client got the same result as us, then
+	   it must know the session key */
+	return (memcmp(digest_final, verf->packet_digest, 
+		       sizeof(verf->packet_digest)) == 0);
 }
-- 
cgit 


From 77373f1f8e3b2f61e9bbcd9fadfb83257d390cf2 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Thu, 24 Jul 2003 23:46:27 +0000
Subject: More printf fixes - size_t is long on some architectures. (This used
 to be commit ba4d334b822248d8ab929c9568533431603d967e)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index efd4914c66..25c44c9da9 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1473,7 +1473,7 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 {
 	uchar digest_final[16];
 
-	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%d\n", a->seq_num, data_len));
+	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%l\n", a->seq_num, data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
 	RSIVAL(verf->seq_num, 0, a->seq_num);
@@ -1544,7 +1544,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		break;
 	}
 
-	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%d\n", a->seq_num, data_len));
+	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%l\n", a->seq_num, data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
 	dump_data_pw("seq_num:\n", seq_num, sizeof(seq_num));
-- 
cgit 


From 7d833de662b83f026b54a236588da27dd8899630 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Fri, 25 Jul 2003 04:24:40 +0000
Subject: More printf portability fixes.  Got caught out by some gcc'isms last
 time.  )-: (This used to be commit 59dae1da66a5eb7e128263bd578f167d8746e9f0)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 25c44c9da9..11d8658b15 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1473,7 +1473,7 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 {
 	uchar digest_final[16];
 
-	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%l\n", a->seq_num, data_len));
+	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
 	RSIVAL(verf->seq_num, 0, a->seq_num);
@@ -1544,7 +1544,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		break;
 	}
 
-	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%l\n", a->seq_num, data_len));
+	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
 	dump_data_pw("seq_num:\n", seq_num, sizeof(seq_num));
-- 
cgit 


From 225048e2e67e85ac6ff33ed4984435ffb7ccab62 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Tue, 12 Aug 2003 05:01:24 +0000
Subject: Fix comment (This used to be commit
 024d32f79390210bee6da8e75c228a4aaa7fe6b0)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 11d8658b15..90fce9eb9d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1429,7 +1429,7 @@ static void netsec_get_sealing_key(struct netsec_auth_struct *a,
 	
 	dump_data_pw("sess_kf0:\n", sess_kf0, sizeof(sess_kf0));
 	
-	/* MD5 of sess_kf0 and the high bytes of the sequence number */
+	/* MD5 of sess_kf0 and 4 zero bytes */
 	hmac_md5(sess_kf0, zeros, 0x4, digest2);
 	dump_data_pw("digest2:\n", digest2, sizeof(digest2));
 	
-- 
cgit 


From aa39cc37dab9c4f8c3295d872bb8cc143890b378 Mon Sep 17 00:00:00 2001
From: Herb Lewis <herb@samba.org>
Date: Fri, 15 Aug 2003 04:42:05 +0000
Subject: get rid of more compiler warnings (This used to be commit
 398bd14fc6e2f8ab2f34211270e179b8928a6669)

---
 source3/rpc_parse/parse_prs.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 90fce9eb9d..81a9573077 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1402,7 +1402,7 @@ static void netsec_digest(struct netsec_auth_struct *a,
 	if (auth_flags & AUTH_PIPE_SEAL) {
 		MD5Update(&ctx3, verf->data8, sizeof(verf->data8));
 	}
-	MD5Update(&ctx3, data, data_len);
+	MD5Update(&ctx3, (const unsigned char *)data, data_len);
 	MD5Final(whole_packet_digest, &ctx3);
 	dump_data_pw("whole_packet_digest:\n", whole_packet_digest, sizeof(whole_packet_digest));
 	
@@ -1506,9 +1506,9 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 		dump_data_pw("verf->data8_enc:\n", verf->data8, sizeof(verf->data8));
 		
 		/* encode the packet payload */
-		dump_data_pw("data:\n", data, data_len);
-		netsechash(sealing_key, data, data_len);
-		dump_data_pw("data_enc:\n", data, data_len);
+		dump_data_pw("data:\n", (const unsigned char *)data, data_len);
+		netsechash(sealing_key, (unsigned char *)data, data_len);
+		dump_data_pw("data_enc:\n", (const unsigned char *)data, data_len);
 	}
 
 	/* encode the sequence number (key based on packet digest) */
@@ -1578,9 +1578,9 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 			     sizeof(verf->data8));
 		
 		/* extract the packet payload */
-		dump_data_pw("data   :\n", data, data_len);
-		netsechash(sealing_key, data, data_len);
-		dump_data_pw("datadec:\n", data, data_len);	
+		dump_data_pw("data   :\n", (const unsigned char *)data, data_len);
+		netsechash(sealing_key, (unsigned char *)data, data_len);
+		dump_data_pw("datadec:\n", (const unsigned char *)data, data_len);	
 	}
 
 	/* digest includes 'data' after unsealing */
-- 
cgit 


From cbe69f65f69b0c7b7c2d0d32005da488b50e52ba Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Wed, 1 Oct 2003 21:18:32 +0000
Subject: commit sign only patch from Andrew; bug 167; tested using 2k & XP
 clientspreviously joined to the Samba domain (This used to be commit
 3802f5895ee18507c6f467bd11db0b1147a6fdfd)

---
 source3/rpc_parse/parse_prs.c | 147 +++++++++++++++++++++++++-----------------
 1 file changed, 87 insertions(+), 60 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 81a9573077..b30c41c090 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -3,7 +3,8 @@
    Samba memory buffer functions
    Copyright (C) Andrew Tridgell              1992-1997
    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
-   Copyright (C) Jeremy Allison 1999.
+   Copyright (C) Jeremy Allison               1999
+   Copyright (C) Andrew Bartlett              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
@@ -1337,47 +1338,6 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
 	return True;
 }
 
-static void netsechash(uchar * key, uchar * data, int data_len)
-{
-	uchar hash[256];
-	uchar index_i = 0;
-	uchar index_j = 0;
-	uchar j = 0;
-	int ind;
-
-	for (ind = 0; ind < 256; ind++)
-	{
-		hash[ind] = (uchar) ind;
-	}
-
-	for (ind = 0; ind < 256; ind++)
-	{
-		uchar tc;
-
-		j += (hash[ind] + key[ind % 16]);
-
-		tc = hash[ind];
-		hash[ind] = hash[j];
-		hash[j] = tc;
-	}
-
-	for (ind = 0; ind < data_len; ind++)
-	{
-		uchar tc;
-		uchar t;
-
-		index_i++;
-		index_j += hash[index_i];
-
-		tc = hash[index_i];
-		hash[index_i] = hash[index_j];
-		hash[index_j] = tc;
-
-		t = hash[index_i] + hash[index_j];
-		data[ind] ^= hash[t];
-	}
-}
-
 
 /*******************************************************************
  Create a digest over the entire packet (including the data), and 
@@ -1400,7 +1360,7 @@ static void netsec_digest(struct netsec_auth_struct *a,
 	MD5Update(&ctx3, zeros, sizeof(zeros));
 	MD5Update(&ctx3, verf->sig, sizeof(verf->sig));
 	if (auth_flags & AUTH_PIPE_SEAL) {
-		MD5Update(&ctx3, verf->data8, sizeof(verf->data8));
+		MD5Update(&ctx3, verf->confounder, sizeof(verf->confounder));
 	}
 	MD5Update(&ctx3, (const unsigned char *)data, data_len);
 	MD5Final(whole_packet_digest, &ctx3);
@@ -1456,10 +1416,29 @@ static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
 	dump_data_pw("sequence_key:\n", sequence_key, sizeof(sequence_key));
 
 	dump_data_pw("seq_num (before):\n", verf->seq_num, sizeof(verf->seq_num));
-	netsechash(sequence_key, verf->seq_num, 8);
+	SamOEMhash(verf->seq_num, sequence_key, 8);
 	dump_data_pw("seq_num (after):\n", verf->seq_num, sizeof(verf->seq_num));
 }
 
+/*******************************************************************
+creates an RPC_AUTH_NETSEC_CHK structure.
+********************************************************************/
+static BOOL init_rpc_auth_netsec_chk(RPC_AUTH_NETSEC_CHK * chk,
+			      const uchar sig[8],
+			      const uchar packet_digest[8],
+			      const uchar seq_num[8], const uchar confounder[8])
+{
+	if (chk == NULL)
+		return False;
+
+	memcpy(chk->sig, sig, sizeof(chk->sig));
+	memcpy(chk->packet_digest, packet_digest, sizeof(chk->packet_digest));
+	memcpy(chk->seq_num, seq_num, sizeof(chk->seq_num));
+	memcpy(chk->confounder, confounder, sizeof(chk->confounder));
+
+	return True;
+}
+
 
 /*******************************************************************
  Encode a blob of data using the netsec (schannel) alogrithm, also produceing
@@ -1469,26 +1448,47 @@ static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
  ********************************************************************/
 void netsec_encode(struct netsec_auth_struct *a, int auth_flags, 
 		   enum netsec_direction direction,
-		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
+		   RPC_AUTH_NETSEC_CHK * verf,
+		   char *data, size_t data_len)
 {
 	uchar digest_final[16];
+	uchar confounder[8];
+	uchar seq_num[8];
+	static const uchar nullbytes[8];
+
+	static const uchar netsec_seal_sig[8] = NETSEC_SEAL_SIGNATURE;
+	static const uchar netsec_sign_sig[8] = NETSEC_SIGN_SIGNATURE;
+	const uchar *netsec_sig;
 
 	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
+	
+	if (auth_flags & AUTH_PIPE_SEAL) {
+		netsec_sig = netsec_seal_sig;
+	} else if (auth_flags & AUTH_PIPE_SIGN) {
+		netsec_sig = netsec_sign_sig;
+	}
+
+	/* fill the 'confounder' with random data */
+	generate_random_buffer(confounder, sizeof(confounder), False);
+
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
-	RSIVAL(verf->seq_num, 0, a->seq_num);
+	RSIVAL(seq_num, 0, a->seq_num);
 
 	switch (direction) {
 	case SENDER_IS_INITIATOR:
-		SIVAL(verf->seq_num, 4, 0x80);
+		SIVAL(seq_num, 4, 0x80);
 		break;
 	case SENDER_IS_ACCEPTOR:
-		SIVAL(verf->seq_num, 4, 0x0);
+		SIVAL(seq_num, 4, 0x0);
 		break;
 	}
 
-	dump_data_pw("verf->seq_num:\n", verf->seq_num, sizeof(verf->seq_num));
+	dump_data_pw("verf->seq_num:\n", seq_num, sizeof(verf->seq_num));
 
+	init_rpc_auth_netsec_chk(verf, netsec_sig, nullbytes,
+				 seq_num, confounder);
+				
 	/* produce a digest of the packet to prove it's legit (before we seal it) */
 	netsec_digest(a, auth_flags, verf, data, data_len, digest_final);
 	memcpy(verf->packet_digest, digest_final, sizeof(verf->packet_digest));
@@ -1500,14 +1500,14 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 		netsec_get_sealing_key(a, verf, sealing_key);
 
 		/* encode the verification data */
-		dump_data_pw("verf->data8:\n", verf->data8, sizeof(verf->data8));
-		netsechash(sealing_key, verf->data8, 8);
+		dump_data_pw("verf->confounder:\n", verf->confounder, sizeof(verf->confounder));
+		SamOEMhash(verf->confounder, sealing_key, 8);
 
-		dump_data_pw("verf->data8_enc:\n", verf->data8, sizeof(verf->data8));
+		dump_data_pw("verf->confounder_enc:\n", verf->confounder, sizeof(verf->confounder));
 		
 		/* encode the packet payload */
 		dump_data_pw("data:\n", (const unsigned char *)data, data_len);
-		netsechash(sealing_key, (unsigned char *)data, data_len);
+		SamOEMhash((unsigned char *)data, sealing_key, data_len);
 		dump_data_pw("data_enc:\n", (const unsigned char *)data, data_len);
 	}
 
@@ -1531,8 +1531,21 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 {
 	uchar digest_final[16];
 
-	/* Create the expected sequence number for comparison */
+	static const uchar netsec_seal_sig[8] = NETSEC_SEAL_SIGNATURE;
+	static const uchar netsec_sign_sig[8] = NETSEC_SIGN_SIGNATURE;
+	const uchar *netsec_sig;
+
 	uchar seq_num[8];
+
+	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
+	
+	if (auth_flags & AUTH_PIPE_SEAL) {
+		netsec_sig = netsec_seal_sig;
+	} else if (auth_flags & AUTH_PIPE_SIGN) {
+		netsec_sig = netsec_sign_sig;
+	}
+
+	/* Create the expected sequence number for comparison */
 	RSIVAL(seq_num, 0, a->seq_num);
 
 	switch (direction) {
@@ -1560,6 +1573,20 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		   digest, as supplied by the client.  We check that it's a valid 
 		   checksum after the decode, below
 		*/
+		DEBUG(2, ("netsec_decode: FAILED: packet sequence number:\n"));
+		dump_data(2, verf->seq_num, sizeof(verf->seq_num));
+		DEBUG(2, ("should be:\n"));
+		dump_data(2, seq_num, sizeof(seq_num));
+
+		return False;
+	}
+
+	if (memcmp(verf->sig, netsec_sig, sizeof(verf->sig))) {
+		/* Validate that the other end sent the expected header */
+		DEBUG(2, ("netsec_decode: FAILED: packet header:\n"));
+		dump_data(2, verf->sig, sizeof(verf->sig));
+		DEBUG(2, ("should be:\n"));
+		dump_data(2, netsec_sig, sizeof(netsec_sig));
 		return False;
 	}
 
@@ -1570,16 +1597,16 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		netsec_get_sealing_key(a, verf, sealing_key);
 
 		/* extract the verification data */
-		dump_data_pw("verf->data8:\n", verf->data8, 
-			     sizeof(verf->data8));
-		netsechash(sealing_key, verf->data8, 8);
+		dump_data_pw("verf->confounder:\n", verf->confounder, 
+			     sizeof(verf->confounder));
+		SamOEMhash(verf->confounder, sealing_key, 8);
 
-		dump_data_pw("verf->data8_dec:\n", verf->data8, 
-			     sizeof(verf->data8));
+		dump_data_pw("verf->confounder_dec:\n", verf->confounder, 
+			     sizeof(verf->confounder));
 		
 		/* extract the packet payload */
 		dump_data_pw("data   :\n", (const unsigned char *)data, data_len);
-		netsechash(sealing_key, (unsigned char *)data, data_len);
+		SamOEMhash((unsigned char *)data, sealing_key, data_len);
 		dump_data_pw("datadec:\n", (const unsigned char *)data, data_len);	
 	}
 
-- 
cgit 


From 490dbaec81007a9b5dd3aabfc188bdb397927e78 Mon Sep 17 00:00:00 2001
From: Tim Potter <tpot@samba.org>
Date: Mon, 3 Nov 2003 14:21:10 +0000
Subject: Fix some uninitialised variable warnings. (This used to be commit
 68945027b5dc6b5e1aee13e4df4d11a34e42a3a9)

---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b30c41c090..9056348239 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1458,7 +1458,7 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 
 	static const uchar netsec_seal_sig[8] = NETSEC_SEAL_SIGNATURE;
 	static const uchar netsec_sign_sig[8] = NETSEC_SIGN_SIGNATURE;
-	const uchar *netsec_sig;
+	const uchar *netsec_sig = NULL;
 
 	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
 	
@@ -1533,7 +1533,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 
 	static const uchar netsec_seal_sig[8] = NETSEC_SEAL_SIGNATURE;
 	static const uchar netsec_sign_sig[8] = NETSEC_SIGN_SIGNATURE;
-	const uchar *netsec_sig;
+	const uchar *netsec_sig = NULL;
 
 	uchar seq_num[8];
 
-- 
cgit 


From 500c28974ded4c4789d9f197de5860b20447e606 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Fri, 9 Jan 2004 14:54:33 +0000
Subject: fix some warnings from the Sun compiler (This used to be commit
 ebabf72a78f0165521268b73e0fcabe1ea7834fd)

---
 source3/rpc_parse/parse_prs.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 9056348239..58652fa0c5 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1574,9 +1574,9 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		   checksum after the decode, below
 		*/
 		DEBUG(2, ("netsec_decode: FAILED: packet sequence number:\n"));
-		dump_data(2, verf->seq_num, sizeof(verf->seq_num));
+		dump_data(2, (const char*)verf->seq_num, sizeof(verf->seq_num));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, seq_num, sizeof(seq_num));
+		dump_data(2, (const char*)seq_num, sizeof(seq_num));
 
 		return False;
 	}
@@ -1584,9 +1584,9 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 	if (memcmp(verf->sig, netsec_sig, sizeof(verf->sig))) {
 		/* Validate that the other end sent the expected header */
 		DEBUG(2, ("netsec_decode: FAILED: packet header:\n"));
-		dump_data(2, verf->sig, sizeof(verf->sig));
+		dump_data(2, (const char*)verf->sig, sizeof(verf->sig));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, netsec_sig, sizeof(netsec_sig));
+		dump_data(2, (const char*)netsec_sig, sizeof(netsec_sig));
 		return False;
 	}
 
-- 
cgit 


From be1b3604ef3d351b1e3013a509dcceb5fed8409f Mon Sep 17 00:00:00 2001
From: Herb Lewis <herb@samba.org>
Date: Wed, 14 Jan 2004 22:53:50 +0000
Subject: source/rpc_parse/parse_prs.c	ZERO_STRUCTP(ps) not needed as it is
 done 				in prs_init now

testsuite/printing/psec.c	cannot do a prs_mem_free() when tdb_prs_fetch fails
				as the prs structure has not been initialized
(This used to be commit a363e5d8c549861329506bd87c11d82ace5520e5)
---
 source3/rpc_parse/parse_prs.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 58652fa0c5..0e5a25fe8c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1307,7 +1307,6 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
     if (!dbuf.dptr)
 	    return -1;
 
-    ZERO_STRUCTP(ps);
     prs_init(ps, 0, mem_ctx, UNMARSHALL);
     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
 
-- 
cgit 


From 5db731d899987d1a53e72f16b92b7e01eafd80c2 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sun, 20 Jun 2004 08:37:01 +0000
Subject: r1202: This hopefully fixes our memory use when unmarshalling
 strings. The test case was 'rpcclient -c "enumprinters 2"' with 4000
 printers. At some point this completely exploded in memory usage. For every
 string we talloc'ed memory up to the end of the buffer. -> O(n^2).

This survives valgrind with this number of printers. It might also have
influence on winbind with a large number of users.

All those who dare to look at samba3 rpc code, could you please take a look? I
know this is a burden, but I would like comments ;-)))

Volker
(This used to be commit af251f4ea63c584604972e1c8add83e65046de80)
---
 source3/rpc_parse/parse_prs.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 0e5a25fe8c..92c5b13632 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1101,10 +1101,13 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 
 		/* the test of the value of *ptr helps to catch the circumstance
 		   where we have an emtpty (non-existent) string in the buffer */
-		for ( ptr = (uint16 *)q; *ptr && (alloc_len <= max_len); alloc_len++)
+		for ( ptr = (uint16 *)q; *ptr++ && (alloc_len <= max_len); alloc_len++)
 			/* do nothing */ 
 			;
 
+		if (alloc_len < max_len)
+			alloc_len += 1;
+
 		/* should we allocate anything at all? */
 		str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
 		if ((str->buffer == NULL) && (alloc_len > 0))
-- 
cgit 


From 9d0783bf211dffe58845b36b0669f05bf8bf25b5 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 14 Jul 2004 04:36:01 +0000
Subject: r1492: Rework our random number generation system.

On systems with /dev/urandom, this avoids a change to secrets.tdb for every fork().

For other systems, we now only re-seed after a fork, and on startup.
No need to do it per-operation.  This removes the 'need_reseed'
parameter from generate_random_buffer().

Andrew Bartlett
(This used to be commit 36741d3cf53a7bd17d361251f2bb50851cdb035f)
---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 92c5b13632..c70011c648 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1471,7 +1471,7 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 	}
 
 	/* fill the 'confounder' with random data */
-	generate_random_buffer(confounder, sizeof(confounder), False);
+	generate_random_buffer(confounder, sizeof(confounder));
 
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
-- 
cgit 


From acf9d61421faa6c0055d57fdee7db300dc5431aa Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 7 Dec 2004 18:25:53 +0000
Subject: r4088: Get medieval on our ass about malloc.... :-). Take control of
 all our allocation functions so we can funnel through some well known
 functions. Should help greatly with malloc checking. HEAD patch to follow.
 Jeremy. (This used to be commit 620f2e608f70ba92f032720c031283d295c5c06a)

---
 source3/rpc_parse/parse_prs.c | 37 ++++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 15 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c70011c648..67a9d96e19 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -105,7 +105,7 @@ BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 
 	if (size != 0) {
 		ps->buffer_size = size;
-		if((ps->data_p = (char *)malloc((size_t)size)) == NULL) {
+		if((ps->data_p = (char *)SMB_MALLOC((size_t)size)) == NULL) {
 			DEBUG(0,("prs_init: malloc fail for %u bytes.\n", (unsigned int)size));
 			return False;
 		}
@@ -143,14 +143,21 @@ void prs_mem_clear(prs_struct *ps)
  Allocate memory when unmarshalling... Always zero clears.
  ********************************************************************/
 
-char *prs_alloc_mem(prs_struct *ps, size_t size)
+#if defined(PARANOID_MALLOC_CHECKER)
+char *prs_alloc_mem_(prs_struct *ps, size_t size, unsigned int count)
+#else
+char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
+#endif
 {
 	char *ret = NULL;
 
 	if (size) {
-		ret = talloc(ps->mem_ctx, size);
-		if (ret)
-			memset(ret, '\0', size);
+		/* We can't call the type-safe version here. */
+#if defined(PARANOID_MALLOC_CHECKER)
+		ret = talloc_zero_array_(ps->mem_ctx, size, count);
+#else
+		ret = talloc_zero_array(ps->mem_ctx, size, count);
+#endif
 	}
 	return ret;
 }
@@ -199,7 +206,7 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 		return prs_force_grow(ps, newsize - ps->buffer_size);
 
 	if (newsize < ps->buffer_size) {
-		char *new_data_p = Realloc(ps->data_p, newsize);
+		char *new_data_p = SMB_REALLOC(ps->data_p, newsize);
 		/* if newsize is zero, Realloc acts like free() & returns NULL*/
 		if (new_data_p == NULL && newsize != 0) {
 			DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
@@ -253,7 +260,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 
 		new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);
 
-		if((new_data = malloc(new_size)) == NULL) {
+		if((new_data = SMB_MALLOC(new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
 			return False;
 		}
@@ -265,7 +272,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		 */
 		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);		
 
-		if ((new_data = Realloc(ps->data_p, new_size)) == NULL) {
+		if ((new_data = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 				(unsigned int)new_size));
 			return False;
@@ -296,7 +303,7 @@ BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 		return False;
 	}
 
-	if((new_data = Realloc(ps->data_p, new_size)) == NULL) {
+	if((new_data = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
 		DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
 			(unsigned int)new_size));
 		return False;
@@ -886,7 +893,7 @@ BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len * sizeof(uint16));
+		str->buffer = PRS_ALLOC_MEM(ps,uint16,str->buf_len);
 		if (str->buffer == NULL)
 			return False;
 	}
@@ -918,7 +925,7 @@ BOOL prs_buffer2(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
 
 	if (UNMARSHALLING(ps)) {
 		if ( str->buf_len ) {
-			str->buffer = (uint16 *)prs_alloc_mem(ps,str->buf_len);
+			str->buffer = PRS_ALLOC_MEM(ps, uint16, str->buf_len);
 			if ( str->buffer == NULL )
 				return False;
 		}
@@ -945,7 +952,7 @@ BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STR
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = (unsigned char *)prs_alloc_mem(ps,str->str_max_len);
+		str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
 		if (str->buffer == NULL)
 			return False;
 	}
@@ -989,7 +996,7 @@ BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNI
 		return True;
 
 	if (UNMARSHALLING(ps)) {
-		str->buffer = (uint16 *)prs_alloc_mem(ps,str->uni_max_len * sizeof(uint16));
+		str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
 		if (str->buffer == NULL)
 			return False;
 	}
@@ -1016,7 +1023,7 @@ BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps,
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->str.buffer = (uint16 *)prs_alloc_mem(ps,str->uni_str_len * sizeof(uint16));
+		str->str.buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_str_len);
 		if (str->str.buffer == NULL)
 			return False;
 	}
@@ -1109,7 +1116,7 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 			alloc_len += 1;
 
 		/* should we allocate anything at all? */
-		str->buffer = (uint16 *)prs_alloc_mem(ps,alloc_len * sizeof(uint16));
+		str->buffer = PRS_ALLOC_MEM(ps,uint16,alloc_len);
 		if ((str->buffer == NULL) && (alloc_len > 0))
 			return False;
 
-- 
cgit 


From 07fdfa2ce9762557c3be632f3e438a1f59970c5c Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sat, 8 Jan 2005 00:51:12 +0000
Subject: r4601: Removed any use of the MAX_XXX_STR style definitions. A little
 larger change than I'd hoped for due to formating changes to tidy up code.
 Jeremy. (This used to be commit a348f9221a9fe719dc6f0db6eb295575c2f95e1e)

---
 source3/rpc_parse/parse_prs.c | 57 +++++++++++++++++++++++++------------------
 1 file changed, 33 insertions(+), 24 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 67a9d96e19..4b78d373ba 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -726,14 +726,14 @@ BOOL prs_uint8s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint
 			SCVAL(q, i, data8s[i]);
 	}
 
-    DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset ,name));
-    if (charmode)
+	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset ,name));
+	if (charmode)
 		print_asc(5, (unsigned char*)data8s, len);
 	else {
-    	for (i = 0; i < len; i++)
+		for (i = 0; i < len; i++)
 			DEBUG(5,("%02x ", data8s[i]));
 	}
-    DEBUG(5,("\n"));
+	DEBUG(5,("\n"));
 
 	ps->data_offset += len;
 
@@ -776,7 +776,7 @@ BOOL prs_uint16s(BOOL charmode, const char *name, prs_struct *ps, int depth, uin
 		for (i = 0; i < len; i++)
 			DEBUG(5,("%04x ", data16s[i]));
 	}
-    DEBUG(5,("\n"));
+	DEBUG(5,("\n"));
 
 	ps->data_offset += (len * sizeof(uint16));
 
@@ -818,7 +818,7 @@ static void dbg_rw_punival(BOOL charmode, const char *name, int depth, prs_struc
 		for (i = 0; i < len; i++)
 			DEBUG(5,("%04x ", out_buf[i]));
 	}
-    DEBUG(5,("\n"));
+	DEBUG(5,("\n"));
 }
 
 /******************************************************************
@@ -873,7 +873,7 @@ BOOL prs_uint32s(BOOL charmode, const char *name, prs_struct *ps, int depth, uin
 		for (i = 0; i < len; i++)
 			DEBUG(5,("%08x ", data32s[i]));
 	}
-    DEBUG(5,("\n"));
+	DEBUG(5,("\n"));
 
 	ps->data_offset += (len * sizeof(uint32));
 
@@ -924,8 +924,11 @@ BOOL prs_buffer2(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		if ( str->buf_len ) {
-			str->buffer = PRS_ALLOC_MEM(ps, uint16, str->buf_len);
+		if (str->buf_len > str->buf_max_len) {
+			return False;
+		}
+		if ( str->buf_max_len ) {
+			str->buffer = PRS_ALLOC_MEM(ps, uint16, str->buf_max_len);
 			if ( str->buffer == NULL )
 				return False;
 		}
@@ -947,11 +950,14 @@ BOOL prs_buffer2(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
 BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
 {
 	unsigned int i;
-	char *q = prs_mem_get(ps, str->str_max_len);
+	char *q = prs_mem_get(ps, str->str_str_len);
 	if (q == NULL)
 		return False;
 
 	if (UNMARSHALLING(ps)) {
+		if (str->str_str_len > str->str_max_len) {
+			return False;
+		}
 		str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
 		if (str->buffer == NULL)
 			return False;
@@ -965,14 +971,14 @@ BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STR
 			SCVAL(q, i, str->buffer[i]);
 	}
 
-    DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
-    if (charmode)
+	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	if (charmode)
 		print_asc(5, (unsigned char*)str->buffer, str->str_str_len);
 	else {
-    	for (i = 0; i < str->str_str_len; i++)
+		for (i = 0; i < str->str_str_len; i++)
 			DEBUG(5,("%02x ", str->buffer[i]));
 	}
-    DEBUG(5,("\n"));
+	DEBUG(5,("\n"));
 
 	ps->data_offset += str->str_str_len;
 
@@ -996,6 +1002,9 @@ BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNI
 		return True;
 
 	if (UNMARSHALLING(ps)) {
+		if (str->uni_str_len > str->uni_max_len) {
+			return False;
+		}
 		str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
 		if (str->buffer == NULL)
 			return False;
@@ -1061,10 +1070,8 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 
 		start = (uint8*)q;
 
-		for(len = 0; str->buffer[len] != 0; len++) 
-		{
-			if(ps->bigendian_data) 
-			{
+		for(len = 0; str->buffer[len] != 0; len++) {
+			if(ps->bigendian_data) {
 				/* swap bytes - p is little endian, q is big endian. */
 				q[0] = (char)p[1];
 				q[1] = (char)p[0];
@@ -1126,8 +1133,7 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 		/* the (len < alloc_len) test is to prevent us from overwriting
 		   memory that is not ours...if we get that far, we have a non-null
 		   terminated string in the buffer and have messed up somewhere */
-		while ((len < alloc_len) && (*(uint16 *)q != 0))
-		{
+		while ((len < alloc_len) && (*(uint16 *)q != 0)) {
 			if(ps->bigendian_data) 
 			{
 				/* swap bytes - q is big endian, p is little endian. */
@@ -1145,8 +1151,7 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 
 			len++;
 		} 
-		if (len < alloc_len)
-		{
+		if (len < alloc_len) {
 			/* NULL terminate the UNISTR */
 			str->buffer[len++] = '\0';
 		}
@@ -1326,6 +1331,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
 /*******************************************************************
  hash a stream.
  ********************************************************************/
+
 BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
 {
 	char *q;
@@ -1347,11 +1353,11 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
 	return True;
 }
 
-
 /*******************************************************************
  Create a digest over the entire packet (including the data), and 
  MD5 it with the session key.
  ********************************************************************/
+
 static void netsec_digest(struct netsec_auth_struct *a,
 			  int auth_flags,
 			  RPC_AUTH_NETSEC_CHK * verf,
@@ -1383,6 +1389,7 @@ static void netsec_digest(struct netsec_auth_struct *a,
 /*******************************************************************
  Calculate the key with which to encode the data payload 
  ********************************************************************/
+
 static void netsec_get_sealing_key(struct netsec_auth_struct *a,
 				   RPC_AUTH_NETSEC_CHK *verf,
 				   uchar sealing_key[16]) 
@@ -1410,6 +1417,7 @@ static void netsec_get_sealing_key(struct netsec_auth_struct *a,
 /*******************************************************************
  Encode or Decode the sequence number (which is symmetric)
  ********************************************************************/
+
 static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
 				     RPC_AUTH_NETSEC_CHK *verf)
 {
@@ -1432,6 +1440,7 @@ static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
 /*******************************************************************
 creates an RPC_AUTH_NETSEC_CHK structure.
 ********************************************************************/
+
 static BOOL init_rpc_auth_netsec_chk(RPC_AUTH_NETSEC_CHK * chk,
 			      const uchar sig[8],
 			      const uchar packet_digest[8],
@@ -1448,13 +1457,13 @@ static BOOL init_rpc_auth_netsec_chk(RPC_AUTH_NETSEC_CHK * chk,
 	return True;
 }
 
-
 /*******************************************************************
  Encode a blob of data using the netsec (schannel) alogrithm, also produceing
  a checksum over the original data.  We currently only support
  signing and sealing togeather - the signing-only code is close, but not
  quite compatible with what MS does.
  ********************************************************************/
+
 void netsec_encode(struct netsec_auth_struct *a, int auth_flags, 
 		   enum netsec_direction direction,
 		   RPC_AUTH_NETSEC_CHK * verf,
-- 
cgit 


From 61dfab9f705cb38e552dcec1822974433997543c Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Tue, 15 Mar 2005 19:43:44 +0000
Subject: r5805: merging spoolss parsing changes from trunk and cleaning up
 resulting segvs (This used to be commit
 25121547caaaed0d60f4db7458570c14e7d21b2a)

---
 source3/rpc_parse/parse_prs.c | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4b78d373ba..566efae7a9 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -646,6 +646,34 @@ BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 	return True;
 }
 
+/*******************************************************************
+ Stream a uint32* (allocate memory if unmarshalling)
+ ********************************************************************/
+
+BOOL prs_uint32_p(const char *name, prs_struct *ps, int depth, uint32 **data32)
+{
+	uint32 data_p;
+
+	/* caputure the pointer value to stream */
+
+	data_p = (uint32) *data32;
+
+	if ( !prs_uint32("ptr", ps, depth, &data_p ))
+		return False;
+
+	/* we're done if there is no data */
+
+	if ( !data_p )
+		return True;
+
+	if (UNMARSHALLING(ps)) {
+		if ( !(*data32 = PRS_ALLOC_MEM(ps, uint32, 1)) )
+			return False;
+	}
+
+	return prs_uint32(name, ps, depth, *data32);
+}
+
 /*******************************************************************
  Stream a NTSTATUS
  ********************************************************************/
-- 
cgit 


From 5d1cb8e79edea9e8581d3c2c9dd297310cd9a98c Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Wed, 23 Mar 2005 23:26:33 +0000
Subject: r6014: rather large change set....

pulling back all recent rpc changes from trunk into
3.0.  I've tested a compile and so don't think I've missed
any files.  But if so, just mail me and I'll clean backup
in a couple of hours.

Changes include \winreg, \eventlog, \svcctl, and
general parse_misc.c updates.

I am planning on bracketing the event code with an
#ifdef ENABLE_EVENTLOG until I finish merging Marcin's
changes (very soon).
(This used to be commit 4e0ac63c36527cd8c52ef720cae17e84f67e7221)
---
 source3/rpc_parse/parse_prs.c | 81 ++++++++++++++++++++++---------------------
 1 file changed, 42 insertions(+), 39 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 566efae7a9..1b9ac51c61 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -588,6 +588,37 @@ BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 	return True;
 }
 
+/*******************************************************************
+ Stream a uint16* (allocate memory if unmarshalling)
+ ********************************************************************/
+
+BOOL prs_pointer( const char *name, prs_struct *ps, int depth, 
+                 void **data, size_t data_size,
+                 BOOL(*prs_fn)(const char*, prs_struct*, int, void*) )
+{
+	uint32 data_p;
+
+	/* caputure the pointer value to stream */
+
+	data_p = (uint32) *data;
+
+	if ( !prs_uint32("ptr", ps, depth, &data_p ))
+		return False;
+
+	/* we're done if there is no data */
+
+	if ( !data_p )
+		return True;
+
+	if (UNMARSHALLING(ps)) {
+		if ( !(*data = PRS_ALLOC_MEM_VOID(ps, data_size)) )
+			return False;
+	}
+
+	return prs_fn(name, ps, depth, *data);
+}
+
+
 /*******************************************************************
  Stream a uint16.
  ********************************************************************/
@@ -598,12 +629,12 @@ BOOL prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
 	if (q == NULL)
 		return False;
 
-    if (UNMARSHALLING(ps)) {
+	if (UNMARSHALLING(ps)) {
 		if (ps->bigendian_data)
 			*data16 = RSVAL(q,0);
 		else
 			*data16 = SVAL(q,0);
-    } else {
+	} else {
 		if (ps->bigendian_data)
 			RSSVAL(q,0,*data16);
 		else
@@ -646,34 +677,6 @@ BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 	return True;
 }
 
-/*******************************************************************
- Stream a uint32* (allocate memory if unmarshalling)
- ********************************************************************/
-
-BOOL prs_uint32_p(const char *name, prs_struct *ps, int depth, uint32 **data32)
-{
-	uint32 data_p;
-
-	/* caputure the pointer value to stream */
-
-	data_p = (uint32) *data32;
-
-	if ( !prs_uint32("ptr", ps, depth, &data_p ))
-		return False;
-
-	/* we're done if there is no data */
-
-	if ( !data_p )
-		return True;
-
-	if (UNMARSHALLING(ps)) {
-		if ( !(*data32 = PRS_ALLOC_MEM(ps, uint32, 1)) )
-			return False;
-	}
-
-	return prs_uint32(name, ps, depth, *data32);
-}
-
 /*******************************************************************
  Stream a NTSTATUS
  ********************************************************************/
@@ -944,28 +947,28 @@ BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
  in byte chars. String is in little-endian format.
  ********************************************************************/
 
-BOOL prs_buffer2(BOOL charmode, const char *name, prs_struct *ps, int depth, BUFFER2 *str)
+BOOL prs_regval_buffer(BOOL charmode, const char *name, prs_struct *ps, int depth, REGVAL_BUFFER *buf)
 {
 	char *p;
-	char *q = prs_mem_get(ps, str->buf_len);
+	char *q = prs_mem_get(ps, buf->buf_len);
 	if (q == NULL)
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		if (str->buf_len > str->buf_max_len) {
+		if (buf->buf_len > buf->buf_max_len) {
 			return False;
 		}
-		if ( str->buf_max_len ) {
-			str->buffer = PRS_ALLOC_MEM(ps, uint16, str->buf_max_len);
-			if ( str->buffer == NULL )
+		if ( buf->buf_max_len ) {
+			buf->buffer = PRS_ALLOC_MEM(ps, uint16, buf->buf_max_len);
+			if ( buf->buffer == NULL )
 				return False;
 		}
 	}
 
-	p = (char *)str->buffer;
+	p = (char *)buf->buffer;
 
-	dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len/2);
-	ps->data_offset += str->buf_len;
+	dbg_rw_punival(charmode, name, depth, ps, q, p, buf->buf_len/2);
+	ps->data_offset += buf->buf_len;
 
 	return True;
 }
-- 
cgit 


From 7b9d6ac23e1a7d8136fffd2e3977b09a815da65a Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 3 May 2005 07:33:49 +0000
Subject: r6595: This is Volkers new-talloc patch. Just got the go-ahead from
 Volker to commit. Woo Hoo ! Jeremy. (This used to be commit
 316df944a456f150944761dab34add5e8c4ab699)

---
 source3/rpc_parse/parse_prs.c | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 1b9ac51c61..cccad9ad55 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -153,11 +153,7 @@ char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
 
 	if (size) {
 		/* We can't call the type-safe version here. */
-#if defined(PARANOID_MALLOC_CHECKER)
-		ret = talloc_zero_array_(ps->mem_ctx, size, count);
-#else
-		ret = talloc_zero_array(ps->mem_ctx, size, count);
-#endif
+		ret = _talloc_zero_array(ps->mem_ctx, size, count, "parse_prs");
 	}
 	return ret;
 }
-- 
cgit 


From fed660877c16562265327c6093ea645cf4176b5c Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Wed, 8 Jun 2005 22:10:34 +0000
Subject: r7415: * big change -- volker's new async winbindd from trunk (This
 used to be commit a0ac9a8ffd4af31a0ebc423b4acbb2f043d865b8)

---
 source3/rpc_parse/parse_prs.c | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index cccad9ad55..493536eb2a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1240,6 +1240,32 @@ BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_
 	return True;
 }
 
+BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth,
+		      const char **str)
+{
+	size_t len;
+	char *tmp_str;
+
+	if (UNMARSHALLING(ps))
+		len = strlen(&ps->data_p[ps->data_offset]);
+	else
+		len = strlen(*str);
+
+	tmp_str = PRS_ALLOC_MEM(ps, char, len+1);
+
+	if (tmp_str == NULL)
+		return False;
+
+	if (MARSHALLING(ps))
+		strncpy(tmp_str, *str, len);
+
+	if (!prs_string(name, ps, depth, tmp_str, len+1))
+		return False;
+
+	*str = tmp_str;
+	return True;
+}
+
 /*******************************************************************
  prs_uint16 wrapper. Call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading.
-- 
cgit 


From adfd5cddf7577ce0db2d46351d02a440db63e4ec Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 2 Sep 2005 00:24:28 +0000
Subject: r9935: Make it easier to find overruns. Jeremy. (This used to be
 commit e68872d1473ea0557fac1072055a6ed21e5b3d82)

---
 source3/rpc_parse/parse_prs.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 493536eb2a..709a5d39af 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -529,8 +529,10 @@ char *prs_mem_get(prs_struct *ps, uint32 extra_size)
 		 * If reading, ensure that we can read the requested size item.
 		 */
 		if (ps->data_offset + extra_size > ps->buffer_size) {
-			DEBUG(0,("prs_mem_get: reading data of size %u would overrun buffer.\n",
-					(unsigned int)extra_size ));
+			DEBUG(0,("prs_mem_get: reading data of size %u would overrun "
+				"buffer by %u bytes.\n",
+				(unsigned int)extra_size,
+				(unsigned int)(ps->data_offset + extra_size - ps->buffer_size) ));
 			return NULL;
 		}
 	} else {
-- 
cgit 


From 54abd2aa66069e6baf7769c496f46d9dba18db39 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Fri, 30 Sep 2005 17:13:37 +0000
Subject: r10656: BIG merge from trunk.  Features not copied over

* \PIPE\unixinfo
* winbindd's {group,alias}membership new functions
* winbindd's lookupsids() functionality
* swat (trunk changes to be reverted as per discussion with Deryck)
(This used to be commit 939c3cb5d78e3a2236209b296aa8aba8bdce32d3)
---
 source3/rpc_parse/parse_prs.c | 146 +++++++++++++++++++++++-------------------
 1 file changed, 80 insertions(+), 66 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 709a5d39af..d174bad444 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -34,7 +34,6 @@ void prs_dump(char *name, int v, prs_struct *ps)
 	prs_dump_region(name, v, ps, ps->data_offset, ps->buffer_size);
 }
 
-
 /**
  * Dump from the start of the prs to the current location.
  **/
@@ -43,7 +42,6 @@ void prs_dump_before(char *name, int v, prs_struct *ps)
 	prs_dump_region(name, v, ps, 0, ps->data_offset);
 }
 
-
 /**
  * Dump everything from the start of the prs up to the current location.
  **/
@@ -52,6 +50,7 @@ void prs_dump_region(char *name, int v, prs_struct *ps,
 {
 	int fd, i;
 	pstring fname;
+	ssize_t sz;
 	if (DEBUGLEVEL < 50) return;
 	for (i=1;i<100;i++) {
 		if (v != -1) {
@@ -63,26 +62,28 @@ void prs_dump_region(char *name, int v, prs_struct *ps,
 		if (fd != -1 || errno != EEXIST) break;
 	}
 	if (fd != -1) {
-		write(fd, ps->data_p + from_off, to_off - from_off);
-		close(fd);
-		DEBUG(0,("created %s\n", fname));
+		sz = write(fd, ps->data_p + from_off, to_off - from_off);
+		i = close(fd);
+		if ( (sz != to_off-from_off) || (i != 0) ) {
+			DEBUG(0,("Error writing/closing %s: %ld!=%ld %d\n", fname, (unsigned long)sz, (unsigned long)to_off-from_off, i ));
+		} else {
+			DEBUG(0,("created %s\n", fname));
+		}
 	}
 }
 
-
-
 /*******************************************************************
- debug output for parsing info.
+ Debug output for parsing info
 
- XXXX side-effect of this function is to increase the debug depth XXXX
+ XXXX side-effect of this function is to increase the debug depth XXXX.
+
+********************************************************************/
 
- ********************************************************************/
 void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
 {
 	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
 }
 
-
 /**
  * Initialise an expandable parse structure.
  *
@@ -91,6 +92,7 @@ void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
  *
  * @return False if allocation fails, otherwise True.
  **/
+
 BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 {
 	ZERO_STRUCTP(ps);
@@ -111,6 +113,9 @@ BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 		}
 		memset(ps->data_p, '\0', (size_t)size);
 		ps->is_dynamic = True; /* We own this memory. */
+	} else if (MARSHALLING(ps)) {
+		/* If size is zero and we're marshalling we should allocate memory on demand. */
+		ps->is_dynamic = True;
 	}
 
 	return True;
@@ -254,7 +259,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		 * is greater.
 		 */
 
-		new_size = MAX(MAX_PDU_FRAG_LEN,extra_space);
+		new_size = MAX(RPC_MAX_PDU_FRAG_LEN,extra_space);
 
 		if((new_data = SMB_MALLOC(new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
@@ -398,7 +403,7 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
  Append the data from a buffer into a parse_struct.
  ********************************************************************/
 
-BOOL prs_copy_data_in(prs_struct *dst, char *src, uint32 len)
+BOOL prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
 {
 	if (len == 0)
 		return True;
@@ -564,6 +569,15 @@ void prs_force_dynamic(prs_struct *ps)
 	ps->is_dynamic=True;
 }
 
+/*******************************************************************
+ Associate a session key with a parse struct.
+ ********************************************************************/
+
+void prs_set_session_key(prs_struct *ps, const char sess_key[16])
+{
+	ps->sess_key = sess_key;
+}
+
 /*******************************************************************
  Stream a uint8.
  ********************************************************************/
@@ -596,9 +610,9 @@ BOOL prs_pointer( const char *name, prs_struct *ps, int depth,
 {
 	uint32 data_p;
 
-	/* caputure the pointer value to stream */
+	/* output f000baaa to stream if the pointer is non-zero. */
 
-	data_p = (uint32) *data;
+	data_p = *data ? 0xf000baaa : 0;
 
 	if ( !prs_uint32("ptr", ps, depth, &data_p ))
 		return False;
@@ -1387,7 +1401,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
  hash a stream.
  ********************************************************************/
 
-BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
+BOOL prs_hash1(prs_struct *ps, uint32 offset, int len)
 {
 	char *q;
 
@@ -1396,10 +1410,10 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
 
 #ifdef DEBUG_PASSWORD
 	DEBUG(100, ("prs_hash1\n"));
-	dump_data(100, sess_key, 16);
+	dump_data(100, ps->sess_key, 16);
 	dump_data(100, q, len);
 #endif
-	SamOEMhash((uchar *) q, sess_key, len);
+	SamOEMhash((uchar *) q, ps->sess_key, len);
 
 #ifdef DEBUG_PASSWORD
 	dump_data(100, q, len);
@@ -1413,9 +1427,9 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, uint8 sess_key[16], int len)
  MD5 it with the session key.
  ********************************************************************/
 
-static void netsec_digest(struct netsec_auth_struct *a,
-			  int auth_flags,
-			  RPC_AUTH_NETSEC_CHK * verf,
+static void schannel_digest(struct schannel_auth_struct *a,
+			  enum pipe_auth_level auth_level,
+			  RPC_AUTH_SCHANNEL_CHK * verf,
 			  char *data, size_t data_len,
 			  uchar digest_final[16]) 
 {
@@ -1429,7 +1443,7 @@ static void netsec_digest(struct netsec_auth_struct *a,
 	   out of order */
 	MD5Update(&ctx3, zeros, sizeof(zeros));
 	MD5Update(&ctx3, verf->sig, sizeof(verf->sig));
-	if (auth_flags & AUTH_PIPE_SEAL) {
+	if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
 		MD5Update(&ctx3, verf->confounder, sizeof(verf->confounder));
 	}
 	MD5Update(&ctx3, (const unsigned char *)data, data_len);
@@ -1445,8 +1459,8 @@ static void netsec_digest(struct netsec_auth_struct *a,
  Calculate the key with which to encode the data payload 
  ********************************************************************/
 
-static void netsec_get_sealing_key(struct netsec_auth_struct *a,
-				   RPC_AUTH_NETSEC_CHK *verf,
+static void schannel_get_sealing_key(struct schannel_auth_struct *a,
+				   RPC_AUTH_SCHANNEL_CHK *verf,
 				   uchar sealing_key[16]) 
 {
 	static uchar zeros[4];
@@ -1473,8 +1487,8 @@ static void netsec_get_sealing_key(struct netsec_auth_struct *a,
  Encode or Decode the sequence number (which is symmetric)
  ********************************************************************/
 
-static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
-				     RPC_AUTH_NETSEC_CHK *verf)
+static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
+				     RPC_AUTH_SCHANNEL_CHK *verf)
 {
 	static uchar zeros[4];
 	uchar sequence_key[16];
@@ -1493,10 +1507,10 @@ static void netsec_deal_with_seq_num(struct netsec_auth_struct *a,
 }
 
 /*******************************************************************
-creates an RPC_AUTH_NETSEC_CHK structure.
+creates an RPC_AUTH_SCHANNEL_CHK structure.
 ********************************************************************/
 
-static BOOL init_rpc_auth_netsec_chk(RPC_AUTH_NETSEC_CHK * chk,
+static BOOL init_rpc_auth_schannel_chk(RPC_AUTH_SCHANNEL_CHK * chk,
 			      const uchar sig[8],
 			      const uchar packet_digest[8],
 			      const uchar seq_num[8], const uchar confounder[8])
@@ -1513,15 +1527,15 @@ static BOOL init_rpc_auth_netsec_chk(RPC_AUTH_NETSEC_CHK * chk,
 }
 
 /*******************************************************************
- Encode a blob of data using the netsec (schannel) alogrithm, also produceing
+ Encode a blob of data using the schannel alogrithm, also produceing
  a checksum over the original data.  We currently only support
  signing and sealing togeather - the signing-only code is close, but not
  quite compatible with what MS does.
  ********************************************************************/
 
-void netsec_encode(struct netsec_auth_struct *a, int auth_flags, 
-		   enum netsec_direction direction,
-		   RPC_AUTH_NETSEC_CHK * verf,
+void schannel_encode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
+		   enum schannel_direction direction,
+		   RPC_AUTH_SCHANNEL_CHK * verf,
 		   char *data, size_t data_len)
 {
 	uchar digest_final[16];
@@ -1529,16 +1543,16 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 	uchar seq_num[8];
 	static const uchar nullbytes[8];
 
-	static const uchar netsec_seal_sig[8] = NETSEC_SEAL_SIGNATURE;
-	static const uchar netsec_sign_sig[8] = NETSEC_SIGN_SIGNATURE;
-	const uchar *netsec_sig = NULL;
+	static const uchar schannel_seal_sig[8] = SCHANNEL_SEAL_SIGNATURE;
+	static const uchar schannel_sign_sig[8] = SCHANNEL_SIGN_SIGNATURE;
+	const uchar *schannel_sig = NULL;
 
-	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
+	DEBUG(10,("SCHANNEL: schannel_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
 	
-	if (auth_flags & AUTH_PIPE_SEAL) {
-		netsec_sig = netsec_seal_sig;
-	} else if (auth_flags & AUTH_PIPE_SIGN) {
-		netsec_sig = netsec_sign_sig;
+	if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
+		schannel_sig = schannel_seal_sig;
+	} else {
+		schannel_sig = schannel_sign_sig;
 	}
 
 	/* fill the 'confounder' with random data */
@@ -1559,18 +1573,18 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 
 	dump_data_pw("verf->seq_num:\n", seq_num, sizeof(verf->seq_num));
 
-	init_rpc_auth_netsec_chk(verf, netsec_sig, nullbytes,
+	init_rpc_auth_schannel_chk(verf, schannel_sig, nullbytes,
 				 seq_num, confounder);
 				
 	/* produce a digest of the packet to prove it's legit (before we seal it) */
-	netsec_digest(a, auth_flags, verf, data, data_len, digest_final);
+	schannel_digest(a, auth_level, verf, data, data_len, digest_final);
 	memcpy(verf->packet_digest, digest_final, sizeof(verf->packet_digest));
 
-	if (auth_flags & AUTH_PIPE_SEAL) {
+	if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
 		uchar sealing_key[16];
 
 		/* get the key to encode the data with */
-		netsec_get_sealing_key(a, verf, sealing_key);
+		schannel_get_sealing_key(a, verf, sealing_key);
 
 		/* encode the verification data */
 		dump_data_pw("verf->confounder:\n", verf->confounder, sizeof(verf->confounder));
@@ -1587,35 +1601,35 @@ void netsec_encode(struct netsec_auth_struct *a, int auth_flags,
 	/* encode the sequence number (key based on packet digest) */
 	/* needs to be done after the sealing, as the original version 
 	   is used in the sealing stuff... */
-	netsec_deal_with_seq_num(a, verf);
+	schannel_deal_with_seq_num(a, verf);
 
 	return;
 }
 
 /*******************************************************************
- Decode a blob of data using the netsec (schannel) alogrithm, also verifiying
+ Decode a blob of data using the schannel alogrithm, also verifiying
  a checksum over the original data.  We currently can verify signed messages,
  as well as decode sealed messages
  ********************************************************************/
 
-BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
-		   enum netsec_direction direction, 
-		   RPC_AUTH_NETSEC_CHK * verf, char *data, size_t data_len)
+BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
+		   enum schannel_direction direction, 
+		   RPC_AUTH_SCHANNEL_CHK * verf, char *data, size_t data_len)
 {
 	uchar digest_final[16];
 
-	static const uchar netsec_seal_sig[8] = NETSEC_SEAL_SIGNATURE;
-	static const uchar netsec_sign_sig[8] = NETSEC_SIGN_SIGNATURE;
-	const uchar *netsec_sig = NULL;
+	static const uchar schannel_seal_sig[8] = SCHANNEL_SEAL_SIGNATURE;
+	static const uchar schannel_sign_sig[8] = SCHANNEL_SIGN_SIGNATURE;
+	const uchar *schannel_sig = NULL;
 
 	uchar seq_num[8];
 
-	DEBUG(10,("SCHANNEL: netsec_encode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
+	DEBUG(10,("SCHANNEL: schannel_decode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
 	
-	if (auth_flags & AUTH_PIPE_SEAL) {
-		netsec_sig = netsec_seal_sig;
-	} else if (auth_flags & AUTH_PIPE_SIGN) {
-		netsec_sig = netsec_sign_sig;
+	if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
+		schannel_sig = schannel_seal_sig;
+	} else {
+		schannel_sig = schannel_sign_sig;
 	}
 
 	/* Create the expected sequence number for comparison */
@@ -1630,7 +1644,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		break;
 	}
 
-	DEBUG(10,("SCHANNEL: netsec_decode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
+	DEBUG(10,("SCHANNEL: schannel_decode seq_num=%d data_len=%lu\n", a->seq_num, (unsigned long)data_len));
 	dump_data_pw("a->sess_key:\n", a->sess_key, sizeof(a->sess_key));
 
 	dump_data_pw("seq_num:\n", seq_num, sizeof(seq_num));
@@ -1638,7 +1652,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 	/* extract the sequence number (key based on supplied packet digest) */
 	/* needs to be done before the sealing, as the original version 
 	   is used in the sealing stuff... */
-	netsec_deal_with_seq_num(a, verf);
+	schannel_deal_with_seq_num(a, verf);
 
 	if (memcmp(verf->seq_num, seq_num, sizeof(seq_num))) {
 		/* don't even bother with the below if the sequence number is out */
@@ -1646,7 +1660,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		   digest, as supplied by the client.  We check that it's a valid 
 		   checksum after the decode, below
 		*/
-		DEBUG(2, ("netsec_decode: FAILED: packet sequence number:\n"));
+		DEBUG(2, ("schannel_decode: FAILED: packet sequence number:\n"));
 		dump_data(2, (const char*)verf->seq_num, sizeof(verf->seq_num));
 		DEBUG(2, ("should be:\n"));
 		dump_data(2, (const char*)seq_num, sizeof(seq_num));
@@ -1654,20 +1668,20 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 		return False;
 	}
 
-	if (memcmp(verf->sig, netsec_sig, sizeof(verf->sig))) {
+	if (memcmp(verf->sig, schannel_sig, sizeof(verf->sig))) {
 		/* Validate that the other end sent the expected header */
-		DEBUG(2, ("netsec_decode: FAILED: packet header:\n"));
+		DEBUG(2, ("schannel_decode: FAILED: packet header:\n"));
 		dump_data(2, (const char*)verf->sig, sizeof(verf->sig));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, (const char*)netsec_sig, sizeof(netsec_sig));
+		dump_data(2, (const char*)schannel_sig, sizeof(schannel_sig));
 		return False;
 	}
 
-	if (auth_flags & AUTH_PIPE_SEAL) {
+	if (auth_level == PIPE_AUTH_LEVEL_PRIVACY) {
 		uchar sealing_key[16];
 		
 		/* get the key to extract the data with */
-		netsec_get_sealing_key(a, verf, sealing_key);
+		schannel_get_sealing_key(a, verf, sealing_key);
 
 		/* extract the verification data */
 		dump_data_pw("verf->confounder:\n", verf->confounder, 
@@ -1684,7 +1698,7 @@ BOOL netsec_decode(struct netsec_auth_struct *a, int auth_flags,
 	}
 
 	/* digest includes 'data' after unsealing */
-	netsec_digest(a, auth_flags, verf, data, data_len, digest_final);
+	schannel_digest(a, auth_level, verf, data, data_len, digest_final);
 
 	dump_data_pw("Calculated digest:\n", digest_final, 
 		     sizeof(digest_final));
-- 
cgit 


From 8c9ad87af2a04bdbe04872441a7bda2ae385a493 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 4 Oct 2005 21:56:53 +0000
Subject: r10720: Add helper function that does prs alignment on a specified
 number of bytes. (This used to be commit
 4576e6843b67c5919823307a196b1582b78fdeaf)

---
 source3/rpc_parse/parse_prs.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d174bad444..088c8f08fb 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -511,6 +511,24 @@ BOOL prs_align_uint64(prs_struct *ps)
 	return ret;
 }
 
+/******************************************************************
+ Align on a specific byte boundary
+ *****************************************************************/
+ 
+BOOL prs_align_custom(prs_struct *ps, uint8 boundary)
+{
+	BOOL ret;
+	uint8 old_align = ps->align;
+
+	ps->align = boundary;
+	ret = prs_align(ps);
+	ps->align = old_align;
+	
+	return ret;
+}
+
+
+
 /*******************************************************************
  Align only if required (for the unistr2 string mainly)
  ********************************************************************/
-- 
cgit 


From 8d7c88667190fe286971ac4fffb64ee5bd9eeeb0 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 18 Oct 2005 03:24:00 +0000
Subject: r11137: Compile with only 2 warnings (I'm still working on that code)
 on a gcc4 x86_64 box. Jeremy. (This used to be commit
 d720867a788c735e56d53d63265255830ec21208)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 088c8f08fb..3742ac95be 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1431,7 +1431,7 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, int len)
 	dump_data(100, ps->sess_key, 16);
 	dump_data(100, q, len);
 #endif
-	SamOEMhash((uchar *) q, ps->sess_key, len);
+	SamOEMhash((uchar *) q, (const unsigned char *)ps->sess_key, len);
 
 #ifdef DEBUG_PASSWORD
 	dump_data(100, q, len);
-- 
cgit 


From 9d4760d1190b907010d67dd938be568b776329b8 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 1 Nov 2005 23:29:02 +0000
Subject: r11446: Remove unused fn. Remove unneeded strncpy use. Jeremy. (This
 used to be commit d202aae3c821f3d78ff063d867bac1f84dca3548)

---
 source3/rpc_parse/parse_prs.c | 26 --------------------------
 1 file changed, 26 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 3742ac95be..77f0e6d5c8 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1274,32 +1274,6 @@ BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_
 	return True;
 }
 
-BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth,
-		      const char **str)
-{
-	size_t len;
-	char *tmp_str;
-
-	if (UNMARSHALLING(ps))
-		len = strlen(&ps->data_p[ps->data_offset]);
-	else
-		len = strlen(*str);
-
-	tmp_str = PRS_ALLOC_MEM(ps, char, len+1);
-
-	if (tmp_str == NULL)
-		return False;
-
-	if (MARSHALLING(ps))
-		strncpy(tmp_str, *str, len);
-
-	if (!prs_string(name, ps, depth, tmp_str, len+1))
-		return False;
-
-	*str = tmp_str;
-	return True;
-}
-
 /*******************************************************************
  prs_uint16 wrapper. Call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading.
-- 
cgit 


From d1f91f7c723733113b4e9792042101c80dfc064c Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sat, 3 Dec 2005 06:46:46 +0000
Subject: r12043: It's amazing the warnings you find when compiling on a 64-bit
 box with gcc4 and -O6... Fix a bunch of C99 dereferencing type-punned pointer
 will break strict-aliasing rules errors. Also added prs_int32 (not uint32...)
 as it's needed in one place. Find places where prs_uint32 was being used to
 marshall/unmarshall a time_t (a big no no on 64-bits). More warning fixes to
 come. Thanks to Volker for nudging me to compile like this. Jeremy. (This
 used to be commit c65b752604f8f58abc4e7ae8514dc2c7f086271c)

---
 source3/rpc_parse/parse_prs.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 77f0e6d5c8..7c84ee800b 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -707,6 +707,35 @@ BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 	return True;
 }
 
+/*******************************************************************
+ Stream an int32.
+ ********************************************************************/
+
+BOOL prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
+{
+	char *q = prs_mem_get(ps, sizeof(int32));
+	if (q == NULL)
+		return False;
+
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data)
+			*data32 = RIVALS(q,0);
+		else
+			*data32 = IVALS(q,0);
+	} else {
+		if (ps->bigendian_data)
+			RSIVALS(q,0,*data32);
+		else
+			SIVALS(q,0,*data32);
+	}
+
+	DEBUG(5,("%s%04x %s: %08x\n", tab_depth(depth), ps->data_offset, name, *data32));
+
+	ps->data_offset += sizeof(int32);
+
+	return True;
+}
+
 /*******************************************************************
  Stream a NTSTATUS
  ********************************************************************/
-- 
cgit 


From 0af1500fc0bafe61019f1b2ab1d9e1d369221240 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Fri, 3 Feb 2006 22:19:41 +0000
Subject: r13316: Let the carnage begin.... Sync with trunk as off r13315 (This
 used to be commit 17e63ac4ed8325c0d44fe62b2442449f3298559f)

---
 source3/rpc_parse/parse_prs.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 7c84ee800b..c4f9f512ab 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1303,6 +1303,35 @@ BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_
 	return True;
 }
 
+BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **str)
+{
+	size_t len;
+	char *tmp_str;
+
+	if (UNMARSHALLING(ps)) {
+		len = strlen(&ps->data_p[ps->data_offset]);
+	} else {
+		len = strlen(*str);
+	}
+
+	tmp_str = PRS_ALLOC_MEM(ps, char, len+1);
+
+	if (tmp_str == NULL) {
+		return False;
+	}
+
+	if (MARSHALLING(ps)) {
+		strncpy(tmp_str, *str, len);
+	}
+
+	if (!prs_string(name, ps, depth, tmp_str, len+1)) {
+		return False;
+	}
+
+	*str = tmp_str;
+	return True;
+}
+
 /*******************************************************************
  prs_uint16 wrapper. Call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading.
-- 
cgit 


From 4ea92f30985466489a3b3faf5a1c90667175aad6 Mon Sep 17 00:00:00 2001
From: Günther Deschner <gd@samba.org>
Date: Mon, 20 Feb 2006 23:22:56 +0000
Subject: r13581: Correctly parse a non-null terminated, little-endian UCS2
 string in the PAC_LOGON_NAME structure. This was broken on big-endian
 machines (Solaris SPARC and ppc). Fixes Bug #3330.

Jerry, this should be in 3.0.21c.

Guenther
(This used to be commit 9732490811f8f02ee547ddc6e2694e1122a3a518)
---
 source3/rpc_parse/parse_prs.c | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c4f9f512ab..857a24cf0e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1332,6 +1332,49 @@ BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **
 	return True;
 }
 
+/*******************************************************************
+ Stream a null-terminated string of fixed len.
+ ********************************************************************/
+
+BOOL prs_string_len(const char *name, prs_struct *ps, int depth, char *str, int len)
+{
+	char *q;
+	int i;
+	BOOL charmode = True;
+
+	q = prs_mem_get(ps, len+1);
+	if (q == NULL)
+		return False;
+
+	for(i = 0; i < len; i++) {
+		if (UNMARSHALLING(ps))
+			str[i] = q[i];
+		else
+			q[i] = str[i];
+	}
+
+	/* The terminating null. */
+	str[i] = '\0';
+
+	if (MARSHALLING(ps)) {
+		q[i] = '\0';
+	}
+
+	ps->data_offset += len+1;
+	
+	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	if (charmode) {
+		print_asc(5, (unsigned char*)str, len);
+	} else {
+		for (i = 0; i < len; i++)
+			DEBUG(5,("%04x ", str[i]));
+	}
+	DEBUG(5,("\n"));
+
+	return True;
+}
+
+
 /*******************************************************************
  prs_uint16 wrapper. Call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading.
-- 
cgit 


From 115996503ced64c478ed1cc857bd5a1528644b46 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 21 Feb 2006 03:08:42 +0000
Subject: r13585: Sorry Gunther, had to revert this. It's got a buffer overrun.
 Spoke to Jerry about the correct fix. Will add this after. Jeremy. (This used
 to be commit 33e13aabd3825c59d15dc897536e2ccf8c8f6d5e)

---
 source3/rpc_parse/parse_prs.c | 43 -------------------------------------------
 1 file changed, 43 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 857a24cf0e..c4f9f512ab 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1332,49 +1332,6 @@ BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **
 	return True;
 }
 
-/*******************************************************************
- Stream a null-terminated string of fixed len.
- ********************************************************************/
-
-BOOL prs_string_len(const char *name, prs_struct *ps, int depth, char *str, int len)
-{
-	char *q;
-	int i;
-	BOOL charmode = True;
-
-	q = prs_mem_get(ps, len+1);
-	if (q == NULL)
-		return False;
-
-	for(i = 0; i < len; i++) {
-		if (UNMARSHALLING(ps))
-			str[i] = q[i];
-		else
-			q[i] = str[i];
-	}
-
-	/* The terminating null. */
-	str[i] = '\0';
-
-	if (MARSHALLING(ps)) {
-		q[i] = '\0';
-	}
-
-	ps->data_offset += len+1;
-	
-	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
-	if (charmode) {
-		print_asc(5, (unsigned char*)str, len);
-	} else {
-		for (i = 0; i < len; i++)
-			DEBUG(5,("%04x ", str[i]));
-	}
-	DEBUG(5,("\n"));
-
-	return True;
-}
-
-
 /*******************************************************************
  prs_uint16 wrapper. Call this and it sets up a pointer to where the
  uint16 should be stored, or gets the size if reading.
-- 
cgit 


From 894358a8f3e338b339b6c37233edef794b312087 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 7 Mar 2006 06:31:04 +0000
Subject: r13915: Fixed a very interesting class of realloc() bugs found by
 Coverity. realloc can return NULL in one of two cases - (1) the realloc
 failed, (2) realloc succeeded but the new size requested was zero, in which
 case this is identical to a free() call.

The error paths dealing with these two cases should be different,
but mostly weren't. Secondly the standard idiom for dealing with
realloc when you know the new size is non-zero is the following :

 tmp = realloc(p, size);
 if (!tmp) {
    SAFE_FREE(p);
    return error;
 } else {
    p = tmp;
 }

However, there were *many* *many* places in Samba where we were
using the old (broken) idiom of :

 p = realloc(p, size)
 if (!p) {
    return error;
 }

which will leak the memory pointed to by p on realloc fail.

This commit (hopefully) fixes all these cases by moving to
a standard idiom of :

 p = SMB_REALLOC(p, size)
 if (!p) {
    return error;
 }

Where if the realloc returns null due to the realloc failing
or size == 0 we *guarentee* that the storage pointed to by p
has been freed. This allows me to remove a lot of code that
was dealing with the standard (more verbose) method that required
a tmp pointer. This is almost always what you want. When a
realloc fails you never usually want the old memory, you
want to free it and get into your error processing asap.

For the 11 remaining cases where we really do need to keep the
old pointer I have invented the new macro SMB_REALLOC_KEEP_OLD_ON_ERROR,
which can be used as follows :

 tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
 if (!tmp) {
    SAFE_FREE(p);
    return error;
 } else {
    p = tmp;
 }

SMB_REALLOC_KEEP_OLD_ON_ERROR guarentees never to free the
pointer p, even on size == 0 or realloc fail. All this is
done by a hidden extra argument to Realloc(), BOOL free_old_on_error
which is set appropriately by the SMB_REALLOC and SMB_REALLOC_KEEP_OLD_ON_ERROR
macros (and their array counterparts).

It remains to be seen what this will do to our Coverity bug count :-).

Jeremy.
(This used to be commit 1d710d06a214f3f1740e80e0bffd6aab44aac2b0)
---
 source3/rpc_parse/parse_prs.c | 39 ++++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 19 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c4f9f512ab..4683f1dbd0 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -207,16 +207,21 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 		return prs_force_grow(ps, newsize - ps->buffer_size);
 
 	if (newsize < ps->buffer_size) {
-		char *new_data_p = SMB_REALLOC(ps->data_p, newsize);
-		/* if newsize is zero, Realloc acts like free() & returns NULL*/
-		if (new_data_p == NULL && newsize != 0) {
-			DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
-				(unsigned int)newsize));
-			DEBUG(0,("prs_set_buffer_size: Reason %s\n",strerror(errno)));
-			return False;
-		}
-		ps->data_p = new_data_p;
 		ps->buffer_size = newsize;
+
+		/* newsize == 0 acts as a free and set pointer to NULL */
+		if (newsize == 0) {
+			SAFE_FREE(ps->data_p);
+		} else {
+			ps->data_p = SMB_REALLOC(ps->data_p, newsize);
+
+			if (ps->data_p == NULL) {
+				DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
+					(unsigned int)newsize));
+				DEBUG(0,("prs_set_buffer_size: Reason %s\n",strerror(errno)));
+				return False;
+			}
+		}
 	}
 
 	return True;
@@ -230,7 +235,6 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 {
 	uint32 new_size;
-	char *new_data;
 
 	ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
 
@@ -261,11 +265,11 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 
 		new_size = MAX(RPC_MAX_PDU_FRAG_LEN,extra_space);
 
-		if((new_data = SMB_MALLOC(new_size)) == NULL) {
+		if((ps->data_p = SMB_MALLOC(new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
 			return False;
 		}
-		memset(new_data, '\0', (size_t)new_size );
+		memset(ps->data_p, '\0', (size_t)new_size );
 	} else {
 		/*
 		 * If the current buffer size is bigger than the space needed, just 
@@ -273,16 +277,15 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		 */
 		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);		
 
-		if ((new_data = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
+		if ((ps->data_p = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 				(unsigned int)new_size));
 			return False;
 		}
 
-		memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
+		memset(&ps->data_p[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 	}
 	ps->buffer_size = new_size;
-	ps->data_p = new_data;
 
 	return True;
 }
@@ -296,7 +299,6 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 {
 	uint32 new_size = ps->buffer_size + extra_space;
-	char *new_data;
 
 	if(!UNMARSHALLING(ps) || !ps->is_dynamic) {
 		DEBUG(0,("prs_force_grow: Buffer overflow - unable to expand buffer by %u bytes.\n",
@@ -304,16 +306,15 @@ BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 		return False;
 	}
 
-	if((new_data = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
+	if((ps->data_p = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
 		DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
 			(unsigned int)new_size));
 		return False;
 	}
 
-	memset(&new_data[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
+	memset(&ps->data_p[ps->buffer_size], '\0', (size_t)(new_size - ps->buffer_size));
 
 	ps->buffer_size = new_size;
-	ps->data_p = new_data;
 
 	return True;
 }
-- 
cgit 


From c34e73cfcf29462de597edf9c96435f38635f7f9 Mon Sep 17 00:00:00 2001
From: Günther Deschner <gd@samba.org>
Date: Fri, 10 Mar 2006 13:14:01 +0000
Subject: r14146: Just some typos.

Guenther
(This used to be commit ade86cc787e266850fee982b008a9caf2c8ed7e7)
---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4683f1dbd0..474e93cc1f 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -607,12 +607,12 @@ BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 	if (q == NULL)
 		return False;
 
-    if (UNMARSHALLING(ps))
+	if (UNMARSHALLING(ps))
 		*data8 = CVAL(q,0);
 	else
 		SCVAL(q,0,*data8);
 
-    DEBUG(5,("%s%04x %s: %02x\n", tab_depth(depth), ps->data_offset, name, *data8));
+	DEBUG(5,("%s%04x %s: %02x\n", tab_depth(depth), ps->data_offset, name, *data8));
 
 	ps->data_offset += 1;
 
-- 
cgit 


From 6e17934ee614f5f129b69898be7eceb09486a48f Mon Sep 17 00:00:00 2001
From: Günther Deschner <gd@samba.org>
Date: Wed, 22 Mar 2006 14:41:07 +0000
Subject: r14643: Merge dcerpc_errstr from Samba 4.

Might need to rework prs_dcerpc_status().

Guenther
(This used to be commit 38b18f428ba941f4d9a14fa2de45cb0cd793a754)
---
 source3/rpc_parse/parse_prs.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 474e93cc1f..f2b002c48c 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -767,6 +767,37 @@ BOOL prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
 	return True;
 }
 
+/*******************************************************************
+ Stream a DCE error code
+ ********************************************************************/
+
+BOOL prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
+{
+	char *q = prs_mem_get(ps, sizeof(uint32));
+	if (q == NULL)
+		return False;
+
+	if (UNMARSHALLING(ps)) {
+		if (ps->bigendian_data)
+			*status = NT_STATUS(RIVAL(q,0));
+		else
+			*status = NT_STATUS(IVAL(q,0));
+	} else {
+		if (ps->bigendian_data)
+			RSIVAL(q,0,NT_STATUS_V(*status));
+		else
+			SIVAL(q,0,NT_STATUS_V(*status));
+	}
+
+	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
+		 dcerpc_errstr(NT_STATUS_V(*status))));
+
+	ps->data_offset += sizeof(uint32);
+
+	return True;
+}
+
+
 /*******************************************************************
  Stream a WERROR
  ********************************************************************/
-- 
cgit 


From d5b6dedfdd1acb9a2340a04865308c7c3c975ffd Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 19 Jun 2006 21:36:19 +0000
Subject: r16365: Fix Klocwork #895, #898, #899, #915, #932, #938 and a few
 other problems Klocwork missed. Jeremy. (This used to be commit
 fe05769a1a85f924c67be7e5dcee4871a86948d7)

---
 source3/rpc_parse/parse_prs.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index f2b002c48c..14e190892d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1469,11 +1469,12 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
     kbuf.dptr = keystr;
     kbuf.dsize = strlen(keystr)+1;
 
+    prs_init(ps, 0, mem_ctx, UNMARSHALL);
+
     dbuf = tdb_fetch(tdb, kbuf);
     if (!dbuf.dptr)
 	    return -1;
 
-    prs_init(ps, 0, mem_ctx, UNMARSHALL);
     prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
 
     return 0;
-- 
cgit 


From fbdcf2663b56007a438ac4f0d8d82436b1bfe688 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 11 Jul 2006 18:01:26 +0000
Subject: r16945: Sync trunk -> 3.0 for 3.0.24 code. Still need to do the upper
 layer directories but this is what everyone is waiting for....

Jeremy.
(This used to be commit 9dafb7f48ca3e7af956b0a7d1720c2546fc4cfb8)
---
 source3/rpc_parse/parse_prs.c | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 14e190892d..29a3e60aa9 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -624,9 +624,10 @@ BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
  ********************************************************************/
 
 BOOL prs_pointer( const char *name, prs_struct *ps, int depth, 
-                 void **data, size_t data_size,
+                 void *dta, size_t data_size,
                  BOOL(*prs_fn)(const char*, prs_struct*, int, void*) )
 {
+	void ** data = (void **)dta;
 	uint32 data_p;
 
 	/* output f000baaa to stream if the pointer is non-zero. */
@@ -1793,3 +1794,32 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 	return (memcmp(digest_final, verf->packet_digest, 
 		       sizeof(verf->packet_digest)) == 0);
 }
+
+/*******************************************************************
+creates a new prs_struct containing a DATA_BLOB
+********************************************************************/
+BOOL prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+{
+	if (!prs_init( prs, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL ))
+		return False;
+
+
+	if (!prs_copy_data_in(prs, (char *)blob->data, blob->length))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
+return the contents of a prs_struct in a DATA_BLOB
+********************************************************************/
+BOOL prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+{
+	blob->length = prs_offset(prs);
+	blob->data = talloc_zero_size(mem_ctx, blob->length);
+
+	if (!prs_copy_all_data_out((char *)blob->data, prs))
+		return False;
+	
+	return True;
+}
-- 
cgit 


From e23781b3b304d1e69ad80af5ae9c0ed8d02cf996 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sun, 30 Jul 2006 16:36:56 +0000
Subject: r17316: More C++ warnings -- 456 left (This used to be commit
 1e4ee728df7eeafc1b4d533240acb032f73b4f5c)

---
 source3/rpc_parse/parse_prs.c | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 29a3e60aa9..820565f09f 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -158,7 +158,8 @@ char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
 
 	if (size) {
 		/* We can't call the type-safe version here. */
-		ret = _talloc_zero_array(ps->mem_ctx, size, count, "parse_prs");
+		ret = (char *)_talloc_zero_array(ps->mem_ctx, size, count,
+						 "parse_prs");
 	}
 	return ret;
 }
@@ -213,7 +214,7 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 		if (newsize == 0) {
 			SAFE_FREE(ps->data_p);
 		} else {
-			ps->data_p = SMB_REALLOC(ps->data_p, newsize);
+			ps->data_p = (char *)SMB_REALLOC(ps->data_p, newsize);
 
 			if (ps->data_p == NULL) {
 				DEBUG(0,("prs_set_buffer_size: Realloc failure for size %u.\n",
@@ -265,7 +266,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 
 		new_size = MAX(RPC_MAX_PDU_FRAG_LEN,extra_space);
 
-		if((ps->data_p = SMB_MALLOC(new_size)) == NULL) {
+		if((ps->data_p = (char *)SMB_MALLOC(new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Malloc failure for size %u.\n", (unsigned int)new_size));
 			return False;
 		}
@@ -277,7 +278,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
 		 */
 		new_size = MAX(ps->buffer_size*2, ps->buffer_size + extra_space);		
 
-		if ((ps->data_p = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
+		if ((ps->data_p = (char *)SMB_REALLOC(ps->data_p, new_size)) == NULL) {
 			DEBUG(0,("prs_grow: Realloc failure for size %u.\n",
 				(unsigned int)new_size));
 			return False;
@@ -306,7 +307,7 @@ BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
 		return False;
 	}
 
-	if((ps->data_p = SMB_REALLOC(ps->data_p, new_size)) == NULL) {
+	if((ps->data_p = (char *)SMB_REALLOC(ps->data_p, new_size)) == NULL) {
 		DEBUG(0,("prs_force_grow: Realloc failure for size %u.\n",
 			(unsigned int)new_size));
 		return False;
@@ -1816,7 +1817,7 @@ return the contents of a prs_struct in a DATA_BLOB
 BOOL prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 {
 	blob->length = prs_offset(prs);
-	blob->data = talloc_zero_size(mem_ctx, blob->length);
+	blob->data = (uint8 *)talloc_zero_size(mem_ctx, blob->length);
 
 	if (!prs_copy_all_data_out((char *)blob->data, prs))
 		return False;
-- 
cgit 


From 6655e1e997fa96408ce257f1c96773db4551f69f Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Mon, 4 Sep 2006 09:51:47 +0000
Subject: r18029: More C++ stuff (This used to be commit
 089b51e28cc5e3674e4edf5464c7a15673c5ec0f)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 820565f09f..e348ef460d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1626,7 +1626,7 @@ void schannel_encode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 	uchar digest_final[16];
 	uchar confounder[8];
 	uchar seq_num[8];
-	static const uchar nullbytes[8];
+	static const uchar nullbytes[8] = { 0, };
 
 	static const uchar schannel_seal_sig[8] = SCHANNEL_SEAL_SIGNATURE;
 	static const uchar schannel_sign_sig[8] = SCHANNEL_SIGN_SIGNATURE;
-- 
cgit 


From 8fad1d204edd6c10380bfa5d72ec7060e34ccdb9 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Mon, 11 Sep 2006 19:32:55 +0000
Subject: r18393: get the data size and not offset when initializing a data
 blob from a prs structure (This used to be commit
 878fd68dfcb237f5332efcf48a3891abcc9ad53c)

---
 source3/rpc_parse/parse_prs.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index e348ef460d..d97b1b0dff 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1816,8 +1816,11 @@ return the contents of a prs_struct in a DATA_BLOB
 ********************************************************************/
 BOOL prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 {
-	blob->length = prs_offset(prs);
+	blob->length = prs_data_size(prs);
 	blob->data = (uint8 *)talloc_zero_size(mem_ctx, blob->length);
+	
+	/* set the pointer at the end of the buffer */
+	prs_set_offset( prs, prs_data_size(prs) );
 
 	if (!prs_copy_all_data_out((char *)blob->data, prs))
 		return False;
-- 
cgit 


From f799df03d4899ce9a8e6c5b025424501ceb17c1f Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sun, 15 Oct 2006 09:16:41 +0000
Subject: r19288: tdb_prs_store is right now used to store printer and share
 security descriptors. Both databases are long-lived and not frequently
 written, so I think storing it deserves a tdb transaction.

Volker
(This used to be commit 2d4b5f5727104f87b8282fc0e94675b0dc4cd9d8)
---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index d97b1b0dff..54bbe3adf6 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1461,7 +1461,7 @@ int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
     kbuf.dsize = strlen(keystr)+1;
     dbuf.dptr = ps->data_p;
     dbuf.dsize = prs_offset(ps);
-    return tdb_store(tdb, kbuf, dbuf, TDB_REPLACE);
+    return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
 }
 
 /* useful function to fetch a structure into rpc wire format */
-- 
cgit 


From a806037b8713cdf0ae32f7091f53819393132a0b Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Tue, 27 Mar 2007 11:15:59 +0000
Subject: r21987: split tdb_prs_*() functions in version which take a keystr
 and a TDB_DATA key

metze
(This used to be commit 724c6fa337bb535e1b97d0452c2489f58339a3bf)
---
 source3/rpc_parse/parse_prs.c | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 54bbe3adf6..ca46807932 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1454,22 +1454,24 @@ BOOL prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32
 }
 
 /* useful function to store a structure in rpc wire format */
-int tdb_prs_store(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
+int tdb_prs_store(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps)
 {
-    TDB_DATA kbuf, dbuf;
-    kbuf.dptr = keystr;
-    kbuf.dsize = strlen(keystr)+1;
+    TDB_DATA dbuf;
     dbuf.dptr = ps->data_p;
     dbuf.dsize = prs_offset(ps);
     return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
 }
 
+int tdb_prs_store_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
+{
+    TDB_DATA kbuf = string_term_tdb_data(keystr);
+    return tdb_prs_store(tdb, kbuf, ps);
+}
+
 /* useful function to fetch a structure into rpc wire format */
-int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
+int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *mem_ctx)
 {
-    TDB_DATA kbuf, dbuf;
-    kbuf.dptr = keystr;
-    kbuf.dsize = strlen(keystr)+1;
+    TDB_DATA dbuf;
 
     prs_init(ps, 0, mem_ctx, UNMARSHALL);
 
@@ -1482,6 +1484,12 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *me
     return 0;
 } 
 
+int tdb_prs_fetch_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
+{
+    TDB_DATA kbuf = string_term_tdb_data(keystr);
+    return tdb_prs_fetch(tdb, kbuf, ps, mem_ctx);
+}
+
 /*******************************************************************
  hash a stream.
  ********************************************************************/
-- 
cgit 


From 56ba44766854ed7cda265bdaf85913f2a1008282 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Wed, 28 Mar 2007 13:34:59 +0000
Subject: r22001: change prototype of dump_data(), so that it takes unsigned
 char * now, which matches what samba4 has.

also fix all the callers to prevent compiler warnings

metze
(This used to be commit fa322f0cc9c26a9537ba3f0a7d4e4a25941317e7)
---
 source3/rpc_parse/parse_prs.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index ca46807932..0fb429b591 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1332,7 +1332,7 @@ BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_
 
 	ps->data_offset += len+1;
 
-	dump_data(5+depth, q, len);
+	dump_data(5+depth, (uint8 *)q, len);
 
 	return True;
 }
@@ -1503,13 +1503,13 @@ BOOL prs_hash1(prs_struct *ps, uint32 offset, int len)
 
 #ifdef DEBUG_PASSWORD
 	DEBUG(100, ("prs_hash1\n"));
-	dump_data(100, ps->sess_key, 16);
-	dump_data(100, q, len);
+	dump_data(100, (uint8 *)ps->sess_key, 16);
+	dump_data(100, (uint8 *)q, len);
 #endif
 	SamOEMhash((uchar *) q, (const unsigned char *)ps->sess_key, len);
 
 #ifdef DEBUG_PASSWORD
-	dump_data(100, q, len);
+	dump_data(100, (uint8 *)q, len);
 #endif
 
 	return True;
@@ -1754,9 +1754,9 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 		   checksum after the decode, below
 		*/
 		DEBUG(2, ("schannel_decode: FAILED: packet sequence number:\n"));
-		dump_data(2, (const char*)verf->seq_num, sizeof(verf->seq_num));
+		dump_data(2, (const uint8 *)verf->seq_num, sizeof(verf->seq_num));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, (const char*)seq_num, sizeof(seq_num));
+		dump_data(2, (const uint8 *)seq_num, sizeof(seq_num));
 
 		return False;
 	}
@@ -1764,9 +1764,9 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 	if (memcmp(verf->sig, schannel_sig, sizeof(verf->sig))) {
 		/* Validate that the other end sent the expected header */
 		DEBUG(2, ("schannel_decode: FAILED: packet header:\n"));
-		dump_data(2, (const char*)verf->sig, sizeof(verf->sig));
+		dump_data(2, (const uint8 *)verf->sig, sizeof(verf->sig));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, (const char*)schannel_sig, sizeof(schannel_sig));
+		dump_data(2, (const uint8 *)schannel_sig, sizeof(schannel_sig));
 		return False;
 	}
 
-- 
cgit 


From bc2b6436d0f5f3e9ffdfaeb7f1b32996a83d5478 Mon Sep 17 00:00:00 2001
From: Stefan Metzmacher <metze@samba.org>
Date: Thu, 29 Mar 2007 09:35:51 +0000
Subject: r22009: change TDB_DATA from char * to unsigned char *

and fix all compiler warnings in the users

metze
(This used to be commit 3a28443079c141a6ce8182c65b56ca210e34f37f)
---
 source3/rpc_parse/parse_prs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 0fb429b591..632a33cb9a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1457,7 +1457,7 @@ BOOL prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32
 int tdb_prs_store(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps)
 {
     TDB_DATA dbuf;
-    dbuf.dptr = ps->data_p;
+    dbuf.dptr = (uint8 *)ps->data_p;
     dbuf.dsize = prs_offset(ps);
     return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
 }
@@ -1479,7 +1479,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *m
     if (!dbuf.dptr)
 	    return -1;
 
-    prs_give_memory(ps, dbuf.dptr, dbuf.dsize, True);
+    prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
 
     return 0;
 } 
-- 
cgit 


From 62683646dc41cac4956c7df622f37c816521051c Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 11 Apr 2007 05:05:33 +0000
Subject: r22163: Pure reformatting. I hate 4 space tabstops :-). Jeremy. (This
 used to be commit 99abe96b2b8e41e4c7536d35cc169f7e6c3eba1c)

---
 source3/rpc_parse/parse_prs.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 632a33cb9a..172195f823 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1456,38 +1456,38 @@ BOOL prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32
 /* useful function to store a structure in rpc wire format */
 int tdb_prs_store(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps)
 {
-    TDB_DATA dbuf;
-    dbuf.dptr = (uint8 *)ps->data_p;
-    dbuf.dsize = prs_offset(ps);
-    return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
+	TDB_DATA dbuf;
+	dbuf.dptr = (uint8 *)ps->data_p;
+	dbuf.dsize = prs_offset(ps);
+	return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
 }
 
 int tdb_prs_store_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
 {
-    TDB_DATA kbuf = string_term_tdb_data(keystr);
-    return tdb_prs_store(tdb, kbuf, ps);
+	TDB_DATA kbuf = string_term_tdb_data(keystr);
+	return tdb_prs_store(tdb, kbuf, ps);
 }
 
 /* useful function to fetch a structure into rpc wire format */
 int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *mem_ctx)
 {
-    TDB_DATA dbuf;
+	TDB_DATA dbuf;
 
-    prs_init(ps, 0, mem_ctx, UNMARSHALL);
+	prs_init(ps, 0, mem_ctx, UNMARSHALL);
 
-    dbuf = tdb_fetch(tdb, kbuf);
-    if (!dbuf.dptr)
-	    return -1;
+	dbuf = tdb_fetch(tdb, kbuf);
+	if (!dbuf.dptr)
+		return -1;
 
-    prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
+	prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
 
-    return 0;
+	return 0;
 } 
 
 int tdb_prs_fetch_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
 {
-    TDB_DATA kbuf = string_term_tdb_data(keystr);
-    return tdb_prs_fetch(tdb, kbuf, ps, mem_ctx);
+	TDB_DATA kbuf = string_term_tdb_data(keystr);
+	return tdb_prs_fetch(tdb, kbuf, ps, mem_ctx);
 }
 
 /*******************************************************************
-- 
cgit 


From 12ba88574bf91bdcc4447bfc3d429b799064bfd9 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 27 Apr 2007 23:18:41 +0000
Subject: r22542: Move over to using the _strict varients of the talloc calls.
 No functional changes. Looks bigger than it is :-). Jeremy. (This used to be
 commit f6fa3080fee1b20df9f1968500840a88cf0ee592)

---
 source3/rpc_parse/parse_prs.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 172195f823..bf79c44395 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -156,9 +156,9 @@ char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
 {
 	char *ret = NULL;
 
-	if (size) {
+	if (size && count) {
 		/* We can't call the type-safe version here. */
-		ret = (char *)_talloc_zero_array(ps->mem_ctx, size, count,
+		ret = (char *)_talloc_zero_array_strict(ps->mem_ctx, size, count,
 						 "parse_prs");
 	}
 	return ret;
@@ -1825,7 +1825,7 @@ return the contents of a prs_struct in a DATA_BLOB
 BOOL prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 {
 	blob->length = prs_data_size(prs);
-	blob->data = (uint8 *)talloc_zero_size(mem_ctx, blob->length);
+	blob->data = (uint8 *)TALLOC_ZERO_SIZE(mem_ctx, blob->length);
 	
 	/* set the pointer at the end of the buffer */
 	prs_set_offset( prs, prs_data_size(prs) );
-- 
cgit 


From 4ab6a8ebb70bbd5d69ad1dc6196c936f01f5aaf7 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Sun, 29 Apr 2007 00:09:22 +0000
Subject: r22564: Move the _strict -> _zeronull functions into lib/util.c and
 out of talloc at tridge's request. Jeremy. (This used to be commit
 da78488b86c464b6861d36398cca7524ad5906fe)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index bf79c44395..56fffcc26e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -158,7 +158,7 @@ char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
 
 	if (size && count) {
 		/* We can't call the type-safe version here. */
-		ret = (char *)_talloc_zero_array_strict(ps->mem_ctx, size, count,
+		ret = (char *)_talloc_zero_array_zeronull(ps->mem_ctx, size, count,
 						 "parse_prs");
 	}
 	return ret;
-- 
cgit 


From d34f6bb969092166c961e328229b1b05a30f6930 Mon Sep 17 00:00:00 2001
From: Gerald Carter <jerry@samba.org>
Date: Mon, 14 May 2007 14:23:51 +0000
Subject: r22852: merge fixes for CVE-2007-2446 and CVE-2007-2447 to all
 branches (This used to be commit f65214be68c1a59d9598bfb9f3b19e71cc3fa07b)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 56fffcc26e..84f64a2a66 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -644,7 +644,7 @@ BOOL prs_pointer( const char *name, prs_struct *ps, int depth,
 		return True;
 
 	if (UNMARSHALLING(ps)) {
-		if ( !(*data = PRS_ALLOC_MEM_VOID(ps, data_size)) )
+		if ( !(*data = PRS_ALLOC_MEM(ps, char, data_size)) )
 			return False;
 	}
 
-- 
cgit 


From 71ee55f98d87ff70e5feb0d2b280e9c71f7b9b6a Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 22 May 2007 20:20:01 +0000
Subject: r23080: Fix bug #4637 - we hads missed some cases where we were
 calling PRS_ALLOC_MEM with zero count. Jeremy. (This used to be commit
 9a10736e6fa276ca4b0726fbb7baf0daafbdc46d)

---
 source3/rpc_parse/parse_prs.c | 48 +++++++++++++++++++++++++++++--------------
 1 file changed, 33 insertions(+), 15 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 84f64a2a66..458eee200a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -644,8 +644,12 @@ BOOL prs_pointer( const char *name, prs_struct *ps, int depth,
 		return True;
 
 	if (UNMARSHALLING(ps)) {
-		if ( !(*data = PRS_ALLOC_MEM(ps, char, data_size)) )
-			return False;
+		if (data_size) {
+			if ( !(*data = PRS_ALLOC_MEM(ps, char, data_size)) )
+				return False;
+		} else {
+			*data = NULL;
+		}
 	}
 
 	return prs_fn(name, ps, depth, *data);
@@ -1016,16 +1020,16 @@ BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
 	if (q == NULL)
 		return False;
 
+	/* If the string is empty, we don't have anything to stream */
+	if (str->buf_len==0)
+		return True;
+
 	if (UNMARSHALLING(ps)) {
 		str->buffer = PRS_ALLOC_MEM(ps,uint16,str->buf_len);
 		if (str->buffer == NULL)
 			return False;
 	}
 
-	/* If the string is empty, we don't have anything to stream */
-	if (str->buf_len==0)
-		return True;
-
 	p = (char *)str->buffer;
 
 	dbg_rw_punival(charmode, name, depth, ps, q, p, str->buf_len);
@@ -1055,6 +1059,8 @@ BOOL prs_regval_buffer(BOOL charmode, const char *name, prs_struct *ps, int dept
 			buf->buffer = PRS_ALLOC_MEM(ps, uint16, buf->buf_max_len);
 			if ( buf->buffer == NULL )
 				return False;
+		} else {
+			buf->buffer = NULL;
 		}
 	}
 
@@ -1082,9 +1088,13 @@ BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STR
 		if (str->str_str_len > str->str_max_len) {
 			return False;
 		}
-		str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
-		if (str->buffer == NULL)
-			return False;
+		if (str->str_max_len) {
+			str->buffer = PRS_ALLOC_MEM(ps,unsigned char, str->str_max_len);
+			if (str->buffer == NULL)
+				return False;
+		} else {
+			str->buffer = NULL;
+		}
 	}
 
 	if (UNMARSHALLING(ps)) {
@@ -1129,9 +1139,13 @@ BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNI
 		if (str->uni_str_len > str->uni_max_len) {
 			return False;
 		}
-		str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
-		if (str->buffer == NULL)
-			return False;
+		if (str->uni_max_len) {
+			str->buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_max_len);
+			if (str->buffer == NULL)
+				return False;
+		} else {
+			str->buffer = NULL;
+		}
 	}
 
 	p = (char *)str->buffer;
@@ -1156,9 +1170,13 @@ BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps,
 		return False;
 
 	if (UNMARSHALLING(ps)) {
-		str->str.buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_str_len);
-		if (str->str.buffer == NULL)
-			return False;
+		if (str->uni_str_len) {
+			str->str.buffer = PRS_ALLOC_MEM(ps,uint16,str->uni_str_len);
+			if (str->str.buffer == NULL)
+				return False;
+		} else {
+			str->str.buffer = NULL;
+		}
 	}
 
 	p = (char *)str->str.buffer;
-- 
cgit 


From 227ba79af9a65f21c7254c51196fe21e029931b4 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 4 Jun 2007 19:29:40 +0000
Subject: r23342: Stop Coverity from getting confused. Jeremy. (This used to be
 commit 34144c63ad0d776c0b01f6bd3ce378921f2d31cd)

---
 source3/rpc_parse/parse_prs.c | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 458eee200a..e21f517974 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1094,6 +1094,9 @@ BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STR
 				return False;
 		} else {
 			str->buffer = NULL;
+			/* Return early to ensure Coverity isn't confused. */
+			DEBUG(5,("%s%04x %s: \n", tab_depth(depth), ps->data_offset, name));
+			return True;
 		}
 	}
 
-- 
cgit 


From d824b98f80ba186030cbb70b3a1e5daf80469ecd Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 9 Jul 2007 19:25:36 +0000
Subject: r23779: Change from v2 or later to v3 or later. Jeremy. (This used to
 be commit 407e6e695b8366369b7c76af1ff76869b45347b3)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index e21f517974..e0cae353eb 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -8,7 +8,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,
-- 
cgit 


From 5e54558c6dea67b56bbfaba5698f3a434d3dffb6 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 00:52:41 +0000
Subject: r23784: use the GPLv3 boilerplate as recommended by the FSF and the
 license text (This used to be commit
 b0132e94fc5fef936aa766fb99a306b3628e9f07)

---
 source3/rpc_parse/parse_prs.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index e0cae353eb..26bd3a5cec 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -17,8 +17,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 c638a84cb1215f9d67531c72959baf10deea2700 Mon Sep 17 00:00:00 2001
From: Derrell Lipman <derrell@samba.org>
Date: Tue, 14 Aug 2007 14:27:42 +0000
Subject: r24410: - I got tricked by function naming.  Contrary to what seemed
 obvious to me,   prs_mem_free() is not the function to be called to free
 memory allocated by   prs_alloc_mem().  I've added a comment so others may
 not get bitten too.

- Remove incorrect memory free calls added yesterday to replace SAFE_FREE.
  The memory is actually now on a talloc context, so gets freed by the caller
  when that context is freed.  We don't need to free it iternally.

Derrell
(This used to be commit 2fde343150c17959fc970b18e1eb4efde800b4db)
---
 source3/rpc_parse/parse_prs.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 26bd3a5cec..c51e1dff4a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -122,6 +122,10 @@ BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
 
 /*******************************************************************
  Delete the memory in a parse structure - if we own it.
+
+ NOTE: Contrary to the somewhat confusing naming, this function is not
+       intended for freeing memory allocated by prs_alloc_mem().  That memory
+       is attached to the talloc context given by ps->mem_ctx.
  ********************************************************************/
 
 void prs_mem_free(prs_struct *ps)
-- 
cgit 


From 7b24eb65a0c4189796fc74319a400c6bfb85fdb7 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Wed, 29 Aug 2007 01:23:31 +0000
Subject: r24759: Comment out the _nonnull calls for 3.2.x, as agreed with
 tridge. Leaving the commented out code for now, in case I need to re-test
 some stuff. Jeremy (This used to be commit
 343be0464342aac14a9592fd73a71b7589ba34d5)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c51e1dff4a..3c1b200ebc 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -161,7 +161,7 @@ char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count)
 
 	if (size && count) {
 		/* We can't call the type-safe version here. */
-		ret = (char *)_talloc_zero_array_zeronull(ps->mem_ctx, size, count,
+		ret = (char *)_talloc_zero_array(ps->mem_ctx, size, count,
 						 "parse_prs");
 	}
 	return ret;
-- 
cgit 


From 8401971a872dba206d7c2ea2c0ffe1aafd891ba0 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Fri, 7 Sep 2007 12:13:16 +0000
Subject: r24993: Apply some const (This used to be commit
 613b9fcd18bcc29bf5313e2287b53b8de430d17e)

---
 source3/rpc_parse/parse_prs.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 3c1b200ebc..b92433f92f 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1551,7 +1551,7 @@ static void schannel_digest(struct schannel_auth_struct *a,
 			  uchar digest_final[16]) 
 {
 	uchar whole_packet_digest[16];
-	static uchar zeros[4];
+	static const uchar zeros[4] = { 0, };
 	struct MD5Context ctx3;
 	
 	/* verfiy the signature on the packet by MD5 over various bits */
@@ -1580,7 +1580,7 @@ static void schannel_get_sealing_key(struct schannel_auth_struct *a,
 				   RPC_AUTH_SCHANNEL_CHK *verf,
 				   uchar sealing_key[16]) 
 {
-	static uchar zeros[4];
+	static const uchar zeros[4] = { 0, };
 	uchar digest2[16];
 	uchar sess_kf0[16];
 	int i;
@@ -1607,7 +1607,7 @@ static void schannel_get_sealing_key(struct schannel_auth_struct *a,
 static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
 				     RPC_AUTH_SCHANNEL_CHK *verf)
 {
-	static uchar zeros[4];
+	static const uchar zeros[4] = { 0, };
 	uchar sequence_key[16];
 	uchar digest1[16];
 
-- 
cgit 


From f708132de775403f582bd3cf216f7ed76e26932e Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sun, 7 Oct 2007 12:56:43 +0000
Subject: r25561: Make use of [un]marshall_sec_desc

Minor cleanup only
(This used to be commit 4dc4364b68b6b68ae0951a84475e2f9ea8cb1f8c)
---
 source3/rpc_parse/parse_prs.c | 12 ------------
 1 file changed, 12 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b92433f92f..c3603fe234 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1486,12 +1486,6 @@ int tdb_prs_store(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps)
 	return tdb_trans_store(tdb, kbuf, dbuf, TDB_REPLACE);
 }
 
-int tdb_prs_store_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps)
-{
-	TDB_DATA kbuf = string_term_tdb_data(keystr);
-	return tdb_prs_store(tdb, kbuf, ps);
-}
-
 /* useful function to fetch a structure into rpc wire format */
 int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *mem_ctx)
 {
@@ -1508,12 +1502,6 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *m
 	return 0;
 } 
 
-int tdb_prs_fetch_bystring(TDB_CONTEXT *tdb, char *keystr, prs_struct *ps, TALLOC_CTX *mem_ctx)
-{
-	TDB_DATA kbuf = string_term_tdb_data(keystr);
-	return tdb_prs_fetch(tdb, kbuf, ps, mem_ctx);
-}
-
 /*******************************************************************
  hash a stream.
  ********************************************************************/
-- 
cgit 


From e5a951325a6cac8567af3a66de6d2df577508ae4 Mon Sep 17 00:00:00 2001
From: "Gerald (Jerry) Carter" <jerry@samba.org>
Date: Wed, 10 Oct 2007 15:34:30 -0500
Subject: [GLUE] Rsync SAMBA_3_2_0 SVN r25598 in order to create the v3-2-test
 branch. (This used to be commit 5c6c8e1fe93f340005110a7833946191659d88ab)

---
 source3/rpc_parse/parse_prs.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index c3603fe234..b22b1faa3f 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1500,7 +1500,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *m
 	prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
 
 	return 0;
-} 
+}
 
 /*******************************************************************
  hash a stream.
@@ -1766,9 +1766,9 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 		   checksum after the decode, below
 		*/
 		DEBUG(2, ("schannel_decode: FAILED: packet sequence number:\n"));
-		dump_data(2, (const uint8 *)verf->seq_num, sizeof(verf->seq_num));
+		dump_data(2, verf->seq_num, sizeof(verf->seq_num));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, (const uint8 *)seq_num, sizeof(seq_num));
+		dump_data(2, seq_num, sizeof(seq_num));
 
 		return False;
 	}
@@ -1776,9 +1776,9 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 	if (memcmp(verf->sig, schannel_sig, sizeof(verf->sig))) {
 		/* Validate that the other end sent the expected header */
 		DEBUG(2, ("schannel_decode: FAILED: packet header:\n"));
-		dump_data(2, (const uint8 *)verf->sig, sizeof(verf->sig));
+		dump_data(2, verf->sig, sizeof(verf->sig));
 		DEBUG(2, ("should be:\n"));
-		dump_data(2, (const uint8 *)schannel_sig, sizeof(schannel_sig));
+		dump_data(2, schannel_sig, sizeof(schannel_sig));
 		return False;
 	}
 
-- 
cgit 


From 30191d1a5704ad2b158386b511558972d539ce47 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Thu, 18 Oct 2007 17:40:25 -0700
Subject: RIP BOOL. Convert BOOL -> bool. I found a few interesting bugs in
 various places whilst doing this (places that assumed BOOL == int). I also
 need to fix the Samba4 pidl generation (next checkin). Jeremy. (This used to
 be commit f35a266b3cbb3e5fa6a86be60f34fe340a3ca71f)

---
 source3/rpc_parse/parse_prs.c | 104 +++++++++++++++++++++---------------------
 1 file changed, 52 insertions(+), 52 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b22b1faa3f..a30e96772a 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -92,7 +92,7 @@ void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
  * @return False if allocation fails, otherwise True.
  **/
 
-BOOL prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, BOOL io)
+bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io)
 {
 	ZERO_STRUCTP(ps);
 	ps->io = io;
@@ -180,7 +180,7 @@ TALLOC_CTX *prs_get_mem_context(prs_struct *ps)
  Hand some already allocated memory to a prs_struct.
  ********************************************************************/
 
-void prs_give_memory(prs_struct *ps, char *buf, uint32 size, BOOL is_dynamic)
+void prs_give_memory(prs_struct *ps, char *buf, uint32 size, bool is_dynamic)
 {
 	ps->is_dynamic = is_dynamic;
 	ps->data_p = buf;
@@ -205,7 +205,7 @@ char *prs_take_memory(prs_struct *ps, uint32 *psize)
  Set a prs_struct to exactly a given size. Will grow or tuncate if neccessary.
  ********************************************************************/
 
-BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
+bool prs_set_buffer_size(prs_struct *ps, uint32 newsize)
 {
 	if (newsize > ps->buffer_size)
 		return prs_force_grow(ps, newsize - ps->buffer_size);
@@ -236,7 +236,7 @@ BOOL prs_set_buffer_size(prs_struct *ps, uint32 newsize)
  Also depends on the data stream mode (io).
  ********************************************************************/
 
-BOOL prs_grow(prs_struct *ps, uint32 extra_space)
+bool prs_grow(prs_struct *ps, uint32 extra_space)
 {
 	uint32 new_size;
 
@@ -300,7 +300,7 @@ BOOL prs_grow(prs_struct *ps, uint32 extra_space)
  when reading an rpc reply, before unmarshalling it.
  ********************************************************************/
 
-BOOL prs_force_grow(prs_struct *ps, uint32 extra_space)
+bool prs_force_grow(prs_struct *ps, uint32 extra_space)
 {
 	uint32 new_size = ps->buffer_size + extra_space;
 
@@ -354,7 +354,7 @@ uint32 prs_offset(prs_struct *ps)
  Set the current offset (external interface).
  ********************************************************************/
 
-BOOL prs_set_offset(prs_struct *ps, uint32 offset)
+bool prs_set_offset(prs_struct *ps, uint32 offset)
 {
 	if(offset <= ps->data_offset) {
 		ps->data_offset = offset;
@@ -372,7 +372,7 @@ BOOL prs_set_offset(prs_struct *ps, uint32 offset)
  Append the data from one parse_struct into another.
  ********************************************************************/
 
-BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
+bool prs_append_prs_data(prs_struct *dst, prs_struct *src)
 {
 	if (prs_offset(src) == 0)
 		return True;
@@ -390,7 +390,7 @@ BOOL prs_append_prs_data(prs_struct *dst, prs_struct *src)
  Append some data from one parse_struct into another.
  ********************************************************************/
 
-BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
+bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
 {	
 	if (len == 0)
 		return True;
@@ -408,7 +408,7 @@ BOOL prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uin
  Append the data from a buffer into a parse_struct.
  ********************************************************************/
 
-BOOL prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
+bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
 {
 	if (len == 0)
 		return True;
@@ -426,7 +426,7 @@ BOOL prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
  Copy some data from a parse_struct into a buffer.
  ********************************************************************/
 
-BOOL prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
+bool prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
 {
 	if (len == 0)
 		return True;
@@ -444,7 +444,7 @@ BOOL prs_copy_data_out(char *dst, prs_struct *src, uint32 len)
  Copy all the data from a parse_struct into a buffer.
  ********************************************************************/
 
-BOOL prs_copy_all_data_out(char *dst, prs_struct *src)
+bool prs_copy_all_data_out(char *dst, prs_struct *src)
 {
 	uint32 len = prs_offset(src);
 
@@ -459,7 +459,7 @@ BOOL prs_copy_all_data_out(char *dst, prs_struct *src)
  Set the data as X-endian (external interface).
  ********************************************************************/
 
-void prs_set_endian_data(prs_struct *ps, BOOL endian)
+void prs_set_endian_data(prs_struct *ps, bool endian)
 {
 	ps->bigendian_data = endian;
 }
@@ -469,7 +469,7 @@ void prs_set_endian_data(prs_struct *ps, BOOL endian)
  zeros.
  ********************************************************************/
 
-BOOL prs_align(prs_struct *ps)
+bool prs_align(prs_struct *ps)
 {
 	uint32 mod = ps->data_offset & (ps->align-1);
 
@@ -488,9 +488,9 @@ BOOL prs_align(prs_struct *ps)
  Align on a 2 byte boundary
  *****************************************************************/
  
-BOOL prs_align_uint16(prs_struct *ps)
+bool prs_align_uint16(prs_struct *ps)
 {
-	BOOL ret;
+	bool ret;
 	uint8 old_align = ps->align;
 
 	ps->align = 2;
@@ -504,9 +504,9 @@ BOOL prs_align_uint16(prs_struct *ps)
  Align on a 8 byte boundary
  *****************************************************************/
  
-BOOL prs_align_uint64(prs_struct *ps)
+bool prs_align_uint64(prs_struct *ps)
 {
-	BOOL ret;
+	bool ret;
 	uint8 old_align = ps->align;
 
 	ps->align = 8;
@@ -520,9 +520,9 @@ BOOL prs_align_uint64(prs_struct *ps)
  Align on a specific byte boundary
  *****************************************************************/
  
-BOOL prs_align_custom(prs_struct *ps, uint8 boundary)
+bool prs_align_custom(prs_struct *ps, uint8 boundary)
 {
-	BOOL ret;
+	bool ret;
 	uint8 old_align = ps->align;
 
 	ps->align = boundary;
@@ -538,7 +538,7 @@ BOOL prs_align_custom(prs_struct *ps, uint8 boundary)
  Align only if required (for the unistr2 string mainly)
  ********************************************************************/
 
-BOOL prs_align_needed(prs_struct *ps, uint32 needed)
+bool prs_align_needed(prs_struct *ps, uint32 needed)
 {
 	if (needed==0)
 		return True;
@@ -577,7 +577,7 @@ char *prs_mem_get(prs_struct *ps, uint32 extra_size)
  Change the struct type.
  ********************************************************************/
 
-void prs_switch_type(prs_struct *ps, BOOL io)
+void prs_switch_type(prs_struct *ps, bool io)
 {
 	if ((ps->io ^ io) == True)
 		ps->io=io;
@@ -605,7 +605,7 @@ void prs_set_session_key(prs_struct *ps, const char sess_key[16])
  Stream a uint8.
  ********************************************************************/
 
-BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
+bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 {
 	char *q = prs_mem_get(ps, 1);
 	if (q == NULL)
@@ -627,9 +627,9 @@ BOOL prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
  Stream a uint16* (allocate memory if unmarshalling)
  ********************************************************************/
 
-BOOL prs_pointer( const char *name, prs_struct *ps, int depth, 
+bool prs_pointer( const char *name, prs_struct *ps, int depth, 
                  void *dta, size_t data_size,
-                 BOOL(*prs_fn)(const char*, prs_struct*, int, void*) )
+                 bool (*prs_fn)(const char*, prs_struct*, int, void*) )
 {
 	void ** data = (void **)dta;
 	uint32 data_p;
@@ -663,7 +663,7 @@ BOOL prs_pointer( const char *name, prs_struct *ps, int depth,
  Stream a uint16.
  ********************************************************************/
 
-BOOL prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
+bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
 {
 	char *q = prs_mem_get(ps, sizeof(uint16));
 	if (q == NULL)
@@ -692,7 +692,7 @@ BOOL prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
  Stream a uint32.
  ********************************************************************/
 
-BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
+bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -721,7 +721,7 @@ BOOL prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
  Stream an int32.
  ********************************************************************/
 
-BOOL prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
+bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
 {
 	char *q = prs_mem_get(ps, sizeof(int32));
 	if (q == NULL)
@@ -750,7 +750,7 @@ BOOL prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
  Stream a NTSTATUS
  ********************************************************************/
 
-BOOL prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
+bool prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -780,7 +780,7 @@ BOOL prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
  Stream a DCE error code
  ********************************************************************/
 
-BOOL prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
+bool prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -811,7 +811,7 @@ BOOL prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *st
  Stream a WERROR
  ********************************************************************/
 
-BOOL prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
+bool prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
 {
 	char *q = prs_mem_get(ps, sizeof(uint32));
 	if (q == NULL)
@@ -842,7 +842,7 @@ BOOL prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
  Stream an array of uint8s. Length is number of uint8s.
  ********************************************************************/
 
-BOOL prs_uint8s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
 {
 	int i;
 	char *q = prs_mem_get(ps, len);
@@ -875,7 +875,7 @@ BOOL prs_uint8s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint
  Stream an array of uint16s. Length is number of uint16s.
  ********************************************************************/
 
-BOOL prs_uint16s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+bool prs_uint16s(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
 	int i;
 	char *q = prs_mem_get(ps, len * sizeof(uint16));
@@ -919,7 +919,7 @@ BOOL prs_uint16s(BOOL charmode, const char *name, prs_struct *ps, int depth, uin
  output must be little-endian, if marshalling, input must be little-endian.
  ********************************************************************/
 
-static void dbg_rw_punival(BOOL charmode, const char *name, int depth, prs_struct *ps,
+static void dbg_rw_punival(bool charmode, const char *name, int depth, prs_struct *ps,
 							char *in_buf, char *out_buf, int len)
 {
 	int i;
@@ -956,7 +956,7 @@ static void dbg_rw_punival(BOOL charmode, const char *name, int depth, prs_struc
  Stream a unistr. Always little endian.
  ********************************************************************/
 
-BOOL prs_uint16uni(BOOL charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
+bool prs_uint16uni(bool charmode, const char *name, prs_struct *ps, int depth, uint16 *data16s, int len)
 {
 	char *q = prs_mem_get(ps, len * sizeof(uint16));
 	if (q == NULL)
@@ -972,7 +972,7 @@ BOOL prs_uint16uni(BOOL charmode, const char *name, prs_struct *ps, int depth, u
  Stream an array of uint32s. Length is number of uint32s.
  ********************************************************************/
 
-BOOL prs_uint32s(BOOL charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
+bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, int depth, uint32 *data32s, int len)
 {
 	int i;
 	char *q = prs_mem_get(ps, len * sizeof(uint32));
@@ -1016,7 +1016,7 @@ BOOL prs_uint32s(BOOL charmode, const char *name, prs_struct *ps, int depth, uin
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUFFER5 *str)
+bool prs_buffer5(bool charmode, const char *name, prs_struct *ps, int depth, BUFFER5 *str)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->buf_len * sizeof(uint16));
@@ -1047,7 +1047,7 @@ BOOL prs_buffer5(BOOL charmode, const char *name, prs_struct *ps, int depth, BUF
  in byte chars. String is in little-endian format.
  ********************************************************************/
 
-BOOL prs_regval_buffer(BOOL charmode, const char *name, prs_struct *ps, int depth, REGVAL_BUFFER *buf)
+bool prs_regval_buffer(bool charmode, const char *name, prs_struct *ps, int depth, REGVAL_BUFFER *buf)
 {
 	char *p;
 	char *q = prs_mem_get(ps, buf->buf_len);
@@ -1080,7 +1080,7 @@ BOOL prs_regval_buffer(BOOL charmode, const char *name, prs_struct *ps, int dept
  in uint8 chars.
  ********************************************************************/
 
-BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
+bool prs_string2(bool charmode, const char *name, prs_struct *ps, int depth, STRING2 *str)
 {
 	unsigned int i;
 	char *q = prs_mem_get(ps, str->str_str_len);
@@ -1130,7 +1130,7 @@ BOOL prs_string2(BOOL charmode, const char *name, prs_struct *ps, int depth, STR
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNISTR2 *str)
+bool prs_unistr2(bool charmode, const char *name, prs_struct *ps, int depth, UNISTR2 *str)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
@@ -1168,7 +1168,7 @@ BOOL prs_unistr2(BOOL charmode, const char *name, prs_struct *ps, int depth, UNI
  in uint16 chars. The unicode string is already in little-endian format.
  ********************************************************************/
 
-BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps, int depth)
+bool prs_unistr3(bool charmode, const char *name, UNISTR3 *str, prs_struct *ps, int depth)
 {
 	char *p;
 	char *q = prs_mem_get(ps, str->uni_str_len * sizeof(uint16));
@@ -1198,7 +1198,7 @@ BOOL prs_unistr3(BOOL charmode, const char *name, UNISTR3 *str, prs_struct *ps,
  in little-endian format then do it as a stream of bytes.
  ********************************************************************/
 
-BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
+bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 {
 	unsigned int len = 0;
 	unsigned char *p = (unsigned char *)str->buffer;
@@ -1323,7 +1323,7 @@ BOOL prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
  not include the null-termination character.
  ********************************************************************/
 
-BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
+bool prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_buf_size)
 {
 	char *q;
 	int i;
@@ -1361,7 +1361,7 @@ BOOL prs_string(const char *name, prs_struct *ps, int depth, char *str, int max_
 	return True;
 }
 
-BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **str)
+bool prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **str)
 {
 	size_t len;
 	char *tmp_str;
@@ -1395,7 +1395,7 @@ BOOL prs_string_alloc(const char *name, prs_struct *ps, int depth, const char **
  uint16 should be stored, or gets the size if reading.
  ********************************************************************/
 
-BOOL prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
+bool prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16, uint32 *offset)
 {
 	*offset = ps->data_offset;
 	if (UNMARSHALLING(ps)) {
@@ -1415,7 +1415,7 @@ BOOL prs_uint16_pre(const char *name, prs_struct *ps, int depth, uint16 *data16,
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 
-BOOL prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16,
+bool prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16,
 				uint32 ptr_uint16, uint32 start_offset)
 {
 	if (MARSHALLING(ps)) {
@@ -1442,7 +1442,7 @@ BOOL prs_uint16_post(const char *name, prs_struct *ps, int depth, uint16 *data16
  uint32 should be stored, or gets the size if reading.
  ********************************************************************/
 
-BOOL prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
+bool prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32, uint32 *offset)
 {
 	*offset = ps->data_offset;
 	if (UNMARSHALLING(ps) && (data32 != NULL)) {
@@ -1459,7 +1459,7 @@ BOOL prs_uint32_pre(const char *name, prs_struct *ps, int depth, uint32 *data32,
  does nothing on reading, as that is already handled by ...._pre()
  ********************************************************************/
 
-BOOL prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32,
+bool prs_uint32_post(const char *name, prs_struct *ps, int depth, uint32 *data32,
 				uint32 ptr_uint32, uint32 data_size)
 {
 	if (MARSHALLING(ps)) {
@@ -1506,7 +1506,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *m
  hash a stream.
  ********************************************************************/
 
-BOOL prs_hash1(prs_struct *ps, uint32 offset, int len)
+bool prs_hash1(prs_struct *ps, uint32 offset, int len)
 {
 	char *q;
 
@@ -1615,7 +1615,7 @@ static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
 creates an RPC_AUTH_SCHANNEL_CHK structure.
 ********************************************************************/
 
-static BOOL init_rpc_auth_schannel_chk(RPC_AUTH_SCHANNEL_CHK * chk,
+static bool init_rpc_auth_schannel_chk(RPC_AUTH_SCHANNEL_CHK * chk,
 			      const uchar sig[8],
 			      const uchar packet_digest[8],
 			      const uchar seq_num[8], const uchar confounder[8])
@@ -1717,7 +1717,7 @@ void schannel_encode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
  as well as decode sealed messages
  ********************************************************************/
 
-BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
+bool schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_level,
 		   enum schannel_direction direction, 
 		   RPC_AUTH_SCHANNEL_CHK * verf, char *data, size_t data_len)
 {
@@ -1819,7 +1819,7 @@ BOOL schannel_decode(struct schannel_auth_struct *a, enum pipe_auth_level auth_l
 /*******************************************************************
 creates a new prs_struct containing a DATA_BLOB
 ********************************************************************/
-BOOL prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+bool prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 {
 	if (!prs_init( prs, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL ))
 		return False;
@@ -1834,7 +1834,7 @@ BOOL prs_init_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 /*******************************************************************
 return the contents of a prs_struct in a DATA_BLOB
 ********************************************************************/
-BOOL prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
+bool prs_data_blob(prs_struct *prs, DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
 {
 	blob->length = prs_data_size(prs);
 	blob->data = (uint8 *)TALLOC_ZERO_SIZE(mem_ctx, blob->length);
-- 
cgit 


From c049b8157d0bb4b5cd57b66740a26813be4f9eba Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 20 Nov 2007 15:31:37 -0800
Subject: More trivial pstring removal. Jeremy. (This used to be commit
 bac3bb2f6e9e15b3a9a6a6511c484f8509918ca1)

---
 source3/rpc_parse/parse_prs.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index a30e96772a..137e0dabac 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -48,14 +48,18 @@ void prs_dump_region(char *name, int v, prs_struct *ps,
 		     int from_off, int to_off)
 {
 	int fd, i;
-	pstring fname;
+	char *fname = NULL;
 	ssize_t sz;
 	if (DEBUGLEVEL < 50) return;
 	for (i=1;i<100;i++) {
 		if (v != -1) {
-			slprintf(fname,sizeof(fname)-1, "/tmp/%s_%d.%d.prs", name, v, i);
+			if (asprintf(&fname,"/tmp/%s_%d.%d.prs", name, v, i) < 0) {
+				return;
+			}
 		} else {
-			slprintf(fname,sizeof(fname)-1, "/tmp/%s.%d.prs", name, i);
+			if (asprintf(&fname,"/tmp/%s.%d.prs", name, i) < 0) {
+				return;
+			}
 		}
 		fd = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0644);
 		if (fd != -1 || errno != EEXIST) break;
@@ -69,6 +73,7 @@ void prs_dump_region(char *name, int v, prs_struct *ps,
 			DEBUG(0,("created %s\n", fname));
 		}
 	}
+	SAFE_FREE(fname);
 }
 
 /*******************************************************************
-- 
cgit 


From 66298d808034bb606478ff66aa156bda4e7e3f2a Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Tue, 20 Nov 2007 17:18:16 -0800
Subject: More pstring elimination. Jeremy. (This used to be commit
 15074de938539e7a9c527d9a6d81792adc2ac3d0)

---
 source3/rpc_parse/parse_prs.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 137e0dabac..4abf63e71d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -28,7 +28,7 @@
 /**
  * Dump a prs to a file: from the current location through to the end.
  **/
-void prs_dump(char *name, int v, prs_struct *ps)
+void prs_dump(const char *name, int v, prs_struct *ps)
 {
 	prs_dump_region(name, v, ps, ps->data_offset, ps->buffer_size);
 }
@@ -36,7 +36,7 @@ void prs_dump(char *name, int v, prs_struct *ps)
 /**
  * Dump from the start of the prs to the current location.
  **/
-void prs_dump_before(char *name, int v, prs_struct *ps)
+void prs_dump_before(const char *name, int v, prs_struct *ps)
 {
 	prs_dump_region(name, v, ps, 0, ps->data_offset);
 }
@@ -44,7 +44,7 @@ void prs_dump_before(char *name, int v, prs_struct *ps)
 /**
  * Dump everything from the start of the prs up to the current location.
  **/
-void prs_dump_region(char *name, int v, prs_struct *ps,
+void prs_dump_region(const char *name, int v, prs_struct *ps,
 		     int from_off, int to_off)
 {
 	int fd, i;
-- 
cgit 


From c8071c3522abefb651596e2335e724ae50cb8a90 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Mon, 17 Dec 2007 16:20:44 -0800
Subject: Use the %*s feature of snprintf to remove anothe static fstring.
 Jeremy. (This used to be commit 4ae4b2358688bf289305a2db0ed01b653ac073b2)

---
 source3/rpc_parse/parse_prs.c | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 4abf63e71d..23dae9f3a1 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -85,7 +85,7 @@ void prs_dump_region(const char *name, int v, prs_struct *ps,
 
 void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name)
 {
-	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(depth), ps->data_offset, fn_name, desc));
+	DEBUG(5+depth, ("%s%06x %s %s\n", tab_depth(5+depth,depth), ps->data_offset, fn_name, desc));
 }
 
 /**
@@ -621,7 +621,7 @@ bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
 	else
 		SCVAL(q,0,*data8);
 
-	DEBUG(5,("%s%04x %s: %02x\n", tab_depth(depth), ps->data_offset, name, *data8));
+	DEBUG(5,("%s%04x %s: %02x\n", tab_depth(5,depth), ps->data_offset, name, *data8));
 
 	ps->data_offset += 1;
 
@@ -686,7 +686,7 @@ bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
 			SSVAL(q,0,*data16);
 	}
 
-	DEBUG(5,("%s%04x %s: %04x\n", tab_depth(depth), ps->data_offset, name, *data16));
+	DEBUG(5,("%s%04x %s: %04x\n", tab_depth(5,depth), ps->data_offset, name, *data16));
 
 	ps->data_offset += sizeof(uint16);
 
@@ -715,7 +715,7 @@ bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
 			SIVAL(q,0,*data32);
 	}
 
-	DEBUG(5,("%s%04x %s: %08x\n", tab_depth(depth), ps->data_offset, name, *data32));
+	DEBUG(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
 
 	ps->data_offset += sizeof(uint32);
 
@@ -744,7 +744,7 @@ bool prs_int32(const char *name, prs_struct *ps, int depth, int32 *data32)
 			SIVALS(q,0,*data32);
 	}
 
-	DEBUG(5,("%s%04x %s: %08x\n", tab_depth(depth), ps->data_offset, name, *data32));
+	DEBUG(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
 
 	ps->data_offset += sizeof(int32);
 
@@ -773,7 +773,7 @@ bool prs_ntstatus(const char *name, prs_struct *ps, int depth, NTSTATUS *status)
 			SIVAL(q,0,NT_STATUS_V(*status));
 	}
 
-	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
+	DEBUG(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name, 
 		 nt_errstr(*status)));
 
 	ps->data_offset += sizeof(uint32);
@@ -803,7 +803,7 @@ bool prs_dcerpc_status(const char *name, prs_struct *ps, int depth, NTSTATUS *st
 			SIVAL(q,0,NT_STATUS_V(*status));
 	}
 
-	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
+	DEBUG(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name, 
 		 dcerpc_errstr(NT_STATUS_V(*status))));
 
 	ps->data_offset += sizeof(uint32);
@@ -834,7 +834,7 @@ bool prs_werror(const char *name, prs_struct *ps, int depth, WERROR *status)
 			SIVAL(q,0,W_ERROR_V(*status));
 	}
 
-	DEBUG(5,("%s%04x %s: %s\n", tab_depth(depth), ps->data_offset, name, 
+	DEBUG(5,("%s%04x %s: %s\n", tab_depth(5,depth), ps->data_offset, name, 
 		 dos_errstr(*status)));
 
 	ps->data_offset += sizeof(uint32);
@@ -862,7 +862,7 @@ bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint
 			SCVAL(q, i, data8s[i]);
 	}
 
-	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset ,name));
+	DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset ,name));
 	if (charmode)
 		print_asc(5, (unsigned char*)data8s, len);
 	else {
@@ -905,7 +905,7 @@ bool prs_uint16s(bool charmode, const char *name, prs_struct *ps, int depth, uin
 		}
 	}
 
-	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
 	if (charmode)
 		print_asc(5, (unsigned char*)data16s, 2*len);
 	else {
@@ -947,7 +947,7 @@ static void dbg_rw_punival(bool charmode, const char *name, int depth, prs_struc
 		}
 	}
 
-	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
 	if (charmode)
 		print_asc(5, (unsigned char*)out_buf, 2*len);
 	else {
@@ -1002,7 +1002,7 @@ bool prs_uint32s(bool charmode, const char *name, prs_struct *ps, int depth, uin
 		}
 	}
 
-	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
 	if (charmode)
 		print_asc(5, (unsigned char*)data32s, 4*len);
 	else {
@@ -1103,7 +1103,7 @@ bool prs_string2(bool charmode, const char *name, prs_struct *ps, int depth, STR
 		} else {
 			str->buffer = NULL;
 			/* Return early to ensure Coverity isn't confused. */
-			DEBUG(5,("%s%04x %s: \n", tab_depth(depth), ps->data_offset, name));
+			DEBUG(5,("%s%04x %s: \n", tab_depth(5,depth), ps->data_offset, name));
 			return True;
 		}
 	}
@@ -1116,7 +1116,7 @@ bool prs_string2(bool charmode, const char *name, prs_struct *ps, int depth, STR
 			SCVAL(q, i, str->buffer[i]);
 	}
 
-	DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+	DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
 	if (charmode)
 		print_asc(5, (unsigned char*)str->buffer, str->str_str_len);
 	else {
@@ -1252,7 +1252,7 @@ bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 
 		len++;
 
-		DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+		DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
 		print_asc(5, (unsigned char*)start, 2*len);	
 		DEBUG(5, ("\n"));
 	}
@@ -1309,7 +1309,7 @@ bool prs_unistr(const char *name, prs_struct *ps, int depth, UNISTR *str)
 			str->buffer[len++] = '\0';
 		}
 
-		DEBUG(5,("%s%04x %s: ", tab_depth(depth), ps->data_offset, name));
+		DEBUG(5,("%s%04x %s: ", tab_depth(5,depth), ps->data_offset, name));
 		print_asc(5, (unsigned char*)str->buffer, 2*len);	
 		DEBUG(5, ("\n"));
 	}
-- 
cgit 


From 533d6f617efc4dfe1e145785cb9736df07671bdf Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@samba.org>
Date: Fri, 28 Dec 2007 17:02:34 +0100
Subject: Remove static zeros (This used to be commit
 dbcc213710a9af31b6094d4741a6f68f573dcdad)

---
 source3/rpc_parse/parse_prs.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 23dae9f3a1..638d71a73e 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1544,9 +1544,11 @@ static void schannel_digest(struct schannel_auth_struct *a,
 			  uchar digest_final[16]) 
 {
 	uchar whole_packet_digest[16];
-	static const uchar zeros[4] = { 0, };
+	uchar zeros[4];
 	struct MD5Context ctx3;
-	
+
+	ZERO_STRUCT(zeros);
+
 	/* verfiy the signature on the packet by MD5 over various bits */
 	MD5Init(&ctx3);
 	/* use our sequence number, which ensures the packet is not
@@ -1573,11 +1575,13 @@ static void schannel_get_sealing_key(struct schannel_auth_struct *a,
 				   RPC_AUTH_SCHANNEL_CHK *verf,
 				   uchar sealing_key[16]) 
 {
-	static const uchar zeros[4] = { 0, };
+	uchar zeros[4];
 	uchar digest2[16];
 	uchar sess_kf0[16];
 	int i;
 
+	ZERO_STRUCT(zeros);
+
 	for (i = 0; i < sizeof(sess_kf0); i++) {
 		sess_kf0[i] = a->sess_key[i] ^ 0xf0;
 	}
@@ -1600,10 +1604,12 @@ static void schannel_get_sealing_key(struct schannel_auth_struct *a,
 static void schannel_deal_with_seq_num(struct schannel_auth_struct *a,
 				     RPC_AUTH_SCHANNEL_CHK *verf)
 {
-	static const uchar zeros[4] = { 0, };
+	uchar zeros[4];
 	uchar sequence_key[16];
 	uchar digest1[16];
 
+	ZERO_STRUCT(zeros);
+
 	hmac_md5(a->sess_key, zeros, sizeof(zeros), digest1);
 	dump_data_pw("(sequence key) digest1:\n", digest1, sizeof(digest1));
 
-- 
cgit 


From e06aa46b9fab1e107fea8f6453fb13deffa91e96 Mon Sep 17 00:00:00 2001
From: Marc VanHeyningen <marc.vanheyningen@isilon.com>
Date: Fri, 14 Mar 2008 14:26:28 -0800
Subject: Coverity fixes (This used to be commit
 3fc85d22590550f0539215d020e4411bf5b14363)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 638d71a73e..072132f5ac 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -1496,7 +1496,7 @@ int tdb_prs_fetch(TDB_CONTEXT *tdb, TDB_DATA kbuf, prs_struct *ps, TALLOC_CTX *m
 {
 	TDB_DATA dbuf;
 
-	prs_init(ps, 0, mem_ctx, UNMARSHALL);
+	prs_init_empty(ps, mem_ctx, UNMARSHALL);
 
 	dbuf = tdb_fetch(tdb, kbuf);
 	if (!dbuf.dptr)
-- 
cgit 


From 84fca380f2040c53d20fff41972d2f4102183766 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vl@sernet.de>
Date: Wed, 3 Sep 2008 14:22:48 +0200
Subject: factor prs_append_some_data out of prs_append_some_prs_data (This
 used to be commit 32cb45c962c822bd79a7d0f666f2f6037060b324)

---
 source3/rpc_parse/parse_prs.c | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index 072132f5ac..b3deb80c5d 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -395,18 +395,26 @@ bool prs_append_prs_data(prs_struct *dst, prs_struct *src)
  Append some data from one parse_struct into another.
  ********************************************************************/
 
-bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start, uint32 len)
-{	
-	if (len == 0)
-		return True;
+bool prs_append_some_data(prs_struct *dst, void *src_base, uint32_t start,
+			  uint32_t len)
+{
+	if (len == 0) {
+		return true;
+	}
 
-	if(!prs_grow(dst, len))
-		return False;
-	
-	memcpy(&dst->data_p[dst->data_offset], src->data_p + start, (size_t)len);
+	if(!prs_grow(dst, len)) {
+		return false;
+	}
+
+	memcpy(&dst->data_p[dst->data_offset], src_base + start, (size_t)len);
 	dst->data_offset += len;
+	return true;
+}
 
-	return True;
+bool prs_append_some_prs_data(prs_struct *dst, prs_struct *src, int32 start,
+			      uint32 len)
+{
+	return prs_append_some_data(dst, src->data_p, start, len);
 }
 
 /*******************************************************************
-- 
cgit 


From beb19da53fc59bd3c09e9967dd243fd963b43382 Mon Sep 17 00:00:00 2001
From: Jeremy Allison <jra@samba.org>
Date: Fri, 5 Sep 2008 15:20:59 -0700
Subject: Fix "warning: pointer of type 'void *' used in arithmetic". Jeremy.
 (This used to be commit 2d95ea38a2f1ead37121fcc036c21a7f20ff41f9)

---
 source3/rpc_parse/parse_prs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source3/rpc_parse/parse_prs.c')

diff --git a/source3/rpc_parse/parse_prs.c b/source3/rpc_parse/parse_prs.c
index b3deb80c5d..5eb6c31ee6 100644
--- a/source3/rpc_parse/parse_prs.c
+++ b/source3/rpc_parse/parse_prs.c
@@ -406,7 +406,7 @@ bool prs_append_some_data(prs_struct *dst, void *src_base, uint32_t start,
 		return false;
 	}
 
-	memcpy(&dst->data_p[dst->data_offset], src_base + start, (size_t)len);
+	memcpy(&dst->data_p[dst->data_offset], ((char *)src_base) + start, (size_t)len);
 	dst->data_offset += len;
 	return true;
 }
-- 
cgit