Sync 3.0 branch with HEAD

(This used to be commit 3823a2ff5a3c6edf325e2ac31bab50175420f0b1)

1 files changed, 1186 insertions, 575 deletions

diff --git a/source3/rpc_client/cli_samr.c b/source3/rpc_client/cli_samr.c
index 0d4db7f88f..7863d32419 100644
--- a/source3/rpc_client/cli_samr.c
+++ b/source3/rpc_client/cli_samr.c
@@ -1,9 +1,12 @@
 /* 
    Unix SMB/CIFS implementation.
-   NT Domain Authentication SMB / MSRPC client
-   Copyright (C) Andrew Tridgell 1994-1997
-   Copyright (C) Luke Kenneth Casson Leighton 1996-1997
-   Copyright (C) Jeremy Allison 1999.
+   RPC pipe client
+   Copyright (C) Tim Potter                        2000-2001,
+   Copyright (C) Andrew Tridgell              1992-1997,2000,
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1997,2000,
+   Copyright (C) Paul Ashton                       1997,2000,
+   Copyright (C) Elrond                                 2000,
+   Copyright (C) Rafal Szczesniak                       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
@@ -22,819 +25,1427 @@
 
 #include "includes.h"
 
-#undef DBGC_CLASS
-#define DBGC_CLASS DBGC_RPC_CLI
+/* Connect to SAMR database */
 
-/****************************************************************************
-do a SAMR query user groups
-****************************************************************************/
-BOOL get_samr_query_usergroups(struct cli_state *cli, 
-				POLICY_HND *pol_open_domain, uint32 user_rid,
-				uint32 *num_groups, DOM_GID *gid)
+NTSTATUS cli_samr_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                          uint32 access_mask, POLICY_HND *connect_pol)
 {
-	POLICY_HND pol_open_user;
-	if (pol_open_domain == NULL || num_groups == NULL || gid == NULL)
-		return False;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_CONNECT q;
+	SAMR_R_CONNECT r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	/* send open domain (on user sid) */
-	if (!do_samr_open_user(cli,
-				pol_open_domain,
-				0x02011b, user_rid,
-				&pol_open_user))
-	{
-		return False;
-	}
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_connect(&q, cli->desthost, access_mask);
+
+	if (!samr_io_q_connect("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_CONNECT, &qbuf, &rbuf))
+		goto done;
 
-	/* send user groups query */
-	if (!do_samr_query_usergroups(cli,
-				&pol_open_user,
-				num_groups, gid))
-	{
-		DEBUG(5,("do_samr_query_usergroups: error in query user groups\n"));
+	/* Unmarshall response */
+
+	if (!samr_io_r_connect("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*connect_pol = r.connect_pol;
+#ifdef __INSURE__
+		connect_pol->marker = malloc(1);
+#endif
 	}
 
-	return do_samr_close(cli, &pol_open_user);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
 }
 
-#if 0
-/* DOES NOT COMPILE WITH THE NEW SAMR PARSE CODE. JRA. */
+/* Connect to SAMR database */
 
-/****************************************************************************
-do a SAMR query user info
-****************************************************************************/
-BOOL get_samr_query_userinfo(struct cli_state *cli, 
-				POLICY_HND *pol_open_domain,
-				uint32 info_level,
-				uint32 user_rid, SAM_USER_INFO_21 *usr)
+NTSTATUS cli_samr_connect4(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+			   uint32 access_mask, POLICY_HND *connect_pol)
 {
-	POLICY_HND pol_open_user;
-	if (pol_open_domain == NULL || usr == NULL)
-		return False;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_CONNECT4 q;
+	SAMR_R_CONNECT4 r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	memset((char *)usr, '\0', sizeof(*usr));
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* send open domain (on user sid) */
-	if (!do_samr_open_user(cli,
-				pol_open_domain,
-				0x02011b, user_rid,
-				&pol_open_user))
-	{
-		return False;
-	}
+	/* Initialise parse structures */
 
-	/* send user info query */
-	if (!do_samr_query_userinfo(cli,
-				&pol_open_user,
-				info_level, (void*)usr))
-	{
-		DEBUG(5,("do_samr_query_userinfo: error in query user info, level 0x%x\n",
-		          info_level));
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_connect4(&q, cli->desthost, access_mask);
+
+	if (!samr_io_q_connect4("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_CONNECT4, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_connect4("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*connect_pol = r.connect_pol;
+#ifdef __INSURE__
+		connect_pol->marker = malloc(1);
+#endif
 	}
 
-	return do_samr_close(cli, &pol_open_user);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
 }
-#endif
 
-/****************************************************************************
-do a SAMR change user password command
-****************************************************************************/
-BOOL do_samr_chgpasswd_user(struct cli_state *cli,
-		char *srv_name, char *user_name,
-		char nt_newpass[516], uchar nt_oldhash[16],
-		char lm_newpass[516], uchar lm_oldhash[16])
+/* Close SAMR handle */
+
+NTSTATUS cli_samr_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                        POLICY_HND *connect_pol)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_CHGPASSWD_USER q_e;
-	SAMR_R_CHGPASSWD_USER r_e;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_CLOSE_HND q;
+	SAMR_R_CLOSE_HND r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	/* create and send a MSRPC command with api SAMR_CHGPASSWD_USER */
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	/* Initialise parse structures */
 
-	DEBUG(4,("SAMR Change User Password. server:%s username:%s\n",
-	        srv_name, user_name));
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	init_samr_q_chgpasswd_user(&q_e, srv_name, user_name,
-	                           nt_newpass, nt_oldhash,
-	                           lm_newpass, lm_oldhash);
+	/* Marshall data and send request */
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_chgpasswd_user("", &q_e, &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	init_samr_q_close_hnd(&q, connect_pol);
+
+	if (!samr_io_q_close_hnd("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_CLOSE_HND, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_close_hnd("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+#ifdef __INSURE__
+		SAFE_FREE(connect_pol->marker);
+#endif
+		*connect_pol = r.pol;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_CHGPASSWD_USER, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Open handle on a domain */
+
+NTSTATUS cli_samr_open_domain(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                              POLICY_HND *connect_pol, uint32 access_mask, 
+                              const DOM_SID *domain_sid, POLICY_HND *domain_pol)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_OPEN_DOMAIN q;
+	SAMR_R_OPEN_DOMAIN r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_open_domain(&q, connect_pol, access_mask, domain_sid);
+
+	if (!samr_io_q_open_domain("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_OPEN_DOMAIN, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_open_domain("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*domain_pol = r.domain_pol;
+#ifdef __INSURE__
+		domain_pol->marker = malloc(1);
+#endif
 	}
 
-	prs_mem_free(&data);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	if(!samr_io_r_chgpasswd_user("", &r_e, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	return result;
+}
+
+/* Open handle on a user */
+
+NTSTATUS cli_samr_open_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                            POLICY_HND *domain_pol, uint32 access_mask, 
+                            uint32 user_rid, POLICY_HND *user_pol)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_OPEN_USER q;
+	SAMR_R_OPEN_USER r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_open_user(&q, domain_pol, access_mask, user_rid);
+
+	if (!samr_io_q_open_user("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_OPEN_USER, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_open_user("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*user_pol = r.user_pol;
+#ifdef __INSURE__
+		user_pol->marker = malloc(1);
+#endif
 	}
 
-	if (r_e.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_CHGPASSWD_USER: %s\n", nt_errstr(r_e.status)));
-		prs_mem_free(&rdata);
-		return False;
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Open handle on a group */
+
+NTSTATUS cli_samr_open_group(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                             POLICY_HND *domain_pol, uint32 access_mask, 
+                             uint32 group_rid, POLICY_HND *group_pol)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_OPEN_GROUP q;
+	SAMR_R_OPEN_GROUP r;
+	NTSTATUS result =  NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_open_group(&q, domain_pol, access_mask, group_rid);
+
+	if (!samr_io_q_open_group("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_OPEN_GROUP, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_open_group("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*group_pol = r.pol;
+#ifdef __INSURE__
+		group_pol->marker = malloc(1);
+#endif
 	}
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
 
-#if 0 
+/* Query user info */
+
+NTSTATUS cli_samr_query_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *user_pol, uint16 switch_value, 
+                                 SAM_USERINFO_CTR **ctr)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_USERINFO q;
+	SAMR_R_QUERY_USERINFO r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_query_userinfo(&q, user_pol, switch_value);
+
+	if (!samr_io_q_query_userinfo("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_USERINFO, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_query_userinfo("", &r, &rbuf, 0))
+		goto done;
 
-/* CURRENTLY THIS DOESN'T COMPILE AND IS NOT USED ANYWHERE. JRA. */
+	/* Return output parameters */
 
-/****************************************************************************
-do a SAMR unknown 0x38 command
-****************************************************************************/
-BOOL do_samr_unknown_38(struct cli_state *cli, char *srv_name)
+	result = r.status;
+	*ctr = r.ctr;
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Query group info */
+
+NTSTATUS cli_samr_query_groupinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                  POLICY_HND *group_pol, uint32 info_level, 
+                                  GROUP_INFO_CTR *ctr)
 {
-	prs_struct data;
-	prs_struct rdata;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_GROUPINFO q;
+	SAMR_R_QUERY_GROUPINFO r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	SAMR_Q_UNKNOWN_38 q_e;
-	SAMR_R_UNKNOWN_38 r_e;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Unknown 38 server:%s\n", srv_name));
+	/* Marshall data and send request */
 
-	init_samr_q_unknown_38(&q_e, srv_name);
+	init_samr_q_query_groupinfo(&q, group_pol, info_level);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_unknown_38("", &q_e, &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
-	}
+	if (!samr_io_q_query_groupinfo("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_GROUPINFO, &qbuf, &rbuf))
+		goto done;
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_UNKNOWN_38, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
-	}
+	/* Unmarshall response */
 
-	prs_mem_free(&data);
+	r.ctr = ctr;
 
-	if(!samr_io_r_unknown_38("", &r_e, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_r_query_groupinfo("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	result = r.status;
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Query user groups */
+
+NTSTATUS cli_samr_query_usergroups(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                   POLICY_HND *user_pol, uint32 *num_groups, 
+                                   DOM_GID **gid)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_USERGROUPS q;
+	SAMR_R_QUERY_USERGROUPS r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_query_usergroups(&q, user_pol);
+
+	if (!samr_io_q_query_usergroups("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_USERGROUPS, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_query_usergroups("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*num_groups = r.num_entries;
+		*gid = r.gid;
 	}
 
-	if (r_e.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_UNKNOWN_38: %s\n", nt_errstr(r_e.status)));
-		prs_mem_free(&rdata);
-		return False;
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Query user aliases */
+
+NTSTATUS cli_samr_query_useraliases(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                   POLICY_HND *user_pol, uint32 num_sids, DOM_SID2 *sid,
+				   uint32 *num_aliases, uint32 **als_rids)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_USERALIASES q;
+	SAMR_R_QUERY_USERALIASES r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	unsigned int ptr=1;
+	
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_query_useraliases(&q, user_pol, num_sids, &ptr, sid);
+
+	if (!samr_io_q_query_useraliases("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_USERALIASES, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_query_useraliases("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*num_aliases = r.num_entries;
+		*als_rids = r.rid;
 	}
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
-#endif
 
-/****************************************************************************
-do a SAMR unknown 0x8 command
-****************************************************************************/
-BOOL do_samr_query_dom_info(struct cli_state *cli, 
-				POLICY_HND *domain_pol, uint16 switch_value)
+/* Query user groups */
+
+NTSTATUS cli_samr_query_groupmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *group_pol, uint32 *num_mem, 
+                                 uint32 **rid, uint32 **attr)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_QUERY_DOMAIN_INFO q_e;
-	SAMR_R_QUERY_DOMAIN_INFO r_e;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_GROUPMEM q;
+	SAMR_R_QUERY_GROUPMEM r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (domain_pol == NULL)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Unknown 8 switch:%d\n", switch_value));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_query_dom_info(&q_e, domain_pol, switch_value);
+	init_samr_q_query_groupmem(&q, group_pol);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_query_dom_info("", &q_e, &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_query_groupmem("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_GROUPMEM, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_query_groupmem("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*num_mem = r.num_entries;
+		*rid = r.rid;
+		*attr = r.attr;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_QUERY_DOMAIN_INFO, &data, &rdata)) {
-		prs_mem_free(&data);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/**
+ * Enumerate domain users
+ *
+ * @param cli client state structure
+ * @param mem_ctx talloc context
+ * @param pol opened domain policy handle
+ * @param start_idx starting index of enumeration, returns context for
+                    next enumeration
+ * @param acb_mask account control bit mask (to enumerate some particular
+ *                 kind of accounts)
+ * @param size max acceptable size of response
+ * @param dom_users returned array of domain user names
+ * @param rids returned array of domain user RIDs
+ * @param num_dom_users numer returned entries
+ * 
+ * @return NTSTATUS returned in rpc response
+ **/
+NTSTATUS cli_samr_enum_dom_users(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *pol, uint32 *start_idx, uint16 acb_mask,
+                                 uint32 size, char ***dom_users, uint32 **rids,
+                                 uint32 *num_dom_users)
+{
+	prs_struct qdata;
+	prs_struct rdata;
+	SAMR_Q_ENUM_DOM_USERS q;
+	SAMR_R_ENUM_DOM_USERS r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	int i;
+	
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+	
+	if (cli == NULL || pol == NULL)
+		return result;
+	
+	/* initialise parse structures */
+	prs_init(&qdata, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rdata, 0, mem_ctx, UNMARSHALL);
+	
+	DEBUG(4, ("SAMR Enum Domain Users. start_idx: %d, acb: %d, size: %d\n",
+			*start_idx, acb_mask, size));
+	
+	/* fill query structure with parameters */
+	init_samr_q_enum_dom_users(&q, pol, *start_idx, acb_mask, 0, size);
+	
+	/* prepare query stream */
+	if (!samr_io_q_enum_dom_users("", &q, &qdata, 0)) {
+		prs_mem_free(&qdata);
+		prs_mem_free(&rdata);
+		return result;
+	}
+	
+	/* send rpc call over the pipe */
+	if (!rpc_api_pipe_req(cli, SAMR_ENUM_DOM_USERS, &qdata, &rdata)) {
+		prs_mem_free(&qdata);
+		prs_mem_free(&rdata);
+		return result;
+	}
+		
+	/* unpack received stream */
+	if(!samr_io_r_enum_dom_users("", &r, &rdata, 0)) {
+		prs_mem_free(&qdata);
 		prs_mem_free(&rdata);
-		return False;
+		result = r.status;
+		return result;
 	}
+	
+	/* return the data obtained in response */
+	if (!NT_STATUS_IS_OK(r.status) &&
+		(NT_STATUS_EQUAL(r.status, STATUS_MORE_ENTRIES) ||
+		NT_STATUS_EQUAL(r.status, NT_STATUS_NO_MORE_ENTRIES))) {
+		return r.status;
+	}
+	
+	*start_idx = r.next_idx;
+	*num_dom_users = r.num_entries2;
+	result = r.status;
+
+	if (r.num_entries2) {
+		/* allocate memory needed to return received data */	
+		*rids = (uint32*)talloc(mem_ctx, sizeof(uint32) * r.num_entries2);
+		if (!*rids) {
+			DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
+			return NT_STATUS_NO_MEMORY;
+		}
+		
+		*dom_users = (char**)talloc(mem_ctx, sizeof(char*) * r.num_entries2);
+		if (!*dom_users) {
+			DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
+			return NT_STATUS_NO_MEMORY;
+		}
+		
+		/* fill output buffers with rpc response */
+		for (i = 0; i < r.num_entries2; i++) {
+			fstring conv_buf;
+			
+			(*rids)[i] = r.sam[i].rid;
+			unistr2_to_ascii(conv_buf, &(r.uni_acct_name[i]), sizeof(conv_buf) - 1);
+			(*dom_users)[i] = talloc_strdup(mem_ctx, conv_buf);
+		}
+	}
+	
+	prs_mem_free(&qdata);
+	prs_mem_free(&rdata);
+	
+	return result;
+};
 
-	prs_mem_free(&data);
 
-	if(!samr_io_r_query_dom_info("", &r_e, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+/* Enumerate domain groups */
+
+NTSTATUS cli_samr_enum_dom_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                  POLICY_HND *pol, uint32 *start_idx, 
+                                  uint32 size, struct acct_info **dom_groups,
+                                  uint32 *num_dom_groups)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_ENUM_DOM_GROUPS q;
+	SAMR_R_ENUM_DOM_GROUPS r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	uint32 name_idx, i;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_enum_dom_groups(&q, pol, *start_idx, size);
+
+	if (!samr_io_q_enum_dom_groups("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_ENUM_DOM_GROUPS, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_enum_dom_groups("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	result = r.status;
+
+	if (!NT_STATUS_IS_OK(result) &&
+	    NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
+		goto done;
+
+	*num_dom_groups = r.num_entries2;
+
+	if (!((*dom_groups) = (struct acct_info *)
+	      talloc(mem_ctx, sizeof(struct acct_info) * *num_dom_groups))) {
+		result = NT_STATUS_UNSUCCESSFUL;
+		goto done;
 	}
 
-	if (r_e.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_QUERY_DOMAIN_INFO: %s\n", nt_errstr(r_e.status)));
-		prs_mem_free(&rdata);
-		return False;
+	memset(*dom_groups, 0, sizeof(struct acct_info) * *num_dom_groups);
+
+	name_idx = 0;
+
+	for (i = 0; i < *num_dom_groups; i++) {
+
+		(*dom_groups)[i].rid = r.sam[i].rid;
+
+		if (r.sam[i].hdr_name.buffer) {
+			unistr2_to_ascii((*dom_groups)[i].acct_name,
+					 &r.uni_grp_name[name_idx],
+					 sizeof(fstring) - 1);
+			name_idx++;
+		}
+
+		*start_idx = r.next_idx;
 	}
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
 
-#if 0
+/* Enumerate domain groups */
 
-/* CURRENTLY DOESN'T COMPILE WITH THE NEW SAMR PARSE CODE. JRA */
-
-/****************************************************************************
-do a SAMR enumerate users
-****************************************************************************/
-BOOL do_samr_enum_dom_users(struct cli_state *cli, 
-				POLICY_HND *pol, uint16 num_entries, uint16 unk_0,
-				uint16 acb_mask, uint16 unk_1, uint32 size,
-				struct acct_info **sam,
-				int *num_sam_users)
+NTSTATUS cli_samr_enum_als_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                  POLICY_HND *pol, uint32 *start_idx, 
+                                  uint32 size, struct acct_info **dom_groups,
+                                  uint32 *num_dom_groups)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_ENUM_DOM_USERS q_e;
-	SAMR_R_ENUM_DOM_USERS r_e;
-	int i;
-	int name_idx = 0;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_ENUM_DOM_ALIASES q;
+	SAMR_R_ENUM_DOM_ALIASES r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	uint32 name_idx, i;
 
-	if (pol == NULL || num_sam_users == NULL)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_enum_dom_users(&q_e, pol,
-	                           num_entries, unk_0,
-	                           acb_mask, unk_1, size);
+	init_samr_q_enum_dom_aliases(&q, pol, *start_idx, size);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_enum_dom_users("", &q_e, &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_enum_dom_aliases("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_ENUM_DOM_ALIASES, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_ENUM_DOM_USERS, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_enum_dom_aliases("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	prs_mem_free(&data);
+	/* Return output parameters */
 
-	if(!samr_io_r_enum_dom_users("", &r_e, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
-	}
+	result = r.status;
 
-	if (r_e.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_ENUM_DOM_USERS: %s\n", nt_errstr(r_e.status)));
-		prs_mem_free(&rdata);
-		return False;
+	if (!NT_STATUS_IS_OK(result) &&
+	    NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
+		goto done;
 	}
 
-	*num_sam_users = r_e.num_entries2;
-	if (*num_sam_users > MAX_SAM_ENTRIES) {
-		*num_sam_users = MAX_SAM_ENTRIES;
-		DEBUG(2,("do_samr_enum_dom_users: sam user entries limited to %d\n",
-		          *num_sam_users));
+	*num_dom_groups = r.num_entries2;
+
+	if (!((*dom_groups) = (struct acct_info *)
+	      talloc(mem_ctx, sizeof(struct acct_info) * *num_dom_groups))) {
+		result = NT_STATUS_UNSUCCESSFUL;
+		goto done;
 	}
 
-	*sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_users));
-				    
-	if ((*sam) == NULL)
-		*num_sam_users = 0;
+	memset(*dom_groups, 0, sizeof(struct acct_info) * *num_dom_groups);
+
+	name_idx = 0;
+
+	for (i = 0; i < *num_dom_groups; i++) {
 
-	for (i = 0; i < *num_sam_users; i++) {
-		(*sam)[i].smb_userid = r_e.sam[i].rid;
-		if (r_e.sam[i].hdr_name.buffer) {
-			char *acct_name = dos_unistrn2(r_e.uni_acct_name[name_idx].buffer,
-			                           r_e.uni_acct_name[name_idx].uni_str_len);
-			fstrcpy((*sam)[i].acct_name, acct_name);
+		(*dom_groups)[i].rid = r.sam[i].rid;
+
+		if (r.sam[i].hdr_name.buffer) {
+			unistr2_to_ascii((*dom_groups)[i].acct_name,
+					 &r.uni_grp_name[name_idx],
+					 sizeof(fstring) - 1);
 			name_idx++;
-		} else {
-			memset((char *)(*sam)[i].acct_name, '\0', sizeof((*sam)[i].acct_name));
 		}
 
-		DEBUG(5,("do_samr_enum_dom_users: idx: %4d rid: %8x acct: %s\n",
-		          i, (*sam)[i].smb_userid, (*sam)[i].acct_name));
+		*start_idx = r.next_idx;
 	}
 
-	prs_mem_free(&rdata  );
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
-#endif
 
-/****************************************************************************
-do a SAMR Connect
-****************************************************************************/
-BOOL do_samr_connect(struct cli_state *cli, 
-				char *srv_name, uint32 unknown_0,
-				POLICY_HND *connect_pol)
+/* Query alias members */
+
+NTSTATUS cli_samr_query_aliasmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *alias_pol, uint32 *num_mem, 
+                                 DOM_SID **sids)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_CONNECT q_o;
-	SAMR_R_CONNECT r_o;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_ALIASMEM q;
+	SAMR_R_QUERY_ALIASMEM r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	uint32 i;
 
-	if (srv_name == NULL || connect_pol == NULL)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_CONNECT */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Open Policy server:%s undoc value:%x\n",
-				srv_name, unknown_0));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_connect(&q_o, srv_name, unknown_0);
+	init_samr_q_query_aliasmem(&q, alias_pol);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_connect("", &q_o,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_query_aliasmem("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_ALIASMEM, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_CONNECT, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_query_aliasmem("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	prs_mem_free(&data);
+	/* Return output parameters */
 
-	if(!samr_io_r_connect("", &r_o, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
 	}
-		
-	if (r_o.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_CONNECT: %s\n", nt_errstr(r_o.status)));
-		prs_mem_free(&rdata);
-		return False;
+
+	*num_mem = r.num_sids;
+
+	if (!(*sids = talloc(mem_ctx, sizeof(DOM_SID) * *num_mem))) {
+		result = NT_STATUS_UNSUCCESSFUL;
+		goto done;
 	}
 
-	memcpy(connect_pol, &r_o.connect_pol, sizeof(r_o.connect_pol));
+	for (i = 0; i < *num_mem; i++) {
+		(*sids)[i] = r.sid[i].sid;
+	}
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
 
-/****************************************************************************
-do a SAMR Open User
-****************************************************************************/
-BOOL do_samr_open_user(struct cli_state *cli, 
-				POLICY_HND *pol, uint32 unk_0, uint32 rid, 
-				POLICY_HND *user_pol)
+/* Open handle on an alias */
+
+NTSTATUS cli_samr_open_alias(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                             POLICY_HND *domain_pol, uint32 access_mask, 
+                             uint32 alias_rid, POLICY_HND *alias_pol)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_OPEN_USER q_o;
-	SAMR_R_OPEN_USER r_o;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_OPEN_ALIAS q;
+	SAMR_R_OPEN_ALIAS r;
+	NTSTATUS result;
 
-	if (pol == NULL || user_pol == NULL)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_OPEN_USER */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Open User.  unk_0: %08x RID:%x\n",
-	          unk_0, rid));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_open_user(&q_o, pol, unk_0, rid);
+	init_samr_q_open_alias(&q, domain_pol, access_mask, alias_rid);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_open_user("", &q_o,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_open_alias("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_OPEN_ALIAS, &qbuf, &rbuf)) {
+		result = NT_STATUS_UNSUCCESSFUL;
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_OPEN_USER, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_open_alias("", &r, &rbuf, 0)) {
+		result = NT_STATUS_UNSUCCESSFUL;
+		goto done;
 	}
 
-	prs_mem_free(&data);
+	/* Return output parameters */
 
-	if(!samr_io_r_open_user("", &r_o, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (NT_STATUS_IS_OK(result = r.status)) {
+		*alias_pol = r.pol;
+#ifdef __INSURE__
+		alias_pol->marker = malloc(1);
+#endif
 	}
-		
-	if (r_o.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_OPEN_USER: %s\n", nt_errstr(r_o.status)));
-		prs_mem_free(&rdata);
-		return False;
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Query domain info */
+
+NTSTATUS cli_samr_query_dom_info(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                 POLICY_HND *domain_pol, uint16 switch_value,
+                                 SAM_UNK_CTR *ctr)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_DOMAIN_INFO q;
+	SAMR_R_QUERY_DOMAIN_INFO r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_query_dom_info(&q, domain_pol, switch_value);
+
+	if (!samr_io_q_query_dom_info("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_DOMAIN_INFO, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
+	/* Unmarshall response */
 
-	prs_mem_free(&rdata);
+	r.ctr = ctr;
+
+	if (!samr_io_r_query_dom_info("", &r, &rbuf, 0)) {
+		goto done;
+	}
+
+	/* Return output parameters */
 
-	return True;
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
+	}
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
 }
 
-/****************************************************************************
-do a SAMR Open Domain
-****************************************************************************/
-BOOL do_samr_open_domain(struct cli_state *cli, 
-				POLICY_HND *connect_pol, uint32 rid, DOM_SID *sid,
-				POLICY_HND *domain_pol)
+/* Query display info */
+
+NTSTATUS cli_samr_query_dispinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                 POLICY_HND *domain_pol, uint32 *start_idx,
+                                 uint16 switch_value, uint32 *num_entries,
+                                 uint32 max_entries, SAM_DISPINFO_CTR *ctr)
 {
-	prs_struct data;
-	prs_struct rdata;
-	pstring sid_str;
-	SAMR_Q_OPEN_DOMAIN q_o;
-	SAMR_R_OPEN_DOMAIN r_o;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_DISPINFO q;
+	SAMR_R_QUERY_DISPINFO r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (connect_pol == NULL || sid == NULL || domain_pol == NULL)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_OPEN_DOMAIN */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	sid_to_string(sid_str, sid);
-	DEBUG(4,("SAMR Open Domain.  SID:%s RID:%x\n", sid_str, rid));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_open_domain(&q_o, connect_pol, rid, sid);
+	init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
+				   *start_idx, max_entries);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_open_domain("", &q_o,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_query_dispinfo("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_DISPINFO, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_OPEN_DOMAIN, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
-	}
+	/* Unmarshall response */
 
-	prs_mem_free(&data);
+	r.ctr = ctr;
 
-	if(!samr_io_r_open_domain("", &r_o, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_r_query_dispinfo("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	if (r_o.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_OPEN_DOMAIN: %s\n", nt_errstr(r_o.status)));
-		prs_mem_free(&rdata);
-		return False;
+	/* Return output parameters */
+
+        result = r.status;
+
+	if (!NT_STATUS_IS_OK(result) &&
+	    NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
+		goto done;
 	}
 
-	memcpy(domain_pol, &r_o.domain_pol, sizeof(r_o.domain_pol));
+	*num_entries = r.num_entries;
+	*start_idx += r.num_entries;  /* No next_idx in this structure! */
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
 
-#if 0
-
-/* CURRENTLY DOES NOT COMPILE AND IS NOT USED ANYWHERE. JRA. */
+/* Lookup rids.  Note that NT4 seems to crash if more than ~1000 rids are
+   looked up in one packet. */
 
-/****************************************************************************
-do a SAMR Query Unknown 12
-****************************************************************************/
-BOOL do_samr_query_unknown_12(struct cli_state *cli, 
-				POLICY_HND *pol, uint32 rid, uint32 num_gids, uint32 *gids,
-				uint32 *num_aliases,
-				fstring als_names    [MAX_LOOKUP_SIDS],
-				uint32  num_als_users[MAX_LOOKUP_SIDS])
+NTSTATUS cli_samr_lookup_rids(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                              POLICY_HND *domain_pol, uint32 flags,
+                              uint32 num_rids, uint32 *rids, 
+                              uint32 *num_names, char ***names,
+                              uint32 **name_types)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_LOOKUP_RIDS q_o;
-	SAMR_R_LOOKUP_RIDS r_o;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_LOOKUP_RIDS q;
+	SAMR_R_LOOKUP_RIDS r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	uint32 i;
 
-	if (pol == NULL || rid == 0 || num_gids == 0 || gids == NULL ||
-	    num_aliases == NULL || als_names == NULL || num_als_users == NULL )
-			return False;
+        if (num_rids > 1000) {
+                DEBUG(2, ("cli_samr_lookup_rids: warning: NT4 can crash if "
+                          "more than ~1000 rids are looked up at once.\n"));
+        }
 
-	/* create and send a MSRPC command with api SAMR_UNKNOWN_12 */
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	/* Initialise parse structures */
 
-	DEBUG(4,("SAMR Query Unknown 12.\n"));
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	/* store the parameters */
-	init_samr_q_lookup_rids(&q_o, pol, rid, num_gids, gids);
+	/* Marshall data and send request */
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_lookup_rids("", &q_o,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, flags,
+				num_rids, rids);
+
+	if (!samr_io_q_lookup_rids("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_LOOKUP_RIDS, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_LOOKUP_RIDS, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_lookup_rids("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	prs_mem_free(&data);
+	/* Return output parameters */
 
-	if(!samr_io_r_lookup_rids("", &r_o, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
 	}
-		
-	if (r_o.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_UNKNOWN_12: %s\n", nt_errstr(r_o.status)));
-		prs_mem_free(&rdata);
-		return False;
+
+	if (r.num_names1 == 0) {
+		*num_names = 0;
+		*names = NULL;
+		goto done;
 	}
 
-	if (r_o.ptr_aliases != 0 && r_o.ptr_als_usrs != 0 &&
-	    r_o.num_als_usrs1 == r_o.num_aliases1) {
-		int i;
+	*num_names = r.num_names1;
+	*names = talloc(mem_ctx, sizeof(char *) * r.num_names1);
+	*name_types = talloc(mem_ctx, sizeof(uint32) * r.num_names1);
 
-		*num_aliases = r_o.num_aliases1;
+	for (i = 0; i < r.num_names1; i++) {
+		fstring tmp;
 
-		for (i = 0; i < r_o.num_aliases1; i++) {
-			fstrcpy(als_names[i], dos_unistrn2(r_o.uni_als_name[i].buffer,
-						r_o.uni_als_name[i].uni_str_len));
-		}
-		for (i = 0; i < r_o.num_als_usrs1; i++) {
-			num_als_users[i] = r_o.num_als_usrs[i];
-		}
-	} else if (r_o.ptr_aliases == 0 && r_o.ptr_als_usrs == 0) {
-		*num_aliases = 0;
-	} else {
-		prs_mem_free(&rdata);
-		return False;
+		unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp) - 1);
+		(*names)[i] = talloc_strdup(mem_ctx, tmp);
+		(*name_types)[i] = r.type[i];
 	}
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }
-#endif
 
-/****************************************************************************
-do a SAMR Query User Groups
-****************************************************************************/
-BOOL do_samr_query_usergroups(struct cli_state *cli, 
-				POLICY_HND *pol, uint32 *num_groups, DOM_GID *gid)
+/* Lookup names */
+
+NTSTATUS cli_samr_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                               POLICY_HND *domain_pol, uint32 flags,
+                               uint32 num_names, const char **names,
+                               uint32 *num_rids, uint32 **rids,
+                               uint32 **rid_types)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_QUERY_USERGROUPS q_o;
-	SAMR_R_QUERY_USERGROUPS r_o;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_LOOKUP_NAMES q;
+	SAMR_R_LOOKUP_NAMES r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+	uint32 i;
 
-	if (pol == NULL || gid == NULL || num_groups == 0)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_QUERY_USERGROUPS */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Query User Groups.\n"));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_query_usergroups(&q_o, pol);
+	init_samr_q_lookup_names(mem_ctx, &q, domain_pol, flags,
+				 num_names, names);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_query_usergroups("", &q_o,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_lookup_names("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_LOOKUP_NAMES, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_QUERY_USERGROUPS, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
-	}
+	/* Unmarshall response */
 
-	prs_mem_free(&data);
+	if (!samr_io_r_lookup_names("", &r, &rbuf, 0)) {
+		goto done;
+	}
 
-	/* get user info */
-	r_o.gid = gid;
+	/* Return output parameters */
 
-	if(!samr_io_r_query_usergroups("", &r_o, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
 	}
-		
-	if (r_o.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_QUERY_USERGROUPS: %s\n", nt_errstr(r_o.status)));
-		prs_mem_free(&rdata);
-		return False;
+
+	if (r.num_rids1 == 0) {
+		*num_rids = 0;
+		goto done;
 	}
 
-	*num_groups = r_o.num_entries;
+	*num_rids = r.num_rids1;
+	*rids = talloc(mem_ctx, sizeof(uint32) * r.num_rids1);
+	*rid_types = talloc(mem_ctx, sizeof(uint32) * r.num_rids1);
 
-	prs_mem_free(&rdata);
+	for (i = 0; i < r.num_rids1; i++) {
+		(*rids)[i] = r.rids[i];
+		(*rid_types)[i] = r.types[i];
+	}
 
-	return True;
-}
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-#if 0
+	return result;
+}
 
-/* CURRENTLY DOES NOT COMPILE WITH THE NEW SAMR PARSE CODE. JRA */
+/* Create a domain user */
 
-/****************************************************************************
-do a SAMR Query User Info
-****************************************************************************/
-BOOL do_samr_query_userinfo(struct cli_state *cli, 
-				POLICY_HND *pol, uint16 switch_value, void* usr)
+NTSTATUS cli_samr_create_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                  POLICY_HND *domain_pol, const char *acct_name,
+                                  uint32 acb_info, uint32 unknown, 
+                                  POLICY_HND *user_pol, uint32 *rid)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_QUERY_USERINFO q_o;
-	SAMR_R_QUERY_USERINFO r_o;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_CREATE_USER q;
+	SAMR_R_CREATE_USER r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (pol == NULL || usr == NULL || switch_value == 0)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	/* create and send a MSRPC command with api SAMR_QUERY_USERINFO */
+	/* Initialise parse structures */
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Query User Info.  level: %d\n", switch_value));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_query_userinfo(&q_o, pol, switch_value);
+	init_samr_q_create_user(&q, domain_pol, acct_name, acb_info, unknown);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_query_userinfo("", &q_o,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_create_user("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_CREATE_USER, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_QUERY_USERINFO, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_create_user("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	prs_mem_free(&data);
+	/* Return output parameters */
 
-	/* get user info */
-	r_o.info.id = usr;
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
+	}
 
-	if(!samr_io_r_query_userinfo("", &r_o, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	if (user_pol)
+		*user_pol = r.user_pol;
+
+	if (rid)
+		*rid = r.user_rid;
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Set userinfo */
+
+NTSTATUS cli_samr_set_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                               POLICY_HND *user_pol, uint16 switch_value,
+                               uchar sess_key[16], SAM_USERINFO_CTR *ctr)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_SET_USERINFO q;
+	SAMR_R_SET_USERINFO r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	q.ctr = ctr;
+
+	init_samr_q_set_userinfo(&q, user_pol, sess_key, switch_value, 
+				 ctr->info.id);
+
+	if (!samr_io_q_set_userinfo("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_SET_USERINFO, &qbuf, &rbuf)) {
+		goto done;
 	}
-		
-	if (r_o.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_R_QUERY_USERINFO: %s\n", nt_errstr(r_o.status)));
-		prs_mem_free(&rdata);
-		return False;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_set_userinfo("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	if (r_o.switch_value != switch_value) {
-		DEBUG(0,("SAMR_R_QUERY_USERINFO: received incorrect level %d\n",
-		          r_o.switch_value));
-		prs_mem_free(&rdata);
-		return False;
+	/* Return output parameters */
+
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
 	}
 
-	if (r_o.ptr == 0) {
-		prs_mem_free(&rdata);
-		return False;
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Set userinfo2 */
+
+NTSTATUS cli_samr_set_userinfo2(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                POLICY_HND *user_pol, uint16 switch_value,
+                                uchar sess_key[16], SAM_USERINFO_CTR *ctr)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_SET_USERINFO2 q;
+	SAMR_R_SET_USERINFO2 r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_set_userinfo2(&q, user_pol, sess_key, switch_value, ctr);
+
+	if (!samr_io_q_set_userinfo2("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_SET_USERINFO2, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	prs_mem_free(&rdata);
+	/* Unmarshall response */
 
-	return True;
+	if (!samr_io_r_set_userinfo2("", &r, &rbuf, 0)) {
+		goto done;
+	}
+
+	/* Return output parameters */
+
+	if (!NT_STATUS_IS_OK(result = r.status)) {
+		goto done;
+	}
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
 }
 
-#endif
+/* Delete domain user */
 
-/****************************************************************************
-do a SAMR Close
-****************************************************************************/
-BOOL do_samr_close(struct cli_state *cli, POLICY_HND *hnd)
+NTSTATUS cli_samr_delete_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                  POLICY_HND *user_pol)
 {
-	prs_struct data;
-	prs_struct rdata;
-	SAMR_Q_CLOSE_HND q_c;
-	SAMR_R_CLOSE_HND r_c;
+	prs_struct qbuf, rbuf;
+	SAMR_Q_DELETE_DOM_USER q;
+	SAMR_R_DELETE_DOM_USER r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	if (hnd == NULL)
-		return False;
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
 
-	prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	/* Initialise parse structures */
 
-	/* create and send a MSRPC command with api SAMR_CLOSE_HND */
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
 
-	DEBUG(4,("SAMR Close\n"));
+	/* Marshall data and send request */
 
-	/* store the parameters */
-	init_samr_q_close_hnd(&q_c, hnd);
+	init_samr_q_delete_dom_user(&q, user_pol);
 
-	/* turn parameters into data stream */
-	if(!samr_io_q_close_hnd("", &q_c,  &data, 0)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	if (!samr_io_q_delete_dom_user("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_DELETE_DOM_USER, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	/* send the data on \PIPE\ */
-	if (!rpc_api_pipe_req(cli, SAMR_CLOSE_HND, &data, &rdata)) {
-		prs_mem_free(&data);
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_delete_dom_user("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	prs_mem_free(&data);
+	/* Return output parameters */
 
-	if(!samr_io_r_close_hnd("", &r_c, &rdata, 0)) {
-		prs_mem_free(&rdata);
-		return False;
+	result = r.status;
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Query user security object */
+
+NTSTATUS cli_samr_query_sec_obj(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *user_pol, uint16 switch_value, 
+                                 TALLOC_CTX *ctx, SEC_DESC_BUF **sec_desc_buf)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_QUERY_SEC_OBJ q;
+	SAMR_R_QUERY_SEC_OBJ r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_query_sec_obj(&q, user_pol, switch_value);
+
+	if (!samr_io_q_query_sec_obj("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_QUERY_SEC_OBJECT, &qbuf, &rbuf)) {
+		goto done;
 	}
 
-	if (r_c.status != 0) {
-		/* report error code */
-		DEBUG(0,("SAMR_CLOSE_HND: %s\n", nt_errstr(r_c.status)));
-		prs_mem_free(&rdata);
-		return False;
+	/* Unmarshall response */
+
+	if (!samr_io_r_query_sec_obj("", &r, &rbuf, 0)) {
+		goto done;
 	}
 
-	/* check that the returned policy handle is all zeros */
+	/* Return output parameters */
 
-	if (IVAL(&r_c.pol.data1,0) || IVAL(&r_c.pol.data2,0) || SVAL(&r_c.pol.data3,0) ||
-		SVAL(&r_c.pol.data4,0) || IVAL(r_c.pol.data5,0) || IVAL(r_c.pol.data5,4) ) {
-			DEBUG(0,("SAMR_CLOSE_HND: non-zero handle returned\n"));
-			prs_mem_free(&rdata);
-			return False;
-	}	
+	result = r.status;
+	*sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
 
-	prs_mem_free(&rdata);
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
+
+	return result;
+}
+
+/* Get domain password info */
+
+NTSTATUS cli_samr_get_dom_pwinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+				 uint16 *unk_0, uint16 *unk_1, uint16 *unk_2)
+{
+	prs_struct qbuf, rbuf;
+	SAMR_Q_GET_DOM_PWINFO q;
+	SAMR_R_GET_DOM_PWINFO r;
+	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+	ZERO_STRUCT(q);
+	ZERO_STRUCT(r);
+
+	/* Initialise parse structures */
+
+	prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+	prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+
+	/* Marshall data and send request */
+
+	init_samr_q_get_dom_pwinfo(&q, cli->desthost);
+
+	if (!samr_io_q_get_dom_pwinfo("", &q, &qbuf, 0) ||
+	    !rpc_api_pipe_req(cli, SAMR_GET_DOM_PWINFO, &qbuf, &rbuf))
+		goto done;
+
+	/* Unmarshall response */
+
+	if (!samr_io_r_get_dom_pwinfo("", &r, &rbuf, 0))
+		goto done;
+
+	/* Return output parameters */
+
+	result = r.status;
+
+	if (NT_STATUS_IS_OK(result)) {
+		if (unk_0)
+			*unk_0 = r.unk_0;
+		if (unk_1)
+			*unk_1 = r.unk_1;
+		if (unk_2)
+			*unk_2 = r.unk_2;
+	}
+
+ done:
+	prs_mem_free(&qbuf);
+	prs_mem_free(&rbuf);
 
-	return True;
+	return result;
 }