r7415: * big change -- volker's new async winbindd from trunk

(This used to be commit a0ac9a8ffd4af31a0ebc423b4acbb2f043d865b8)

5 files changed, 746 insertions, 242 deletions

diff --git a/source3/rpc_client/cli_ds.c b/source3/rpc_client/cli_ds.c
index 40a32c7ee0..41063a5d7f 100644
--- a/source3/rpc_client/cli_ds.c
+++ b/source3/rpc_client/cli_ds.c
@@ -26,8 +26,9 @@
  Get information about the server and directory services
 ********************************************************************/
 
-NTSTATUS cli_ds_getprimarydominfo(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-				  uint16 level, DS_DOMINFO_CTR *ctr)
+NTSTATUS rpccli_ds_getprimarydominfo(struct rpc_pipe_client *cli,
+				     TALLOC_CTX *mem_ctx, 
+				     uint16 level, DS_DOMINFO_CTR *ctr)
 {
 	prs_struct qbuf, rbuf;
 	DS_Q_GETPRIMDOMINFO q;
@@ -50,7 +51,7 @@ NTSTATUS cli_ds_getprimarydominfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	q.level = level;
 	
 	if (!ds_io_q_getprimdominfo("", &qbuf, 0, &q) 
-	    || !rpc_api_pipe_req(cli, PI_LSARPC_DS, DS_GETPRIMDOMINFO, &qbuf, &rbuf)) {
+	    || !rpc_api_pipe_req_int(cli, DS_GETPRIMDOMINFO, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -81,13 +82,23 @@ done:
 	return result;
 }
 
+NTSTATUS cli_ds_getprimarydominfo(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+				  uint16 level, DS_DOMINFO_CTR *ctr)
+{
+	return rpccli_ds_getprimarydominfo(&cli->pipes[PI_LSARPC_DS], mem_ctx,
+					   level, ctr);
+}
+
+
 /********************************************************************
  Enumerate trusted domains in an AD forest
 ********************************************************************/
 
-NTSTATUS cli_ds_enum_domain_trusts(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-				  const char *server, uint32 flags, 
-				  struct ds_domain_trust **trusts, uint32 *num_domains)
+NTSTATUS rpccli_ds_enum_domain_trusts(struct rpc_pipe_client *cli,
+				      TALLOC_CTX *mem_ctx, 
+				      const char *server, uint32 flags, 
+				      struct ds_domain_trust **trusts,
+				      uint32 *num_domains)
 {
 	prs_struct qbuf, rbuf;
 	DS_Q_ENUM_DOM_TRUSTS q;
@@ -110,7 +121,7 @@ NTSTATUS cli_ds_enum_domain_trusts(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_q_ds_enum_domain_trusts( &q, server, flags );
 		
 	if (!ds_io_q_enum_domain_trusts("", &qbuf, 0, &q) 
-	    || !rpc_api_pipe_req(cli, PI_NETLOGON, DS_ENUM_DOM_TRUSTS, &qbuf, &rbuf)) {
+	    || !rpc_api_pipe_req_int(cli, DS_ENUM_DOM_TRUSTS, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -163,3 +174,13 @@ done:
 
 	return result;
 }
+
+NTSTATUS cli_ds_enum_domain_trusts(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+				   const char *server, uint32 flags, 
+				   struct ds_domain_trust **trusts,
+				   uint32 *num_domains)
+{
+	return rpccli_ds_enum_domain_trusts(&cli->pipes[PI_NETLOGON], mem_ctx,
+					    server, flags, trusts,
+					    num_domains);
+}
diff --git a/source3/rpc_client/cli_lsarpc.c b/source3/rpc_client/cli_lsarpc.c
index 47dd0b1ea3..26f82cdfbe 100644
--- a/source3/rpc_client/cli_lsarpc.c
+++ b/source3/rpc_client/cli_lsarpc.c
@@ -43,8 +43,10 @@
  *
  * @param cli Handle on an initialised SMB connection */
 
-NTSTATUS cli_lsa_open_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                             BOOL sec_qos, uint32 des_access, POLICY_HND *pol)
+NTSTATUS rpccli_lsa_open_policy(struct rpc_pipe_client *cli,
+				TALLOC_CTX *mem_ctx,
+				BOOL sec_qos, uint32 des_access,
+				POLICY_HND *pol)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_OPEN_POL q;
@@ -52,6 +54,8 @@ NTSTATUS cli_lsa_open_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	LSA_SEC_QOS qos;
 	NTSTATUS result;
 
+	SMB_ASSERT(cli->pipe_idx == PI_LSARPC);
+
 	ZERO_STRUCT(q);
 	ZERO_STRUCT(r);
 
@@ -72,7 +76,7 @@ NTSTATUS cli_lsa_open_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	/* Marshall data and send request */
 
 	if (!lsa_io_q_open_pol("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_OPENPOLICY, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_OPENPOLICY, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -100,13 +104,21 @@ NTSTATUS cli_lsa_open_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_open_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                             BOOL sec_qos, uint32 des_access, POLICY_HND *pol)
+{
+	return rpccli_lsa_open_policy(&cli->pipes[PI_LSARPC], mem_ctx,
+				      sec_qos, des_access, pol);
+}
+
 /** Open a LSA policy handle
   *
   * @param cli Handle on an initialised SMB connection 
   */
 
-NTSTATUS cli_lsa_open_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                              BOOL sec_qos, uint32 des_access, POLICY_HND *pol)
+NTSTATUS rpccli_lsa_open_policy2(struct rpc_pipe_client *cli,
+				 TALLOC_CTX *mem_ctx, BOOL sec_qos,
+				 uint32 des_access, POLICY_HND *pol)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_OPEN_POL2 q;
@@ -126,17 +138,17 @@ NTSTATUS cli_lsa_open_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 	if (sec_qos) {
 		init_lsa_sec_qos(&qos, 2, 1, 0);
-		init_q_open_pol2(&q, cli->srv_name_slash, 0, des_access, 
+		init_q_open_pol2(&q, cli->cli->srv_name_slash, 0, des_access, 
                                  &qos);
 	} else {
-		init_q_open_pol2(&q, cli->srv_name_slash, 0, des_access, 
+		init_q_open_pol2(&q, cli->cli->srv_name_slash, 0, des_access, 
                                  NULL);
 	}
 
 	/* Marshall data and send request */
 
 	if (!lsa_io_q_open_pol2("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_OPENPOLICY2, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_OPENPOLICY2, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -164,16 +176,26 @@ NTSTATUS cli_lsa_open_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_open_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                              BOOL sec_qos, uint32 des_access, POLICY_HND *pol)
+{
+	return rpccli_lsa_open_policy2(&cli->pipes[PI_LSARPC], mem_ctx,
+				       sec_qos, des_access, pol);
+}
+
+
 /** Close a LSA policy handle */
 
-NTSTATUS cli_lsa_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-                       POLICY_HND *pol)
+NTSTATUS rpccli_lsa_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, 
+			  POLICY_HND *pol)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_CLOSE q;
 	LSA_R_CLOSE r;
 	NTSTATUS result;
 
+	SMB_ASSERT(cli->pipe_idx == PI_LSARPC);
+
 	ZERO_STRUCT(q);
 	ZERO_STRUCT(r);
 
@@ -187,7 +209,7 @@ NTSTATUS cli_lsa_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_lsa_q_close(&q, pol);
 
 	if (!lsa_io_q_close("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_CLOSE, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_CLOSE, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -215,11 +237,19 @@ NTSTATUS cli_lsa_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                       POLICY_HND *pol)
+{
+	return rpccli_lsa_close(&cli->pipes[PI_LSARPC], mem_ctx, pol);
+}
+
 /** Lookup a list of sids */
 
-NTSTATUS cli_lsa_lookup_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                             POLICY_HND *pol, int num_sids, const DOM_SID *sids, 
-                             char ***domains, char ***names, uint32 **types)
+NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli,
+				TALLOC_CTX *mem_ctx,
+				POLICY_HND *pol, int num_sids,
+				const DOM_SID *sids, 
+				char ***domains, char ***names, uint32 **types)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_LOOKUP_SIDS q;
@@ -242,7 +272,7 @@ NTSTATUS cli_lsa_lookup_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_q_lookup_sids(mem_ctx, &q, pol, num_sids, sids, 1);
 
 	if (!lsa_io_q_lookup_sids("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_LOOKUPSIDS, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_LOOKUPSIDS, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -332,12 +362,23 @@ NTSTATUS cli_lsa_lookup_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_lookup_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                             POLICY_HND *pol, int num_sids,
+			     const DOM_SID *sids, 
+                             char ***domains, char ***names, uint32 **types)
+{
+	return rpccli_lsa_lookup_sids(&cli->pipes[PI_LSARPC], mem_ctx,
+				      pol, num_sids, sids,
+				      domains, names, types);
+}
+
 /** Lookup a list of names */
 
-NTSTATUS cli_lsa_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                              POLICY_HND *pol, int num_names, 
-			      const char **names, DOM_SID **sids, 
-			      uint32 **types)
+NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli,
+				 TALLOC_CTX *mem_ctx,
+				 POLICY_HND *pol, int num_names, 
+				 const char **names, DOM_SID **sids, 
+				 uint32 **types)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_LOOKUP_NAMES q;
@@ -359,7 +400,7 @@ NTSTATUS cli_lsa_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_q_lookup_names(mem_ctx, &q, pol, num_names, names);
 
 	if (!lsa_io_q_lookup_names("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_LOOKUPNAMES, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_LOOKUPNAMES, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -433,19 +474,31 @@ NTSTATUS cli_lsa_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                              POLICY_HND *pol, int num_names, 
+			      const char **names, DOM_SID **sids, 
+			      uint32 **types)
+{
+	return rpccli_lsa_lookup_names(&cli->pipes[PI_LSARPC], mem_ctx,
+				       pol, num_names, names, sids, types);
+}
+
 /** Query info policy
  *
  *  @param domain_sid - returned remote server's domain sid */
 
-NTSTATUS cli_lsa_query_info_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                                   POLICY_HND *pol, uint16 info_class, 
-                                   char **domain_name, DOM_SID **domain_sid)
+NTSTATUS rpccli_lsa_query_info_policy(struct rpc_pipe_client *cli,
+				      TALLOC_CTX *mem_ctx,
+				      POLICY_HND *pol, uint16 info_class, 
+				      char **domain_name, DOM_SID **domain_sid)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_QUERY_INFO q;
 	LSA_R_QUERY_INFO r;
 	NTSTATUS result;
 
+	SMB_ASSERT(cli->pipe_idx == PI_LSARPC);
+
 	ZERO_STRUCT(q);
 	ZERO_STRUCT(r);
 
@@ -459,7 +512,7 @@ NTSTATUS cli_lsa_query_info_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_q_query(&q, pol, info_class);
 
 	if (!lsa_io_q_query("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_QUERYINFOPOLICY, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_QUERYINFOPOLICY, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -523,6 +576,15 @@ NTSTATUS cli_lsa_query_info_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_query_info_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                   POLICY_HND *pol, uint16 info_class, 
+                                   char **domain_name, DOM_SID **domain_sid)
+{
+	return rpccli_lsa_query_info_policy(&cli->pipes[PI_LSARPC], mem_ctx,
+					    pol, info_class, domain_name,
+					    domain_sid);
+}
+
 /** Query info policy2
  *
  *  @param domain_name - returned remote server's domain name
@@ -531,11 +593,13 @@ NTSTATUS cli_lsa_query_info_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  *  @param domain_guid - returned remote server's domain guid
  *  @param domain_sid - returned remote server's domain sid */
 
-NTSTATUS cli_lsa_query_info_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-				    POLICY_HND *pol, uint16 info_class, 
-				    char **domain_name, char **dns_name,
-				    char **forest_name, struct uuid **domain_guid,
-				    DOM_SID **domain_sid)
+NTSTATUS rpccli_lsa_query_info_policy2(struct rpc_pipe_client *cli,
+				       TALLOC_CTX *mem_ctx,
+				       POLICY_HND *pol, uint16 info_class, 
+				       char **domain_name, char **dns_name,
+				       char **forest_name,
+				       struct uuid **domain_guid,
+				       DOM_SID **domain_sid)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_QUERY_INFO2 q;
@@ -558,7 +622,7 @@ NTSTATUS cli_lsa_query_info_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_q_query2(&q, pol, info_class);
 
 	if (!lsa_io_q_query_info2("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_LSARPC, LSA_QUERYINFO2, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, LSA_QUERYINFO2, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -616,6 +680,19 @@ NTSTATUS cli_lsa_query_info_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_lsa_query_info_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+				    POLICY_HND *pol, uint16 info_class, 
+				    char **domain_name, char **dns_name,
+				    char **forest_name,
+				    struct uuid **domain_guid,
+				    DOM_SID **domain_sid)
+{
+	return rpccli_lsa_query_info_policy2(&cli->pipes[PI_LSARPC], mem_ctx,
+					     pol, info_class, domain_name,
+					     dns_name, forest_name,
+					     domain_guid, domain_sid);
+}
+
 /**
  * Enumerate list of trusted domains
  *
@@ -631,10 +708,11 @@ NTSTATUS cli_lsa_query_info_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  * @return nt status code of response
  **/
 
-NTSTATUS cli_lsa_enum_trust_dom(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                                POLICY_HND *pol, uint32 *enum_ctx, 
-                                uint32 *num_domains,
-                                char ***domain_names, DOM_SID **domain_sids)
+NTSTATUS rpccli_lsa_enum_trust_dom(struct rpc_pipe_client *cli,
+				   TALLOC_CTX *mem_ctx,
+				   POLICY_HND *pol, uint32 *enum_ctx, 
+				   uint32 *num_domains,
+				   char ***domain_names, DOM_SID **domain_sids)
 {
 	prs_struct qbuf, rbuf;
 	LSA_Q_ENUM_TRUST_DOM in;
@@ -650,7 +728,7 @@ NTSTATUS cli_lsa_enum_trust_dom(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	
         init_q_enum_trust_dom(&in, pol, *enum_ctx, 0x10000);
 
-	CLI_DO_RPC( cli, mem_ctx, PI_LSARPC, LSA_ENUMTRUSTDOM, 
+	CLI_DO_RPC_EX( cli, mem_ctx, PI_LSARPC, LSA_ENUMTRUSTDOM, 
 	            in, out, 
 	            qbuf, rbuf,
 	            lsa_io_q_enum_trust_dom,
@@ -701,6 +779,15 @@ NTSTATUS cli_lsa_enum_trust_dom(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return out.status;
 }
 
+NTSTATUS cli_lsa_enum_trust_dom(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                POLICY_HND *pol, uint32 *enum_ctx, 
+                                uint32 *num_domains,
+                                char ***domain_names, DOM_SID **domain_sids)
+{
+	return rpccli_lsa_enum_trust_dom(&cli->pipes[PI_LSARPC], mem_ctx,
+					 pol, enum_ctx, num_domains,
+					 domain_names, domain_sids);
+}
 
 /** Enumerate privileges*/
 
diff --git a/source3/rpc_client/cli_netlogon.c b/source3/rpc_client/cli_netlogon.c
index 08b52fa718..1474c94513 100644
--- a/source3/rpc_client/cli_netlogon.c
+++ b/source3/rpc_client/cli_netlogon.c
@@ -75,6 +75,55 @@ NTSTATUS cli_net_req_chal(struct cli_state *cli, DOM_CHAL *clnt_chal,
         return result;
 }
 
+NTSTATUS rpccli_net_req_chal(struct rpc_pipe_client *cli,
+			     const char *server_name,
+			     const char *computer_name,
+			     DOM_CHAL *clnt_chal, DOM_CHAL *srv_chal)
+{
+        prs_struct qbuf, rbuf;
+        NET_Q_REQ_CHAL q;
+        NET_R_REQ_CHAL r;
+        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+        prs_init(&qbuf, MAX_PDU_FRAG_LEN, cli->cli->mem_ctx, MARSHALL);
+        prs_init(&rbuf, 0, cli->cli->mem_ctx, UNMARSHALL);
+        
+        /* create and send a MSRPC command with api NET_REQCHAL */
+
+        DEBUG(4,("cli_net_req_chal: LSA Request Challenge from %s to %s\n",
+                 computer_name, server_name));
+        
+        /* store the parameters */
+        init_q_req_chal(&q, server_name, computer_name, clnt_chal);
+        
+        /* Marshall data and send request */
+
+        if (!net_io_q_req_chal("", &q,  &qbuf, 0) ||
+            !rpc_api_pipe_req_int(cli, NET_REQCHAL, &qbuf, &rbuf)) {
+                goto done;
+        }
+
+        /* Unmarhall response */
+
+        if (!net_io_r_req_chal("", &r, &rbuf, 0)) {
+                goto done;
+        }
+
+        result = r.status;
+
+        /* Return result */
+
+        if (NT_STATUS_IS_OK(result)) {
+                memcpy(srv_chal, r.srv_chal.data, sizeof(srv_chal->data));
+        }
+        
+ done:
+        prs_mem_free(&qbuf);
+        prs_mem_free(&rbuf);
+        
+        return result;
+}
+
 /****************************************************************************
 LSA Authenticate 2
 
@@ -158,6 +207,61 @@ password ?).\n", cli->desthost ));
         return result;
 }
 
+NTSTATUS rpccli_net_auth2(struct rpc_pipe_client *cli,
+			  const char *server_name,
+			  const char *account_name,
+			  uint16 sec_chan_type,
+			  const char *computer_name,
+			  const DOM_CHAL *credentials,
+			  uint32 *neg_flags,
+			  DOM_CHAL *srv_chal)
+{
+        prs_struct qbuf, rbuf;
+        NET_Q_AUTH_2 q;
+        NET_R_AUTH_2 r;
+        NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+        prs_init(&qbuf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
+        prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL);
+
+        /* create and send a MSRPC command with api NET_AUTH2 */
+
+        DEBUG(4,("cli_net_auth2: srv:%s acct:%s sc:%x mc: %s neg: %x\n",
+                 server_name, account_name, sec_chan_type, computer_name,
+                 *neg_flags));
+
+        /* store the parameters */
+
+        init_q_auth_2(&q, server_name, account_name, sec_chan_type,
+		      computer_name, credentials, *neg_flags);
+
+        /* turn parameters into data stream */
+
+        if (!net_io_q_auth_2("", &q,  &qbuf, 0) ||
+            !rpc_api_pipe_req_int(cli, NET_AUTH2, &qbuf, &rbuf)) {
+                goto done;
+        }
+        
+        /* Unmarshall response */
+        
+        if (!net_io_r_auth_2("", &r, &rbuf, 0)) {
+                goto done;
+        }
+
+        result = r.status;
+
+        if (NT_STATUS_IS_OK(result)) {
+		*srv_chal = r.srv_chal;
+		*neg_flags = r.srv_flgs.neg_flags;
+        }
+
+ done:
+        prs_mem_free(&qbuf);
+        prs_mem_free(&rbuf);
+        
+        return result;
+}
+
 /****************************************************************************
 LSA Authenticate 3
 
@@ -340,8 +444,9 @@ NTSTATUS cli_netlogon_logon_ctrl2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* GetDCName */
 
-NTSTATUS cli_netlogon_getdcname(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-				const char *domainname, fstring dcname)
+NTSTATUS rpccli_netlogon_getdcname(struct rpc_pipe_client *cli,
+				   TALLOC_CTX *mem_ctx, const char *mydcname,
+				   const char *domainname, fstring newdcname)
 {
 	prs_struct qbuf, rbuf;
 	NET_Q_GETDCNAME q;
@@ -358,12 +463,12 @@ NTSTATUS cli_netlogon_getdcname(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 	/* Initialise input parameters */
 
-	init_net_q_getdcname(&q, cli->srv_name_slash, domainname);
+	init_net_q_getdcname(&q, mydcname, domainname);
 
 	/* Marshall data and send request */
 
 	if (!net_io_q_getdcname("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_NETLOGON, NET_GETDCNAME, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, NET_GETDCNAME, &qbuf, &rbuf)) {
 		result = NT_STATUS_UNSUCCESSFUL;
 		goto done;
 	}
@@ -378,7 +483,7 @@ NTSTATUS cli_netlogon_getdcname(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	result = r.status;
 
 	if (NT_STATUS_IS_OK(result))
-		rpcstr_pull_unistr2_fstring(dcname, &r.uni_dcname);
+		rpcstr_pull_unistr2_fstring(newdcname, &r.uni_dcname);
 
  done:
 	prs_mem_free(&qbuf);
@@ -387,6 +492,14 @@ NTSTATUS cli_netlogon_getdcname(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_netlogon_getdcname(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+				const char *domainname, fstring dcname)
+{
+	return rpccli_netlogon_getdcname(&cli->pipes[PI_NETLOGON], mem_ctx,
+					 cli->srv_name_slash, domainname,
+					 dcname);
+}
+
 /****************************************************************************
 Generate the next creds to use.
 ****************************************************************************/
@@ -636,19 +749,25 @@ NTSTATUS cli_netlogon_sam_logon(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  * @param info3 Pointer to a NET_USER_INFO_3 already allocated by the caller.
  **/
 
-NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-					DOM_CRED *ret_creds,
-					const char *username, const char *domain, const char *workstation, 
-					const uint8 chal[8], 
-					DATA_BLOB lm_response, DATA_BLOB nt_response,
-					NET_USER_INFO_3 *info3)
-
+NTSTATUS rpccli_netlogon_sam_network_logon(struct rpc_pipe_client *cli,
+					   TALLOC_CTX *mem_ctx,
+					   const char *server_name_slash,
+					   DOM_CRED *clnt_creds,
+					   DOM_CRED *ret_creds,
+					   const char *username,
+					   const char *domain,
+					   const char *workstation, 
+					   const uint8 chal[8], 
+					   DATA_BLOB lm_response,
+					   DATA_BLOB nt_response,
+					   NET_USER_INFO_3 *info3,
+					   const uint8 *session_key)
 {
 	prs_struct qbuf, rbuf;
 	NET_Q_SAM_LOGON q;
 	NET_R_SAM_LOGON r;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
-        DOM_CRED clnt_creds, dummy_rtn_creds;
+        DOM_CRED dummy_rtn_creds;
 	NET_ID_INFO_CTR ctr;
 	int validation_level = 3;
 	char *workstation_name_slash;
@@ -661,7 +780,6 @@ NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli, TALLOC_CTX *mem_c
 	ZERO_STRUCT(dummy_rtn_creds);
 
 	workstation_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", workstation);
-	
 	if (!workstation_name_slash) {
 		DEBUG(0, ("talloc_asprintf failed!\n"));
 		return NT_STATUS_NO_MEMORY;
@@ -674,8 +792,6 @@ NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli, TALLOC_CTX *mem_c
 
 	/* Initialise input parameters */
 
-	gen_next_creds(cli, &clnt_creds);
-
 	q.validation_level = validation_level;
 
 	if (ret_creds == NULL)
@@ -689,14 +805,14 @@ NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli, TALLOC_CTX *mem_c
 		      username, workstation_name_slash, (const uchar*)chal,
 		      lm_response.data, lm_response.length, nt_response.data, nt_response.length);
  
-        init_sam_info(&q.sam_id, cli->srv_name_slash, global_myname(),
-                      &clnt_creds, ret_creds, NET_LOGON_TYPE,
+        init_sam_info(&q.sam_id, server_name_slash, global_myname(),
+                      clnt_creds, ret_creds, NET_LOGON_TYPE,
                       &ctr);
 
         /* Marshall data and send request */
 
 	if (!net_io_q_sam_logon("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_NETLOGON, NET_SAMLOGON, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, NET_SAMLOGON, &qbuf, &rbuf)) {
 		goto done;
 	}
 
@@ -709,7 +825,7 @@ NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli, TALLOC_CTX *mem_c
 	}
 
 	ZERO_STRUCT(netlogon_sess_key);
-	memcpy(netlogon_sess_key, cli->sess_key, 8);
+	memcpy(netlogon_sess_key, session_key, 8);
 	
 	if (memcmp(zeros, info3->user_sess_key, 16) != 0) {
 		SamOEMhash(info3->user_sess_key, netlogon_sess_key, 16);
@@ -740,6 +856,30 @@ NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli, TALLOC_CTX *mem_c
         return result;
 }
 
+NTSTATUS cli_netlogon_sam_network_logon(struct cli_state *cli,
+					TALLOC_CTX *mem_ctx,
+					DOM_CRED *ret_creds,
+					const char *username,
+					const char *domain,
+					const char *workstation, 
+					const uint8 chal[8], 
+					DATA_BLOB lm_response,
+					DATA_BLOB nt_response,
+					NET_USER_INFO_3 *info3)
+{
+	DOM_CRED clnt_creds;
+
+	gen_next_creds(cli, &clnt_creds);
+
+	return rpccli_netlogon_sam_network_logon(&cli->pipes[PI_NETLOGON],
+						 mem_ctx, cli->srv_name_slash,
+						 &clnt_creds,
+						 ret_creds, username,
+						 domain, workstation, chal, 
+						 lm_response, nt_response,
+						 info3, cli->sess_key);
+}
+
 /***************************************************************************
 LSA Server Password Set.
 ****************************************************************************/
diff --git a/source3/rpc_client/cli_pipe.c b/source3/rpc_client/cli_pipe.c
index 8f6576a165..5f34fbde5d 100644
--- a/source3/rpc_client/cli_pipe.c
+++ b/source3/rpc_client/cli_pipe.c
@@ -62,7 +62,8 @@ static uint32 get_rpc_call_id(void)
  Use SMBreadX to get rest of one fragment's worth of rpc data.
  ********************************************************************/
 
-static BOOL rpc_read(struct cli_state *cli, int pipe_idx, prs_struct *rdata, uint32 data_to_read, uint32 *rdata_offset)
+static BOOL rpc_read(struct rpc_pipe_client *cli, prs_struct *rdata,
+		     uint32 data_to_read, uint32 *rdata_offset)
 {
 	size_t size = (size_t)cli->max_recv_frag;
 	int stream_offset = 0;
@@ -95,13 +96,14 @@ static BOOL rpc_read(struct cli_state *cli, int pipe_idx, prs_struct *rdata, uin
 		if (size > (size_t)data_to_read)
 			size = (size_t)data_to_read;
 
-		num_read = (int)cli_read(cli, cli->nt_pipe_fnum[pipe_idx], pdata, (off_t)stream_offset, size);
+		num_read = (int)cli_read(cli->cli, cli->fnum, pdata,
+					 (off_t)stream_offset, size);
 
 		DEBUG(5,("rpc_read: num_read = %d, read offset: %d, to read: %d\n",
 		          num_read, stream_offset, data_to_read));
 
-		if (cli_is_dos_error(cli)) {
-                        cli_dos_error(cli, &eclass, &ecode);
+		if (cli_is_dos_error(cli->cli)) {
+                        cli_dos_error(cli->cli, &eclass, &ecode);
                         if (eclass != ERRDOS && ecode != ERRmoredata) {
                                 DEBUG(0,("rpc_read: Error %d/%u in cli_read\n",
                                          eclass, (unsigned int)ecode));
@@ -168,7 +170,7 @@ static BOOL rpc_check_hdr(prs_struct *rdata, RPC_HDR *rhdr,
  Never on bind requests/responses.
  ****************************************************************************/
 
-static BOOL rpc_auth_pipe(struct cli_state *cli, prs_struct *rdata,
+static BOOL rpc_auth_pipe(struct rpc_pipe_client *cli, prs_struct *rdata,
 			  uint32 fragment_start, int len, int auth_len, uint8 pkt_type,
 			  int *pauth_padding_len)
 {
@@ -219,7 +221,7 @@ static BOOL rpc_auth_pipe(struct cli_state *cli, prs_struct *rdata,
 	DEBUG(10,("rpc_auth_pipe: packet:\n"));
 	dump_data(100, dp, auth_len);
 
-	prs_init(&auth_verf, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&auth_verf, 0, cli->cli->mem_ctx, UNMARSHALL);
 	
 	/* The endinness must be preserved. JRA. */
 	prs_set_endian_data( &auth_verf, rdata->bigendian_data);
@@ -394,7 +396,7 @@ static BOOL rpc_auth_pipe(struct cli_state *cli, prs_struct *rdata,
 
  ****************************************************************************/
 
-static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data, prs_struct *rdata,
+static BOOL rpc_api_pipe(struct rpc_pipe_client *cli, prs_struct *data, prs_struct *rdata,
 			 uint8 expected_pkt_type)
 {
 	uint32 len;
@@ -416,23 +418,24 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 	/* Create setup parameters - must be in native byte order. */
 
 	setup[0] = TRANSACT_DCERPCCMD; 
-	setup[1] = cli->nt_pipe_fnum[pipe_idx]; /* Pipe file handle. */
+	setup[1] = cli->fnum; /* Pipe file handle. */
 
-	DEBUG(5,("rpc_api_pipe: fnum:%x\n", (int)cli->nt_pipe_fnum[pipe_idx]));
+	DEBUG(5,("rpc_api_pipe: fnum:%x\n", (int)cli->fnum));
 
 	/* Send the RPC request and receive a response.  For short RPC
 	   calls (about 1024 bytes or so) the RPC request and response
 	   appears in a SMBtrans request and response.  Larger RPC
 	   responses are received further on. */
 
-	if (!cli_api_pipe(cli, "\\PIPE\\",
+	if (!cli_api_pipe(cli->cli, "\\PIPE\\",
 	          setup, 2, 0,                     /* Setup, length, max */
 	          NULL, 0, 0,                      /* Params, length, max */
 	          pdata, data_len, max_data,   	   /* data, length, max */
 	          &rparam, &rparam_len,            /* return params, len */
 	          &prdata, &rdata_len))            /* return data, len */
 	{
-		DEBUG(0, ("cli_pipe: return critical error. Error was %s\n", cli_errstr(cli)));
+		DEBUG(0, ("cli_pipe: return critical error. Error was %s\n",
+			  cli_errstr(cli->cli)));
 		return False;
 	}
 
@@ -442,7 +445,7 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 
 	if (prdata == NULL) {
 		DEBUG(0,("rpc_api_pipe: pipe %x failed to return data.\n",
-			(int)cli->nt_pipe_fnum[pipe_idx]));
+			(int)cli->fnum));
 		return False;
 	}
 
@@ -470,7 +473,7 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 	}
 
 	if (rhdr.pkt_type == RPC_BINDNACK) {
-		DEBUG(3, ("Bind NACK received on pipe %x!\n", (int)cli->nt_pipe_fnum[pipe_idx]));
+		DEBUG(3, ("Bind NACK received on pipe %x!\n", (int)cli->fnum));
 		prs_mem_free(rdata);
 		return False;
 	}
@@ -485,7 +488,9 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 	}
 
 	if (rhdr.pkt_type != expected_pkt_type) {
-		DEBUG(3, ("Connection to pipe %x got an unexpected RPC packet type - %d, not %d\n", (int)cli->nt_pipe_fnum[pipe_idx], rhdr.pkt_type, expected_pkt_type));
+		DEBUG(3, ("Connection to pipe %x got an unexpected RPC packet "
+			  "type - %d, not %d\n", (int)cli->fnum,
+			  rhdr.pkt_type, expected_pkt_type));
 		prs_mem_free(rdata);
 		return False;
 	}
@@ -502,7 +507,7 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 
 		/* Read the remaining part of the first response fragment */
 
-		if (!rpc_read(cli, pipe_idx, rdata, len, &current_offset)) {
+		if (!rpc_read(cli, rdata, len, &current_offset)) {
 			prs_mem_free(rdata);
 			return False;
 		}
@@ -554,12 +559,13 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 		 * First read the header of the next PDU.
 		 */
 
-		prs_init(&hps, 0, cli->mem_ctx, UNMARSHALL);
+		prs_init(&hps, 0, cli->cli->mem_ctx, UNMARSHALL);
 		prs_give_memory(&hps, hdr_data, sizeof(hdr_data), False);
 
-		num_read = cli_read(cli, cli->nt_pipe_fnum[pipe_idx], hdr_data, 0, RPC_HEADER_LEN+RPC_HDR_RESP_LEN);
-		if (cli_is_dos_error(cli)) {
-                        cli_dos_error(cli, &eclass, &ecode);
+		num_read = cli_read(cli->cli, cli->fnum, hdr_data, 0,
+				    RPC_HEADER_LEN+RPC_HDR_RESP_LEN);
+		if (cli_is_dos_error(cli->cli)) {
+                        cli_dos_error(cli->cli, &eclass, &ecode);
                         if (eclass != ERRDOS && ecode != ERRmoredata) {
                                 DEBUG(0,("rpc_api_pipe: cli_read error : %d/%d\n", eclass, ecode));
                                 return False;
@@ -602,7 +608,7 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 		 * Now read the rest of the PDU.
 		 */
 
-		if (!rpc_read(cli, pipe_idx, rdata, len, &current_offset)) {
+		if (!rpc_read(cli, rdata, len, &current_offset)) {
 			prs_mem_free(rdata);
 			return False;
 		}
@@ -644,7 +650,8 @@ static BOOL rpc_api_pipe(struct cli_state *cli, int pipe_idx, prs_struct *data,
 
  ********************************************************************/
 
-static NTSTATUS create_rpc_bind_req(struct cli_state *cli, prs_struct *rpc_out, 
+static NTSTATUS create_rpc_bind_req(struct rpc_pipe_client *cli,
+				    prs_struct *rpc_out, 
 				    uint32 rpc_call_id,
 				    RPC_IFACE *abstract, RPC_IFACE *transfer,
 				    const char *my_name, const char *domain)
@@ -783,7 +790,7 @@ static NTSTATUS create_rpc_bind_req(struct cli_state *cli, prs_struct *rpc_out,
  the authentication handshake.
  ********************************************************************/
 
-static NTSTATUS create_rpc_bind_resp(struct cli_state *cli,
+static NTSTATUS create_rpc_bind_resp(struct rpc_pipe_client *cli,
 				 uint32 rpc_call_id,
 				 prs_struct *rpc_out)
 {
@@ -916,8 +923,8 @@ static BOOL create_auth_hdr(prs_struct *outgoing_packet,
  * @param rdata Unparsed NDR response data.
 **/
 
-BOOL rpc_api_pipe_req(struct cli_state *cli, int pipe_idx, uint8 op_num,
-                      prs_struct *data, prs_struct *rdata)
+BOOL rpc_api_pipe_req_int(struct rpc_pipe_client *cli, uint8 op_num,
+			  prs_struct *data, prs_struct *rdata)
 {
 	uint32 auth_len, real_auth_len, auth_hdr_len, max_data, data_left, data_sent;
 	NTSTATUS nt_status;
@@ -959,7 +966,7 @@ BOOL rpc_api_pipe_req(struct cli_state *cli, int pipe_idx, uint8 op_num,
 		send_size = MIN(data_left, max_data);
 
 		if (!prs_init(&sec_blob, send_size, /* will need at least this much */
-			      cli->mem_ctx, MARSHALL)) {
+			      cli->cli->mem_ctx, MARSHALL)) {
 			DEBUG(0,("Could not malloc %u bytes",
 				 send_size+auth_padding));
 			return False;
@@ -1066,7 +1073,7 @@ BOOL rpc_api_pipe_req(struct cli_state *cli, int pipe_idx, uint8 op_num,
 		 * Malloc parse struct to hold it (and enough for alignments).
 		 */
 		if(!prs_init(&outgoing_packet, data_len + 8, 
-			     cli->mem_ctx, MARSHALL)) {
+			     cli->cli->mem_ctx, MARSHALL)) {
 			DEBUG(0,("rpc_api_pipe_req: Failed to malloc %u bytes.\n", (unsigned int)data_len ));
 			return False;
 		}
@@ -1095,10 +1102,10 @@ BOOL rpc_api_pipe_req(struct cli_state *cli, int pipe_idx, uint8 op_num,
 			   prs_offset(&outgoing_packet)));
 		
 		if (flags & RPC_FLG_LAST)
-			ret = rpc_api_pipe(cli, pipe_idx, &outgoing_packet, 
+			ret = rpc_api_pipe(cli, &outgoing_packet, 
 					   rdata, RPC_RESPONSE);
 		else {
-			cli_write(cli, cli->nt_pipe_fnum[pipe_idx], 0x0008,
+			cli_write(cli->cli, cli->fnum, 0x0008,
 				   prs_data_p(&outgoing_packet),
 				   data_sent, data_len);
 		}
@@ -1108,17 +1115,26 @@ BOOL rpc_api_pipe_req(struct cli_state *cli, int pipe_idx, uint8 op_num,
 	}
 	/* Also capture received data */
 	slprintf(dump_name, sizeof(dump_name) - 1, "reply_%s",
-		 cli_pipe_get_name(cli));
+		 cli_pipe_get_name(cli->cli));
 	prs_dump(dump_name, op_num, rdata);
 
 	return ret;
 }
 
+BOOL rpc_api_pipe_req(struct cli_state *cli, int pipe_idx, uint8 op_num,
+                      prs_struct *data, prs_struct *rdata)
+{
+	return rpc_api_pipe_req_int(&cli->pipes[pipe_idx], op_num,
+				    data, rdata);
+}
+
+
 /****************************************************************************
  Set the handle state.
 ****************************************************************************/
 
-static BOOL rpc_pipe_set_hnd_state(struct cli_state *cli, int pipe_idx, const char *pipe_name, uint16 device_state)
+static BOOL rpc_pipe_set_hnd_state(struct rpc_pipe_client *cli,
+				   const char *pipe_name, uint16 device_state)
 {
 	BOOL state_set = False;
 	char param[2];
@@ -1131,17 +1147,17 @@ static BOOL rpc_pipe_set_hnd_state(struct cli_state *cli, int pipe_idx, const ch
 		return False;
 
 	DEBUG(5,("Set Handle state Pipe[%x]: %s - device state:%x\n",
-	cli->nt_pipe_fnum[pipe_idx], pipe_name, device_state));
+		 cli->fnum, pipe_name, device_state));
 
 	/* create parameters: device state */
 	SSVAL(param, 0, device_state);
 
 	/* create setup parameters. */
 	setup[0] = 0x0001; 
-	setup[1] = cli->nt_pipe_fnum[pipe_idx]; /* pipe file handle.  got this from an SMBOpenX. */
+	setup[1] = cli->fnum; /* pipe file handle.  got this from an SMBOpenX. */
 
 	/* send the data on \PIPE\ */
-	if (cli_api_pipe(cli, "\\PIPE\\",
+	if (cli_api_pipe(cli->cli, "\\PIPE\\",
 	            setup, 2, 0,                /* setup, length, max */
 	            param, 2, 0,                /* param, length, max */
 	            NULL, 0, 1024,              /* data, length, max */
@@ -1281,20 +1297,21 @@ static BOOL check_bind_response(RPC_HDR_BA *hdr_ba, const int pipe_idx, RPC_IFAC
  Create and send the third packet in an RPC auth.
 ****************************************************************************/
 
-static BOOL rpc_send_auth_reply(struct cli_state *cli, int pipe_idx, prs_struct *rdata, uint32 rpc_call_id)
+static BOOL rpc_send_auth_reply(struct rpc_pipe_client *cli,
+				prs_struct *rdata, uint32 rpc_call_id)
 {
 	prs_struct rpc_out;
 	ssize_t ret;
 
 	prs_init(&rpc_out, RPC_HEADER_LEN + RPC_HDR_AUTHA_LEN, /* need at least this much */ 
-		 cli->mem_ctx, MARSHALL);
+		 cli->cli->mem_ctx, MARSHALL);
 
 	if (!NT_STATUS_IS_OK(create_rpc_bind_resp(cli, rpc_call_id,
 						  &rpc_out))) {
 		return False;
 	}
 
-	if ((ret = cli_write(cli, cli->nt_pipe_fnum[pipe_idx], 0x8, prs_data_p(&rpc_out), 
+	if ((ret = cli_write(cli->cli, cli->fnum, 0x8, prs_data_p(&rpc_out), 
 			0, (size_t)prs_offset(&rpc_out))) != (ssize_t)prs_offset(&rpc_out)) {
 		DEBUG(0,("rpc_send_auth_reply: cli_write failed. Return was %d\n", (int)ret));
 		prs_mem_free(&rpc_out);
@@ -1309,7 +1326,7 @@ static BOOL rpc_send_auth_reply(struct cli_state *cli, int pipe_idx, prs_struct
  Do an rpc bind.
 ****************************************************************************/
 
-static BOOL rpc_pipe_bind(struct cli_state *cli, int pipe_idx, const char *my_name)
+static BOOL rpc_pipe_bind(struct rpc_pipe_client *cli)
 {
 	RPC_IFACE abstract;
 	RPC_IFACE transfer;
@@ -1318,15 +1335,16 @@ static BOOL rpc_pipe_bind(struct cli_state *cli, int pipe_idx, const char *my_na
 	uint32 rpc_call_id;
 	char buffer[MAX_PDU_FRAG_LEN];
 
-	if ( (pipe_idx < 0) || (pipe_idx >= PI_MAX_PIPES) )
+	if ( (cli->pipe_idx < 0) || (cli->pipe_idx >= PI_MAX_PIPES) )
 		return False;
 
-	DEBUG(5,("Bind RPC Pipe[%x]: %s\n", cli->nt_pipe_fnum[pipe_idx], pipe_names[pipe_idx].client_pipe));
+	DEBUG(5,("Bind RPC Pipe[%x]: %s\n", cli->fnum,
+		 pipe_names[cli->pipe_idx].client_pipe));
 
-	if (!valid_pipe_name(pipe_idx, &abstract, &transfer))
+	if (!valid_pipe_name(cli->pipe_idx, &abstract, &transfer))
 		return False;
 
-	prs_init(&rpc_out, 0, cli->mem_ctx, MARSHALL);
+	prs_init(&rpc_out, 0, cli->cli->mem_ctx, MARSHALL);
 
 	/*
 	 * Use the MAX_PDU_FRAG_LEN buffer to store the bind request.
@@ -1391,10 +1409,10 @@ static BOOL rpc_pipe_bind(struct cli_state *cli, int pipe_idx, const char *my_na
 	                    global_myname(), cli->domain);
 
 	/* Initialize the incoming data struct. */
-	prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
+	prs_init(&rdata, 0, cli->cli->mem_ctx, UNMARSHALL);
 
 	/* send data on \PIPE\.  receive a response */
-	if (rpc_api_pipe(cli, pipe_idx, &rpc_out, &rdata, RPC_BINDACK)) {
+	if (rpc_api_pipe(cli, &rpc_out, &rdata, RPC_BINDACK)) {
 		RPC_HDR_BA   hdr_ba;
 
 		DEBUG(5, ("rpc_pipe_bind: rpc_api_pipe returned OK.\n"));
@@ -1405,7 +1423,7 @@ static BOOL rpc_pipe_bind(struct cli_state *cli, int pipe_idx, const char *my_na
 			return False;
 		}
 
-		if(!check_bind_response(&hdr_ba, pipe_idx, &transfer)) {
+		if(!check_bind_response(&hdr_ba, cli->pipe_idx, &transfer)) {
 			DEBUG(2,("rpc_pipe_bind: check_bind_response failed.\n"));
 			prs_mem_free(&rdata);
 			return False;
@@ -1421,7 +1439,7 @@ static BOOL rpc_pipe_bind(struct cli_state *cli, int pipe_idx, const char *my_na
 		 */
 
 		if ((cli->pipe_auth_flags & AUTH_PIPE_NTLMSSP) 
-		    && !rpc_send_auth_reply(cli, pipe_idx, &rdata, rpc_call_id)) {
+		    && !rpc_send_auth_reply(cli, &rdata, rpc_call_id)) {
 			DEBUG(0,("rpc_pipe_bind: rpc_send_auth_reply failed.\n"));
 			prs_mem_free(&rdata);
 			return False;
@@ -1440,11 +1458,9 @@ static BOOL rpc_pipe_bind(struct cli_state *cli, int pipe_idx, const char *my_na
 BOOL cli_nt_session_open(struct cli_state *cli, const int pipe_idx)
 {
 	int fnum;
+	struct rpc_pipe_client *cli_pipe;
 
-	/* At the moment we can't have more than one pipe open over
-           a cli connection. )-: */
-
-	SMB_ASSERT(cli->nt_pipe_fnum[pipe_idx] == 0);
+	SMB_ASSERT(cli->pipes[pipe_idx].fnum == 0);
 	
 	/* The pipe index must fall within our array */
 
@@ -1457,7 +1473,7 @@ BOOL cli_nt_session_open(struct cli_state *cli, const int pipe_idx)
 			return False;
 		}
 
-		cli->nt_pipe_fnum[pipe_idx] = (uint16)fnum;
+		cli->pipes[pipe_idx].fnum = (uint16)fnum;
 	} else {
 		if ((fnum = cli_open(cli, pipe_names[pipe_idx].client_pipe, O_CREAT|O_RDWR, DENY_NONE)) == -1) {
 			DEBUG(1,("cli_nt_session_open: cli_open failed on pipe %s to machine %s.  Error was %s\n",
@@ -1465,25 +1481,32 @@ BOOL cli_nt_session_open(struct cli_state *cli, const int pipe_idx)
 			return False;
 		}
 
-		cli->nt_pipe_fnum[pipe_idx] = (uint16)fnum;
+		cli->pipes[pipe_idx].fnum = (uint16)fnum;
 
 		/**************** Set Named Pipe State ***************/
-		if (!rpc_pipe_set_hnd_state(cli, pipe_idx, pipe_names[pipe_idx].client_pipe, 0x4300)) {
+		if (!rpc_pipe_set_hnd_state(&cli->pipes[pipe_idx], pipe_names[pipe_idx].client_pipe, 0x4300)) {
 			DEBUG(0,("cli_nt_session_open: pipe hnd state failed.  Error was %s\n",
 				  cli_errstr(cli)));
-			cli_close(cli, cli->nt_pipe_fnum[pipe_idx]);
-			cli->nt_pipe_fnum[pipe_idx] = 0;
+			cli_close(cli, cli->pipes[pipe_idx].fnum);
+			cli->pipes[pipe_idx].fnum = 0;
 			return False;
 		}
 	}
 
+	cli_pipe = &cli->pipes[pipe_idx];
+	cli_pipe->pipe_idx = pipe_idx;
+	cli_pipe->cli = cli;
+	cli_pipe->pipe_auth_flags = cli->pipe_auth_flags;
+	memcpy(&cli_pipe->auth_info.sess_key,
+	       cli->sess_key, sizeof(cli->sess_key));
+
 	/******************* bind request on pipe *****************/
 
-	if (!rpc_pipe_bind(cli, pipe_idx, global_myname())) {
+	if (!rpc_pipe_bind(&cli->pipes[pipe_idx])) {
 		DEBUG(2,("cli_nt_session_open: rpc bind to %s failed\n",
 			 get_pipe_name_from_index(pipe_idx)));
-		cli_close(cli, cli->nt_pipe_fnum[pipe_idx]);
-		cli->nt_pipe_fnum[pipe_idx] = 0;
+		cli_close(cli, cli->pipes[pipe_idx].fnum);
+		cli->pipes[pipe_idx].fnum = 0;
 		return False;
 	}
 
@@ -1523,7 +1546,6 @@ NTSTATUS cli_nt_establish_netlogon(struct cli_state *cli, int sec_chan,
 {
 	NTSTATUS result;	
 	uint32 neg_flags = NETLOGON_NEG_AUTH2_FLAGS;
-	int fnum;
 
 	cli_nt_netlogon_netsec_session_close(cli);
 
@@ -1554,60 +1576,20 @@ NTSTATUS cli_nt_establish_netlogon(struct cli_state *cli, int sec_chan,
 
 	}
 
-	/* Server offered schannel, so try it. */
+	cli->netlogon_pipe = cli->pipes[PI_NETLOGON];
+	ZERO_STRUCT(cli->pipes[PI_NETLOGON]);
 
-	memcpy(cli->auth_info.sess_key, cli->sess_key,
-	       sizeof(cli->auth_info.sess_key));
+	/* Server offered schannel, so try it. */
 
-	cli->saved_netlogon_pipe_fnum = cli->nt_pipe_fnum[PI_NETLOGON];
+	memcpy(cli->pipes[PI_NETLOGON].auth_info.sess_key, cli->sess_key,
+	       sizeof(cli->pipes[PI_NETLOGON].auth_info.sess_key));
 
 	cli->pipe_auth_flags = AUTH_PIPE_NETSEC;
 	cli->pipe_auth_flags |= AUTH_PIPE_SIGN;
 	cli->pipe_auth_flags |= AUTH_PIPE_SEAL;
 
-	if (cli->capabilities & CAP_NT_SMBS) {
-
-		/* The secure channel connection must be opened on the same 
-                   session (TCP connection) as the one the challenge was
-                   requested from. */
-		if ((fnum = cli_nt_create(cli, PIPE_NETLOGON_PLAIN,
-					  DESIRED_ACCESS_PIPE)) == -1) {
-			DEBUG(0,("cli_nt_create failed to %s machine %s. "
-				 "Error was %s\n",
-				 PIPE_NETLOGON, cli->desthost,
-				 cli_errstr(cli)));
-			return NT_STATUS_UNSUCCESSFUL;
-		}
-		
-		cli->nt_pipe_fnum[PI_NETLOGON] = (uint16)fnum;
-	} else {
-		if ((fnum = cli_open(cli, PIPE_NETLOGON,
-				     O_CREAT|O_RDWR, DENY_NONE)) == -1) {
-			DEBUG(0,("cli_open failed on pipe %s to machine %s. "
-				 "Error was %s\n",
-				 PIPE_NETLOGON, cli->desthost,
-				 cli_errstr(cli)));
-			return NT_STATUS_UNSUCCESSFUL;
-		}
-
-		cli->nt_pipe_fnum[PI_NETLOGON] = (uint16)fnum;
-
-		/**************** Set Named Pipe State ***************/
-		if (!rpc_pipe_set_hnd_state(cli, PI_NETLOGON, PIPE_NETLOGON, 0x4300)) {
-			DEBUG(0,("Pipe hnd state failed.  Error was %s\n",
-				  cli_errstr(cli)));
-			cli_close(cli, cli->nt_pipe_fnum[PI_NETLOGON]);
-			return NT_STATUS_UNSUCCESSFUL;
-		}
-	}
-	
-	if (!rpc_pipe_bind(cli, PI_NETLOGON, global_myname())) {
-		DEBUG(2,("rpc bind to %s failed\n", PIPE_NETLOGON));
-		cli_close(cli, cli->nt_pipe_fnum[PI_NETLOGON]);
-		return NT_STATUS_UNSUCCESSFUL;
-	}
-
-	return NT_STATUS_OK;
+	return cli_nt_session_open(cli, PI_NETLOGON) ?
+		NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 }
 
 
@@ -1640,19 +1622,20 @@ NTSTATUS cli_nt_setup_netsec(struct cli_state *cli, int sec_chan, int auth_flags
 	}
 
 	if (!NT_STATUS_IS_OK(result)) {
-		ZERO_STRUCT(cli->auth_info.sess_key);
+		ZERO_STRUCT(cli->pipes[cli->pipe_idx].auth_info.sess_key);
 		ZERO_STRUCT(cli->sess_key);
 		cli->pipe_auth_flags = 0;
 		cli_nt_session_close(cli);
 		return result;
 	}
 
-	memcpy(cli->auth_info.sess_key, cli->sess_key,
-	       sizeof(cli->auth_info.sess_key));
-
-	cli->saved_netlogon_pipe_fnum = cli->nt_pipe_fnum[PI_NETLOGON];
-	cli->nt_pipe_fnum[PI_NETLOGON] = 0;
+	memcpy(cli->pipes[PI_NETLOGON].auth_info.sess_key, cli->sess_key,
+	       sizeof(cli->pipes[PI_NETLOGON].auth_info.sess_key));
 
+	cli_close(cli, cli->pipes[PI_NETLOGON].fnum);
+	cli->pipes[PI_NETLOGON].fnum = 0;
+	cli->pipe_idx = -1;
+	
 	/* doing schannel, not per-user auth */
 	cli->pipe_auth_flags = auth_flags;
 
@@ -1664,4 +1647,124 @@ const char *cli_pipe_get_name(struct cli_state *cli)
 	return cli->pipe_name;
 }
 
+static struct rpc_pipe_client *cli_rpc_open(struct cli_state *cli,
+					    int pipe_idx)
+{
+	TALLOC_CTX *mem_ctx;
+	struct rpc_pipe_client *result;
+	int fnum;
+
+	/* The pipe index must fall within our array */
+	SMB_ASSERT((pipe_idx >= 0) && (pipe_idx < PI_MAX_PIPES));
+
+	mem_ctx = talloc_init("struct rpc_pipe_client");
+	if (mem_ctx == NULL) return NULL;
+
+	result = TALLOC_P(mem_ctx, struct rpc_pipe_client);
+	if (result == NULL) return NULL;
+
+	result->mem_ctx = mem_ctx;
+
+	fnum = cli_nt_create(cli, &pipe_names[pipe_idx].client_pipe[5],
+			     DESIRED_ACCESS_PIPE);
+
+	if (fnum == -1) {
+		DEBUG(0,("cli_rpc_open failed on pipe %s "
+			 "to machine %s.  Error was %s\n",
+			 &pipe_names[pipe_idx].client_pipe[5], cli->desthost,
+			 cli_errstr(cli)));
+		talloc_destroy(result->mem_ctx);
+		return NULL;
+	}
+
+	result->fnum = fnum;
+	result->cli = cli;
+	result->pipe_idx = pipe_idx;
+
+	return result;
+}
+
+struct rpc_pipe_client *cli_rpc_open_noauth(struct cli_state *cli,
+					    int pipe_idx)
+{
+	struct rpc_pipe_client *result;
+
+	result = cli_rpc_open(cli, pipe_idx);
+	if (result == NULL) return NULL;
+
+	result->max_xmit_frag = 0;
+	result->pipe_auth_flags = 0;
+
+	if (!rpc_pipe_bind(result)) {
+		DEBUG(0, ("rpc_pipe_bind failed\n"));
+		talloc_destroy(result->mem_ctx);
+		return NULL;
+	}
+
+	return result;
+}
+
+struct rpc_pipe_client *cli_rpc_open_ntlmssp(struct cli_state *cli,
+					     int pipe_idx,
+					     const char *domain,
+					     const char *username,
+					     const char *password)
+{
+	struct rpc_pipe_client *result;
+
+	result = cli_rpc_open(cli, pipe_idx);
+	if (result == NULL) return NULL;
+	
+	result->max_xmit_frag = 0;
+	result->pipe_auth_flags =
+		AUTH_PIPE_NTLMSSP|AUTH_PIPE_SIGN|AUTH_PIPE_SEAL;
+	result->domain = domain;
+	result->user_name = username;
+	pwd_set_cleartext(&result->pwd, password);
+
+	if (!rpc_pipe_bind(result)) {
+		DEBUG(0, ("cli_rpc_pipe_bind failed\n"));
+		talloc_destroy(result->mem_ctx);
+		return NULL;
+	}
+
+	return result;
+}
+
+struct rpc_pipe_client *cli_rpc_open_schannel(struct cli_state *cli,
+					      int pipe_idx,
+					      const uchar session_key[16],
+					      const char *domain)
+{
+	struct rpc_pipe_client *result;
+
+	result = cli_rpc_open(cli, pipe_idx);
+	if (result == NULL) return NULL;
+	
+	result->max_xmit_frag = 0;
+	result->pipe_auth_flags =
+		AUTH_PIPE_NETSEC | AUTH_PIPE_SIGN | AUTH_PIPE_SEAL;
+	result->domain = domain;
+	memcpy(result->auth_info.sess_key, session_key, 16);
+
+	if (!rpc_pipe_bind(result)) {
+		DEBUG(0, ("cli_rpc_pipe_bind failed\n"));
+		talloc_destroy(result->mem_ctx);
+		return NULL;
+	}
+
+	return result;
+}
+
+void cli_rpc_close(struct rpc_pipe_client *cli_pipe)
+{
+	if (!cli_close(cli_pipe->cli, cli_pipe->fnum))
+		DEBUG(0,("cli_rpc_open failed on pipe %s "
+			 "to machine %s.  Error was %s\n",
+			 &pipe_names[cli_pipe->pipe_idx].client_pipe[5],
+			 cli_pipe->cli->desthost,
+			 cli_errstr(cli_pipe->cli)));
+
+	talloc_destroy(cli_pipe->mem_ctx);	
+}
 
diff --git a/source3/rpc_client/cli_samr.c b/source3/rpc_client/cli_samr.c
index 45f9bd67a5..01ec0bd51e 100644
--- a/source3/rpc_client/cli_samr.c
+++ b/source3/rpc_client/cli_samr.c
@@ -27,15 +27,15 @@
 
 /* Connect to SAMR database */
 
-NTSTATUS cli_samr_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-                          uint32 access_mask, POLICY_HND *connect_pol)
+NTSTATUS rpccli_samr_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, 
+			     uint32 access_mask, POLICY_HND *connect_pol)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_CONNECT q;
 	SAMR_R_CONNECT r;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	DEBUG(10,("cli_samr_connect to %s\n", cli->desthost));
+	DEBUG(10,("cli_samr_connect to %s\n", cli->cli->desthost));
 
 	ZERO_STRUCT(q);
 	ZERO_STRUCT(r);
@@ -47,10 +47,10 @@ NTSTATUS cli_samr_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 	/* Marshall data and send request */
 
-	init_samr_q_connect(&q, cli->desthost, access_mask);
+	init_samr_q_connect(&q, cli->cli->desthost, access_mask);
 
 	if (!samr_io_q_connect("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_CONNECT, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_CONNECT, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -74,6 +74,12 @@ NTSTATUS cli_samr_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                          uint32 access_mask, POLICY_HND *connect_pol)
+{
+	return rpccli_samr_connect(&cli->pipes[PI_SAMR], mem_ctx,
+				   access_mask, connect_pol);
+}
 /* Connect to SAMR database */
 
 NTSTATUS cli_samr_connect4(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
@@ -125,8 +131,8 @@ NTSTATUS cli_samr_connect4(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* Close SAMR handle */
 
-NTSTATUS cli_samr_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
-                        POLICY_HND *connect_pol)
+NTSTATUS rpccli_samr_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+			   POLICY_HND *connect_pol)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_CLOSE_HND q;
@@ -148,7 +154,7 @@ NTSTATUS cli_samr_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_close_hnd(&q, connect_pol);
 
 	if (!samr_io_q_close_hnd("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_CLOSE_HND, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_CLOSE_HND, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -172,11 +178,18 @@ NTSTATUS cli_samr_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_close(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                        POLICY_HND *connect_pol)
+{
+	return rpccli_samr_close(&cli->pipes[PI_SAMR], mem_ctx, connect_pol);
+}
+
 /* 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)
+NTSTATUS rpccli_samr_open_domain(struct rpc_pipe_client *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;
@@ -198,7 +211,7 @@ NTSTATUS cli_samr_open_domain(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	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, PI_SAMR, SAMR_OPEN_DOMAIN, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_OPEN_DOMAIN, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -224,9 +237,21 @@ NTSTATUS cli_samr_open_domain(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* 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)
+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)
+{
+	return rpccli_samr_open_domain(&cli->pipes[PI_SAMR], mem_ctx,
+				       connect_pol, access_mask, domain_sid,
+				       domain_pol);
+}
+
+
+NTSTATUS rpccli_samr_open_user(struct rpc_pipe_client *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;
@@ -248,7 +273,7 @@ NTSTATUS cli_samr_open_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	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, PI_SAMR, SAMR_OPEN_USER, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_OPEN_USER, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -272,11 +297,21 @@ NTSTATUS cli_samr_open_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+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)
+{
+	return rpccli_samr_open_user(&cli->pipes[PI_SAMR], mem_ctx, domain_pol,
+				     access_mask, user_rid, user_pol);
+}
+
+
 /* 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)
+NTSTATUS rpccli_samr_open_group(struct rpc_pipe_client *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;
@@ -298,7 +333,7 @@ NTSTATUS cli_samr_open_group(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	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, PI_SAMR, SAMR_OPEN_GROUP, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_OPEN_GROUP, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -322,6 +357,15 @@ NTSTATUS cli_samr_open_group(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+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)
+{
+	return rpccli_samr_open_group(&cli->pipes[PI_SAMR], mem_ctx,
+				      domain_pol, access_mask, group_rid,
+				      group_pol);
+}
+
 /* Create domain group */
 
 NTSTATUS cli_samr_create_dom_group(struct cli_state *cli, TALLOC_CTX *mem_ctx,
@@ -461,9 +505,10 @@ NTSTATUS cli_samr_del_groupmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* 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)
+NTSTATUS rpccli_samr_query_userinfo(struct rpc_pipe_client *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;
@@ -485,7 +530,7 @@ NTSTATUS cli_samr_query_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_query_userinfo(&q, user_pol, switch_value);
 
 	if (!samr_io_q_query_userinfo("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_QUERY_USERINFO, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_QUERY_USERINFO, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -505,6 +550,14 @@ NTSTATUS cli_samr_query_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_query_userinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *user_pol, uint16 switch_value, 
+                                 SAM_USERINFO_CTR **ctr)
+{
+	return rpccli_samr_query_userinfo(&cli->pipes[PI_SAMR], mem_ctx,
+					  user_pol, switch_value, ctr);
+}
+
 /* Set group info */
 
 NTSTATUS cli_samr_set_groupinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
@@ -598,9 +651,11 @@ NTSTATUS cli_samr_query_groupinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* 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)
+NTSTATUS rpccli_samr_query_usergroups(struct rpc_pipe_client *cli,
+				      TALLOC_CTX *mem_ctx, 
+				      POLICY_HND *user_pol,
+				      uint32 *num_groups, 
+				      DOM_GID **gid)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_QUERY_USERGROUPS q;
@@ -622,7 +677,7 @@ NTSTATUS cli_samr_query_usergroups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_query_usergroups(&q, user_pol);
 
 	if (!samr_io_q_query_usergroups("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_QUERY_USERGROUPS, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_QUERY_USERGROUPS, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -644,6 +699,14 @@ NTSTATUS cli_samr_query_usergroups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_query_usergroups(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                                   POLICY_HND *user_pol, uint32 *num_groups, 
+                                   DOM_GID **gid)
+{
+	return rpccli_samr_query_usergroups(&cli->pipes[PI_SAMR], mem_ctx,
+					    user_pol, num_groups, gid);
+}
+
 /* Set alias info */
 
 NTSTATUS cli_samr_set_aliasinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
@@ -690,9 +753,11 @@ NTSTATUS cli_samr_set_aliasinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* Query user aliases */
 
-NTSTATUS cli_samr_query_useraliases(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-                                   POLICY_HND *dom_pol, uint32 num_sids, DOM_SID2 *sid,
-				   uint32 *num_aliases, uint32 **als_rids)
+NTSTATUS rpccli_samr_query_useraliases(struct rpc_pipe_client *cli,
+				       TALLOC_CTX *mem_ctx, 
+				       POLICY_HND *dom_pol, uint32 num_sids,
+				       DOM_SID2 *sid,
+				       uint32 *num_aliases, uint32 **als_rids)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_QUERY_USERALIASES q;
@@ -723,7 +788,7 @@ NTSTATUS cli_samr_query_useraliases(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_query_useraliases(&q, dom_pol, num_sids, sid_ptrs, sid);
 
 	if (!samr_io_q_query_useraliases("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_QUERY_USERALIASES, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_QUERY_USERALIASES, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -745,11 +810,24 @@ NTSTATUS cli_samr_query_useraliases(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_query_useraliases(struct cli_state *cli,
+				    TALLOC_CTX *mem_ctx, 
+				    POLICY_HND *dom_pol, uint32 num_sids,
+				    DOM_SID2 *sid,
+				    uint32 *num_aliases, uint32 **als_rids)
+{
+	return rpccli_samr_query_useraliases(&cli->pipes[PI_SAMR], mem_ctx,
+					     dom_pol, num_sids, sid,
+					     num_aliases, als_rids);
+}
+
+
 /* 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)
+NTSTATUS rpccli_samr_query_groupmem(struct rpc_pipe_client *cli,
+				    TALLOC_CTX *mem_ctx,
+				    POLICY_HND *group_pol, uint32 *num_mem, 
+				    uint32 **rid, uint32 **attr)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_QUERY_GROUPMEM q;
@@ -771,7 +849,7 @@ NTSTATUS cli_samr_query_groupmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_query_groupmem(&q, group_pol);
 
 	if (!samr_io_q_query_groupmem("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_QUERY_GROUPMEM, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_QUERY_GROUPMEM, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -794,6 +872,15 @@ NTSTATUS cli_samr_query_groupmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_query_groupmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+                                 POLICY_HND *group_pol, uint32 *num_mem, 
+                                 uint32 **rid, uint32 **attr)
+{
+	return rpccli_samr_query_groupmem(&cli->pipes[PI_SAMR], mem_ctx,
+					  group_pol, num_mem, rid, attr);
+}
+
+
 /**
  * Enumerate domain users
  *
@@ -892,10 +979,11 @@ done:
 
 /* 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)
+NTSTATUS rpccli_samr_enum_dom_groups(struct rpc_pipe_client *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;
@@ -918,7 +1006,7 @@ NTSTATUS cli_samr_enum_dom_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	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, PI_SAMR, SAMR_ENUM_DOM_GROUPS, &qbuf, &rbuf))
+	    !rpc_api_pipe_req_int(cli, SAMR_ENUM_DOM_GROUPS, &qbuf, &rbuf))
 		goto done;
 
 	/* Unmarshall response */
@@ -969,12 +1057,23 @@ NTSTATUS cli_samr_enum_dom_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+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)
+{
+	return rpccli_samr_enum_dom_groups(&cli->pipes[PI_SAMR], mem_ctx,
+					   pol, start_idx, size, dom_groups,
+					   num_dom_groups);
+}
+
 /* Enumerate domain groups */
 
-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_aliases,
-                                  uint32 *num_dom_aliases)
+NTSTATUS rpccli_samr_enum_als_groups(struct rpc_pipe_client *cli,
+				     TALLOC_CTX *mem_ctx, 
+				     POLICY_HND *pol, uint32 *start_idx, 
+				     uint32 size, struct acct_info **dom_aliases,
+				     uint32 *num_dom_aliases)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_ENUM_DOM_ALIASES q;
@@ -997,7 +1096,7 @@ NTSTATUS cli_samr_enum_als_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_enum_dom_aliases(&q, pol, *start_idx, size);
 
 	if (!samr_io_q_enum_dom_aliases("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_ENUM_DOM_ALIASES, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, SAMR_ENUM_DOM_ALIASES, &qbuf, &rbuf)) {
 		goto done;
 	}
 
@@ -1051,6 +1150,16 @@ NTSTATUS cli_samr_enum_als_groups(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+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_aliases,
+                                  uint32 *num_dom_aliases)
+{
+	return rpccli_samr_enum_als_groups(&cli->pipes[PI_SAMR], mem_ctx,
+					   pol, start_idx, size, dom_aliases,
+					   num_dom_aliases);
+}
+
 /* Query alias members */
 
 NTSTATUS cli_samr_query_aliasmem(struct cli_state *cli, TALLOC_CTX *mem_ctx,
@@ -1326,7 +1435,7 @@ NTSTATUS cli_samr_query_alias_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	SAMR_R_QUERY_ALIASINFO r;
 	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 
-	DEBUG(10,("cli_samr_query_dom_info\n"));
+	DEBUG(10,("cli_samr_query_alias_info\n"));
 
 	ZERO_STRUCT(q);
 	ZERO_STRUCT(r);
@@ -1368,9 +1477,11 @@ NTSTATUS cli_samr_query_alias_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 /* 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)
+NTSTATUS rpccli_samr_query_dom_info(struct rpc_pipe_client *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;
@@ -1392,7 +1503,7 @@ NTSTATUS cli_samr_query_dom_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	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, PI_SAMR, SAMR_QUERY_DOMAIN_INFO, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, SAMR_QUERY_DOMAIN_INFO, &qbuf, &rbuf)) {
 		goto done;
 	}
 
@@ -1417,12 +1528,21 @@ NTSTATUS cli_samr_query_dom_info(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+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)
+{
+	return rpccli_samr_query_dom_info(&cli->pipes[PI_SAMR], mem_ctx,
+					  domain_pol, switch_value, ctr);
+}
+
 /* User change password */
 
-NTSTATUS cli_samr_chgpasswd_user(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-				 const char *username, 
-				 const char *newpassword, 
-				 const char *oldpassword )
+NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli,
+				    TALLOC_CTX *mem_ctx, 
+				    const char *username, 
+				    const char *newpassword, 
+				    const char *oldpassword )
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_CHGPASSWD_USER q;
@@ -1477,14 +1597,14 @@ NTSTATUS cli_samr_chgpasswd_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 
 	/* Marshall data and send request */
 
-	init_samr_q_chgpasswd_user(&q, cli->srv_name_slash, username, 
+	init_samr_q_chgpasswd_user(&q, cli->cli->srv_name_slash, username, 
 				   new_nt_password, 
 				   old_nt_hash_enc, 
 				   new_lm_password,
 				   old_lanman_hash_enc);
 
 	if (!samr_io_q_chgpasswd_user("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_CHGPASSWD_USER, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, SAMR_CHGPASSWD_USER, &qbuf, &rbuf)) {
 		goto done;
 	}
 
@@ -1507,6 +1627,15 @@ NTSTATUS cli_samr_chgpasswd_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_chgpasswd_user(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+				 const char *username, 
+				 const char *newpassword, 
+				 const char *oldpassword )
+{
+	return rpccli_samr_chgpasswd_user(&cli->pipes[PI_SAMR], mem_ctx,
+					  username, newpassword, oldpassword);
+}
+
 /* This function returns the bizzare set of (max_entries, max_size) required
    for the QueryDisplayInfo RPC to actually work against a domain controller
    with large (10k and higher) numbers of users.  These values were 
@@ -1541,11 +1670,12 @@ void get_query_dispinfo_params(int loop_count, uint32 *max_entries,
 
 /* 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, uint32 max_size,
-				 SAM_DISPINFO_CTR *ctr)
+NTSTATUS rpccli_samr_query_dispinfo(struct rpc_pipe_client *cli,
+				    TALLOC_CTX *mem_ctx, 
+				    POLICY_HND *domain_pol, uint32 *start_idx,
+				    uint16 switch_value, uint32 *num_entries,
+				    uint32 max_entries, uint32 max_size,
+				    SAM_DISPINFO_CTR *ctr)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_QUERY_DISPINFO q;
@@ -1570,7 +1700,7 @@ NTSTATUS cli_samr_query_dispinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 				   *start_idx, max_entries, max_size);
 
 	if (!samr_io_q_query_dispinfo("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_QUERY_DISPINFO, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, SAMR_QUERY_DISPINFO, &qbuf, &rbuf)) {
 		goto done;
 	}
 
@@ -1601,14 +1731,26 @@ NTSTATUS cli_samr_query_dispinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+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, uint32 max_size,
+				 SAM_DISPINFO_CTR *ctr)
+{
+	return rpccli_samr_query_dispinfo(&cli->pipes[PI_SAMR], mem_ctx,
+					  domain_pol, start_idx, switch_value,
+					  num_entries, max_entries, max_size, ctr);
+}
+
 /* Lookup rids.  Note that NT4 seems to crash if more than ~1000 rids are
    looked up in one packet. */
 
-NTSTATUS cli_samr_lookup_rids(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
-                              POLICY_HND *domain_pol,
-                              uint32 num_rids, uint32 *rids, 
-                              uint32 *num_names, char ***names,
-                              uint32 **name_types)
+NTSTATUS rpccli_samr_lookup_rids(struct rpc_pipe_client *cli,
+				 TALLOC_CTX *mem_ctx, 
+				 POLICY_HND *domain_pol,
+				 uint32 num_rids, uint32 *rids, 
+				 uint32 *num_names, char ***names,
+				 uint32 **name_types)
 {
 	prs_struct qbuf, rbuf;
 	SAMR_Q_LOOKUP_RIDS q;
@@ -1636,7 +1778,7 @@ NTSTATUS cli_samr_lookup_rids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, 1000, num_rids, rids);
 
 	if (!samr_io_q_lookup_rids("", &q, &qbuf, 0) ||
-	    !rpc_api_pipe_req(cli, PI_SAMR, SAMR_LOOKUP_RIDS, &qbuf, &rbuf)) {
+	    !rpc_api_pipe_req_int(cli, SAMR_LOOKUP_RIDS, &qbuf, &rbuf)) {
 		goto done;
 	}
 
@@ -1679,6 +1821,17 @@ NTSTATUS cli_samr_lookup_rids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 	return result;
 }
 
+NTSTATUS cli_samr_lookup_rids(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
+                              POLICY_HND *domain_pol,
+                              uint32 num_rids, uint32 *rids, 
+                              uint32 *num_names, char ***names,
+                              uint32 **name_types)
+{
+	return rpccli_samr_lookup_rids(&cli->pipes[PI_SAMR], mem_ctx, 
+				       domain_pol, num_rids, rids, 
+				       num_names, names, name_types);
+}
+
 /* Lookup names */
 
 NTSTATUS cli_samr_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,