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.
+ Copyright (C) Jeremy Allison 2005.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
/* 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->cli->desthost));
+
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;
-
- /* Unmarshall response */
-
- if (!samr_io_r_connect("", &r, &rbuf, 0))
- goto done;
+ init_samr_q_connect(&q, cli->cli->desthost, access_mask);
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_connect,
+ samr_io_r_connect,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
if (NT_STATUS_IS_OK(result = r.status)) {
#endif
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* Connect to SAMR database */
-NTSTATUS cli_samr_connect4(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_samr_connect4(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
uint32 access_mask, POLICY_HND *connect_pol)
{
prs_struct qbuf, rbuf;
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_connect4(&q, cli->desthost, access_mask);
+ init_samr_q_connect4(&q, cli->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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT4,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_connect4,
+ samr_io_r_connect4,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
#endif
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* 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;
SAMR_R_CLOSE_HND r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_close\n"));
+
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_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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CLOSE_HND,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_close_hnd,
+ samr_io_r_close_hnd,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*connect_pol = r.pol;
}
- 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)
+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;
SAMR_R_OPEN_DOMAIN r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_open_domain with sid %s\n",
+ sid_string_dbg(domain_sid) ));
+
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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_DOMAIN,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_open_domain,
+ samr_io_r_open_domain,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
#endif
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
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)
+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;
SAMR_R_OPEN_USER r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_open_user with rid 0x%x\n", user_rid ));
+
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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_USER,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_open_user,
+ samr_io_r_open_user,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
#endif
}
- 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)
+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;
SAMR_R_OPEN_GROUP r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_open_group with rid 0x%x\n", group_rid ));
+
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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_GROUP,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_open_group,
+ samr_io_r_open_group,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
#endif
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
+ return result;
+}
+
+/* Create domain group */
+
+NTSTATUS rpccli_samr_create_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *domain_pol,
+ const char *group_name,
+ uint32 access_mask, POLICY_HND *group_pol)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_CREATE_DOM_GROUP q;
+ SAMR_R_CREATE_DOM_GROUP r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_create_dom_group\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_create_dom_group(&q, domain_pol, group_name, access_mask);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_GROUP,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_create_dom_group,
+ samr_io_r_create_dom_group,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ result = r.status;
+
+ if (NT_STATUS_IS_OK(result))
+ *group_pol = r.pol;
return result;
}
-/* Query user info */
+/* Add a domain group member */
-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_add_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *group_pol, uint32 rid)
{
prs_struct qbuf, rbuf;
- SAMR_Q_QUERY_USERINFO q;
- SAMR_R_QUERY_USERINFO r;
+ SAMR_Q_ADD_GROUPMEM q;
+ SAMR_R_ADD_GROUPMEM r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_add_groupmem\n"));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
- /* Initialise parse structures */
+ /* Marshall data and send request */
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
- prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+ init_samr_q_add_groupmem(&q, group_pol, rid);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_GROUPMEM,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_add_groupmem,
+ samr_io_r_add_groupmem,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ result = r.status;
+
+ return result;
+}
+
+/* Delete a domain group member */
+
+NTSTATUS rpccli_samr_del_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *group_pol, uint32 rid)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_DEL_GROUPMEM q;
+ SAMR_R_DEL_GROUPMEM r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_del_groupmem\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
/* Marshall data and send request */
- init_samr_q_query_userinfo(&q, user_pol, switch_value);
+ init_samr_q_del_groupmem(&q, group_pol, rid);
- if (!samr_io_q_query_userinfo("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_QUERY_USERINFO, &qbuf, &rbuf))
- goto done;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_GROUPMEM,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_del_groupmem,
+ samr_io_r_del_groupmem,
+ NT_STATUS_UNSUCCESSFUL);
- /* Unmarshall response */
+ /* Return output parameters */
- if (!samr_io_r_query_userinfo("", &r, &rbuf, 0))
- goto done;
+ result = r.status;
+
+ return result;
+}
+
+/* Query user info */
+
+NTSTATUS rpccli_samr_query_userinfo(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const 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;
+
+ DEBUG(10,("cli_samr_query_userinfo\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_query_userinfo(&q, user_pol, switch_value);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_userinfo,
+ samr_io_r_query_userinfo,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
result = r.status;
*ctr = r.ctr;
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
+ return result;
+}
+
+/* Set group info */
+
+NTSTATUS rpccli_samr_set_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *group_pol, GROUP_INFO_CTR *ctr)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_SET_GROUPINFO q;
+ SAMR_R_SET_GROUPINFO r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_set_groupinfo\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_set_groupinfo(&q, group_pol, ctr);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_GROUPINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_set_groupinfo,
+ samr_io_r_set_groupinfo,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ result = r.status;
return result;
}
/* Query group info */
-NTSTATUS cli_samr_query_groupinfo(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_samr_query_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *group_pol, uint32 info_level,
GROUP_INFO_CTR **ctr)
{
SAMR_R_QUERY_GROUPINFO r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_query_groupinfo\n"));
+
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_groupinfo(&q, group_pol, info_level);
- if (!samr_io_q_query_groupinfo("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_QUERY_GROUPINFO, &qbuf, &rbuf))
- goto done;
-
- /* Unmarshall response */
-
- if (!samr_io_r_query_groupinfo("", &r, &rbuf, 0))
- goto done;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_groupinfo,
+ samr_io_r_query_groupinfo,
+ NT_STATUS_UNSUCCESSFUL);
*ctr = r.ctr;
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)
+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;
SAMR_R_QUERY_USERGROUPS r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_query_usergroups\n"));
+
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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERGROUPS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_usergroups,
+ samr_io_r_query_usergroups,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*gid = r.gid;
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
+ return result;
+}
+
+/* Set alias info */
+
+NTSTATUS rpccli_samr_set_aliasinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_SET_ALIASINFO q;
+ SAMR_R_SET_ALIASINFO r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_set_aliasinfo\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_set_aliasinfo(&q, alias_pol, ctr);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_ALIASINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_set_aliasinfo,
+ samr_io_r_set_aliasinfo,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ result = r.status;
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)
+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;
SAMR_R_QUERY_USERALIASES r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
- unsigned int ptr=1;
+ int i;
+ uint32 *sid_ptrs;
+ DEBUG(10,("cli_samr_query_useraliases\n"));
+
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);
+ if (num_sids) {
+ sid_ptrs = TALLOC_ARRAY(mem_ctx, uint32, num_sids);
+ if (sid_ptrs == NULL)
+ return NT_STATUS_NO_MEMORY;
+ } else {
+ sid_ptrs = NULL;
+ }
+
+ for (i=0; i<num_sids; i++)
+ sid_ptrs[i] = 1;
/* 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 */
+ init_samr_q_query_useraliases(&q, dom_pol, num_sids, sid_ptrs, sid);
- if (!samr_io_r_query_useraliases("", &r, &rbuf, 0))
- goto done;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERALIASES,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_useraliases,
+ samr_io_r_query_useraliases,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*als_rids = r.rid;
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* 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;
SAMR_R_QUERY_GROUPMEM r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_query_groupmem\n"));
+
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_groupmem(&q, group_pol);
- 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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPMEM,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_groupmem,
+ samr_io_r_query_groupmem,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*attr = r.attr;
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
*
* @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,
+
+NTSTATUS rpccli_samr_enum_dom_users(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *pol, uint32 *start_idx, uint32 acb_mask,
uint32 size, char ***dom_users, uint32 **rids,
uint32 *num_dom_users)
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
int i;
+ DEBUG(10,("cli_samr_enum_dom_users starting at index %u\n", (unsigned int)*start_idx));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
/* always init this */
*num_dom_users = 0;
- /* Initialise parse structures */
-
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
- prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
-
/* Fill query structure with parameters */
- init_samr_q_enum_dom_users(&q, pol, *start_idx, acb_mask, 0, size);
+ init_samr_q_enum_dom_users(&q, pol, *start_idx, acb_mask, size);
- if (!samr_io_q_enum_dom_users("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_ENUM_DOM_USERS, &qbuf, &rbuf)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_USERS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_enum_dom_users,
+ samr_io_r_enum_dom_users,
+ NT_STATUS_UNSUCCESSFUL);
- /* unpack received stream */
-
- if(!samr_io_r_enum_dom_users("", &r, &rbuf, 0))
- goto done;
-
result = r.status;
if (!NT_STATUS_IS_OK(result) &&
if (r.num_entries2) {
/* allocate memory needed to return received data */
- *rids = (uint32*)talloc(mem_ctx, sizeof(uint32) * r.num_entries2);
+ *rids = TALLOC_ARRAY(mem_ctx, 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);
+ *dom_users = TALLOC_ARRAY(mem_ctx, 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;
fstring conv_buf;
(*rids)[i] = r.sam[i].rid;
- unistr2_to_ascii(conv_buf, &(r.uni_acct_name[i]), sizeof(conv_buf) - 1);
+ unistr2_to_ascii(conv_buf, &(r.uni_acct_name[i]), sizeof(conv_buf));
(*dom_users)[i] = talloc_strdup(mem_ctx, conv_buf);
}
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
-};
+}
/* 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;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
uint32 name_idx, i;
+ DEBUG(10,("cli_samr_enum_dom_groups starting at index %u\n", (unsigned int)*start_idx));
+
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;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_GROUPS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_enum_dom_groups,
+ samr_io_r_enum_dom_groups,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
if (*num_dom_groups == 0)
goto done;
- if (!((*dom_groups) = (struct acct_info *)
- talloc(mem_ctx, sizeof(struct acct_info) * *num_dom_groups))) {
+ if (!((*dom_groups) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_groups))) {
result = NT_STATUS_NO_MEMORY;
goto done;
}
if (r.sam[i].hdr_name.buffer) {
unistr2_to_ascii((*dom_groups)[i].acct_name,
&r.uni_grp_name[name_idx],
- sizeof(fstring) - 1);
+ sizeof((*dom_groups)[i].acct_name));
name_idx++;
}
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* 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;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
uint32 name_idx, i;
+ DEBUG(10,("cli_samr_enum_als_groups starting at index %u\n", (unsigned int)*start_idx));
+
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_aliases(&q, pol, *start_idx, size);
- if (!samr_io_q_enum_dom_aliases("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_ENUM_DOM_ALIASES, &qbuf, &rbuf)) {
- goto done;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_enum_dom_aliases("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_ALIASES,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_enum_dom_aliases,
+ samr_io_r_enum_dom_aliases,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
if (*num_dom_aliases == 0)
goto done;
- if (!((*dom_aliases) = (struct acct_info *)
- talloc(mem_ctx, sizeof(struct acct_info) * *num_dom_aliases))) {
+ if (!((*dom_aliases) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_aliases))) {
result = NT_STATUS_NO_MEMORY;
goto done;
}
if (r.sam[i].hdr_name.buffer) {
unistr2_to_ascii((*dom_aliases)[i].acct_name,
&r.uni_grp_name[name_idx],
- sizeof(fstring) - 1);
+ sizeof((*dom_aliases)[i].acct_name));
name_idx++;
}
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* 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)
+NTSTATUS rpccli_samr_query_aliasmem(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ POLICY_HND *alias_pol, uint32 *num_mem,
+ DOM_SID **sids)
{
prs_struct qbuf, rbuf;
SAMR_Q_QUERY_ALIASMEM q;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
uint32 i;
+ DEBUG(10,("cli_samr_query_aliasmem\n"));
+
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_aliasmem(&q, alias_pol);
- if (!samr_io_q_query_aliasmem("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_QUERY_ALIASMEM, &qbuf, &rbuf)) {
- goto done;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_query_aliasmem("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASMEM,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_aliasmem,
+ samr_io_r_query_aliasmem,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*num_mem = r.num_sids;
- if (!(*sids = talloc(mem_ctx, sizeof(DOM_SID) * *num_mem))) {
+ if (*num_mem == 0) {
+ *sids = NULL;
+ result = NT_STATUS_OK;
+ goto done;
+ }
+
+ if (!(*sids = TALLOC_ARRAY(mem_ctx, DOM_SID, *num_mem))) {
result = NT_STATUS_UNSUCCESSFUL;
goto done;
}
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* 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)
+NTSTATUS rpccli_samr_open_alias(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ POLICY_HND *domain_pol, uint32 access_mask,
+ uint32 alias_rid, POLICY_HND *alias_pol)
{
prs_struct qbuf, rbuf;
SAMR_Q_OPEN_ALIAS q;
SAMR_R_OPEN_ALIAS r;
NTSTATUS result;
+ DEBUG(10,("cli_samr_open_alias with rid 0x%x\n", alias_rid));
+
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_alias(&q, domain_pol, access_mask, alias_rid);
- 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;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_open_alias("", &r, &rbuf, 0)) {
- result = NT_STATUS_UNSUCCESSFUL;
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_ALIAS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_open_alias,
+ samr_io_r_open_alias,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
#endif
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
+ return result;
+}
+
+/* Create an alias */
+
+NTSTATUS rpccli_samr_create_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *domain_pol, const char *name,
+ POLICY_HND *alias_pol)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_CREATE_DOM_ALIAS q;
+ SAMR_R_CREATE_DOM_ALIAS r;
+ NTSTATUS result;
+
+ DEBUG(10,("cli_samr_create_dom_alias named %s\n", name));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_create_dom_alias(&q, domain_pol, name);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_ALIAS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_create_dom_alias,
+ samr_io_r_create_dom_alias,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ if (NT_STATUS_IS_OK(result = r.status)) {
+ *alias_pol = r.alias_pol;
+ }
+
+ return result;
+}
+
+/* Add an alias member */
+
+NTSTATUS rpccli_samr_add_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *alias_pol, DOM_SID *member)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_ADD_ALIASMEM q;
+ SAMR_R_ADD_ALIASMEM r;
+ NTSTATUS result;
+
+ DEBUG(10,("cli_samr_add_aliasmem"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_add_aliasmem(&q, alias_pol, member);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_ALIASMEM,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_add_aliasmem,
+ samr_io_r_add_aliasmem,
+ NT_STATUS_UNSUCCESSFUL);
+
+ result = r.status;
+
+ return result;
+}
+
+/* Delete an alias member */
+
+NTSTATUS rpccli_samr_del_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *alias_pol, DOM_SID *member)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_DEL_ALIASMEM q;
+ SAMR_R_DEL_ALIASMEM r;
+ NTSTATUS result;
+
+ DEBUG(10,("cli_samr_del_aliasmem"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_del_aliasmem(&q, alias_pol, member);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_ALIASMEM,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_del_aliasmem,
+ samr_io_r_del_aliasmem,
+ NT_STATUS_UNSUCCESSFUL);
+
+ result = r.status;
+
+ return result;
+}
+
+/* Query alias info */
+
+NTSTATUS rpccli_samr_query_alias_info(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *alias_pol, uint16 switch_value,
+ ALIAS_INFO_CTR *ctr)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_QUERY_ALIASINFO q;
+ SAMR_R_QUERY_ALIASINFO r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_query_alias_info\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_query_aliasinfo(&q, alias_pol, switch_value);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_aliasinfo,
+ samr_io_r_query_aliasinfo,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ if (!NT_STATUS_IS_OK(result = r.status)) {
+ goto done;
+ }
+
+ *ctr = *r.ctr;
+
+ done:
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)
+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;
SAMR_R_QUERY_DOMAIN_INFO r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_query_dom_info\n"));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
- /* Initialise parse structures */
+ /* Marshall data and send request */
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
- prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+ init_samr_q_query_domain_info(&q, domain_pol, switch_value);
- /* Marshall data and send request */
+ r.ctr = ctr;
- init_samr_q_query_dom_info(&q, domain_pol, switch_value);
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_domain_info,
+ samr_io_r_query_domain_info,
+ NT_STATUS_UNSUCCESSFUL);
- if (!samr_io_q_query_dom_info("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_QUERY_DOMAIN_INFO, &qbuf, &rbuf)) {
+ /* Return output parameters */
+
+ if (!NT_STATUS_IS_OK(result = r.status)) {
goto done;
}
- /* Unmarshall response */
+ done:
+
+ return result;
+}
+
+/* Query domain info2 */
+
+NTSTATUS rpccli_samr_query_dom_info2(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_INFO2 q;
+ SAMR_R_QUERY_DOMAIN_INFO2 r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_query_dom_info2\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_query_domain_info2(&q, domain_pol, switch_value);
r.ctr = ctr;
- if (!samr_io_r_query_dom_info("", &r, &rbuf, 0)) {
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO2,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_domain_info2,
+ samr_io_r_query_domain_info2,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ if (!NT_STATUS_IS_OK(result = r.status)) {
+ goto done;
+ }
+
+ done:
+
+ return result;
+}
+
+/* Set domain info */
+
+NTSTATUS rpccli_samr_set_domain_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_SET_DOMAIN_INFO q;
+ SAMR_R_SET_DOMAIN_INFO r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_set_domain_info\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_set_domain_info(&q, domain_pol, switch_value, ctr);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_DOMAIN_INFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_set_domain_info,
+ samr_io_r_set_domain_info,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ if (!NT_STATUS_IS_OK(result = r.status)) {
+ goto done;
+ }
+
+ done:
+
+ return result;
+}
+
+/* User change password */
+
+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;
+ SAMR_R_CHGPASSWD_USER r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ uchar new_nt_password[516];
+ uchar new_lm_password[516];
+ uchar old_nt_hash[16];
+ uchar old_lanman_hash[16];
+ uchar old_nt_hash_enc[16];
+ uchar old_lanman_hash_enc[16];
+
+ uchar new_nt_hash[16];
+ uchar new_lanman_hash[16];
+
+ char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
+
+ DEBUG(10,("rpccli_samr_chgpasswd_user\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Calculate the MD4 hash (NT compatible) of the password */
+ E_md4hash(oldpassword, old_nt_hash);
+ E_md4hash(newpassword, new_nt_hash);
+
+ if (lp_client_lanman_auth()
+ && E_deshash(newpassword, new_lanman_hash)
+ && E_deshash(oldpassword, old_lanman_hash)) {
+ /* E_deshash returns false for 'long' passwords (> 14
+ DOS chars). This allows us to match Win2k, which
+ does not store a LM hash for these passwords (which
+ would reduce the effective password length to 14) */
+
+ encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
+
+ SamOEMhash( new_lm_password, old_nt_hash, 516);
+ E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
+ } else {
+ ZERO_STRUCT(new_lm_password);
+ ZERO_STRUCT(old_lanman_hash_enc);
+ }
+
+ encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
+
+ SamOEMhash( new_nt_password, old_nt_hash, 516);
+ E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
+
+ /* Marshall data and send request */
+
+ init_samr_q_chgpasswd_user(&q, srv_name_slash, username,
+ new_nt_password,
+ old_nt_hash_enc,
+ new_lm_password,
+ old_lanman_hash_enc);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_chgpasswd_user,
+ samr_io_r_chgpasswd_user,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ if (!NT_STATUS_IS_OK(result = r.status)) {
goto done;
}
+ done:
+
+ return result;
+}
+
+/* User change password given blobs */
+
+NTSTATUS rpccli_samr_chng_pswd_auth_crap(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const char *username,
+ DATA_BLOB new_nt_password,
+ DATA_BLOB old_nt_hash_enc,
+ DATA_BLOB new_lm_password,
+ DATA_BLOB old_lm_hash_enc)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_CHGPASSWD_USER q;
+ SAMR_R_CHGPASSWD_USER r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
+
+ DEBUG(10,("rpccli_samr_chng_pswd_auth_crap\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_chgpasswd_user(&q, srv_name_slash, username,
+ new_nt_password.data,
+ old_nt_hash_enc.data,
+ new_lm_password.data,
+ old_lm_hash_enc.data);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_chgpasswd_user,
+ samr_io_r_chgpasswd_user,
+ NT_STATUS_UNSUCCESSFUL);
+
/* Return output parameters */
if (!NT_STATUS_IS_OK(result = r.status)) {
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
return result;
}
+
+/* change password 3 */
+
+NTSTATUS rpccli_samr_chgpasswd3(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ const char *username,
+ const char *newpassword,
+ const char *oldpassword,
+ SAM_UNK_INFO_1 *info,
+ SAMR_CHANGE_REJECT *reject)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_CHGPASSWD_USER3 q;
+ SAMR_R_CHGPASSWD_USER3 r;
+
+ uchar new_nt_password[516];
+ uchar new_lm_password[516];
+ uchar old_nt_hash[16];
+ uchar old_lanman_hash[16];
+ uchar old_nt_hash_enc[16];
+ uchar old_lanman_hash_enc[16];
+
+ uchar new_nt_hash[16];
+ uchar new_lanman_hash[16];
+
+ char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
+
+ DEBUG(10,("rpccli_samr_chgpasswd_user3\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Calculate the MD4 hash (NT compatible) of the password */
+ E_md4hash(oldpassword, old_nt_hash);
+ E_md4hash(newpassword, new_nt_hash);
+
+ if (lp_client_lanman_auth()
+ && E_deshash(newpassword, new_lanman_hash)
+ && E_deshash(oldpassword, old_lanman_hash)) {
+ /* E_deshash returns false for 'long' passwords (> 14
+ DOS chars). This allows us to match Win2k, which
+ does not store a LM hash for these passwords (which
+ would reduce the effective password length to 14) */
+
+ encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
+
+ SamOEMhash( new_lm_password, old_nt_hash, 516);
+ E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
+ } else {
+ ZERO_STRUCT(new_lm_password);
+ ZERO_STRUCT(old_lanman_hash_enc);
+ }
+
+ encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
+
+ SamOEMhash( new_nt_password, old_nt_hash, 516);
+ E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
+
+ /* Marshall data and send request */
+
+ init_samr_q_chgpasswd_user3(&q, srv_name_slash, username,
+ new_nt_password,
+ old_nt_hash_enc,
+ new_lm_password,
+ old_lanman_hash_enc);
+ r.info = info;
+ r.reject = reject;
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER3,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_chgpasswd_user3,
+ samr_io_r_chgpasswd_user3,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ return r.status;
+}
+
/* 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
/* 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;
SAMR_R_QUERY_DISPINFO r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_query_dispinfo for start_idx = %u\n", *start_idx));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
*num_entries = 0;
- /* 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_dispinfo(&q, domain_pol, switch_value,
*start_idx, max_entries, max_size);
- if (!samr_io_q_query_dispinfo("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_QUERY_DISPINFO, &qbuf, &rbuf)) {
- goto done;
- }
-
- /* Unmarshall response */
-
r.ctr = ctr;
- if (!samr_io_r_query_dispinfo("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_dispinfo,
+ samr_io_r_query_dispinfo,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*start_idx += r.num_entries; /* No next_idx in this structure! */
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
/* 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 flags,
- 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;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
uint32 i;
+ DEBUG(10,("cli_samr_lookup_rids\n"));
+
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"));
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_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;
- }
-
- /* Unmarshall response */
+ init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, 1000, num_rids, rids);
- if (!samr_io_r_lookup_rids("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_RIDS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_lookup_rids,
+ samr_io_r_lookup_rids,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
- if (!NT_STATUS_IS_OK(result = r.status)) {
+ result = r.status;
+
+ if (!NT_STATUS_IS_OK(result) &&
+ !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
goto done;
- }
if (r.num_names1 == 0) {
*num_names = 0;
}
*num_names = r.num_names1;
- *names = talloc(mem_ctx, sizeof(char *) * r.num_names1);
- *name_types = talloc(mem_ctx, sizeof(uint32) * r.num_names1);
+ *names = TALLOC_ARRAY(mem_ctx, char *, r.num_names1);
+ *name_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_names1);
+
+ if ((*names == NULL) || (*name_types == NULL)) {
+ TALLOC_FREE(*names);
+ TALLOC_FREE(*name_types);
+ return NT_STATUS_NO_MEMORY;
+ }
for (i = 0; i < r.num_names1; i++) {
fstring tmp;
- unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp) - 1);
+ unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp));
(*names)[i] = talloc_strdup(mem_ctx, tmp);
(*name_types)[i] = r.type[i];
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
return result;
}
/* Lookup names */
-NTSTATUS cli_samr_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_samr_lookup_names(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *domain_pol, uint32 flags,
uint32 num_names, const char **names,
uint32 *num_rids, uint32 **rids,
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
uint32 i;
+ DEBUG(10,("cli_samr_lookup_names\n"));
+
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_lookup_names(mem_ctx, &q, domain_pol, flags,
num_names, names);
- if (!samr_io_q_lookup_names("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_LOOKUP_NAMES, &qbuf, &rbuf)) {
- goto done;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_lookup_names("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_NAMES,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_lookup_names,
+ samr_io_r_lookup_names,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
}
*num_rids = r.num_rids1;
- *rids = talloc(mem_ctx, sizeof(uint32) * r.num_rids1);
- *rid_types = talloc(mem_ctx, sizeof(uint32) * r.num_rids1);
+ *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
+ *rid_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
+
+ if ((*rids == NULL) || (*rid_types == NULL)) {
+ TALLOC_FREE(*rids);
+ TALLOC_FREE(*rid_types);
+ return NT_STATUS_NO_MEMORY;
+ }
for (i = 0; i < r.num_rids1; i++) {
(*rids)[i] = r.rids[i];
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
return result;
}
/* Create a domain user */
-NTSTATUS cli_samr_create_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_samr_create_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *domain_pol, const char *acct_name,
- uint32 acb_info, uint32 unknown,
+ uint32 acb_info, uint32 access_mask,
POLICY_HND *user_pol, uint32 *rid)
{
prs_struct qbuf, rbuf;
SAMR_R_CREATE_USER r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_create_dom_user %s\n", acct_name));
+
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_create_user(&q, domain_pol, acct_name, acb_info, unknown);
+ init_samr_q_create_user(&q, domain_pol, acct_name, acb_info, access_mask);
- if (!samr_io_q_create_user("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_CREATE_USER, &qbuf, &rbuf)) {
- goto done;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_create_user("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_USER,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_create_user,
+ samr_io_r_create_user,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
*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)
+NTSTATUS rpccli_samr_set_userinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ const POLICY_HND *user_pol, uint16 switch_value,
+ DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
{
prs_struct qbuf, rbuf;
SAMR_Q_SET_USERINFO q;
SAMR_R_SET_USERINFO r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_set_userinfo\n"));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
+ if (!sess_key->length) {
+ DEBUG(1, ("No user session key\n"));
+ return NT_STATUS_NO_USER_SESSION_KEY;
+ }
+
/* Initialise parse structures */
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
+ prs_init(&qbuf, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
/* Marshall data and send request */
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;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_set_userinfo("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_set_userinfo,
+ samr_io_r_set_userinfo,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
}
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)
+NTSTATUS rpccli_samr_set_userinfo2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ const POLICY_HND *user_pol, uint16 switch_value,
+ DATA_BLOB *sess_key, 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);
+ DEBUG(10,("cli_samr_set_userinfo2\n"));
- /* Initialise parse structures */
+ if (!sess_key->length) {
+ DEBUG(1, ("No user session key\n"));
+ return NT_STATUS_NO_USER_SESSION_KEY;
+ }
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
- prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
/* 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;
- }
-
- /* Unmarshall response */
-
- if (!samr_io_r_set_userinfo2("", &r, &rbuf, 0)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO2,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_set_userinfo2,
+ samr_io_r_set_userinfo2,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
}
done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
+
+ return result;
+}
+
+/* Delete domain group */
+
+NTSTATUS rpccli_samr_delete_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *group_pol)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_DELETE_DOM_GROUP q;
+ SAMR_R_DELETE_DOM_GROUP r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_delete_dom_group\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_delete_dom_group(&q, group_pol);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_GROUP,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_delete_dom_group,
+ samr_io_r_delete_dom_group,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ result = r.status;
+
+ return result;
+}
+
+/* Delete domain alias */
+
+NTSTATUS rpccli_samr_delete_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *alias_pol)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_DELETE_DOM_ALIAS q;
+ SAMR_R_DELETE_DOM_ALIAS r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_delete_dom_alias\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_delete_dom_alias(&q, alias_pol);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_ALIAS,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_delete_dom_alias,
+ samr_io_r_delete_dom_alias,
+ NT_STATUS_UNSUCCESSFUL);
+
+ /* Return output parameters */
+
+ result = r.status;
return result;
}
/* Delete domain user */
-NTSTATUS cli_samr_delete_dom_user(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_samr_delete_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *user_pol)
{
prs_struct qbuf, rbuf;
SAMR_R_DELETE_DOM_USER r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_delete_dom_user\n"));
+
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_delete_dom_user(&q, user_pol);
- if (!samr_io_q_delete_dom_user("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_DELETE_DOM_USER, &qbuf, &rbuf)) {
- goto done;
- }
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_USER,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_delete_dom_user,
+ samr_io_r_delete_dom_user,
+ NT_STATUS_UNSUCCESSFUL);
- /* Unmarshall response */
+ /* Return output parameters */
- if (!samr_io_r_delete_dom_user("", &r, &rbuf, 0)) {
- goto done;
- }
+ result = r.status;
+
+ return result;
+}
+
+/* Remove foreign SID */
+
+NTSTATUS rpccli_samr_remove_sid_foreign_domain(struct rpc_pipe_client *cli,
+ TALLOC_CTX *mem_ctx,
+ POLICY_HND *user_pol,
+ DOM_SID *sid)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN q;
+ SAMR_R_REMOVE_SID_FOREIGN_DOMAIN r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_remove_sid_foreign_domain\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_remove_sid_foreign_domain(&q, user_pol, sid);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_REMOVE_SID_FOREIGN_DOMAIN,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_remove_sid_foreign_domain,
+ samr_io_r_remove_sid_foreign_domain,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
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,
+NTSTATUS rpccli_samr_query_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *user_pol, uint32 sec_info,
TALLOC_CTX *ctx, SEC_DESC_BUF **sec_desc_buf)
{
prs_struct qbuf, rbuf;
SAMR_R_QUERY_SEC_OBJ r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_query_sec_obj\n"));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
- /* Initialise parse structures */
+ /* Marshall data and send request */
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
- prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+ init_samr_q_query_sec_obj(&q, user_pol, sec_info);
- /* Marshall data and send request */
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_SEC_OBJECT,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_query_sec_obj,
+ samr_io_r_query_sec_obj,
+ NT_STATUS_UNSUCCESSFUL);
- init_samr_q_query_sec_obj(&q, user_pol, switch_value);
+ /* Return output parameters */
- if (!samr_io_q_query_sec_obj("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_QUERY_SEC_OBJECT, &qbuf, &rbuf)) {
- goto done;
- }
+ result = r.status;
+ *sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
- /* Unmarshall response */
+ return result;
+}
- if (!samr_io_r_query_sec_obj("", &r, &rbuf, 0)) {
- goto done;
- }
+/* Set user security object */
+
+NTSTATUS rpccli_samr_set_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *user_pol, uint32 sec_info,
+ SEC_DESC_BUF *sec_desc_buf)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_SET_SEC_OBJ q;
+ SAMR_R_SET_SEC_OBJ r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_set_sec_obj\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_set_sec_obj(&q, user_pol, sec_info, sec_desc_buf);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_SEC_OBJECT,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_set_sec_obj,
+ samr_io_r_set_sec_obj,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
result = r.status;
- *sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
-
- 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)
+NTSTATUS rpccli_samr_get_dom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ uint16 *min_pwd_length, uint32 *password_properties)
{
prs_struct qbuf, rbuf;
SAMR_Q_GET_DOM_PWINFO q;
SAMR_R_GET_DOM_PWINFO r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_get_dom_pwinfo\n"));
+
ZERO_STRUCT(q);
ZERO_STRUCT(r);
- /* Initialise parse structures */
+ /* Marshall data and send request */
- prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
- prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
+ init_samr_q_get_dom_pwinfo(&q, cli->cli->desthost);
- /* Marshall data and send request */
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DOM_PWINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_get_dom_pwinfo,
+ samr_io_r_get_dom_pwinfo,
+ NT_STATUS_UNSUCCESSFUL);
- init_samr_q_get_dom_pwinfo(&q, cli->desthost);
+ /* Return output parameters */
- if (!samr_io_q_get_dom_pwinfo("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_GET_DOM_PWINFO, &qbuf, &rbuf))
- goto done;
+ result = r.status;
- /* Unmarshall response */
+ if (NT_STATUS_IS_OK(result)) {
+ if (min_pwd_length)
+ *min_pwd_length = r.min_pwd_length;
+ if (password_properties)
+ *password_properties = r.password_properties;
+ }
- if (!samr_io_r_get_dom_pwinfo("", &r, &rbuf, 0))
- goto done;
+ return result;
+}
+
+/* Get domain password info */
+
+NTSTATUS rpccli_samr_get_usrdom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+ POLICY_HND *pol, uint16 *min_pwd_length,
+ uint32 *password_properties, uint32 *unknown1)
+{
+ prs_struct qbuf, rbuf;
+ SAMR_Q_GET_USRDOM_PWINFO q;
+ SAMR_R_GET_USRDOM_PWINFO r;
+ NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+
+ DEBUG(10,("cli_samr_get_usrdom_pwinfo\n"));
+
+ ZERO_STRUCT(q);
+ ZERO_STRUCT(r);
+
+ /* Marshall data and send request */
+
+ init_samr_q_get_usrdom_pwinfo(&q, pol);
+
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_USRDOM_PWINFO,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_get_usrdom_pwinfo,
+ samr_io_r_get_usrdom_pwinfo,
+ NT_STATUS_UNSUCCESSFUL);
/* 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;
+ if (min_pwd_length)
+ *min_pwd_length = r.min_pwd_length;
+ if (password_properties)
+ *password_properties = r.password_properties;
+ if (unknown1)
+ *unknown1 = r.unknown_1;
}
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
+
/* Lookup Domain Name */
-NTSTATUS cli_samr_lookup_domain(struct cli_state *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_samr_lookup_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
POLICY_HND *user_pol, char *domain_name,
DOM_SID *sid)
{
SAMR_R_LOOKUP_DOMAIN r;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
+ DEBUG(10,("cli_samr_lookup_domain\n"));
+
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_lookup_domain(&q, user_pol, domain_name);
- if (!samr_io_q_lookup_domain("", &q, &qbuf, 0) ||
- !rpc_api_pipe_req(cli, SAMR_LOOKUP_DOMAIN, &qbuf, &rbuf))
- goto done;
-
- /* Unmarshall response */
-
- if (!samr_io_r_lookup_domain("", &r, &rbuf, 0))
- goto done;
+ CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_DOMAIN,
+ q, r,
+ qbuf, rbuf,
+ samr_io_q_lookup_domain,
+ samr_io_r_lookup_domain,
+ NT_STATUS_UNSUCCESSFUL);
/* Return output parameters */
if (NT_STATUS_IS_OK(result))
sid_copy(sid, &r.dom_sid.sid);
- done:
- prs_mem_free(&qbuf);
- prs_mem_free(&rbuf);
-
return result;
}
git.samba.org / tprouty / samba.git / blobdiff