"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)

1 files changed, 2796 insertions, 0 deletions

diff --git a/source3/rpc_parse/parse_samr.c b/source3/rpc_parse/parse_samr.c
new file mode 100644
index 0000000000..a72769d9c0
--- /dev/null
+++ b/source3/rpc_parse/parse_samr.c
@@ -0,0 +1,2796 @@
+/* 
+ *  Unix SMB/Netbios implementation.
+ *  Version 1.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.
+ *  
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *  
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *  
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include "includes.h"
+
+extern int DEBUGLEVEL;
+
+
+/*******************************************************************
+makes a SAMR_Q_CLOSE_HND structure.
+********************************************************************/
+void make_samr_q_close_hnd(SAMR_Q_CLOSE_HND *q_c, POLICY_HND *hnd)
+{
+	if (q_c == NULL || hnd == NULL) return;
+
+	DEBUG(5,("make_samr_q_close_hnd\n"));
+
+	memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_close_hnd(char *desc,  SAMR_Q_CLOSE_HND *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_close_hnd(char *desc,  SAMR_R_CLOSE_HND *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(r_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void make_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN *q_u,
+				POLICY_HND *connect_pol, uint32 rid, char *sid)
+{
+	if (q_u == NULL) return;
+
+	DEBUG(5,("samr_make_q_open_domain\n"));
+
+	memcpy(&q_u->connect_pol, connect_pol, sizeof(q_u->connect_pol));
+	q_u->rid = rid;
+	make_dom_sid2(&(q_u->dom_sid), sid);
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_open_domain(char *desc,  SAMR_Q_OPEN_DOMAIN *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_open_domain");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("connect_pol", &(q_u->connect_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("rid", ps, depth, &(q_u->rid));
+
+	smb_io_dom_sid2("sid", &(q_u->dom_sid), ps, depth); 
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_open_domain(char *desc,  SAMR_R_OPEN_DOMAIN *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_open_domain");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("domain_pol", &(r_u->domain_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void make_samr_q_unknown_8(SAMR_Q_UNKNOWN_8 *q_u,
+				POLICY_HND *domain_pol, uint16 switch_value)
+{
+	if (q_u == NULL) return;
+
+	DEBUG(5,("samr_make_q_unknown_8\n"));
+
+	memcpy(&q_u->domain_pol, domain_pol, sizeof(q_u->domain_pol));
+	q_u->switch_value = switch_value;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_8(char *desc,  SAMR_Q_UNKNOWN_8 *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_8");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
+	prs_align(ps);
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void make_samr_q_unknown_3(SAMR_Q_UNKNOWN_3 *q_u,
+				POLICY_HND *user_pol, uint16 switch_value)
+{
+	if (q_u == NULL) return;
+
+	DEBUG(5,("samr_make_q_unknown_3\n"));
+
+	memcpy(&q_u->user_pol, user_pol, sizeof(q_u->user_pol));
+	q_u->switch_value = switch_value;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_3(char *desc,  SAMR_Q_UNKNOWN_3 *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_3");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("user_pol", &(q_u->user_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("switch_value", ps, depth, &(q_u->switch_value));
+	prs_align(ps);
+}
+
+/*******************************************************************
+ makes a DOM_SID3 structure.
+
+ calculate length by adding up the size of the components.
+ ********************************************************************/
+void make_dom_sid3(DOM_SID3 *sid3, uint16 unk_0, uint16 unk_1, char *sid)
+{
+	if (sid3 == NULL) return;
+
+	make_dom_sid(&(sid3->sid), sid);
+	sid3->len = 2 + 8 + sid3->sid.num_auths * 4;
+}
+
+/*******************************************************************
+reads or writes a SAM_SID3 structure.
+
+this one's odd, because the length (in bytes) is specified at the beginning.
+the length _includes_ the length of the length, too :-)
+
+********************************************************************/
+void sam_io_dom_sid3(char *desc,  DOM_SID3 *sid3, prs_struct *ps, int depth)
+{
+	if (sid3 == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_dom_sid3");
+	depth++;
+
+	prs_uint16("len", ps, depth, &(sid3->len));
+	prs_align(ps);
+	smb_io_dom_sid("", &(sid3->sid), ps, depth); 
+}
+
+/*******************************************************************
+makes a SAMR_R_UNKNOWN3 structure.
+
+unknown_2   : 0x0001
+unknown_3   : 0x8004
+
+unknown_4,5 : 0x0000 0014
+
+unknown_6   : 0x0002
+unknown_7   : 0x5800 or 0x0070
+
+********************************************************************/
+void make_sam_sid_stuff(SAM_SID_STUFF *stf,
+				uint16 unknown_2, uint16 unknown_3,
+				uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
+				int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS])
+{
+	stf->unknown_2 = unknown_2;
+	stf->unknown_3 = unknown_3;
+
+	bzero(stf->padding1, sizeof(stf->padding1));
+
+	stf->unknown_4 = unknown_4;
+	stf->unknown_5 = unknown_4;
+
+	stf->unknown_6 = unknown_6;
+	stf->unknown_7 = unknown_7;
+
+	stf->num_sids  = num_sid3s;
+
+	stf->padding2  = 0x0000;
+
+	memcpy(stf->sid, sid3, sizeof(DOM_SID3) * num_sid3s);
+}
+
+/*******************************************************************
+reads or writes a SAM_SID_STUFF structure.
+********************************************************************/
+void sam_io_sid_stuff(char *desc,  SAM_SID_STUFF *stf, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (stf == NULL) return;
+
+	DEBUG(5,("make_sam_sid_stuff\n"));
+
+	prs_uint16("unknown_2", ps, depth, &(stf->unknown_2));
+	prs_uint16("unknown_3", ps, depth, &(stf->unknown_3));
+
+	prs_uint8s(False, "padding1", ps, depth, stf->padding1, sizeof(stf->padding1)); 
+	
+	prs_uint32("unknown_4", ps, depth, &(stf->unknown_4));
+	prs_uint32("unknown_5", ps, depth, &(stf->unknown_5));
+	prs_uint16("unknown_6", ps, depth, &(stf->unknown_6));
+	prs_uint16("unknown_7", ps, depth, &(stf->unknown_7));
+
+	prs_uint32("num_sids ", ps, depth, &(stf->num_sids ));
+	prs_uint16("padding2 ", ps, depth, &(stf->padding2 ));
+
+	for (i = 0; i < stf->num_sids; i++)
+	{
+		sam_io_dom_sid3("", &(stf->sid[i]), ps, depth); 
+	}
+}
+
+/*******************************************************************
+reads or writes a SAMR_R_UNKNOWN3 structure.
+********************************************************************/
+void make_samr_r_unknown_3(SAMR_R_UNKNOWN_3 *r_u,
+				uint16 unknown_2, uint16 unknown_3,
+				uint32 unknown_4, uint16 unknown_6, uint16 unknown_7,
+				int num_sid3s, DOM_SID3 sid3[MAX_SAM_SIDS],
+				uint32 status)
+{
+	if (r_u == NULL) return;
+
+	DEBUG(5,("samr_make_r_unknown_3\n"));
+
+	r_u->ptr_0 = 0;
+	r_u->ptr_1 = 0;
+
+	if (status == 0x0)
+	{
+		r_u->ptr_0 = 1;
+		r_u->ptr_1 = 1;
+		make_sam_sid_stuff(&(r_u->sid_stuff), unknown_2, unknown_3,
+	               unknown_4, unknown_6, unknown_7,
+	               num_sid3s, sid3);
+	}
+
+	r_u->status = status;
+}
+
+
+/*******************************************************************
+reads or writes a SAMR_R_UNKNOWN_3 structure.
+
+this one's odd, because the daft buggers use a different mechanism
+for writing out the array of sids. they put the number of sids in
+only one place: they've calculated the length of each sid and jumped
+by that amount.  then, retrospectively, the length of the whole buffer
+is put at the beginning of the data stream.
+
+wierd.  
+
+********************************************************************/
+void samr_io_r_unknown_3(char *desc,  SAMR_R_UNKNOWN_3 *r_u, prs_struct *ps, int depth)
+{
+	int ptr_len0;
+	int ptr_len1;
+	int ptr_sid_stuff = 0;
+
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_unknown_3");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr_0         ", ps, depth, &(r_u->ptr_0         ));
+
+	if (ps->io) 
+	{
+		/* reading.  do the length later */
+		prs_uint32("sid_stuff_len0", ps, depth, &(r_u->sid_stuff_len0));
+	}
+	else
+	{
+		/* storing */
+		ptr_len0 = ps->offset; ps->offset += 4;
+	}
+
+	if (r_u->ptr_0 != 0)
+	{
+		prs_uint32("ptr_1         ", ps, depth, &(r_u->ptr_1         ));
+		if (ps->io)
+		{
+			/* reading.  do the length later */
+			prs_uint32("sid_stuff_len1", ps, depth, &(r_u->sid_stuff_len1));
+		}
+		else
+		{
+			/* storing */
+			ptr_len1 = ps->offset; ps->offset += 4;
+		}
+
+		if (r_u->ptr_1 != 0)
+		{
+			ptr_sid_stuff = ps->offset;
+			sam_io_sid_stuff("", &(r_u->sid_stuff), ps, depth); 
+		}
+	}
+
+	if (!(ps->io)) /* storing not reading.  do the length, now. */
+	{
+		if (ptr_sid_stuff != 0)
+		{
+			uint32 sid_stuff_len = ps->offset - ptr_sid_stuff;
+			int old_len = ps->offset;
+
+			ps->offset = ptr_len0;
+			prs_uint32("sid_stuff_len0", ps, depth, &sid_stuff_len); 
+
+			ps->offset = ptr_len1;
+			prs_uint32("sid_stuff_len1", ps, depth, &sid_stuff_len);
+
+			ps->offset = old_len;
+		}
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+makes a SAM_STR1 structure.
+********************************************************************/
+void make_sam_str1(SAM_STR1 *sam, char *sam_acct, char *sam_name, char *sam_desc)
+{
+	int len_sam_acct = sam_acct != NULL ? strlen(sam_acct) : 0;
+	int len_sam_name = sam_name != NULL ? strlen(sam_name) : 0;
+	int len_sam_desc = sam_desc != NULL ? strlen(sam_desc) : 0;
+
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_str1: %d\n", __LINE__));
+
+	make_unistr2(&(sam->uni_acct_name), sam_acct, len_sam_acct);
+	make_unistr2(&(sam->uni_full_name), sam_name, len_sam_name);
+	make_unistr2(&(sam->uni_acct_desc), sam_desc, len_sam_desc);
+}
+
+/*******************************************************************
+reads or writes a SAM_STR1 structure.
+********************************************************************/
+void sam_io_sam_str1(char *desc,  SAM_STR1 *sam, uint32 acct_buf, uint32 name_buf, uint32 desc_buf, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_str1");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_unistr2("unistr2", &(sam->uni_acct_name), acct_buf, ps, depth); /* account name unicode string */
+	smb_io_unistr2("unistr2", &(sam->uni_full_name), name_buf, ps, depth); /* full name unicode string */
+	smb_io_unistr2("unistr2", &(sam->uni_acct_desc), desc_buf, ps, depth); /* account description unicode string */
+}
+
+/*******************************************************************
+makes a SAM_ENTRY1 structure.
+********************************************************************/
+void make_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx, 
+				uint32 len_sam_name, uint32 len_sam_full, uint32 len_sam_desc,
+				uint32 rid_user, uint16 acb_info)
+{
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_entry2: %d\n", __LINE__));
+
+	sam->user_idx = user_idx;
+	sam->rid_user = rid_user;
+	sam->acb_info = acb_info;
+	sam->pad      = 0;
+
+	make_uni_hdr(&(sam->hdr_acct_name), len_sam_name, len_sam_name, len_sam_name != 0);
+	make_uni_hdr(&(sam->hdr_user_name), len_sam_full, len_sam_full, len_sam_full != 0);
+	make_uni_hdr(&(sam->hdr_user_desc), len_sam_desc, len_sam_desc, len_sam_desc != 0);
+}
+
+/*******************************************************************
+reads or writes a SAM_ENTRY1 structure.
+********************************************************************/
+void sam_io_sam_entry1(char *desc,  SAM_ENTRY1 *sam, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_entry2");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
+
+	prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
+	prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
+	prs_uint16("pad      ", ps, depth, &(sam->pad      ));
+
+	smb_io_unihdr("unihdr", &(sam->hdr_acct_name), ps, depth); /* account name unicode string header */
+	smb_io_unihdr("unihdr", &(sam->hdr_user_name), ps, depth); /* account name unicode string header */
+	smb_io_unihdr("unihdr", &(sam->hdr_user_desc), ps, depth); /* account name unicode string header */
+}
+
+/*******************************************************************
+makes a SAM_STR2 structure.
+********************************************************************/
+void make_sam_str2(SAM_STR2 *sam, char *sam_acct, char *sam_desc)
+{
+	int len_sam_acct = sam_acct != NULL ? strlen(sam_acct) : 0;
+	int len_sam_desc = sam_desc != NULL ? strlen(sam_desc) : 0;
+
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_str2: %d\n", __LINE__));
+
+	make_unistr2(&(sam->uni_srv_name), sam_acct, len_sam_acct);
+	make_unistr2(&(sam->uni_srv_desc), sam_desc, len_sam_desc);
+}
+
+/*******************************************************************
+reads or writes a SAM_STR2 structure.
+********************************************************************/
+void sam_io_sam_str2(char *desc,  SAM_STR2 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_str2");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_unistr2("unistr2", &(sam->uni_srv_name), acct_buf, ps, depth); /* account name unicode string */
+	smb_io_unistr2("unistr2", &(sam->uni_srv_desc), desc_buf, ps, depth); /* account description unicode string */
+}
+
+/*******************************************************************
+makes a SAM_ENTRY2 structure.
+********************************************************************/
+void make_sam_entry2(SAM_ENTRY2 *sam, uint32 user_idx, 
+				uint32 len_sam_name, uint32 len_sam_desc,
+				uint32 rid_user, uint16 acb_info)
+{
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_entry2: %d\n", __LINE__));
+
+	sam->user_idx = user_idx;
+	sam->rid_user = rid_user;
+	sam->acb_info = acb_info;
+	sam->pad      = 0;
+
+	make_uni_hdr(&(sam->hdr_srv_name), len_sam_name, len_sam_name, len_sam_name != 0);
+	make_uni_hdr(&(sam->hdr_srv_desc), len_sam_desc, len_sam_desc, len_sam_desc != 0);
+}
+
+/*******************************************************************
+reads or writes a SAM_ENTRY2 structure.
+********************************************************************/
+void sam_io_sam_entry2(char *desc,  SAM_ENTRY2 *sam, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_entry2");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("user_idx ", ps, depth, &(sam->user_idx ));
+
+	prs_uint32("rid_user ", ps, depth, &(sam->rid_user ));
+	prs_uint16("acb_info ", ps, depth, &(sam->acb_info ));
+	prs_uint16("pad      ", ps, depth, &(sam->pad      ));
+
+	smb_io_unihdr("unihdr", &(sam->hdr_srv_name), ps, depth); /* account name unicode string header */
+	smb_io_unihdr("unihdr", &(sam->hdr_srv_desc), ps, depth); /* account name unicode string header */
+}
+
+/*******************************************************************
+makes a SAM_STR3 structure.
+********************************************************************/
+void make_sam_str3(SAM_STR3 *sam, char *grp_acct, char *grp_desc)
+{
+	int len_grp_acct = strlen(grp_acct);
+	int len_grp_desc = strlen(grp_desc);
+
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_str3: %d\n", __LINE__));
+
+	make_unistr2(&(sam->uni_grp_name), grp_acct, len_grp_acct);
+	make_unistr2(&(sam->uni_grp_desc), grp_desc, len_grp_desc);
+}
+
+/*******************************************************************
+reads or writes a SAM_STR3 structure.
+********************************************************************/
+void sam_io_sam_str3(char *desc,  SAM_STR3 *sam, uint32 acct_buf, uint32 desc_buf, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_str3");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_unistr2("unistr2", &(sam->uni_grp_name), acct_buf, ps, depth); /* account name unicode string */
+	smb_io_unistr2("unistr2", &(sam->uni_grp_desc), desc_buf, ps, depth); /* account description unicode string */
+}
+
+/*******************************************************************
+makes a SAM_ENTRY3 structure.
+********************************************************************/
+void make_sam_entry3(SAM_ENTRY3 *sam, uint32 grp_idx, 
+				uint32 len_grp_name, uint32 len_grp_desc, uint32 rid_grp)
+{
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_entry3: %d\n", __LINE__));
+
+	sam->grp_idx = grp_idx;
+	sam->rid_grp = rid_grp;
+	sam->attr    = 0x07; /* group rid attributes - gets ignored by nt 4.0 */
+
+	make_uni_hdr(&(sam->hdr_grp_name), len_grp_name, len_grp_name, len_grp_name != 0);
+	make_uni_hdr(&(sam->hdr_grp_desc), len_grp_desc, len_grp_desc, len_grp_desc != 0);
+}
+
+/*******************************************************************
+reads or writes a SAM_ENTRY3 structure.
+********************************************************************/
+void sam_io_sam_entry3(char *desc,  SAM_ENTRY3 *sam, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_entry3");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("grp_idx", ps, depth, &(sam->grp_idx));
+
+	prs_uint32("rid_grp", ps, depth, &(sam->rid_grp));
+	prs_uint32("attr   ", ps, depth, &(sam->attr   ));
+
+	smb_io_unihdr("unihdr", &(sam->hdr_grp_name), ps, depth); /* account name unicode string header */
+	smb_io_unihdr("unihdr", &(sam->hdr_grp_desc), ps, depth); /* account name unicode string header */
+}
+
+/*******************************************************************
+makes a SAM_ENTRY structure.
+********************************************************************/
+void make_sam_entry(SAM_ENTRY *sam, uint32 len_sam_name, uint32 rid)
+{
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_entry: %d\n", __LINE__));
+
+	sam->rid = rid;
+	make_uni_hdr(&(sam->hdr_name), len_sam_name, len_sam_name, len_sam_name != 0);
+}
+
+/*******************************************************************
+reads or writes a SAM_ENTRY structure.
+********************************************************************/
+void sam_io_sam_entry(char *desc,  SAM_ENTRY *sam, prs_struct *ps, int depth)
+{
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_entry");
+	depth++;
+
+	prs_align(ps);
+	prs_uint32("rid", ps, depth, &(sam->rid ));
+	smb_io_unihdr("unihdr", &(sam->hdr_name), ps, depth); /* account name unicode string header */
+}
+
+/*******************************************************************
+makes a SAMR_Q_ENUM_DOM_USERS structure.
+********************************************************************/
+void make_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS *q_e, POLICY_HND *pol,
+				uint16 req_num_entries, uint16 unk_0,
+				uint16 acb_mask, uint16 unk_1, uint32 size)
+{
+	if (q_e == NULL || pol == NULL) return;
+
+	DEBUG(5,("make_q_enum_dom_users\n"));
+
+	memcpy(&(q_e->pol), pol, sizeof(*pol));
+
+	q_e->req_num_entries = req_num_entries; /* zero indicates lots */
+	q_e->unknown_0 = unk_0; /* this gets returned in the response */
+	q_e->acb_mask  = acb_mask;
+	q_e->unknown_1 = unk_1;
+	q_e->max_size = size;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_enum_dom_users(char *desc,  SAMR_Q_ENUM_DOM_USERS *q_e, prs_struct *ps, int depth)
+{
+	if (q_e == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_e->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("req_num_entries", ps, depth, &(q_e->req_num_entries));
+	prs_uint16("unknown_0      ", ps, depth, &(q_e->unknown_0      ));
+
+	prs_uint16("acb_mask       ", ps, depth, &(q_e->acb_mask       ));
+	prs_uint16("unknown_1      ", ps, depth, &(q_e->unknown_1      ));
+
+	prs_uint32("max_size       ", ps, depth, &(q_e->max_size       ));
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAMR_R_ENUM_DOM_USERS structure.
+********************************************************************/
+void make_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS *r_u,
+		uint16 total_num_entries, uint16 unk_0,
+		uint32 num_sam_entries, SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES], uint32 status)
+{
+	int i;
+
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_enum_dom_users\n"));
+
+	if (num_sam_entries >= MAX_SAM_ENTRIES)
+	{
+		num_sam_entries = MAX_SAM_ENTRIES;
+		DEBUG(5,("limiting number of entries to %d %s\n", num_sam_entries));
+	}
+
+	r_u->total_num_entries = total_num_entries;
+	r_u->unknown_0         = unk_0;
+
+	if (total_num_entries > 0)
+	{
+		r_u->ptr_entries1 = 1;
+		r_u->ptr_entries2 = 1;
+		r_u->num_entries2 = num_sam_entries;
+		r_u->num_entries3 = num_sam_entries;
+
+		for (i = 0; i < num_sam_entries; i++)
+		{
+			make_sam_entry(&(r_u->sam[i]),
+			               pass[i].uni_user_name.uni_str_len,
+			               pass[i].user_rid);
+
+			copy_unistr2(&(r_u->uni_acct_name[i]), &(pass[i].uni_user_name));
+		}
+
+		r_u->num_entries4 = num_sam_entries;
+	}
+	else
+	{
+		r_u->ptr_entries1 = 0;
+		r_u->num_entries2 = num_sam_entries;
+		r_u->ptr_entries2 = 1;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_enum_dom_users(char *desc,  SAMR_R_ENUM_DOM_USERS *r_u, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint16("total_num_entries", ps, depth, &(r_u->total_num_entries));
+	prs_uint16("unknown_0        ", ps, depth, &(r_u->unknown_0        ));
+	prs_uint32("ptr_entries1", ps, depth, &(r_u->ptr_entries1));
+
+	if (r_u->total_num_entries != 0 && r_u->ptr_entries1 != 0)
+	{
+		prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
+		prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
+		prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
+
+		for (i = 0; i < r_u->num_entries2; i++)
+		{
+			prs_grow(ps);
+			sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
+		}
+
+		for (i = 0; i < r_u->num_entries2; i++)
+		{
+			prs_grow(ps);
+			smb_io_unistr2("", &(r_u->uni_acct_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
+		}
+
+		prs_align(ps);
+
+		prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+makes a SAMR_Q_ENUM_DOM_ALIASES structure.
+********************************************************************/
+void make_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES *q_e, POLICY_HND *pol, uint32 size)
+{
+	if (q_e == NULL || pol == NULL) return;
+
+	DEBUG(5,("make_q_enum_dom_aliases\n"));
+
+	memcpy(&(q_e->pol), pol, sizeof(*pol));
+
+	q_e->unknown_0 = 0;
+	q_e->max_size = size;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_enum_dom_aliases(char *desc,  SAMR_Q_ENUM_DOM_ALIASES *q_e, prs_struct *ps, int depth)
+{
+	if (q_e == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_e->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("unknown_0", ps, depth, &(q_e->unknown_0));
+	prs_uint32("max_size ", ps, depth, &(q_e->max_size ));
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAMR_R_ENUM_DOM_ALIASES structure.
+********************************************************************/
+void make_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u,
+		uint32 num_sam_entries, SAM_USER_INFO_21 grps[MAX_SAM_ENTRIES],
+		uint32 status)
+{
+	int i;
+
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_enum_dom_aliases\n"));
+
+	if (num_sam_entries >= MAX_SAM_ENTRIES)
+	{
+		num_sam_entries = MAX_SAM_ENTRIES;
+		DEBUG(5,("limiting number of entries to %d %s\n", num_sam_entries));
+	}
+
+	r_u->num_entries  = num_sam_entries;
+
+	if (num_sam_entries > 0)
+	{
+		r_u->ptr_entries  = 1;
+		r_u->num_entries2 = num_sam_entries;
+		r_u->ptr_entries2 = 1;
+		r_u->num_entries3 = num_sam_entries;
+
+		for (i = 0; i < num_sam_entries; i++)
+		{
+			make_sam_entry(&(r_u->sam[i]),
+			               grps[i].uni_user_name.uni_str_len,
+			               grps[i].user_rid);
+
+			copy_unistr2(&(r_u->uni_grp_name[i]), &(grps[i].uni_user_name));
+		}
+
+		r_u->num_entries4 = num_sam_entries;
+	}
+	else
+	{
+		r_u->ptr_entries = 0;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_enum_dom_aliases(char *desc,  SAMR_R_ENUM_DOM_ALIASES *r_u, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
+	prs_uint32("ptr_entries", ps, depth, &(r_u->ptr_entries));
+
+	if (r_u->num_entries != 0 && r_u->ptr_entries != 0)
+	{
+		prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
+		prs_uint32("ptr_entries2", ps, depth, &(r_u->ptr_entries2));
+		prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
+
+		for (i = 0; i < r_u->num_entries; i++)
+		{
+			sam_io_sam_entry("", &(r_u->sam[i]), ps, depth);
+		}
+
+		for (i = 0; i < r_u->num_entries; i++)
+		{
+			smb_io_unistr2("", &(r_u->uni_grp_name[i]), r_u->sam[i].hdr_name.buffer, ps, depth);
+		}
+
+		prs_align(ps);
+
+		prs_uint32("num_entries4", ps, depth, &(r_u->num_entries4));
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+makes a SAMR_Q_QUERY_DISPINFO structure.
+********************************************************************/
+void make_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO *q_e, POLICY_HND *pol,
+				uint16 switch_level, uint32 start_idx, uint32 size)
+{
+	if (q_e == NULL || pol == NULL) return;
+
+	DEBUG(5,("make_q_query_dispinfo\n"));
+
+	memcpy(&(q_e->pol), pol, sizeof(*pol));
+
+	q_e->switch_level = switch_level;
+
+	q_e->unknown_0 = 0;
+	q_e->start_idx = start_idx;
+	q_e->unknown_1 = 0x000007d0;
+	q_e->max_size  = size;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_query_dispinfo(char *desc,  SAMR_Q_QUERY_DISPINFO *q_e, prs_struct *ps, int depth)
+{
+	if (q_e == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_e->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
+	prs_uint16("unknown_0   ", ps, depth, &(q_e->unknown_0   ));
+	prs_uint32("start_idx   ", ps, depth, &(q_e->start_idx   ));
+	prs_uint32("unknown_1   ", ps, depth, &(q_e->unknown_1   ));
+	prs_uint32("max_size    ", ps, depth, &(q_e->max_size    ));
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAM_INFO_2 structure.
+********************************************************************/
+void make_sam_info_2(SAM_INFO_2 *sam, uint32 acb_mask,
+		uint32 start_idx, uint32 num_sam_entries,
+		SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
+{
+	int i;
+	int entries_added;
+
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_info_2\n"));
+
+	if (num_sam_entries >= MAX_SAM_ENTRIES)
+	{
+		num_sam_entries = MAX_SAM_ENTRIES;
+		DEBUG(5,("limiting number of entries to %d %s\n", num_sam_entries));
+	}
+
+	for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
+	{
+		if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
+		{
+			make_sam_entry2(&(sam->sam[entries_added]),
+			                start_idx + entries_added + 1,
+			                pass[i].uni_user_name.uni_str_len,
+			                pass[i].uni_acct_desc.uni_str_len,
+			                pass[i].user_rid,
+			                pass[i].acb_info);
+
+			copy_unistr2(&(sam->str[entries_added].uni_srv_name), &(pass[i].uni_user_name));
+			copy_unistr2(&(sam->str[entries_added].uni_srv_desc), &(pass[i].uni_acct_desc));
+
+			entries_added++;
+		}
+
+		sam->num_entries   = entries_added;
+		sam->ptr_entries   = 1;
+		sam->num_entries2  = entries_added;
+	}
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void sam_io_sam_info_2(char *desc,  SAM_INFO_2 *sam, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_info_2");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("num_entries  ", ps, depth, &(sam->num_entries  ));
+	prs_uint32("ptr_entries  ", ps, depth, &(sam->ptr_entries  ));
+
+	prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
+
+	for (i = 0; i < sam->num_entries; i++)
+	{
+		sam_io_sam_entry2("", &(sam->sam[i]), ps, depth);
+	}
+
+	for (i = 0; i < sam->num_entries; i++)
+	{
+		sam_io_sam_str2 ("", &(sam->str[i]),
+							 sam->sam[i].hdr_srv_name.buffer,
+							 sam->sam[i].hdr_srv_desc.buffer,
+							 ps, depth);
+	}
+}
+
+
+/*******************************************************************
+makes a SAM_INFO_1 structure.
+********************************************************************/
+void make_sam_info_1(SAM_INFO_1 *sam, uint32 acb_mask,
+		uint32 start_idx, uint32 num_sam_entries,
+		SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES])
+{
+	int i;
+	int entries_added;
+
+	if (sam == NULL) return;
+
+	DEBUG(5,("make_sam_info_1\n"));
+
+	if (num_sam_entries >= MAX_SAM_ENTRIES)
+	{
+		num_sam_entries = MAX_SAM_ENTRIES;
+		DEBUG(5,("limiting number of entries to %d %s\n", num_sam_entries));
+	}
+
+	for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
+	{
+		if (IS_BITS_SET_ALL(pass[i].acb_info, acb_mask))
+		{
+			make_sam_entry1(&(sam->sam[entries_added]),
+						start_idx + entries_added + 1,
+						pass[i].uni_user_name.uni_str_len,
+						pass[i].uni_full_name.uni_str_len, 
+						pass[i].uni_acct_desc.uni_str_len,
+						pass[i].user_rid,
+						pass[i].acb_info);
+
+			copy_unistr2(&(sam->str[entries_added].uni_acct_name), &(pass[i].uni_user_name));
+			copy_unistr2(&(sam->str[entries_added].uni_full_name), &(pass[i].uni_full_name));
+			copy_unistr2(&(sam->str[entries_added].uni_acct_desc), &(pass[i].uni_acct_desc));
+
+			entries_added++;
+		}
+	}
+
+	sam->num_entries   = entries_added;
+	sam->ptr_entries   = 1;
+	sam->num_entries2  = entries_added;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void sam_io_sam_info_1(char *desc,  SAM_INFO_1 *sam, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (sam == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_sam_info_1");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("num_entries  ", ps, depth, &(sam->num_entries  ));
+	prs_uint32("ptr_entries  ", ps, depth, &(sam->ptr_entries  ));
+
+	prs_uint32("num_entries2 ", ps, depth, &(sam->num_entries2 ));
+
+	for (i = 0; i < sam->num_entries; i++)
+	{
+		sam_io_sam_entry1("", &(sam->sam[i]), ps, depth);
+	}
+
+	for (i = 0; i < sam->num_entries; i++)
+	{
+		sam_io_sam_str1 ("", &(sam->str[i]),
+							 sam->sam[i].hdr_acct_name.buffer,
+							 sam->sam[i].hdr_user_name.buffer,
+							 sam->sam[i].hdr_user_desc.buffer,
+							 ps, depth);
+	}
+}
+
+
+/*******************************************************************
+makes a SAMR_R_QUERY_DISPINFO structure.
+********************************************************************/
+void make_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO *r_u,
+		uint16 switch_level, SAM_INFO_CTR *ctr, uint32 status)
+{
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_query_dispinfo\n"));
+
+	if (status == 0x0)
+	{
+		r_u->unknown_0 = 0x0000001;
+		r_u->unknown_1 = 0x0000001;
+	}
+	else
+	{
+		r_u->unknown_0 = 0x0;
+		r_u->unknown_1 = 0x0;
+	}
+
+	r_u->switch_level = switch_level;
+	r_u->ctr = ctr;
+	r_u->status = status;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_query_dispinfo(char *desc,  SAMR_R_QUERY_DISPINFO *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("unknown_0    ", ps, depth, &(r_u->unknown_0    ));
+	prs_uint32("unknown_1    ", ps, depth, &(r_u->unknown_1    ));
+	prs_uint16("switch_level ", ps, depth, &(r_u->switch_level ));
+
+	prs_align(ps);
+
+	switch (r_u->switch_level)
+	{
+		case 0x1:
+		{
+			sam_io_sam_info_1("users", r_u->ctr->sam.info1, ps, depth);
+			break;
+		}
+		case 0x2:
+		{
+			sam_io_sam_info_2("servers", r_u->ctr->sam.info2, ps, depth);
+			break;
+		}
+		default:
+		{
+			DEBUG(5,("samr_io_r_query_dispinfo: unknown switch value\n"));
+			break;
+		}
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+makes a SAMR_Q_ENUM_DOM_GROUPS structure.
+********************************************************************/
+void make_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS *q_e, POLICY_HND *pol,
+				uint16 switch_level, uint32 start_idx, uint32 size)
+{
+	if (q_e == NULL || pol == NULL) return;
+
+	DEBUG(5,("make_q_enum_dom_groups\n"));
+
+	memcpy(&(q_e->pol), pol, sizeof(*pol));
+
+	q_e->switch_level = switch_level;
+
+	q_e->unknown_0 = 0;
+	q_e->start_idx = start_idx;
+	q_e->unknown_1 = 0x000007d0;
+	q_e->max_size  = size;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_enum_dom_groups(char *desc,  SAMR_Q_ENUM_DOM_GROUPS *q_e, prs_struct *ps, int depth)
+{
+	if (q_e == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_e->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
+	prs_uint16("unknown_0   ", ps, depth, &(q_e->unknown_0   ));
+	prs_uint32("start_idx   ", ps, depth, &(q_e->start_idx   ));
+	prs_uint32("unknown_1   ", ps, depth, &(q_e->unknown_1   ));
+	prs_uint32("max_size    ", ps, depth, &(q_e->max_size    ));
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAMR_R_ENUM_DOM_GROUPS structure.
+********************************************************************/
+void make_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS *r_u,
+		uint32 start_idx, uint32 num_sam_entries,
+		SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES],
+		uint32 status)
+{
+	int i;
+	int entries_added;
+
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_enum_dom_groups\n"));
+
+	if (num_sam_entries >= MAX_SAM_ENTRIES)
+	{
+		num_sam_entries = MAX_SAM_ENTRIES;
+		DEBUG(5,("limiting number of entries to %d %s\n", num_sam_entries));
+	}
+
+	if (status == 0x0)
+	{
+		for (i = start_idx, entries_added = 0; i < num_sam_entries; i++)
+		{
+			make_sam_entry3(&(r_u->sam[entries_added]),
+			                start_idx + entries_added + 1,
+			                pass[i].uni_user_name.uni_str_len,
+			                pass[i].uni_acct_desc.uni_str_len,
+			                pass[i].user_rid);
+
+			copy_unistr2(&(r_u->str[entries_added].uni_grp_name), &(pass[i].uni_user_name));
+			copy_unistr2(&(r_u->str[entries_added].uni_grp_desc), &(pass[i].uni_acct_desc));
+
+			entries_added++;
+		}
+
+		if (entries_added > 0)
+		{
+			r_u->unknown_0 = 0x0000492;
+			r_u->unknown_1 = 0x000049a;
+		}
+		else
+		{
+			r_u->unknown_0 = 0x0;
+			r_u->unknown_1 = 0x0;
+		}
+		r_u->switch_level  = 3;
+		r_u->num_entries   = entries_added;
+		r_u->ptr_entries   = 1;
+		r_u->num_entries2  = entries_added;
+	}
+	else
+	{
+		r_u->switch_level = 0;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_enum_dom_groups(char *desc,  SAMR_R_ENUM_DOM_GROUPS *r_u, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("unknown_0    ", ps, depth, &(r_u->unknown_0    ));
+	prs_uint32("unknown_1    ", ps, depth, &(r_u->unknown_1    ));
+	prs_uint32("switch_level ", ps, depth, &(r_u->switch_level ));
+
+	if (r_u->switch_level != 0)
+	{
+		prs_uint32("num_entries  ", ps, depth, &(r_u->num_entries  ));
+		prs_uint32("ptr_entries  ", ps, depth, &(r_u->ptr_entries  ));
+
+		prs_uint32("num_entries2 ", ps, depth, &(r_u->num_entries2 ));
+
+		for (i = 0; i < r_u->num_entries; i++)
+		{
+			sam_io_sam_entry3("", &(r_u->sam[i]), ps, depth);
+		}
+
+		for (i = 0; i < r_u->num_entries; i++)
+		{
+			sam_io_sam_str3 ("", &(r_u->str[i]),
+			                     r_u->sam[i].hdr_grp_name.buffer,
+			                     r_u->sam[i].hdr_grp_desc.buffer,
+			                     ps, depth);
+		}
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+makes a SAMR_Q_QUERY_ALIASINFO structure.
+********************************************************************/
+void make_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO *q_e,
+				POLICY_HND *pol,
+				uint16 switch_level)
+{
+	if (q_e == NULL || pol == NULL) return;
+
+	DEBUG(5,("make_q_query_aliasinfo\n"));
+
+	memcpy(&(q_e->pol), pol, sizeof(*pol));
+
+	q_e->switch_level = switch_level;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_query_aliasinfo(char *desc,  SAMR_Q_QUERY_ALIASINFO *q_e, prs_struct *ps, int depth)
+{
+	if (q_e == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_e->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("switch_level", ps, depth, &(q_e->switch_level));
+}
+
+
+/*******************************************************************
+makes a SAMR_R_QUERY_ALIASINFO structure.
+********************************************************************/
+void make_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *r_u,
+		uint16 switch_value, char *acct_desc,
+		uint32 status)
+{
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_query_aliasinfo\n"));
+
+	r_u->ptr = 0;
+
+	if (status == 0)
+	{
+		r_u->switch_value = switch_value;
+
+		switch (switch_value)
+		{
+			case 3:
+			{
+				int acct_len = acct_desc ? strlen(acct_desc) : 0;
+
+				r_u->ptr = 1;
+
+				make_uni_hdr(&(r_u->alias.info3.hdr_acct_desc), acct_len , acct_len, acct_desc ? 1 : 0);
+				make_unistr2(&(r_u->alias.info3.uni_acct_desc), acct_desc, acct_len);
+
+				break;
+			}
+
+			default:
+			{
+				DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
+				break;
+			}
+		}
+	}
+
+	r_u->status = status;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_query_aliasinfo(char *desc,  SAMR_R_QUERY_ALIASINFO *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
+	
+	if (r_u->ptr != 0)
+	{
+		prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
+		prs_align(ps);
+
+		if (r_u->switch_value != 0)
+		{
+			switch (r_u->switch_value)
+			{
+				case 3:
+				{
+					smb_io_unihdr ("", &(r_u->alias.info3.hdr_acct_desc), ps, depth);
+					smb_io_unistr2("", &(r_u->alias.info3.uni_acct_desc), r_u->alias.info3.hdr_acct_desc.buffer, ps, depth);
+					break;
+				}
+				default:
+				{
+					DEBUG(4,("samr_io_r_query_aliasinfo: unsupported switch level\n"));
+					break;
+				}
+			}
+		}
+	}
+
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+reads or writes a SAMR_Q_LOOKUP_IDS structure.
+********************************************************************/
+void samr_io_q_lookup_ids(char *desc,  SAMR_Q_LOOKUP_IDS *q_u, prs_struct *ps, int depth)
+{
+	fstring tmp;
+	int i;
+
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_lookup_ids");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("num_sids1", ps, depth, &(q_u->num_sids1));
+	prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
+	prs_uint32("num_sids2", ps, depth, &(q_u->num_sids2));
+
+	for (i = 0; i < q_u->num_sids2; i++)
+	{
+		sprintf(tmp, "ptr[%02d]", i);
+		prs_uint32(tmp, ps, depth, &(q_u->ptr_sid[i]));
+	}
+
+	for (i = 0; i < q_u->num_sids2; i++)
+	{
+		if (q_u->ptr_sid[i] != 0)
+		{
+			sprintf(tmp, "sid[%02d]", i);
+			smb_io_dom_sid2(tmp, &(q_u->sid[i]), ps, depth); 
+		}
+	}
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAMR_R_LOOKUP_IDS structure.
+********************************************************************/
+void make_samr_r_lookup_ids(SAMR_R_LOOKUP_IDS *r_u,
+		uint32 num_rids, uint32 *rid, uint32 status)
+{
+	int i;
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_lookup_ids\n"));
+
+	if (status == 0x0)
+	{
+		r_u->num_entries  = num_rids;
+		r_u->ptr = 1;
+		r_u->num_entries2 = num_rids;
+
+		for (i = 0; i < num_rids; i++)
+		{
+			r_u->rid[i] = rid[i];
+		}
+	}
+	else
+	{
+		r_u->num_entries  = 0;
+		r_u->ptr = 0;
+		r_u->num_entries2 = 0;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_lookup_ids(char *desc,  SAMR_R_LOOKUP_IDS *r_u, prs_struct *ps, int depth)
+{
+	fstring tmp;
+	int i;
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_lookup_ids");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("num_entries", ps, depth, &(r_u->num_entries));
+	prs_uint32("ptr        ", ps, depth, &(r_u->ptr        ));
+	prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
+
+	if (r_u->num_entries != 0)
+	{
+
+		for (i = 0; i < r_u->num_entries2; i++)
+		{
+			sprintf(tmp, "rid[%02d]", i);
+			prs_uint32(tmp, ps, depth, &(r_u->rid[i]));
+		}
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_lookup_names(char *desc,  SAMR_Q_LOOKUP_NAMES *q_u, prs_struct *ps, int depth)
+{
+	int i;
+
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("num_rids1", ps, depth, &(q_u->num_rids1));
+	prs_uint32("rid      ", ps, depth, &(q_u->rid      ));
+	prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
+	prs_uint32("num_rids2", ps, depth, &(q_u->num_rids2));
+
+	for (i = 0; i < q_u->num_rids2; i++)
+	{
+		smb_io_unihdr ("", &(q_u->hdr_user_name[i]), ps, depth); 
+	}
+	for (i = 0; i < q_u->num_rids2; i++)
+	{
+		smb_io_unistr2("", &(q_u->uni_user_name[i]), q_u->hdr_user_name[i].buffer, ps, depth); 
+	}
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAMR_R_LOOKUP_NAMES structure.
+********************************************************************/
+void make_samr_r_lookup_names(SAMR_R_LOOKUP_NAMES *r_u,
+		uint32 num_rids, uint32 *rid, uint32 status)
+{
+	int i;
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_lookup_names\n"));
+
+	if (status == 0x0)
+	{
+		r_u->num_entries  = num_rids;
+		r_u->undoc_buffer = 1;
+		r_u->num_entries2 = num_rids;
+
+		for (i = 0; i < num_rids; i++)
+		{
+			make_dom_rid3(&(r_u->dom_rid[i]), rid[i]);
+		}
+
+		r_u->num_entries3 = num_rids;
+	}
+	else
+	{
+		r_u->num_entries  = 0;
+		r_u->undoc_buffer = 0;
+		r_u->num_entries2 = 0;
+		r_u->num_entries3 = 0;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_lookup_names(char *desc,  SAMR_R_LOOKUP_NAMES *r_u, prs_struct *ps, int depth)
+{
+	int i;
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("num_entries ", ps, depth, &(r_u->num_entries ));
+	prs_uint32("undoc_buffer", ps, depth, &(r_u->undoc_buffer));
+	prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
+
+	if (r_u->num_entries != 0)
+	{
+		for (i = 0; i < r_u->num_entries2; i++)
+		{
+			smb_io_dom_rid3("", &(r_u->dom_rid[i]), ps, depth);
+		}
+
+	}
+
+	prs_uint32("num_entries3", ps, depth, &(r_u->num_entries3));
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+makes a SAMR_Q_UNKNOWN_12 structure.
+********************************************************************/
+void make_samr_q_unknown_12(SAMR_Q_UNKNOWN_12 *q_u,
+		POLICY_HND *pol, uint32 rid,
+		uint32 num_gids, uint32 *gid)
+{
+	int i;
+	if (q_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_unknwon_12\n"));
+
+	memcpy(&(q_u->pol), pol, sizeof(*pol));
+
+	q_u->num_gids1 = num_gids;
+	q_u->rid       = rid;
+	q_u->ptr       = 0;
+	q_u->num_gids2 = num_gids;
+
+	for (i = 0; i < num_gids; i++)
+	{
+		q_u->gid[i] = gid[i];
+	}
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_12(char *desc,  SAMR_Q_UNKNOWN_12 *q_u, prs_struct *ps, int depth)
+{
+	int i;
+	fstring tmp;
+
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_12");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("num_gids1", ps, depth, &(q_u->num_gids1));
+	prs_uint32("rid      ", ps, depth, &(q_u->rid      ));
+	prs_uint32("ptr      ", ps, depth, &(q_u->ptr      ));
+	prs_uint32("num_gids2", ps, depth, &(q_u->num_gids2));
+
+	for (i = 0; i < q_u->num_gids2; i++)
+	{
+		sprintf(tmp, "gid[%02d]  ", i);
+		prs_uint32(tmp, ps, depth, &(q_u->gid[i]));
+	}
+
+	prs_align(ps);
+}
+
+
+/*******************************************************************
+makes a SAMR_R_UNKNOWN_12 structure.
+********************************************************************/
+void make_samr_r_unknown_12(SAMR_R_UNKNOWN_12 *r_u,
+		uint32 num_aliases, fstring *als_name, uint32 *num_als_usrs,
+		uint32 status)
+{
+	int i;
+	if (r_u == NULL || als_name == NULL || num_als_usrs == NULL) return;
+
+	DEBUG(5,("make_samr_r_unknown_12\n"));
+
+	if (status == 0x0)
+	{
+		r_u->num_aliases1 = num_aliases;
+		r_u->ptr_aliases  = 1;
+		r_u->num_aliases2 = num_aliases;
+
+		r_u->num_als_usrs1 = num_aliases;
+		r_u->ptr_als_usrs  = 1;
+		r_u->num_als_usrs2 = num_aliases;
+
+		for (i = 0; i < num_aliases; i++)
+		{
+			int als_len = als_name[i] != NULL ? strlen(als_name[i]) : 0;
+			make_uni_hdr(&(r_u->hdr_als_name[i]), als_len    , als_len, als_name[i] ? 1 : 0);
+			make_unistr2(&(r_u->uni_als_name[i]), als_name[i], als_len);
+			r_u->num_als_usrs[i] = num_als_usrs[i];
+		}
+	}
+	else
+	{
+		r_u->num_aliases1 = num_aliases;
+		r_u->ptr_aliases  = 0;
+		r_u->num_aliases2 = num_aliases;
+
+		r_u->num_als_usrs1 = num_aliases;
+		r_u->ptr_als_usrs  = 0;
+		r_u->num_als_usrs2 = num_aliases;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_unknown_12(char *desc,  SAMR_R_UNKNOWN_12 *r_u, prs_struct *ps, int depth)
+{
+	int i;
+	fstring tmp;
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_unknown_12");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("num_aliases1", ps, depth, &(r_u->num_aliases1));
+	prs_uint32("ptr_aliases ", ps, depth, &(r_u->ptr_aliases ));
+	prs_uint32("num_aliases2", ps, depth, &(r_u->num_aliases2));
+
+	if (r_u->ptr_aliases != 0 && r_u->num_aliases1 != 0)
+	{
+		for (i = 0; i < r_u->num_aliases2; i++)
+		{
+			sprintf(tmp, "als_hdr[%02d]  ", i);
+			smb_io_unihdr ("", &(r_u->hdr_als_name[i]), ps, depth); 
+		}
+		for (i = 0; i < r_u->num_aliases2; i++)
+		{
+			sprintf(tmp, "als_str[%02d]  ", i);
+			smb_io_unistr2("", &(r_u->uni_als_name[i]), r_u->hdr_als_name[i].buffer, ps, depth); 
+		}
+	}
+
+	prs_align(ps);
+
+	prs_uint32("num_als_usrs1", ps, depth, &(r_u->num_als_usrs1));
+	prs_uint32("ptr_als_usrs ", ps, depth, &(r_u->ptr_als_usrs ));
+	prs_uint32("num_als_usrs2", ps, depth, &(r_u->num_als_usrs2));
+
+	if (r_u->ptr_als_usrs != 0 && r_u->num_als_usrs1 != 0)
+	{
+		for (i = 0; i < r_u->num_als_usrs2; i++)
+		{
+			sprintf(tmp, "als_usrs[%02d]  ", i);
+			prs_uint32(tmp, ps, depth, &(r_u->num_als_usrs[i]));
+		}
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void make_samr_q_open_user(SAMR_Q_OPEN_USER *q_u,
+				POLICY_HND *pol,
+				uint32 unk_0, uint32 rid)
+{
+	if (q_u == NULL) return;
+
+	DEBUG(5,("samr_make_q_open_user\n"));
+
+	memcpy(&q_u->domain_pol, pol, sizeof(q_u->domain_pol));
+	
+	q_u->unknown_0 = unk_0;
+	q_u->user_rid  = rid;
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_open_user(char *desc,  SAMR_Q_OPEN_USER *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_open_user");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("domain_pol", &(q_u->domain_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
+	prs_uint32("user_rid ", ps, depth, &(q_u->user_rid ));
+
+	prs_align(ps);
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_open_user(char *desc,  SAMR_R_OPEN_USER *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_open_user");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("user_pol", &(r_u->user_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+makes a SAMR_Q_QUERY_USERGROUPS structure.
+********************************************************************/
+void make_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS *q_u,
+				POLICY_HND *hnd)
+{
+	if (q_u == NULL || hnd == NULL) return;
+
+	DEBUG(5,("make_samr_q_query_usergroups\n"));
+
+	memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_query_usergroups(char *desc,  SAMR_Q_QUERY_USERGROUPS *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+}
+
+/*******************************************************************
+makes a SAMR_R_QUERY_USERGROUPS structure.
+********************************************************************/
+void make_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS *r_u,
+		uint32 num_gids, DOM_GID *gid, uint32 status)
+{
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_samr_r_query_usergroups\n"));
+
+	if (status == 0x0)
+	{
+		r_u->ptr_0        = 1;
+		r_u->num_entries  = num_gids;
+		r_u->ptr_1        = 1;
+		r_u->num_entries2 = num_gids;
+
+		r_u->gid = gid;
+
+#if 0
+		int i;
+		for (i = 0; i < num_gids && i < LSA_MAX_GROUPS; i++)
+		{
+			r_u->gid[i].g_rid = gid[i].g_rid;
+			r_u->gid[i].attr  = gid[i].attr ;
+		}
+#endif
+
+	}
+	else
+	{
+		r_u->ptr_0       = 0;
+		r_u->num_entries = 0;
+		r_u->ptr_1       = 0;
+	}
+
+	r_u->status = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_query_usergroups(char *desc,  SAMR_R_QUERY_USERGROUPS *r_u, prs_struct *ps, int depth)
+{
+	int i;
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr_0       ", ps, depth, &(r_u->ptr_0      ));
+
+	if (r_u->ptr_0 != 0)
+	{
+		prs_uint32("num_entries ", ps, depth, &(r_u->num_entries));
+		prs_uint32("ptr_1       ", ps, depth, &(r_u->ptr_1      ));
+
+		if (r_u->num_entries != 0)
+		{
+			prs_uint32("num_entries2", ps, depth, &(r_u->num_entries2));
+
+			for (i = 0; i < r_u->num_entries2; i++)
+			{
+				smb_io_gid("", &(r_u->gid[i]), ps, depth);
+			}
+		}
+	}
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+makes a SAMR_Q_QUERY_USERINFO structure.
+********************************************************************/
+void make_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO *q_u,
+				POLICY_HND *hnd, uint16 switch_value)
+{
+	if (q_u == NULL || hnd == NULL) return;
+
+	DEBUG(5,("make_samr_q_query_userinfo\n"));
+
+	memcpy(&(q_u->pol), hnd, sizeof(q_u->pol));
+	q_u->switch_value = switch_value;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_query_userinfo(char *desc,  SAMR_Q_QUERY_USERINFO *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("switch_value", ps, depth, &(q_u->switch_value)); /* 0x0015 or 0x0011 */
+
+	prs_align(ps);
+}
+
+/*******************************************************************
+reads or writes a LOGON_HRS structure.
+********************************************************************/
+void sam_io_logon_hrs(char *desc,  LOGON_HRS *hrs, prs_struct *ps, int depth)
+{
+	if (hrs == NULL) return;
+
+	prs_debug(ps, depth, desc, "sam_io_logon_hrs");
+	depth++;
+
+	prs_align(ps);
+	
+	prs_uint32 (       "len  ", ps, depth, &(hrs->len ));
+
+	if (hrs->len > 64)
+	{
+		DEBUG(5,("sam_io_logon_hrs: truncating length\n"));
+		hrs->len = 64;
+	}
+
+	prs_uint8s (False, "hours", ps, depth, hrs->hours, hrs->len);
+}
+
+/*******************************************************************
+makes a SAM_USER_INFO_11 structure.
+********************************************************************/
+void make_sam_user_info11(SAM_USER_INFO_11 *usr,
+				NTTIME *expiry,
+				char *mach_acct,
+				uint32 rid_user,
+				uint32 rid_group,
+				uint16 acct_ctrl)
+				
+{
+	int len_mach_acct;
+	if (usr == NULL || expiry == NULL || mach_acct == NULL) return;
+
+	DEBUG(5,("make_samr_r_unknown_24\n"));
+
+	len_mach_acct = strlen(mach_acct);
+
+	memcpy(&(usr->expiry),expiry, sizeof(usr->expiry)); /* expiry time or something? */
+	bzero(usr->padding_1, sizeof(usr->padding_1)); /* 0 - padding 24 bytes */
+
+	make_uni_hdr(&(usr->hdr_mach_acct), len_mach_acct, len_mach_acct, 4);  /* unicode header for machine account */
+	usr->padding_2 = 0;               /* 0 - padding 4 bytes */
+
+	usr->ptr_1        = 1;            /* pointer */
+	bzero(usr->padding_3, sizeof(usr->padding_3)); /* 0 - padding 32 bytes */
+	usr->padding_4    = 0;            /* 0 - padding 4 bytes */
+
+	usr->ptr_2        = 1;            /* pointer */
+	usr->padding_5    = 0;            /* 0 - padding 4 bytes */
+
+	usr->ptr_3        = 1;          /* pointer */
+	bzero(usr->padding_6, sizeof(usr->padding_6)); /* 0 - padding 32 bytes */
+
+	usr->rid_user     = rid_user; 
+	usr->rid_group    = rid_group;
+
+	usr->acct_ctrl    = acct_ctrl;
+	usr->unknown_3    = 0x0000;
+
+	usr->unknown_4    = 0x003f;       /* 0x003f      - 16 bit unknown */
+	usr->unknown_5    = 0x003c;       /* 0x003c      - 16 bit unknown */
+
+	bzero(usr->padding_7, sizeof(usr->padding_7)); /* 0 - padding 16 bytes */
+	usr->padding_8    = 0;            /* 0 - padding 4 bytes */
+	
+	make_unistr2(&(usr->uni_mach_acct), mach_acct, len_mach_acct);  /* unicode string for machine account */
+
+	bzero(usr->padding_9, sizeof(usr->padding_9)); /* 0 - padding 48 bytes */
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void sam_io_user_info11(char *desc,  SAM_USER_INFO_11 *usr, prs_struct *ps, int depth)
+{
+	if (usr == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_unknown_24");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint8s (False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)); 
+
+	smb_io_time("time", &(usr->expiry), ps, depth); 
+
+	prs_uint8s (False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1));
+
+	smb_io_unihdr ("unihdr", &(usr->hdr_mach_acct), ps, depth); 
+	prs_uint32(        "padding_2", ps, depth, &(usr->padding_2));
+
+	prs_uint32(        "ptr_1    ", ps, depth, &(usr->ptr_1    ));
+	prs_uint8s (False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3));
+	prs_uint32(        "padding_4", ps, depth, &(usr->padding_4));
+
+	prs_uint32(        "ptr_2    ", ps, depth, &(usr->ptr_2    ));
+	prs_uint32(        "padding_5", ps, depth, &(usr->padding_5));
+
+	prs_uint32(        "ptr_3    ", ps, depth, &(usr->ptr_3    ));
+	prs_uint8s (False, "padding_6", ps, depth, usr->padding_6, sizeof(usr->padding_6));
+
+	prs_uint32(        "rid_user ", ps, depth, &(usr->rid_user ));
+	prs_uint32(        "rid_group", ps, depth, &(usr->rid_group));
+	prs_uint16(        "acct_ctrl", ps, depth, &(usr->acct_ctrl));
+	prs_uint16(        "unknown_3", ps, depth, &(usr->unknown_3));
+	prs_uint16(        "unknown_4", ps, depth, &(usr->unknown_4));
+	prs_uint16(        "unknown_5", ps, depth, &(usr->unknown_5));
+
+	prs_uint8s (False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7));
+	prs_uint32(        "padding_8", ps, depth, &(usr->padding_8));
+	
+	smb_io_unistr2("unistr2", &(usr->uni_mach_acct), True, ps, depth); 
+	prs_align(ps);
+
+	prs_uint8s (False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9));
+}
+
+/*************************************************************************
+ make_sam_user_info21
+
+ unknown_3 = 0x00ff ffff
+ unknown_5 = 0x0002 0000
+ unknown_6 = 0x0000 04ec 
+
+ *************************************************************************/
+void make_sam_user_info21(SAM_USER_INFO_21 *usr,
+
+	NTTIME *logon_time,
+	NTTIME *logoff_time,
+	NTTIME *kickoff_time,
+	NTTIME *pass_last_set_time,
+	NTTIME *pass_can_change_time,
+	NTTIME *pass_must_change_time,
+
+	char *user_name,
+	char *full_name,
+	char *home_dir,
+	char *dir_drive,
+	char *logon_script,
+	char *profile_path,
+	char *description,
+	char *workstations,
+	char *unknown_str,
+	char *munged_dial,
+
+	uint32 user_rid,
+	uint32 group_rid,
+	uint16 acb_info, 
+
+	uint32 unknown_3,
+	uint16 logon_divs,
+	LOGON_HRS *hrs,
+	uint32 unknown_5,
+	uint32 unknown_6)
+{
+	int len_user_name    = user_name    != NULL ? strlen(user_name   ) : 0;
+	int len_full_name    = full_name    != NULL ? strlen(full_name   ) : 0;
+	int len_home_dir     = home_dir     != NULL ? strlen(home_dir    ) : 0;
+	int len_dir_drive    = dir_drive    != NULL ? strlen(dir_drive   ) : 0;
+	int len_logon_script = logon_script != NULL ? strlen(logon_script) : 0;
+	int len_profile_path = profile_path != NULL ? strlen(profile_path) : 0;
+	int len_description  = description  != NULL ? strlen(description ) : 0;
+	int len_workstations = workstations != NULL ? strlen(workstations) : 0;
+	int len_unknown_str  = unknown_str  != NULL ? strlen(unknown_str ) : 0;
+	int len_munged_dial  = munged_dial  != NULL ? strlen(munged_dial ) : 0;
+
+	usr->logon_time            = *logon_time;
+	usr->logoff_time           = *logoff_time;
+	usr->kickoff_time          = *kickoff_time;
+	usr->pass_last_set_time    = *pass_last_set_time;
+	usr->pass_can_change_time  = *pass_can_change_time;
+	usr->pass_must_change_time = *pass_must_change_time;
+
+	make_uni_hdr(&(usr->hdr_user_name   ), len_user_name   , len_user_name   , len_user_name    != 0);
+	make_uni_hdr(&(usr->hdr_full_name   ), len_full_name   , len_full_name   , len_full_name    != 0);
+	make_uni_hdr(&(usr->hdr_home_dir    ), len_home_dir    , len_home_dir    , len_home_dir     != 0);
+	make_uni_hdr(&(usr->hdr_dir_drive   ), len_dir_drive   , len_dir_drive   , len_dir_drive    != 0);
+	make_uni_hdr(&(usr->hdr_logon_script), len_logon_script, len_logon_script, len_logon_script != 0);
+	make_uni_hdr(&(usr->hdr_profile_path), len_profile_path, len_profile_path, len_profile_path != 0);
+	make_uni_hdr(&(usr->hdr_acct_desc   ), len_description , len_description , len_description  != 0);
+	make_uni_hdr(&(usr->hdr_workstations), len_workstations, len_workstations, len_workstations != 0);
+	make_uni_hdr(&(usr->hdr_unknown_str ), len_unknown_str , len_unknown_str , len_workstations != 0);
+	make_uni_hdr(&(usr->hdr_munged_dial ), len_munged_dial , len_munged_dial , len_workstations != 0);
+
+	bzero(usr->nt_pwd, sizeof(usr->nt_pwd));
+	bzero(usr->lm_pwd, sizeof(usr->lm_pwd));
+
+	usr->user_rid  = user_rid;
+	usr->group_rid = group_rid;
+	usr->acb_info = acb_info;
+	usr->unknown_3 = unknown_3; /* 0x00ff ffff */
+
+	usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
+	usr->ptr_logon_hrs = hrs ? 1 : 0;
+	usr->unknown_5 = unknown_5; /* 0x0002 0000 */
+
+	bzero(usr->padding1, sizeof(usr->padding1));
+
+	make_unistr2(&(usr->uni_user_name   ), user_name   , len_user_name   );
+	make_unistr2(&(usr->uni_full_name   ), full_name   , len_full_name   );
+	make_unistr2(&(usr->uni_home_dir    ), home_dir    , len_home_dir    );
+	make_unistr2(&(usr->uni_dir_drive   ), dir_drive   , len_dir_drive   );
+	make_unistr2(&(usr->uni_logon_script), logon_script, len_logon_script);
+	make_unistr2(&(usr->uni_profile_path), profile_path, len_profile_path);
+	make_unistr2(&(usr->uni_acct_desc ), description , len_description );
+	make_unistr2(&(usr->uni_workstations), workstations, len_workstations);
+	make_unistr2(&(usr->uni_unknown_str ), unknown_str , len_unknown_str );
+	make_unistr2(&(usr->uni_munged_dial ), munged_dial , len_munged_dial );
+
+	usr->unknown_6 = unknown_6; /* 0x0000 04ec */
+	usr->padding4 = 0;
+
+	if (hrs)
+	{
+		memcpy(&(usr->logon_hrs), hrs, sizeof(usr->logon_hrs));
+	}
+	else
+	{
+		memset(&(usr->logon_hrs), 0xff, sizeof(usr->logon_hrs));
+	}
+}
+
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void sam_io_user_info21(char *desc,  SAM_USER_INFO_21 *usr, prs_struct *ps, int depth)
+{
+	if (usr == NULL) return;
+
+	prs_debug(ps, depth, desc, "lsa_io_user_info");
+	depth++;
+
+	prs_align(ps);
+	
+	smb_io_time("logon_time           ", &(usr->logon_time)           , ps, depth);
+	smb_io_time("logoff_time          ", &(usr->logoff_time)          , ps, depth); 
+	smb_io_time("kickoff_time         ", &(usr->kickoff_time)         , ps, depth); 
+	smb_io_time("pass_last_set_time   ", &(usr->pass_last_set_time)   , ps, depth); 
+	smb_io_time("pass_can_change_time ", &(usr->pass_can_change_time) , ps, depth); 
+	smb_io_time("pass_must_change_time", &(usr->pass_must_change_time), ps, depth); 
+
+	smb_io_unihdr("hdr_user_name   ", &(usr->hdr_user_name)   , ps, depth); /* username unicode string header */
+	smb_io_unihdr("hdr_full_name   ", &(usr->hdr_full_name)   , ps, depth); /* user's full name unicode string header */
+	smb_io_unihdr("hdr_home_dir    ", &(usr->hdr_home_dir)    , ps, depth); /* home directory unicode string header */
+	smb_io_unihdr("hdr_dir_drive   ", &(usr->hdr_dir_drive)   , ps, depth); /* home directory drive */
+	smb_io_unihdr("hdr_logon_script", &(usr->hdr_logon_script), ps, depth); /* logon script unicode string header */
+	smb_io_unihdr("hdr_profile_path", &(usr->hdr_profile_path), ps, depth); /* profile path unicode string header */
+	smb_io_unihdr("hdr_acct_desc   ", &(usr->hdr_acct_desc  ) , ps, depth); /* account description */
+	smb_io_unihdr("hdr_workstations", &(usr->hdr_workstations), ps, depth); /* workstations user can log on from */
+	smb_io_unihdr("hdr_unknown_str ", &(usr->hdr_unknown_str ), ps, depth); /* unknown string */
+	smb_io_unihdr("hdr_munged_dial ", &(usr->hdr_munged_dial ), ps, depth); /* workstations user can log on from */
+
+	prs_uint8s (False, "lm_pwd        ", ps, depth, usr->lm_pwd   , sizeof(usr->lm_pwd   ));
+	prs_uint8s (False, "nt_pwd        ", ps, depth, usr->nt_pwd   , sizeof(usr->nt_pwd   ));
+
+	prs_uint32("user_rid      ", ps, depth, &(usr->user_rid     ));       /* User ID */
+	prs_uint32("group_rid     ", ps, depth, &(usr->group_rid    ));      /* Group ID */
+	prs_uint16("acb_info      ", ps, depth, &(usr->acb_info     ));      /* Group ID */
+	prs_align(ps);
+
+	prs_uint32("unknown_3     ", ps, depth, &(usr->unknown_3    ));
+	prs_uint16("logon_divs    ", ps, depth, &(usr->logon_divs   ));     /* logon divisions per week */
+	prs_align(ps);
+	prs_uint32("ptr_logon_hrs ", ps, depth, &(usr->ptr_logon_hrs));
+	prs_uint32("unknown_5     ", ps, depth, &(usr->unknown_5    ));
+
+	prs_uint8s (False, "padding1      ", ps, depth, usr->padding1, sizeof(usr->padding1));
+
+	/* here begins pointed-to data */
+
+	smb_io_unistr2("uni_user_name   ", &(usr->uni_user_name)   , usr->hdr_user_name   .buffer, ps, depth); /* username unicode string */
+	smb_io_unistr2("uni_full_name   ", &(usr->uni_full_name)   , usr->hdr_full_name   .buffer, ps, depth); /* user's full name unicode string */
+	smb_io_unistr2("uni_home_dir    ", &(usr->uni_home_dir)    , usr->hdr_home_dir    .buffer, ps, depth); /* home directory unicode string */
+	smb_io_unistr2("uni_dir_drive   ", &(usr->uni_dir_drive)   , usr->hdr_dir_drive   .buffer, ps, depth); /* home directory drive unicode string */
+	smb_io_unistr2("uni_logon_script", &(usr->uni_logon_script), usr->hdr_logon_script.buffer, ps, depth); /* logon script unicode string */
+	smb_io_unistr2("uni_profile_path", &(usr->uni_profile_path), usr->hdr_profile_path.buffer, ps, depth); /* profile path unicode string */
+	smb_io_unistr2("uni_acct_desc   ", &(usr->uni_acct_desc   ), usr->hdr_acct_desc   .buffer, ps, depth); /* user description unicode string */
+	smb_io_unistr2("uni_workstations", &(usr->uni_workstations), usr->hdr_workstations.buffer, ps, depth); /* worksations user can log on from */
+	smb_io_unistr2("uni_unknown_str ", &(usr->uni_unknown_str ), usr->hdr_unknown_str .buffer, ps, depth); /* unknown string */
+	smb_io_unistr2("uni_munged_dial ", &(usr->uni_munged_dial ), usr->hdr_munged_dial .buffer, ps, depth); /* worksations user can log on from */
+
+	prs_uint32("unknown_6     ", ps, depth, &(usr->unknown_6  ));
+	prs_uint32("padding4      ", ps, depth, &(usr->padding4   ));
+
+	if (usr->ptr_logon_hrs)
+	{
+		sam_io_logon_hrs("logon_hrs", &(usr->logon_hrs)   , ps, depth);
+	}
+}
+
+
+/*******************************************************************
+makes a SAMR_R_QUERY_USERINFO structure.
+********************************************************************/
+void make_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO *r_u,
+				uint16 switch_value, void *info, uint32 status)
+				
+{
+	if (r_u == NULL || info == NULL) return;
+
+	DEBUG(5,("make_samr_r_query_userinfo\n"));
+
+	r_u->ptr = 0;
+	r_u->switch_value = 0;
+
+	if (status == 0)
+	{
+		r_u->switch_value = switch_value;
+
+		switch (switch_value)
+		{
+			case 0x10:
+			{
+				r_u->ptr = 1;
+				r_u->info.id10 = (SAM_USER_INFO_10*)info;
+
+				break;
+			}
+
+			case 0x11:
+			{
+				r_u->ptr = 1;
+				r_u->info.id11 = (SAM_USER_INFO_11*)info;
+
+				break;
+			}
+
+			case 21:
+			{
+				r_u->ptr = 1;
+				r_u->info.id21 = (SAM_USER_INFO_21*)info;
+
+				break;
+			}
+
+			default:
+			{
+				DEBUG(4,("make_samr_r_query_aliasinfo: unsupported switch level\n"));
+				break;
+			}
+		}
+	}
+
+	r_u->status = status;         /* return status */
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_query_userinfo(char *desc,  SAMR_R_QUERY_USERINFO *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr         ", ps, depth, &(r_u->ptr         ));
+	prs_uint16("switch_value", ps, depth, &(r_u->switch_value));
+	prs_align(ps);
+
+	if (r_u->ptr != 0 && r_u->switch_value != 0)
+	{
+		switch (r_u->switch_value)
+		{
+/*
+			case 0x10:
+			{
+				if (r_u->info.id10 != NULL)
+				{
+					sam_io_user_info10("", r_u->info.id10, ps, depth);
+				}
+				else
+				{
+					DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
+					return NULL;
+				}
+				break;
+			}
+			case 0x11:
+			{
+				if (r_u->info.id11 != NULL)
+				{
+					sam_io_user_info11("", r_u->info.id11, ps, depth);
+				}
+				else
+				{
+					DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
+					return NULL;
+				}
+				break;
+			}
+*/
+			case 21:
+			{
+				if (r_u->info.id21 != NULL)
+				{
+					sam_io_user_info21("", r_u->info.id21, ps, depth);
+				}
+				else
+				{
+					DEBUG(2,("samr_io_r_query_userinfo: info pointer not initialised\n"));
+					return;
+				}
+				break;
+			}
+			default:
+			{
+				DEBUG(2,("samr_io_r_query_userinfo: unknown switch level\n"));
+				break;
+			}
+				
+		}
+	}
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+makes a SAMR_Q_UNKNOWN_21 structure.
+********************************************************************/
+void make_samr_q_unknown_21(SAMR_Q_UNKNOWN_21 *q_c,
+				POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
+{
+	if (q_c == NULL || hnd == NULL) return;
+
+	DEBUG(5,("make_samr_q_unknown_21\n"));
+
+	memcpy(&(q_c->group_pol), hnd, sizeof(q_c->group_pol));
+	q_c->unknown_1 = unk_1;
+	q_c->unknown_2 = unk_2;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_21(char *desc,  SAMR_Q_UNKNOWN_21 *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_21");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("group_pol", &(q_u->group_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
+	prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
+}
+
+/*******************************************************************
+makes a SAMR_Q_UNKNOWN_13 structure.
+********************************************************************/
+void make_samr_q_unknown_13(SAMR_Q_UNKNOWN_13 *q_c,
+				POLICY_HND *hnd, uint16 unk_1, uint16 unk_2)
+{
+	if (q_c == NULL || hnd == NULL) return;
+
+	DEBUG(5,("make_samr_q_unknown_13\n"));
+
+	memcpy(&(q_c->alias_pol), hnd, sizeof(q_c->alias_pol));
+	q_c->unknown_1 = unk_1;
+	q_c->unknown_2 = unk_2;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_13(char *desc,  SAMR_Q_UNKNOWN_13 *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_13");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("alias_pol", &(q_u->alias_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
+	prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_32(char *desc,  SAMR_Q_UNKNOWN_32 *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_32");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(q_u->pol), ps, depth); 
+	prs_align(ps);
+
+	smb_io_unihdr ("", &(q_u->hdr_mach_acct), ps, depth); 
+	smb_io_unistr2("", &(q_u->uni_mach_acct), q_u->hdr_mach_acct.buffer, ps, depth); 
+
+	prs_align(ps);
+
+	prs_uint32("acct_ctrl", ps, depth, &(q_u->acct_ctrl));
+	prs_uint16("unknown_1", ps, depth, &(q_u->unknown_1));
+	prs_uint16("unknown_2", ps, depth, &(q_u->unknown_2));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_unknown_32(char *desc,  SAMR_R_UNKNOWN_32 *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_unknown_32");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(r_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+
+/*******************************************************************
+makes a SAMR_Q_CONNECT structure.
+********************************************************************/
+void make_samr_q_connect(SAMR_Q_CONNECT *q_u,
+				char *srv_name, uint32 unknown_0)
+{
+	int len_srv_name = strlen(srv_name);
+
+	if (q_u == NULL) return;
+
+	DEBUG(5,("make_q_connect\n"));
+
+	/* make PDC server name \\server */
+	make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);  
+
+	/* example values: 0x0000 0002 */
+	q_u->unknown_0 = unknown_0; 
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_connect(char *desc,  SAMR_Q_CONNECT *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_connect");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr_srv_name", ps, depth, &(q_u->ptr_srv_name));
+	smb_io_unistr2("", &(q_u->uni_srv_name), q_u->ptr_srv_name, ps, depth); 
+
+	prs_align(ps);
+
+	prs_uint32("unknown_0   ", ps, depth, &(q_u->unknown_0   ));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_connect(char *desc,  SAMR_R_CONNECT *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_connect");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("connect_pol", &(r_u->connect_pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+makes a SAMR_Q_OPEN_ALIAS structure.
+********************************************************************/
+void make_samr_q_open_alias(SAMR_Q_OPEN_ALIAS *q_u,
+				uint32 unknown_0, uint32 rid)
+{
+	if (q_u == NULL) return;
+
+	DEBUG(5,("make_q_open_alias\n"));
+
+	/* example values: 0x0000 0008 */
+	q_u->unknown_0 = unknown_0; 
+
+	q_u->rid_alias = rid; 
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_open_alias(char *desc,  SAMR_Q_OPEN_ALIAS *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_open_alias");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("unknown_0", ps, depth, &(q_u->unknown_0));
+	prs_uint32("rid_alias", ps, depth, &(q_u->rid_alias));
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_open_alias(char *desc,  SAMR_R_OPEN_ALIAS *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_open_alias");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_pol_hnd("pol", &(r_u->pol), ps, depth); 
+	prs_align(ps);
+
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+makes a SAMR_Q_UNKNOWN_38 structure.
+********************************************************************/
+void make_samr_q_unknown_38(SAMR_Q_UNKNOWN_38 *q_u, char *srv_name)
+{
+	int len_srv_name = strlen(srv_name);
+
+	if (q_u == NULL) return;
+
+	DEBUG(5,("make_q_unknown_38\n"));
+
+	q_u->ptr = 1;
+	make_uni_hdr(&(q_u->hdr_srv_name), len_srv_name, len_srv_name, len_srv_name != 0);
+	make_unistr2(&(q_u->uni_srv_name), srv_name, len_srv_name);  
+
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_q_unknown_38(char *desc,  SAMR_Q_UNKNOWN_38 *q_u, prs_struct *ps, int depth)
+{
+	if (q_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_q_unknown_38");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr", ps, depth, &(q_u->ptr));
+	if (q_u->ptr != 0)
+	{
+		smb_io_unihdr ("", &(q_u->hdr_srv_name), ps, depth); 
+		smb_io_unistr2("", &(q_u->uni_srv_name), q_u->hdr_srv_name.buffer, ps, depth); 
+	}
+}
+
+/*******************************************************************
+makes a SAMR_R_UNKNOWN_38 structure.
+********************************************************************/
+void make_samr_r_unknown_38(SAMR_R_UNKNOWN_38 *r_u,
+				uint16 level, uint32 status)
+{
+	if (r_u == NULL) return;
+
+	DEBUG(5,("make_r_unknown_38\n"));
+
+	r_u->level.value = level;
+	r_u->ptr_0       = 0;
+	r_u->status      = status;
+}
+
+/*******************************************************************
+reads or writes a structure.
+********************************************************************/
+void samr_io_r_unknown_38(char *desc,  SAMR_R_UNKNOWN_38 *r_u, prs_struct *ps, int depth)
+{
+	if (r_u == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_r_unknown_38");
+	depth++;
+
+	prs_align(ps);
+
+	smb_io_lookup_level("level ", &(r_u->level), ps, depth); 
+	prs_uint32("ptr_0 ", ps, depth, &(r_u->ptr_0 ));
+	prs_uint32("status", ps, depth, &(r_u->status));
+}
+
+/*******************************************************************
+reads or writes a SAMR_ENC_PASSWD structure.
+********************************************************************/
+void samr_io_enc_passwd(char *desc, SAMR_ENC_PASSWD *pwd, prs_struct *ps, int depth)
+{
+	if (pwd == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_enc_passwd");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr", ps, depth, &(pwd->ptr));
+	prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)); 
+}
+
+/*******************************************************************
+reads or writes a SAMR_ENC_HASH structure.
+********************************************************************/
+void samr_io_enc_hash(char *desc, SAMR_ENC_HASH *hsh, prs_struct *ps, int depth)
+{
+	if (hsh == NULL) return;
+
+	prs_debug(ps, depth, desc, "samr_io_enc_hash");
+	depth++;
+
+	prs_align(ps);
+
+	prs_uint32("ptr ", ps, depth, &(hsh->ptr));
+	prs_uint8s(False, "hash", ps, depth, hsh->hash, sizeof(hsh->hash)); 
+}
+
+#if 0
+/* SAMR_Q_CHGPASSWD_USER */
+typedef struct q_samr_chgpasswd_user_info
+{
+	uint32 ptr_0;
+
+	UNIHDR hdr_server; /* server name unicode header */
+	UNISTR2 uni_server; /* server name unicode string */
+
+	UNIHDR hdr_user_name;    /* username unicode string header */
+	UNISTR2 uni_user_name;    /* username unicode string */
+
+	SAMR_ENC_PASSWD nt_newpass;
+	SAMR_ENC_HASH nt_oldhash;
+
+	uint32 unknown_1; /* seems to always contain 0001 */
+
+	SAMR_ENC_PASSWD lm_newpass;
+	SAMR_ENC_HASH lm_oldhash;
+
+} SAMR_Q_CHGPASSWD_USER;
+
+/* SAMR_R_CHGPASSWD_USER */
+typedef struct r_samr_chgpasswd_user_info
+{
+	uint32 result; /* 0 == OK, C000006A (NT_STATUS_WRONG_PASSWORD) */
+
+} SAMR_R_CHGPASSWD_USER;
+
+#endif /* 0 */
+