sync 3.0 branch with head

(This used to be commit 3928578b52cfc949be5e0ef444fce1558d75f290)

7 files changed, 1141 insertions, 139 deletions

diff --git a/source3/rpc_parse/parse_lsa.c b/source3/rpc_parse/parse_lsa.c
index a6aecb7967..375bbd31d7 100644
--- a/source3/rpc_parse/parse_lsa.c
+++ b/source3/rpc_parse/parse_lsa.c
@@ -3,8 +3,9 @@
  *  RPC Pipe client / server routines
  *  Copyright (C) Andrew Tridgell              1992-1997,
  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
- *  Copyright (C) Paul Ashton                       1997.
- *  Copyright (C) Andrew Bartlett                   2002.
+ *  Copyright (C) Paul Ashton                       1997,
+ *  Copyright (C) Andrew Bartlett                   2002,
+ *  Copyright (C) Jim McDonough                     2002.
  *  
  *  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
@@ -2117,3 +2118,121 @@ BOOL policy_handle_is_valid(const POLICY_HND *hnd)
 	ZERO_STRUCT(zero_pol);
 	return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? False : True );
 }
+
+/*******************************************************************
+ Reads or writes an LSA_DNS_DOM_INFO structure.
+********************************************************************/
+
+BOOL lsa_io_dns_dom_info(char *desc, LSA_DNS_DOM_INFO *info,
+			 prs_struct *ps, int depth)
+{
+	prs_debug(ps, depth, desc, "lsa_io_dns_dom_info");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+	if(!smb_io_unihdr("nb_name", &info->hdr_nb_dom_name, ps, depth))
+		return False;
+	if(!smb_io_unihdr("dns_name", &info->hdr_dns_dom_name, ps, depth))
+		return False;
+	if(!smb_io_unihdr("forest", &info->hdr_forest_name, ps, depth))
+		return False;
+
+	if(!prs_align(ps))
+		return False;
+	if (!prs_uint8s(False, "dom_guid", ps, depth, info->dom_guid.info, GUID_SIZE))
+		return False;
+
+	if(!prs_align(ps))
+		return False;
+	if(!prs_uint32("dom_sid", ps, depth, &info->ptr_dom_sid))
+		return False;
+
+	if(!smb_io_unistr2("nb_name", &info->uni_nb_dom_name,
+			   info->hdr_nb_dom_name.buffer, ps, depth))
+		return False;
+	if(!smb_io_unistr2("dns_name", &info->uni_dns_dom_name, 
+			   info->hdr_dns_dom_name.buffer, ps, depth))
+		return False;
+	if(!smb_io_unistr2("forest", &info->uni_forest_name, 
+			   info->hdr_forest_name.buffer, ps, depth))
+		return False;
+
+	if(!smb_io_dom_sid2("dom_sid", &info->dom_sid, ps, depth))
+		return False;
+
+	return True;
+	
+}
+
+/*******************************************************************
+ Inits an LSA_Q_QUERY_INFO2 structure.
+********************************************************************/
+
+void init_q_query2(LSA_Q_QUERY_INFO2 *q_q, POLICY_HND *hnd, uint16 info_class)
+{
+	DEBUG(5, ("init_q_query2\n"));
+
+	memcpy(&q_q->pol, hnd, sizeof(q_q->pol));
+
+	q_q->info_class = info_class;
+}
+
+/*******************************************************************
+ Reads or writes an LSA_Q_QUERY_DNSDOMINFO structure.
+********************************************************************/
+
+BOOL lsa_io_q_query_info2(char *desc, LSA_Q_QUERY_INFO2 *q_c,
+			  prs_struct *ps, int depth)
+{
+	prs_debug(ps, depth, desc, "lsa_io_q_query_info2");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+ 
+	if(!smb_io_pol_hnd("pol", &q_c->pol, ps, depth))
+		return False;
+	
+	if(!prs_uint16("info_class", ps, depth, &q_c->info_class))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
+ Reads or writes an LSA_R_QUERY_DNSDOMINFO structure.
+********************************************************************/
+
+BOOL lsa_io_r_query_info2(char *desc, LSA_R_QUERY_INFO2 *r_c,
+			  prs_struct *ps, int depth)
+{
+	prs_debug(ps, depth, desc, "lsa_io_r_query_info2");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("ptr", ps, depth, &r_c->ptr))
+		return False;
+	if(!prs_uint16("info_class", ps, depth, &r_c->info_class))
+		return False;
+	switch(r_c->info_class) {
+	case 0x000c:
+		if (!lsa_io_dns_dom_info("info12", &r_c->info.dns_dom_info,
+					 ps, depth))
+			return False;
+		break;
+	default:
+		DEBUG(0,("lsa_io_r_query_info2: unknown info class %d\n",
+			 r_c->info_class));
+		return False;
+	}
+
+	if(!prs_align(ps))
+		return False;
+	if(!prs_ntstatus("status", ps, depth, &r_c->status))
+		return False;
+
+	return True;
+}
diff --git a/source3/rpc_parse/parse_net.c b/source3/rpc_parse/parse_net.c
index 46fdce63ff..da49a6531d 100644
--- a/source3/rpc_parse/parse_net.c
+++ b/source3/rpc_parse/parse_net.c
@@ -1335,7 +1335,7 @@ void init_net_user_info3(TALLOC_CTX *ctx, NET_USER_INFO_3 *usr,
 ********************************************************************/
 
 BOOL net_io_user_info3(const char *desc, NET_USER_INFO_3 *usr, prs_struct *ps, 
-			      int depth, uint16 validation_level)
+		       int depth, uint16 validation_level)
 {
 	int i;
 
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;
diff --git a/source3/rpc_parse/parse_reg.c b/source3/rpc_parse/parse_reg.c
index 1ebc1532f3..365ad2dc70 100644
--- a/source3/rpc_parse/parse_reg.c
+++ b/source3/rpc_parse/parse_reg.c
@@ -1,4 +1,4 @@
-/* 
+/*
  *  Unix SMB/CIFS implementation.
  *  RPC Pipe client / server routines
  *  Copyright (C) Andrew Tridgell              1992-1997,
@@ -6,6 +6,7 @@
  *  Copyright (C) Paul Ashton                       1997.
  *  Copyright (C) Marc Jacobsen                     1999.
  *  Copyright (C) Simo Sorce                        2000.
+ *  Copyright (C) Gerald Carter                     2002.
  *  
  *  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
@@ -28,6 +29,89 @@
 #define DBGC_CLASS DBGC_RPC_PARSE
 
 /*******************************************************************
+ Fill in a BUFFER2 for the data given a REGISTRY_VALUE
+ *******************************************************************/
+
+static uint32 reg_init_buffer2( BUFFER2 *buf2, REGISTRY_VALUE *val )
+{
+	UNISTR2		unistr;
+	uint32		real_size = 0;
+	char 		*string;
+	char 		*list = NULL;
+	char 		*list2 = NULL;
+	
+	if ( !buf2 || !val )
+		return 0;
+		
+	real_size = val->size;
+		
+	switch (val->type )
+	{
+		case REG_SZ:
+			string = (char*)val->data_p;
+			DEBUG(10,("reg_init_buffer2: REG_SZ string => [%s]\n", string));
+			
+			init_unistr2( &unistr, (char*)val->data_p, strlen((char*)val->data_p)+1 );
+			init_buffer2( buf2, (char*)unistr.buffer, unistr.uni_str_len*2 );
+			real_size = unistr.uni_str_len*2;
+			break;
+			
+		case REG_MULTI_SZ:
+			string = (char*)val->data_p;
+			real_size = 0;
+			while ( string && *string )
+			{
+				DEBUG(10,("reg_init_buffer2: REG_MULTI_SZ string => [%s], size => [%d]\n", string, real_size ));
+				
+				init_unistr2( &unistr, string, strlen(string)+1 );
+				
+				list2 = Realloc( list, real_size + unistr.uni_str_len*2 );
+				if ( !list2 )
+					break;
+				list = list2;
+				
+				memcpy( list+real_size, unistr.buffer, unistr.uni_str_len*2 );
+				
+				real_size += unistr.uni_str_len*2;
+				
+				string += strlen(string)+1;
+			}
+			
+			list2 = Realloc( list, real_size + 2 );
+			if ( !list2 )
+				break;
+			list = list2;
+			list[real_size++] = 0x0;
+			list[real_size++] = 0x0;
+			
+			init_buffer2( buf2, (char*)list, real_size );
+			
+			DEBUG(10,("reg_init_buffer2: REG_MULTI_SZ size => [%d]\n", real_size ));
+			
+			break;
+			
+		case REG_BINARY:
+			DEBUG(10,("reg_init_buffer2: REG_BINARY size => [%d]\n", val->size ));
+			
+			init_buffer2( buf2, val->data_p, val->size );
+			break;
+			
+		case REG_DWORD: 
+			DEBUG(10,("reg_init_buffer2: REG_DWORD value => [%d]\n", *(uint32*)val->data_p));
+			init_buffer2( buf2, val->data_p, val->size );
+			break;
+			
+		default:
+			DEBUG(0,("reg_init_buffer2: Unsupported registry data type [%d]\n", val->type));
+			break;
+	}
+	
+	SAFE_FREE( list );
+
+	return real_size;
+}
+
+/*******************************************************************
  Inits a structure.
 ********************************************************************/
 
@@ -165,6 +249,8 @@ BOOL reg_io_r_open_hklm(char *desc, REG_R_OPEN_HKLM * r_r, prs_struct *ps,
 }
 
 
+
+
 /*******************************************************************
  Inits a structure.
 ********************************************************************/
@@ -583,7 +669,7 @@ BOOL reg_io_r_query_key(char *desc,  REG_R_QUERY_KEY *r_r, prs_struct *ps, int d
 		return False;
 	if(!smb_io_time("mod_time     ", &r_r->mod_time, ps, depth))
 		return False;
-	
+
 	if(!prs_ntstatus("status", ps, depth, &r_r->status))
 		return False;
 
@@ -599,6 +685,7 @@ void init_reg_q_unknown_1a(REG_Q_UNKNOWN_1A *q_o, POLICY_HND *hnd)
 	memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
 }
 
+
 /*******************************************************************
 reads or writes a structure.
 ********************************************************************/
@@ -613,7 +700,7 @@ BOOL reg_io_q_unknown_1a(char *desc,  REG_Q_UNKNOWN_1A *r_q, prs_struct *ps, int
 
 	if(!prs_align(ps))
 		return False;
-	
+
 	if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
 		return False;
 
@@ -634,7 +721,7 @@ BOOL reg_io_r_unknown_1a(char *desc,  REG_R_UNKNOWN_1A *r_r, prs_struct *ps, int
 
 	if(!prs_align(ps))
 		return False;
-	
+
 	if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
 		return False;
 	if(!prs_ntstatus("status" , ps, depth, &r_r->status))
@@ -643,6 +730,57 @@ BOOL reg_io_r_unknown_1a(char *desc,  REG_R_UNKNOWN_1A *r_r, prs_struct *ps, int
 	return True;
 }
 
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+
+BOOL reg_io_q_save_key(char *desc,  REG_Q_SAVE_KEY *r_q, prs_struct *ps, int depth)
+{
+	if (r_q == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "reg_io_q_save_key");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
+		return False;
+
+	if(!smb_io_unihdr ("hdr_file", &r_q->hdr_file, ps, depth))
+		return False;
+	if(!smb_io_unistr2("uni_file", &r_q->uni_file, r_q->hdr_file.buffer, ps, depth))
+		return False;
+
+	if(!prs_uint32("unknown", ps, depth, &r_q->unknown))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+
+BOOL reg_io_r_save_key(char *desc,  REG_R_SAVE_KEY *r_r, prs_struct *ps, int depth)
+{
+	if (r_r == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "reg_io_r_save_key");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+	
+	if(!prs_ntstatus("status" , ps, depth, &r_r->status))
+		return False;
+
+	return True;
+}
+
 /*******************************************************************
  Inits a structure.
 ********************************************************************/
@@ -1025,33 +1163,77 @@ BOOL reg_io_q_info(char *desc,  REG_Q_INFO *r_q, prs_struct *ps, int depth)
 
 /*******************************************************************
  Inits a structure.
+ New version to replace older init_reg_r_info()
+********************************************************************/
+
+BOOL new_init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_r,
+		     REGISTRY_VALUE *val, NTSTATUS status)
+{
+	uint32		buf_len = 0;
+	BUFFER2		buf2;
+		
+	if(r_r == NULL)
+		return False;
+	
+	if ( !val )
+		return False;
+  
+	r_r->ptr_type = 1;
+	r_r->type = val->type;
+
+	/* if include_keyval is not set, don't send the key value, just
+	   the buflen data. probably used by NT5 to allocate buffer space - SK */
+
+	if ( include_keyval ) {
+		r_r->ptr_uni_val = 1;
+		buf_len = reg_init_buffer2( &r_r->uni_val, val );
+	
+	}
+	else {
+		/* dummy buffer used so we can get the size */
+		r_r->ptr_uni_val = 0;
+		buf_len = reg_init_buffer2( &buf2, val );
+	}
+
+	r_r->ptr_max_len = 1;
+	r_r->buf_max_len = buf_len;
+
+	r_r->ptr_len = 1;
+	r_r->buf_len = buf_len;
+
+	r_r->status = status;
+
+	return True;
+}
+
+/*******************************************************************
+ Inits a structure.
 ********************************************************************/
 
 BOOL init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_r,
 		     BUFFER2* buf, uint32 type, NTSTATUS status)
 {
-  if(r_r == NULL)
-    return False;
-
+	if(r_r == NULL)
+		return False;
   
-  r_r->ptr_type = 1;
-  r_r->type = type;
+	r_r->ptr_type = 1;
+	r_r->type = type;
 
-  /* if include_keyval is not set, don't send the key value, just
-     the buflen data. probably used by NT5 to allocate buffer space - SK */
-  r_r->ptr_uni_val = include_keyval ? 1:0;
-  r_r->uni_val = buf;
+	/* if include_keyval is not set, don't send the key value, just
+	   the buflen data. probably used by NT5 to allocate buffer space - SK */
 
-  r_r->ptr_max_len = 1;
-  r_r->buf_max_len = r_r->uni_val->buf_max_len;
+	r_r->ptr_uni_val = include_keyval ? 1:0;
+	r_r->uni_val = *buf;
 
-  r_r->ptr_len = 1;
-  r_r->buf_len = r_r->uni_val->buf_len;
+	r_r->ptr_max_len = 1;
+	r_r->buf_max_len = r_r->uni_val.buf_max_len;
 
-  r_r->status = status;
+	r_r->ptr_len = 1;
+	r_r->buf_len = r_r->uni_val.buf_len;
 
-  return True;
-  
+	r_r->status = status;
+
+	return True;
 }
 
 /*******************************************************************
@@ -1081,7 +1263,7 @@ BOOL reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
 		return False;
 
 	if(r_r->ptr_uni_val != 0) {
-		if(!smb_io_buffer2("uni_val", r_r->uni_val, r_r->ptr_uni_val, ps, depth))
+		if(!smb_io_buffer2("uni_val", &r_r->uni_val, r_r->ptr_uni_val, ps, depth))
 			return False;
 	}
 
@@ -1139,6 +1321,46 @@ void init_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
 }
 
 /*******************************************************************
+makes a structure.
+********************************************************************/
+
+void init_reg_r_enum_val(REG_R_ENUM_VALUE *r_u, REGISTRY_VALUE *val )
+{
+	uint32 real_size;
+	
+	DEBUG(8,("init_reg_r_enum_val: Enter\n"));
+	
+	ZERO_STRUCTP(r_u);
+
+	/* value name */
+
+	DEBUG(10,("init_reg_r_enum_val: Valuename => [%s]\n", val->valuename));
+	
+	init_uni_hdr( &r_u->hdr_name, strlen(val->valuename)+1 );
+	init_unistr2( &r_u->uni_name, val->valuename, strlen(val->valuename)+1 );
+		
+	/* type */
+	
+	r_u->ptr_type = 1;
+	r_u->type = val->type;
+
+	/* REG_SZ & REG_MULTI_SZ must be converted to UNICODE */
+	
+	r_u->ptr_value = 1;
+	real_size = reg_init_buffer2( &r_u->buf_value, val );
+	
+	/* lengths */
+
+	r_u->ptr1 = 1;
+	r_u->len_value1 = real_size;
+	
+	r_u->ptr2 = 1;
+	r_u->len_value2 = real_size;
+		
+	DEBUG(8,("init_reg_r_enum_val: Exit\n"));
+}
+
+/*******************************************************************
 reads or writes a structure.
 ********************************************************************/
 
@@ -1158,6 +1380,7 @@ BOOL reg_io_q_enum_val(char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int d
 	
 	if(!prs_uint32("val_index", ps, depth, &q_q->val_index))
 		return False;
+		
 	if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
 		return False;
 	if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
@@ -1228,7 +1451,7 @@ BOOL reg_io_r_enum_val(char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int d
 
 	if(!prs_uint32("ptr_value", ps, depth, &r_q->ptr_value))
 		return False;
-	if(!smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth))
+	if(!smb_io_buffer2("buf_value", &r_q->buf_value, r_q->ptr_value, ps, depth))
 		return False;
 	if(!prs_align(ps))
 		return False;
@@ -1531,7 +1754,7 @@ BOOL reg_io_q_open_entry(char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int
 	
 	if(!prs_uint32("unknown_0        ", ps, depth, &r_q->unknown_0))
 		return False;
-	if(!prs_uint32("asccess_desired  ", ps, depth, &r_q->access_desired))
+	if(!prs_uint32("access_desired  ", ps, depth, &r_q->access_desired))
 		return False;
 
 	return True;
diff --git a/source3/rpc_parse/parse_samr.c b/source3/rpc_parse/parse_samr.c
index c16232204c..1137993bb6 100644
--- a/source3/rpc_parse/parse_samr.c
+++ b/source3/rpc_parse/parse_samr.c
@@ -5,8 +5,10 @@
  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
  *  Copyright (C) Paul Ashton                  1997-2000,
  *  Copyright (C) Elrond                            2000,
- *  Copyright (C) Jeremy Allison                    2001
- *  Copyright (C) Jean François Micouleau      1998-2001.
+ *  Copyright (C) Jeremy Allison                    2001,
+ *  Copyright (C) Jean François Micouleau      1998-2001,
+ *  Copyright (C) Anthony Liguori                   2002,
+ *  Copyright (C) Jim McDonough                     2002.
  *  
  *  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
@@ -5067,7 +5069,7 @@ BOOL samr_io_r_create_user(char *desc, SAMR_R_CREATE_USER * r_u,
 	if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
 		return False;
 
-	if(!prs_uint32("unknown_0", ps, depth, &r_u->unknown_0))
+	if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
 		return False;
 	if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
 		return False;
@@ -5945,7 +5947,7 @@ NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, SAM_ACCOUNT *pw, DOM_SID *
 	const char*		user_name = pdb_get_username(pw);
 	const char*		full_name = pdb_get_fullname(pw);
 	const char*		home_dir  = pdb_get_homedir(pw);
-	const char*		dir_drive = pdb_get_dirdrive(pw);
+	const char*		dir_drive = pdb_get_dir_drive(pw);
 	const char*		logon_script = pdb_get_logon_script(pw);
 	const char*		profile_path = pdb_get_profile_path(pw);
 	const char*		description = pdb_get_acct_desc(pw);
@@ -6717,6 +6719,84 @@ BOOL samr_io_r_connect(char *desc, SAMR_R_CONNECT * r_u,
 }
 
 /*******************************************************************
+inits a SAMR_Q_CONNECT4 structure.
+********************************************************************/
+
+void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
+			  char *srv_name, uint32 access_mask)
+{
+	int len_srv_name = strlen(srv_name);
+
+	DEBUG(5, ("init_samr_q_connect\n"));
+
+	/* make PDC server name \\server */
+	q_u->ptr_srv_name = len_srv_name > 0 ? 1 : 0;
+	init_unistr2(&q_u->uni_srv_name, srv_name, len_srv_name + 1);
+
+	/* Only value we've seen, possibly an address type ? */
+	q_u->unk_0 = 2;
+
+	/* example values: 0x0000 0002 */
+	q_u->access_mask = access_mask;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+
+BOOL samr_io_q_connect4(char *desc, SAMR_Q_CONNECT4 * q_u,
+			prs_struct *ps, int depth)
+{
+	if (q_u == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "samr_io_q_connect4");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
+		return False;
+	if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
+		return False;
+
+	if(!prs_align(ps))
+		return False;
+	if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
+		return False;
+	if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+
+BOOL samr_io_r_connect4(char *desc, SAMR_R_CONNECT4 * r_u,
+			prs_struct *ps, int depth)
+{
+	if (r_u == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "samr_io_r_connect4");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
+		return False;
+
+	if(!prs_ntstatus("status", ps, depth, &r_u->status))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
 inits a SAMR_Q_CONNECT_ANON structure.
 ********************************************************************/
 
diff --git a/source3/rpc_parse/parse_spoolss.c b/source3/rpc_parse/parse_spoolss.c
index b10a5c4377..3a7f4b57ae 100644
--- a/source3/rpc_parse/parse_spoolss.c
+++ b/source3/rpc_parse/parse_spoolss.c
@@ -322,7 +322,7 @@ reads or writes an NOTIFY INFO DATA structure.
 
 static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs_struct *ps, int depth)
 {
-	uint32 useless_ptr=0xADDE0FF0;
+	uint32 useless_ptr=0x0FF0ADDE;
 
 	prs_debug(ps, depth, desc, "smb_io_notify_info_data");
 	depth++;
@@ -378,6 +378,14 @@ static BOOL smb_io_notify_info_data(char *desc,SPOOL_NOTIFY_INFO_DATA *data, prs
 
 		break;
 
+	case NOTIFY_SECDESC:
+		if( !prs_uint32( "sd size", ps, depth, &data->notify_data.sd.size ) )
+			return False;
+		if( !prs_uint32( "pointer", ps, depth, &useless_ptr ) )
+			return False;
+		
+		break;
+
 	default:
 		DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data\n",
 			  data->enc_type));
@@ -451,6 +459,13 @@ BOOL smb_io_notify_info_data_strings(char *desc,SPOOL_NOTIFY_INFO_DATA *data,
 
 		break;
 
+	case NOTIFY_SECDESC:	
+		if( !prs_uint32("secdesc size ", ps, depth, &data->notify_data.sd.size ) )
+			return False;
+		if ( !sec_io_desc( "sec_desc", &data->notify_data.sd.desc, ps, depth ) )
+			return False;
+		break;
+
 	default:
 		DEBUG(3, ("invalid enc_type %d for smb_io_notify_info_data_strings\n",
 			  data->enc_type));
@@ -675,9 +690,11 @@ BOOL spoolss_io_devmode(char *desc, prs_struct *ps, int depth, DEVICEMODE *devmo
 	   Let the size determine that */
 	   
 	switch (devmode->specversion) {
+		/* list of observed spec version's */
 		case 0x0320:
 		case 0x0400:
 		case 0x0401:
+		case 0x040d:
 			break;
 			
 		default:
@@ -5183,7 +5200,7 @@ static BOOL uniarray_2_dosarray(BUFFER5 *buf5, fstring **ar)
 	*ar = NULL;
 
 	while (src < ((char *)buf5->buffer) + buf5->buf_len*2) {
-		rpcstr_pull(f, src, sizeof(f)-1, -1, 0);
+		rpcstr_pull(f, src, sizeof(f)-1, -1, STR_TERMINATE);
 		src = skip_unibuf(src, 2*buf5->buf_len - PTR_DIFF(src,buf5->buffer));
 		tar = (fstring *)Realloc(*ar, sizeof(fstring)*(n+2));
 		if (!tar)
@@ -6171,42 +6188,6 @@ BOOL spoolss_io_r_resetprinter(char *desc, SPOOL_R_RESETPRINTER *r_u, prs_struct
 
 /*******************************************************************
 ********************************************************************/  
-BOOL convert_specific_param(NT_PRINTER_PARAM **param, const UNISTR2 *value,
-				uint32 type, const uint8 *data, uint32 len)
-{
-	DEBUG(5,("converting a specific param struct\n"));
-
-	if (*param == NULL)
-	{
-		*param=(NT_PRINTER_PARAM *)malloc(sizeof(NT_PRINTER_PARAM));
-		if(*param == NULL)
-			return False;
-		memset((char *)*param, '\0', sizeof(NT_PRINTER_PARAM));
-		DEBUGADD(6,("Allocated a new PARAM struct\n"));
-	}
-	unistr2_to_ascii((*param)->value, value, sizeof((*param)->value)-1);
-	(*param)->type = type;
-	
-	/* le champ data n'est pas NULL termine */
-	/* on stocke donc la longueur */
-	
-	(*param)->data_len=len;
-	
-	if (len) {
-		(*param)->data=(uint8 *)malloc(len * sizeof(uint8));
-		if((*param)->data == NULL)
-			return False;
-		memcpy((*param)->data, data, len);
-	}
-		
-	DEBUGADD(6,("\tvalue:[%s], len:[%d]\n",(*param)->value, (*param)->data_len));
-	dump_data(10, (char *)(*param)->data, (*param)->data_len);
-
-	return True;
-}
-
-/*******************************************************************
-********************************************************************/  
 
 static BOOL spoolss_io_addform(char *desc, FORM *f, uint32 ptr, prs_struct *ps, int depth)
 {
@@ -6750,7 +6731,7 @@ BOOL make_spoolss_q_reply_rrpcn(SPOOL_Q_REPLY_RRPCN *q_u, POLICY_HND *hnd,
 	q_u->unknown0=0x0;
 	q_u->unknown1=0x0;
 
-	q_u->info_ptr=0xaddee11e;
+	q_u->info_ptr=0x0FF0ADDE;
 
 	q_u->info.version=2;
 	
@@ -7528,3 +7509,31 @@ BOOL make_spoolss_q_deleteprinterdata(SPOOL_Q_DELETEPRINTERDATA *q_u,
 
 	return True;
 }
+
+/*******************************************************************
+ * init a structure.
+ ********************************************************************/
+
+BOOL make_spoolss_q_rffpcnex(SPOOL_Q_RFFPCNEX *q_u, POLICY_HND *handle,
+			     uint32 flags, uint32 options, char *localmachine,
+			     uint32 printerlocal, SPOOL_NOTIFY_OPTION *option)
+{
+        memcpy(&q_u->handle, handle, sizeof(POLICY_HND));
+
+	q_u->flags = flags;
+	q_u->options = options;
+
+	q_u->localmachine_ptr = 1;
+
+	init_unistr2(&q_u->localmachine, localmachine, 
+		     strlen(localmachine) + 1);
+
+	q_u->printerlocal = printerlocal;
+
+	if (option)
+		q_u->option_ptr = 1;
+
+	q_u->option = option;
+
+	return True;
+}
diff --git a/source3/rpc_parse/parse_srv.c b/source3/rpc_parse/parse_srv.c
index 3dc054d2b1..531267c308 100644
--- a/source3/rpc_parse/parse_srv.c
+++ b/source3/rpc_parse/parse_srv.c
@@ -3,9 +3,10 @@
  *  RPC Pipe client / server routines
  *  Copyright (C) Andrew Tridgell              1992-1997,
  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
- *  Copyright (C) Paul Ashton                       1997.
- *  Copyright (C) Jeremy Allison		    1999.
- *  Copyright (C) Jim McDonough (jmcd@us.ibm.com)   2002
+ *  Copyright (C) Paul Ashton                       1997,
+ *  Copyright (C) Jeremy Allison		    1999,
+ *  Copyright (C) Nigel Williams		    2001,
+ *  Copyright (C) Jim McDonough (jmcd@us.ibm.com)   2002.
  *  
  *  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
@@ -28,6 +29,71 @@
 #define DBGC_CLASS DBGC_RPC_PARSE
 
 /*******************************************************************
+ Inits a SH_INFO_0_STR structure
+********************************************************************/
+
+void init_srv_share_info0_str(SH_INFO_0_STR *sh0, char *net_name)
+{
+	DEBUG(5,("init_srv_share_info0_str\n"));
+
+	if(net_name)
+		init_unistr2(&sh0->uni_netname, net_name, strlen(net_name)+1);
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+static BOOL srv_io_share_info0_str(char *desc, SH_INFO_0_STR *sh0, prs_struct *ps, int depth)
+{
+	if (sh0 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info0_str");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+	if(sh0->ptrs->ptr_netname)
+		if(!smb_io_unistr2("", &sh0->uni_netname, True, ps, depth))
+			return False;
+
+	return True;
+}
+
+/*******************************************************************
+ makes a SH_INFO_0 structure
+********************************************************************/
+
+void init_srv_share_info0(SH_INFO_0 *sh0, char *net_name)
+{
+	DEBUG(5,("init_srv_share_info0: %s\n", net_name));
+
+	sh0->ptr_netname = (net_name != NULL) ? 1 : 0;
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+static BOOL srv_io_share_info0(char *desc, SH_INFO_0 *sh0, prs_struct *ps, int depth)
+{
+	if (sh0 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info0");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("ptr_netname", ps, depth, &sh0->ptr_netname))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
  Inits a SH_INFO_1_STR structure
 ********************************************************************/
 
@@ -35,8 +101,10 @@ void init_srv_share_info1_str(SH_INFO_1_STR *sh1, char *net_name, char *remark)
 {
 	DEBUG(5,("init_srv_share_info1_str\n"));
 
-	init_unistr2(&sh1->uni_netname, net_name, strlen(net_name)+1);
-	init_unistr2(&sh1->uni_remark, remark, strlen(remark)+1);
+	if(net_name)
+		init_unistr2(&sh1->uni_netname, net_name, strlen(net_name)+1);
+	if(remark)
+		init_unistr2(&sh1->uni_remark, remark, strlen(remark)+1);
 }
 
 /*******************************************************************
@@ -47,20 +115,24 @@ static BOOL srv_io_share_info1_str(char *desc, SH_INFO_1_STR *sh1, prs_struct *p
 {
 	if (sh1 == NULL)
 		return False;
-
+	
 	prs_debug(ps, depth, desc, "srv_io_share_info1_str");
 	depth++;
-
+	
 	if(!prs_align(ps))
 		return False;
-	if(!smb_io_unistr2("", &sh1->uni_netname, True, ps, depth))
-		return False;
 
+	if(sh1->ptrs->ptr_netname)
+		if(!smb_io_unistr2("", &sh1->uni_netname, True, ps, depth))
+			return False;
+	
 	if(!prs_align(ps))
 		return False;
-	if(!smb_io_unistr2("", &sh1->uni_remark, True, ps, depth))
-		return False;
-
+	
+	if(sh1->ptrs->ptr_remark)
+		if(!smb_io_unistr2("", &sh1->uni_remark, True, ps, depth))
+			return False;
+	
 	return True;
 }
 
@@ -71,7 +143,7 @@ static BOOL srv_io_share_info1_str(char *desc, SH_INFO_1_STR *sh1, prs_struct *p
 void init_srv_share_info1(SH_INFO_1 *sh1, char *net_name, uint32 type, char *remark)
 {
 	DEBUG(5,("init_srv_share_info1: %s %8x %s\n", net_name, type, remark));
-
+	
 	sh1->ptr_netname = (net_name != NULL) ? 1 : 0;
 	sh1->type        = type;
 	sh1->ptr_remark  = (remark != NULL) ? 1 : 0;
@@ -139,6 +211,7 @@ static BOOL srv_io_share_info2_str(char *desc, SH_INFO_2 *sh, SH_INFO_2_STR *sh2
 
 	if(!prs_align(ps))
 		return False;
+
 	if (sh->ptr_netname)
 		if(!smb_io_unistr2("", &sh2->uni_netname, True, ps, depth))
 			return False;
@@ -175,7 +248,6 @@ void init_srv_share_info2(SH_INFO_2 *sh2,
 	sh2->perms       = perms;
 	sh2->max_uses    = max_uses;
 	sh2->num_uses    = num_uses;
-	sh2->type        = type;
 	sh2->ptr_path    = (path != NULL) ? 1 : 0;
 	sh2->ptr_passwd  = (passwd != NULL) ? 1 : 0;
 }
@@ -216,6 +288,21 @@ static BOOL srv_io_share_info2(char *desc, SH_INFO_2 *sh2, prs_struct *ps, int d
 }
 
 /*******************************************************************
+ Inits a SH_INFO_501_STR structure
+********************************************************************/
+
+void init_srv_share_info501_str(SH_INFO_501_STR *sh501,
+				char *net_name, char *remark)
+{
+	DEBUG(5,("init_srv_share_info501_str\n"));
+
+	if(net_name)
+		init_unistr2(&sh501->uni_netname, net_name, strlen(net_name)+1);
+	if(remark)
+		init_unistr2(&sh501->uni_remark, remark, strlen(remark)+1);
+}
+
+/*******************************************************************
  Inits a SH_INFO_2 structure
 *******************************************************************/
 
@@ -259,18 +346,6 @@ static BOOL srv_io_share_info501(char *desc, SH_INFO_501 *sh501, prs_struct *ps,
 	return True;
 }
 
-/********************************************************************
- Inits a SH_INFO_501_STR structure
-********************************************************************/
-
-void init_srv_share_info501_str(SH_INFO_501_STR *sh501, char *net_name, char *remark)
-{
-	DEBUG(5,("init_srv_share_info501_str\n"));
-
-	init_unistr2(&sh501->uni_netname, net_name, strlen(net_name)+1);
-	init_unistr2(&sh501->uni_remark, remark, strlen(remark)+1);
-}
-
 /*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
@@ -301,7 +376,7 @@ static BOOL srv_io_share_info501_str(char *desc, SH_INFO_501_STR *sh501, prs_str
 ********************************************************************/
 
 void init_srv_share_info502(SH_INFO_502 *sh502,
-				char *net_name, uint32 type, char *remark,
+				const char *net_name, uint32 type, char *remark,
 				uint32 perms, uint32 max_uses, uint32 num_uses,
 				char *path, char *passwd, SEC_DESC *psd, size_t sd_size)
 {
@@ -315,9 +390,9 @@ void init_srv_share_info502(SH_INFO_502 *sh502,
 	sh502->perms       = perms;
 	sh502->max_uses    = max_uses;
 	sh502->num_uses    = num_uses;
-	sh502->type        = type;
 	sh502->ptr_path    = (path != NULL) ? 1 : 0;
 	sh502->ptr_passwd  = (passwd != NULL) ? 1 : 0;
+	sh502->reserved    = 0;  /* actual size within rpc */
 	sh502->sd_size     = (uint32)sd_size;
 	sh502->ptr_sd      = (psd != NULL) ? 1 : 0;
 }
@@ -353,7 +428,7 @@ static BOOL srv_io_share_info502(char *desc, SH_INFO_502 *sh502, prs_struct *ps,
 		return False;
 	if(!prs_uint32("ptr_passwd ", ps, depth, &sh502->ptr_passwd))
 		return False;
-	if(!prs_uint32("sd_size    ", ps, depth, &sh502->sd_size))
+	if(!prs_uint32_pre("reserved   ", ps, depth, &sh502->reserved, &sh502->reserved_offset))
 		return False;
 	if(!prs_uint32("ptr_sd     ", ps, depth, &sh502->ptr_sd))
 		return False;
@@ -366,26 +441,22 @@ static BOOL srv_io_share_info502(char *desc, SH_INFO_502 *sh502, prs_struct *ps,
 ********************************************************************/
 
 void init_srv_share_info502_str(SH_INFO_502_STR *sh502str,
-				SH_INFO_502 *ptrs,
 				char *net_name, char *remark,
 				char *path, char *passwd, SEC_DESC *psd, size_t sd_size)
 {
 	DEBUG(5,("init_srv_share_info502_str\n"));
 
-	sh502str->ptrs = ptrs;
-
-	if(sh502str->ptrs->ptr_netname)
+	if(net_name)
 		init_unistr2(&sh502str->uni_netname, net_name, strlen(net_name)+1);
-	if(sh502str->ptrs->ptr_remark)
+	if(remark)
 		init_unistr2(&sh502str->uni_remark, remark, strlen(remark)+1);
-	if(sh502str->ptrs->ptr_path)
+	if(path)
 		init_unistr2(&sh502str->uni_path, path, strlen(path)+1);
-	if(sh502str->ptrs->ptr_passwd)
+	if(passwd)
 		init_unistr2(&sh502str->uni_passwd, passwd, strlen(passwd)+1);
-	if(sh502str->ptrs->ptr_sd) {
 		sh502str->sd = psd;
+	sh502str->reserved = 0;
 		sh502str->sd_size = sd_size;
-	}
 }
 
 /*******************************************************************
@@ -436,21 +507,112 @@ static BOOL srv_io_share_info502_str(char *desc, SH_INFO_502_STR *sh502, prs_str
 		return False;
 
 	if(sh502->ptrs->ptr_sd) {
-		if(!prs_uint32("sd_size   ", ps, depth, &sh502->sd_size))
+		uint32 old_offset;
+		uint32 reserved_offset;
+
+		if(!prs_uint32_pre("reserved ", ps, depth, &sh502->reserved, &reserved_offset))
 			return False;
+	  
+		old_offset = prs_offset(ps);
+	  
 		if (!sec_io_desc(desc, &sh502->sd, ps, depth))
 			return False;
+
+		if(UNMARSHALLING(ps)) {
+
+			sh502->ptrs->sd_size = sh502->sd_size = sec_desc_size(sh502->sd);
+
+			prs_set_offset(ps, old_offset + sh502->reserved);
+		}
+
+		prs_align(ps);
+
+		if(MARSHALLING(ps)) {
+
+			sh502->ptrs->reserved = sh502->reserved = prs_offset(ps) - old_offset;
+		}
+	    
+		if(!prs_uint32_post("reserved ", ps, depth, 
+				    &sh502->reserved, reserved_offset, sh502->reserved))
+			return False;
+		if(!prs_uint32_post("reserved ", ps, depth, 
+				    &sh502->ptrs->reserved, sh502->ptrs->reserved_offset, sh502->ptrs->reserved))
+			return False;
 	}
 
 	return True;
 }
 
 /*******************************************************************
+ Inits a SH_INFO_1004_STR structure
+********************************************************************/
+
+void init_srv_share_info1004_str(SH_INFO_1004_STR *sh1004, char *remark)
+{
+	DEBUG(5,("init_srv_share_info1004_str\n"));
+
+	if(remark)
+		init_unistr2(&sh1004->uni_remark, remark, strlen(remark)+1);
+}
+
+/*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
 
-static BOOL srv_io_share_info1005(char* desc, SRV_SHARE_INFO_1005* sh1005,
-				  prs_struct* ps, int depth)
+static BOOL srv_io_share_info1004_str(char *desc, SH_INFO_1004_STR *sh1004, prs_struct *ps, int depth)
+{
+	if (sh1004 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info1004_str");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+	if(sh1004->ptrs->ptr_remark)
+		if(!smb_io_unistr2("", &sh1004->uni_remark, True, ps, depth))
+			return False;
+
+	return True;
+}
+
+/*******************************************************************
+ makes a SH_INFO_1004 structure
+********************************************************************/
+
+void init_srv_share_info1004(SH_INFO_1004 *sh1004, char *remark)
+{
+	DEBUG(5,("init_srv_share_info1004: %s\n", remark));
+
+	sh1004->ptr_remark = (remark != NULL) ? 1 : 0;
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+static BOOL srv_io_share_info1004(char *desc, SH_INFO_1004 *sh1004, prs_struct *ps, int depth)
+{
+	if (sh1004 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info1004");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("ptr_remark", ps, depth, &sh1004->ptr_remark))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+static BOOL srv_io_share_info1005(char* desc, SRV_SHARE_INFO_1005* sh1005, prs_struct* ps, int depth)
 {
 	if(sh1005 == NULL)
 		return False;
@@ -471,6 +633,95 @@ static BOOL srv_io_share_info1005(char* desc, SRV_SHARE_INFO_1005* sh1005,
  Reads or writes a structure.
 ********************************************************************/
 
+static BOOL srv_io_share_info1006(char* desc, SRV_SHARE_INFO_1006* sh1006, prs_struct* ps, int depth)
+{
+	if(sh1006 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info1006");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("max uses     ", ps, depth, &sh1006->max_uses))
+		return False;
+
+	return True;
+}   
+
+/*******************************************************************
+ Inits a SH_INFO_1007_STR structure
+********************************************************************/
+
+void init_srv_share_info1007_str(SH_INFO_1007_STR *sh1007, const char *alternate_directory_name)
+{
+	DEBUG(5,("init_srv_share_info1007_str\n"));
+
+	if(alternate_directory_name)
+		init_unistr2(&sh1007->uni_AlternateDirectoryName, alternate_directory_name, strlen(alternate_directory_name)+1);
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+static BOOL srv_io_share_info1007_str(char *desc, SH_INFO_1007_STR *sh1007, prs_struct *ps, int depth)
+{
+	if (sh1007 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info1007_str");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+	if(sh1007->ptrs->ptr_AlternateDirectoryName)
+		if(!smb_io_unistr2("", &sh1007->uni_AlternateDirectoryName, True, ps, depth))
+			return False;
+
+	return True;
+}
+
+/*******************************************************************
+ makes a SH_INFO_1007 structure
+********************************************************************/
+
+void init_srv_share_info1007(SH_INFO_1007 *sh1007, uint32 flags, const char *alternate_directory_name)
+{
+	DEBUG(5,("init_srv_share_info1007: %s\n", alternate_directory_name));
+
+	sh1007->flags                      = flags;
+	sh1007->ptr_AlternateDirectoryName = (alternate_directory_name != NULL) ? 1 : 0;
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
+static BOOL srv_io_share_info1007(char *desc, SH_INFO_1007 *sh1007, prs_struct *ps, int depth)
+{
+	if (sh1007 == NULL)
+		return False;
+
+	prs_debug(ps, depth, desc, "srv_io_share_info1007");
+	depth++;
+
+	if(!prs_align(ps))
+		return False;
+
+	if(!prs_uint32("flags      ", ps, depth, &sh1007->flags))
+		return False;
+	if(!prs_uint32("ptr_Alter..", ps, depth, &sh1007->ptr_AlternateDirectoryName))
+		return False;
+
+	return True;
+}
+
+/*******************************************************************
+ Reads or writes a structure.
+********************************************************************/
+
 static BOOL srv_io_share_info1501(char* desc, SRV_SHARE_INFO_1501* sh1501,
 				  prs_struct* ps, int depth)
 {
@@ -511,9 +762,6 @@ static BOOL srv_io_srv_share_ctr(char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct
 	if(!prs_uint32("info_level", ps, depth, &ctr->info_level))
 		return False;
 
-	if (ctr->info_level == 0)
-		return True;
-
 	if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
 		return False;
 	if(!prs_uint32("ptr_share_info", ps, depth, &ctr->ptr_share_info))
@@ -541,6 +789,33 @@ static BOOL srv_io_srv_share_ctr(char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct
 		return False;
 
 	switch (ctr->switch_value) {
+
+	case 0:
+	{
+		SRV_SHARE_INFO_0 *info0 = ctr->share.info0;
+		int num_entries = ctr->num_entries;
+		int i;
+
+		if (UNMARSHALLING(ps)) {
+			if (!(info0 = (SRV_SHARE_INFO_0 *)prs_alloc_mem(ps, num_entries * sizeof(SRV_SHARE_INFO_0))))
+				return False;
+			ctr->share.info0 = info0;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			if(!srv_io_share_info0("", &info0[i].info_0, ps, depth))
+				return False;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			info0[i].info_0_str.ptrs = &info0[i].info_0;
+			if(!srv_io_share_info0_str("", &info0[i].info_0_str, ps, depth))
+				return False;
+		}
+
+		break;
+	}
+
 	case 1:
 	{
 		SRV_SHARE_INFO_1 *info1 = ctr->share.info1;
@@ -559,6 +834,7 @@ static BOOL srv_io_srv_share_ctr(char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct
 		}
 
 		for (i = 0; i < num_entries; i++) {
+			info1[i].info_1_str.ptrs = &info1[i].info_1;
 			if(!srv_io_share_info1_str("", &info1[i].info_1_str, ps, depth))
 				return False;
 		}
@@ -632,8 +908,8 @@ static BOOL srv_io_srv_share_ctr(char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct
 		for (i = 0; i < num_entries; i++) {
 			if(!srv_io_share_info502("", &info502[i].info_502, ps, depth))
 				return False;
-		}
-
+	}
+		
 		for (i = 0; i < num_entries; i++) {
 			info502[i].info_502_str.ptrs = &info502[i].info_502;
 			if(!srv_io_share_info502_str("", &info502[i].info_502_str, ps, depth))
@@ -643,6 +919,118 @@ static BOOL srv_io_srv_share_ctr(char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct
 		break;
 	}
 
+	case 1004:
+	{
+		SRV_SHARE_INFO_1004 *info1004 = ctr->share.info1004;
+		int num_entries = ctr->num_entries;
+		int i;
+
+		if (UNMARSHALLING(ps)) {
+			if (!(info1004 = (SRV_SHARE_INFO_1004 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1004))))
+				return False;
+			ctr->share.info1004 = info1004;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			if(!srv_io_share_info1004("", &info1004[i].info_1004, ps, depth))
+				return False;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			info1004[i].info_1004_str.ptrs = &info1004[i].info_1004;
+			if(!srv_io_share_info1004_str("", &info1004[i].info_1004_str, ps, depth))
+				return False;
+		}
+
+		break;
+	}
+
+	case 1005:
+	{
+		SRV_SHARE_INFO_1005 *info1005 = ctr->share.info1005;
+		int num_entries = ctr->num_entries;
+		int i;
+
+		if (UNMARSHALLING(ps)) {
+			if (!(info1005 = (SRV_SHARE_INFO_1005 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1005))))
+				return False;
+			ctr->share.info1005 = info1005;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			if(!srv_io_share_info1005("", &info1005[i], ps, depth))
+				return False;
+		}
+
+		break;
+	}
+
+	case 1006:
+	{
+		SRV_SHARE_INFO_1006 *info1006 = ctr->share.info1006;
+		int num_entries = ctr->num_entries;
+		int i;
+
+		if (UNMARSHALLING(ps)) {
+			if (!(info1006 = (SRV_SHARE_INFO_1006 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1006))))
+				return False;
+			ctr->share.info1006 = info1006;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			if(!srv_io_share_info1006("", &info1006[i], ps, depth))
+				return False;
+		}
+
+		break;
+	}
+
+	case 1007:
+	{
+		SRV_SHARE_INFO_1007 *info1007 = ctr->share.info1007;
+		int num_entries = ctr->num_entries;
+		int i;
+
+		if (UNMARSHALLING(ps)) {
+			if (!(info1007 = (SRV_SHARE_INFO_1007 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1007))))
+				return False;
+			ctr->share.info1007 = info1007;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			if(!srv_io_share_info1007("", &info1007[i].info_1007, ps, depth))
+				return False;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			info1007[i].info_1007_str.ptrs = &info1007[i].info_1007;
+			if(!srv_io_share_info1007_str("", &info1007[i].info_1007_str, ps, depth))
+				return False;
+		}
+
+		break;
+	}
+
+	case 1501:
+	{
+		SRV_SHARE_INFO_1501 *info1501 = ctr->share.info1501;
+		int num_entries = ctr->num_entries;
+		int i;
+
+		if (UNMARSHALLING(ps)) {
+			if (!(info1501 = (SRV_SHARE_INFO_1501 *)prs_alloc_mem(ps,num_entries * sizeof(SRV_SHARE_INFO_1501))))
+				return False;
+			ctr->share.info1501 = info1501;
+		}
+
+		for (i = 0; i < num_entries; i++) {
+			if(!srv_io_share_info1501("", &info1501[i], ps, depth))
+				return False;
+		}
+
+		break;
+	}
+
 	default:
 		DEBUG(5,("%s no share info at switch_value %d\n",
 			 tab_depth(depth), ctr->switch_value));
@@ -667,8 +1055,9 @@ void init_srv_q_net_share_enum(SRV_Q_NET_SHARE_ENUM *q_n,
 
 	q_n->ctr.info_level = q_n->ctr.switch_value = info_level;
 	q_n->ctr.ptr_share_info = 1;
-	q_n->ctr.num_entries = 0;
-	q_n->ctr.ptr_entries = 0;
+	q_n->ctr.num_entries  = 0;
+	q_n->ctr.ptr_entries  = 0;
+	q_n->ctr.num_entries2 = 0;
 	q_n->preferred_len = preferred_len;
 
 	memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
@@ -729,8 +1118,12 @@ BOOL srv_io_r_net_share_enum(char *desc, SRV_R_NET_SHARE_ENUM *r_n, prs_struct *
 
 	if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
 		return False;
-	if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
-		return False;
+
+	if(r_n->total_entries != 0) {
+		if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
+			return False;
+	}
+
 	if(!prs_werror("status", ps, depth, &r_n->status))
 		return False;
 
@@ -738,6 +1131,25 @@ BOOL srv_io_r_net_share_enum(char *desc, SRV_R_NET_SHARE_ENUM *r_n, prs_struct *
 }
 
 /*******************************************************************
+ initialises a structure.
+********************************************************************/
+
+BOOL init_srv_q_net_share_get_info(SRV_Q_NET_SHARE_GET_INFO *q_n, const char *srv_name, const char *share_name, uint32 info_level)
+{
+
+	uint32 ptr_share_name;
+
+	DEBUG(5,("init_srv_q_net_share_get_info\n"));
+
+	init_buf_unistr2(&q_n->uni_srv_name,   &q_n->ptr_srv_name, srv_name);
+	init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name,    share_name);
+
+	q_n->info_level = info_level;
+
+	return True;
+}
+
+/*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
 
@@ -792,10 +1204,24 @@ static BOOL srv_io_srv_share_info(char *desc, prs_struct *ps, int depth, SRV_SHA
 
 	if (r_n->ptr_share_ctr != 0) {
 		switch (r_n->switch_value) {
+		case 0:
+			if(!srv_io_share_info0("", &r_n->share.info0.info_0, ps, depth))
+				return False;
+
+			/* allow access to pointers in the str part. */
+			r_n->share.info0.info_0_str.ptrs = &r_n->share.info0.info_0;
+
+			if(!srv_io_share_info0_str("", &r_n->share.info0.info_0_str, ps, depth))
+				return False;
+
+			break;
 		case 1:
 			if(!srv_io_share_info1("", &r_n->share.info1.info_1, ps, depth))
 				return False;
 
+			/* allow access to pointers in the str part. */
+			r_n->share.info1.info_1_str.ptrs = &r_n->share.info1.info_1;
+
 			if(!srv_io_share_info1_str("", &r_n->share.info1.info_1_str, ps, depth))
 				return False;
 
@@ -819,16 +1245,40 @@ static BOOL srv_io_srv_share_info(char *desc, prs_struct *ps, int depth, SRV_SHA
 			if(!srv_io_share_info502("", &r_n->share.info502.info_502, ps, depth))
 				return False;
 
-			/*allow access to pointers in the str part. */
+			/* allow access to pointers in the str part. */
 			r_n->share.info502.info_502_str.ptrs = &r_n->share.info502.info_502;
 
 			if(!srv_io_share_info502_str("", &r_n->share.info502.info_502_str, ps, depth))
 				return False;
 			break;
+		case 1004:
+			if(!srv_io_share_info1004("", &r_n->share.info1004.info_1004, ps, depth))
+				return False;
+
+			/* allow access to pointers in the str part. */
+			r_n->share.info1004.info_1004_str.ptrs = &r_n->share.info1004.info_1004;
+
+			if(!srv_io_share_info1004_str("", &r_n->share.info1004.info_1004_str, ps, depth))
+				return False;
+			break;
 		case 1005:
 			if(!srv_io_share_info1005("", &r_n->share.info1005, ps, depth))
 				return False;  		
 			break;
+		case 1006:
+			if(!srv_io_share_info1006("", &r_n->share.info1006, ps, depth))
+				return False;  		
+			break;
+		case 1007:
+			if(!srv_io_share_info1007("", &r_n->share.info1007.info_1007, ps, depth))
+				return False;
+
+			/* allow access to pointers in the str part. */
+			r_n->share.info1007.info_1007_str.ptrs = &r_n->share.info1007.info_1007;
+
+			if(!srv_io_share_info1007_str("", &r_n->share.info1007.info_1007_str, ps, depth))
+				return False;
+			break;
 		case 1501:
 			if (!srv_io_share_info1501("", &r_n->share.info1501, ps, depth))
 				return False;
@@ -870,6 +1320,34 @@ BOOL srv_io_r_net_share_get_info(char *desc, SRV_R_NET_SHARE_GET_INFO *r_n, prs_
 }
 
 /*******************************************************************
+ intialises a structure.
+********************************************************************/
+
+BOOL init_srv_q_net_share_set_info(SRV_Q_NET_SHARE_SET_INFO *q_n, 
+				   const char *srv_name, 
+				   const char *share_name, 
+				   uint32 info_level, 
+				   const SRV_SHARE_INFO *info) 
+{
+
+	uint32 ptr_share_name;
+
+	DEBUG(5,("init_srv_q_net_share_set_info\n"));
+
+	init_buf_unistr2(&q_n->uni_srv_name,   &q_n->ptr_srv_name, srv_name);
+	init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name,    share_name);
+
+	q_n->info_level = info_level;
+  
+	q_n->info = *info;
+
+	q_n->ptr_parm_error = 1;
+	q_n->parm_error     = 0;
+
+	return True;
+}
+
+/*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
 
@@ -904,6 +1382,15 @@ BOOL srv_io_q_net_share_set_info(char *desc, SRV_Q_NET_SHARE_SET_INFO *q_n, prs_
 	if(!srv_io_srv_share_info("info  ", ps, depth, &q_n->info))
 		return False;
 
+	if(!prs_align(ps))
+		return False;
+	if(!prs_uint32("ptr_parm_error", ps, depth, &q_n->ptr_parm_error))
+		return False;
+	if(q_n->ptr_parm_error!=0) {
+		if(!prs_uint32("parm_error", ps, depth, &q_n->parm_error))
+			return False;
+	}
+
 	return True;
 }
 
@@ -911,9 +1398,9 @@ BOOL srv_io_q_net_share_set_info(char *desc, SRV_Q_NET_SHARE_SET_INFO *q_n, prs_
  Reads or writes a structure.
 ********************************************************************/
 
-BOOL srv_io_r_net_share_set_info(char *desc, SRV_R_NET_SHARE_SET_INFO *q_n, prs_struct *ps, int depth)
+BOOL srv_io_r_net_share_set_info(char *desc, SRV_R_NET_SHARE_SET_INFO *r_n, prs_struct *ps, int depth)
 {
-	if (q_n == NULL)
+	if (r_n == NULL)
 		return False;
 
 	prs_debug(ps, depth, desc, "srv_io_r_net_share_set_info");
@@ -922,14 +1409,22 @@ BOOL srv_io_r_net_share_set_info(char *desc, SRV_R_NET_SHARE_SET_INFO *q_n, prs_
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
+	if(!prs_uint32("ptr_parm_error  ", ps, depth, &r_n->ptr_parm_error))
 		return False;
-	if(!prs_werror("status", ps, depth, &q_n->status))
+
+	if(r_n->ptr_parm_error) {
+
+		if(!prs_uint32("parm_error  ", ps, depth, &r_n->parm_error))
+			return False;
+	}
+
+	if(!prs_werror("status", ps, depth, &r_n->status))
 		return False;
 
 	return True;
 }	
 
+
 /*******************************************************************
  Reads or writes a structure.
 ********************************************************************/
@@ -962,6 +1457,9 @@ BOOL srv_io_q_net_share_add(char *desc, SRV_Q_NET_SHARE_ADD *q_n, prs_struct *ps
 	if(!srv_io_srv_share_info("info  ", ps, depth, &q_n->info))
 		return False;
 
+	if(!prs_align(ps))
+		return False;
+
 	if(!prs_uint32("ptr_err_index", ps, depth, &q_n->ptr_err_index))
 		return False;
 	if (q_n->ptr_err_index)
@@ -994,9 +1492,9 @@ void init_srv_q_net_share_add(SRV_Q_NET_SHARE_ADD *q, char *srvname,
  Reads or writes a structure.
 ********************************************************************/
 
-BOOL srv_io_r_net_share_add(char *desc, SRV_R_NET_SHARE_ADD *q_n, prs_struct *ps, int depth)
+BOOL srv_io_r_net_share_add(char *desc, SRV_R_NET_SHARE_ADD *r_n, prs_struct *ps, int depth)
 {
-	if (q_n == NULL)
+	if (r_n == NULL)
 		return False;
 
 	prs_debug(ps, depth, desc, "srv_io_r_net_share_add");
@@ -1005,14 +1503,25 @@ BOOL srv_io_r_net_share_add(char *desc, SRV_R_NET_SHARE_ADD *q_n, prs_struct *ps
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("switch_value  ", ps, depth, &q_n->switch_value))
+	if(!prs_uint32("ptr_parm_error", ps, depth, &r_n->ptr_parm_error))
 		return False;
-	if(!prs_werror("status", ps, depth, &q_n->status))
+
+	if(r_n->ptr_parm_error) {
+	  
+		if(!prs_uint32("parm_error", ps, depth, &r_n->parm_error))
+			return False;
+	}
+
+	if(!prs_werror("status", ps, depth, &r_n->status))
 		return False;
 
 	return True;
 }	
 
+/*******************************************************************
+ initialises a structure.
+********************************************************************/
+
 void init_srv_q_net_share_del(SRV_Q_NET_SHARE_DEL *del, const char *srvname,
 			      const char *sharename)
 {
@@ -1889,8 +2398,8 @@ static BOOL srv_io_file_info3_str(char *desc, FILE_INFO_3_STR *sh1, prs_struct *
 ********************************************************************/
 
 void init_srv_file_info3(FILE_INFO_3 *fl3,
-				uint32 id, uint32 perms, uint32 num_locks,
-				char *path_name, char *user_name)
+			 uint32 id, uint32 perms, uint32 num_locks,
+			 char *path_name, char *user_name)
 {
 	DEBUG(5,("init_srv_file_info3: %s %s\n", path_name, user_name));
 
@@ -2004,7 +2513,8 @@ static BOOL srv_io_srv_file_ctr(char *desc, SRV_FILE_INFO_CTR *ctr, prs_struct *
 ********************************************************************/
 
 void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n, 
-			      char *srv_name, char *qual_name, char *user_name,
+			      const char *srv_name, const char *qual_name, 
+			      const char *user_name,
 			      uint32 file_level, SRV_FILE_INFO_CTR *ctr,
 			      uint32 preferred_len,
 			      ENUM_HND *hnd)
@@ -2295,7 +2805,7 @@ void init_srv_info_102(SRV_INFO_102 *sv102, uint32 platform_id, char *name,
 	sv102->disc         = disc;
 	sv102->hidden       = hidden;
 	sv102->announce     = announce;
-	sv102->ann_delta    =ann_delta;
+	sv102->ann_delta    = ann_delta;
 	sv102->licenses     = licenses;
 	init_buf_unistr2(&sv102->uni_usr_path, &sv102->ptr_usr_path, usr_path);
 }
@@ -2559,7 +3069,7 @@ BOOL srv_io_r_net_srv_set_info(char *desc, SRV_R_NET_SRV_SET_INFO *r_n,
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("switch_value  ", ps, depth, &r_n->switch_value))
+	if(!prs_uint32("switch value ", ps, depth, &r_n->switch_value))
 		return False;
 
 	if(!prs_werror("status", ps, depth, &r_n->status))
@@ -2688,6 +3198,31 @@ BOOL srv_io_r_net_remote_tod(char *desc, SRV_R_NET_REMOTE_TOD *r_n, prs_struct *
 }
 
 /*******************************************************************
+ initialises a structure.
+ ********************************************************************/
+
+BOOL init_srv_q_net_disk_enum(SRV_Q_NET_DISK_ENUM *q_n,
+			      const char *srv_name,
+			      uint32 preferred_len,
+			      ENUM_HND *enum_hnd
+	) 
+{
+  
+
+	DEBUG(5,("init_srv_q_net_srv_disk_enum\n"));
+
+	init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
+
+	q_n->disk_enum_ctr.level = 0;
+	q_n->disk_enum_ctr.disk_info_ptr   = 0;
+  
+	q_n->preferred_len = preferred_len;
+	memcpy(&q_n->enum_hnd, enum_hnd, sizeof(*enum_hnd));
+
+	return True;
+}
+
+/*******************************************************************
  Reads or writes a structure.
  ********************************************************************/
 
@@ -2737,7 +3272,9 @@ BOOL srv_io_q_net_disk_enum(char *desc, SRV_Q_NET_DISK_ENUM *q_n, prs_struct *ps
 
 BOOL srv_io_r_net_disk_enum(char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_struct *ps, int depth)
 {
+
 	int i;
+	uint32 entries_read, entries_read2, entries_read3;
 
 	if (r_n == NULL)
 		return False;
@@ -2745,23 +3282,36 @@ BOOL srv_io_r_net_disk_enum(char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_struct *ps
 	prs_debug(ps, depth, desc, "srv_io_r_net_disk_enum");
 	depth++;
 
+	entries_read = entries_read2 = entries_read3 = r_n->disk_enum_ctr.entries_read;
+
 	if(!prs_align(ps))
 		return False;
 
-	if(!prs_uint32("entries_read", ps, depth, &r_n->disk_enum_ctr.entries_read))
+	if(!prs_uint32("entries_read", ps, depth, &entries_read))
 		return False;
 	if(!prs_uint32("ptr_disk_info", ps, depth, &r_n->disk_enum_ctr.disk_info_ptr))
 		return False;
 
 	/*this may be max, unknown, actual?*/
 
-	if(!prs_uint32("max_elements", ps, depth, &r_n->disk_enum_ctr.entries_read))
+	if(!prs_uint32("max_elements", ps, depth, &entries_read2))
 		return False;
 	if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.unknown))
 		return False;
-	if(!prs_uint32("actual_elements", ps, depth, &r_n->disk_enum_ctr.entries_read))
+	if(!prs_uint32("actual_elements", ps, depth, &entries_read3))
 		return False;
 
+	r_n->disk_enum_ctr.entries_read = entries_read3;
+
+	if(UNMARSHALLING(ps)) {
+
+		DISK_INFO *dinfo;
+
+		if(!(dinfo = (DISK_INFO *)prs_alloc_mem(ps, sizeof(*dinfo) * entries_read3)))
+		return False;
+		r_n->disk_enum_ctr.disk_info = dinfo;
+	}
+
 	for(i=0; i < r_n->disk_enum_ctr.entries_read; i++) {
 
 		if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.disk_info[i].unknown))
@@ -2787,6 +3337,25 @@ BOOL srv_io_r_net_disk_enum(char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_struct *ps
 }
 
 /*******************************************************************
+ initialises a structure.
+ ********************************************************************/
+
+BOOL init_srv_q_net_name_validate(SRV_Q_NET_NAME_VALIDATE *q_n, const char *srv_name, const char *share_name, int type) 
+{
+	uint32 ptr_share_name;
+
+	DEBUG(5,("init_srv_q_net_name_validate\n"));
+  
+	init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
+	init_buf_unistr2(&q_n->uni_name,     &ptr_share_name,    share_name);
+
+	q_n->type  = type;
+	q_n->flags = 0;
+
+	return True;
+}
+
+/*******************************************************************
  Reads or writes a structure.
  ********************************************************************/