From 3478427f2e5ab634d61e6863f41bba84cce8d05e Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Fri, 8 Dec 2000 03:34:00 +0000 Subject: Port of lsa_lookup_sids() and lsa_lookup_names() rpc client functions from TNG branch. Re-instated lsa_lookup_sids and lsa_lookup_names functions in rpcclient. This requires most samba binaries to link in another handful of object files due to uncessary coupling between modules. )-: (This used to be commit 817819d0cc3ecf642be5a1656be3b71bed260ee4) --- source3/rpc_client/cli_lsarpc.c | 418 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 411 insertions(+), 7 deletions(-) (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_lsarpc.c b/source3/rpc_client/cli_lsarpc.c index a9b9eddfb8..a1e63475cf 100644 --- a/source3/rpc_client/cli_lsarpc.c +++ b/source3/rpc_client/cli_lsarpc.c @@ -1,4 +1,3 @@ - /* * Unix SMB/Netbios implementation. * Version 1.9. @@ -23,16 +22,10 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ - -#ifdef SYSLOG -#undef SYSLOG -#endif - #include "includes.h" extern int DEBUGLEVEL; - /**************************************************************************** do a LSA Open Policy ****************************************************************************/ @@ -402,3 +395,414 @@ BOOL cli_lsa_get_domain_sid(struct cli_state *cli, char *server) return res3; } + +/**************************************************************************** +do a LSA Open Policy +****************************************************************************/ +uint32 lsa_open_policy(const char *system_name, POLICY_HND *hnd, + BOOL sec_qos, uint32 des_access) +{ + prs_struct rbuf; + prs_struct buf; + LSA_Q_OPEN_POL q_o; + LSA_SEC_QOS qos; + struct cli_connection *con = NULL; + uint32 result; + + if (!cli_connection_init(system_name, PIPE_LSARPC, &con)) { + return NT_STATUS_UNSUCCESSFUL; + } + + if (hnd == NULL) return NT_STATUS_UNSUCCESSFUL; + + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, NULL, False); + prs_init(&rbuf, 0, 4, NULL, True); + + /* create and send a MSRPC command with api LSA_OPENPOLICY */ + + DEBUG(4, ("LSA Open Policy\n")); + + /* store the parameters */ + if (sec_qos) { + init_lsa_sec_qos(&qos, 2, 1, 0, des_access); + init_q_open_pol(&q_o, '\\', 0, des_access, &qos); + } else { + init_q_open_pol(&q_o, '\\', 0, des_access, NULL); + } + + /* turn parameters into data stream */ + if (lsa_io_q_open_pol("", &q_o, &buf, 0) && + rpc_con_pipe_req(con, LSA_OPENPOLICY, &buf, &rbuf)) { + LSA_R_OPEN_POL r_o; + BOOL p; + + lsa_io_r_open_pol("", &r_o, &rbuf, 0); + p = rbuf.data_offset != 0; + + result = r_o.status; + + if (p && r_o.status != 0) { + /* report error code */ + DEBUG(0, + ("LSA_OPENPOLICY: %s\n", + get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) { + + /* Return the policy handle */ + + *hnd = r_o.pol; + + if (!RpcHndList_set_connection(hnd, con)) { + result = NT_STATUS_NO_MEMORY; + } + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf); + + return result; +} + +/**************************************************************************** +do a LSA Close +****************************************************************************/ +uint32 lsa_close(POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct buf; + LSA_Q_CLOSE q_c; + uint32 result; + + if (hnd == NULL) return False; + + /* Create and send a MSRPC command with api LSA_OPENPOLICY */ + + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, NULL, False); + prs_init(&rbuf, 0, 4, NULL, True); + + DEBUG(4, ("LSA Close\n")); + + /* Store the parameters */ + + init_lsa_q_close(&q_c, hnd); + + /* Turn parameters into data stream */ + + if (lsa_io_q_close("", &q_c, &buf, 0) && + rpc_hnd_pipe_req(hnd, LSA_CLOSE, &buf, &rbuf)) { + LSA_R_CLOSE r_c; + BOOL p; + + lsa_io_r_close("", &r_c, &rbuf, 0); + p = rbuf.data_offset != 0; + result = r_c.status; + + if (p && r_c.status != 0) { + + /* Report error code */ + + DEBUG(0, ("LSA_CLOSE: %s\n", + get_nt_error_msg(r_c.status))); + + p = False; + } + + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf); + + return result; +} + +/**************************************************************************** +do a LSA Lookup SIDs +****************************************************************************/ +uint32 lsa_lookup_sids(POLICY_HND *hnd, int num_sids, DOM_SID *sids, + char ***names, uint32 **types, int *num_names) +{ + prs_struct rbuf; + prs_struct buf; + LSA_Q_LOOKUP_SIDS q_l; + TALLOC_CTX *ctx = talloc_init(); + uint32 result; + + ZERO_STRUCT(q_l); + + if (hnd == NULL || num_sids == 0 || sids == NULL) return False; + + if (num_names != NULL) { + *num_names = 0; + } + + if (types != NULL) { + *types = NULL; + } + + if (names != NULL) { + *names = NULL; + } + + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, ctx, False); + prs_init(&rbuf, 0, 4, ctx, True); + + /* Create and send a MSRPC command with api LSA_LOOKUP_SIDS */ + + DEBUG(4, ("LSA Lookup SIDs\n")); + + /* Store the parameters */ + + init_q_lookup_sids(&q_l, hnd, num_sids, sids, 1); + + /* turn parameters into data stream */ + if (lsa_io_q_lookup_sids("", &q_l, &buf, 0) && + rpc_hnd_pipe_req(hnd, LSA_LOOKUPSIDS, &buf, &rbuf)) { + LSA_R_LOOKUP_SIDS r_l; + DOM_R_REF ref; + LSA_TRANS_NAME_ENUM t_names; + BOOL p, valid_response; + + r_l.dom_ref = &ref; + r_l.names = &t_names; + + lsa_io_r_lookup_sids("", &r_l, &rbuf, 0); + p = rbuf.data_offset != 0; + result = r_l.status; + + if (p && r_l.status != 0 && + r_l.status != 0x107 && + r_l.status != (0xC0000000 | NT_STATUS_NONE_MAPPED)) { + + /* Report error code */ + + DEBUG(1, ("LSA_LOOKUP_SIDS: %s\n", + get_nt_error_msg(r_l.status))); + + return r_l.status; + } + + result = NT_STATUS_NOPROBLEMO; + + if (p) { + if (t_names.ptr_trans_names != 0 + && r_l.ptr_dom_ref != 0) { + valid_response = True; + } + } + + if (num_names != NULL && valid_response) { + (*num_names) = t_names.num_entries; + } + + if (valid_response) { + uint32 i; + + for (i = 0; i < t_names.num_entries; i++) { + if ((t_names.name[i].domain_idx >= + ref.num_ref_doms_1) + && (t_names.name[i].domain_idx != + 0xffffffff)) { + DEBUG(0, + ("LSA_LOOKUP_SIDS: domain index out of bounds\n")); + valid_response = False; + break; + } + } + } + + if (types != NULL && valid_response && (*num_names) != 0) { + (*types) = (uint32 *) malloc((*num_names) * + sizeof(uint32)); + } + + if (names != NULL && valid_response && (*num_names) != 0) { + (*names) = (char **)malloc((*num_names) * + sizeof(char *)); + } + + if (names != NULL && (*names) != NULL) { + int i; + + /* Take each name, construct a \DOMAIN\name string */ + + for (i = 0; i < (*num_names); i++) { + fstring name; + fstring dom_name; + fstring full_name; + uint32 dom_idx = t_names.name[i].domain_idx; + + if (dom_idx != 0xffffffff) { + unistr2_to_ascii(dom_name, + &ref. + ref_dom[dom_idx]. + uni_dom_name, + sizeof(dom_name) - + 1); + unistr2_to_ascii(name, + &t_names.uni_name[i], + sizeof(name) - 1); + + memset(full_name, 0, + sizeof(full_name)); + + slprintf(full_name, + sizeof(full_name) - 1, + "%s\\%s", dom_name, name); + + (*names)[i] = strdup(full_name); + if (types != NULL && + (*types) != NULL) { + (*types)[i] = t_names.name[i].sid_name_use; + } + } else { + (*names)[i] = NULL; + if (types != NULL && + (*types) != NULL) { + (*types)[i] = SID_NAME_UNKNOWN; + } + } + } + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf); + + return result; +} + +/**************************************************************************** +do a LSA Lookup Names +****************************************************************************/ +uint32 lsa_lookup_names(POLICY_HND *hnd, int num_names, char **names, + DOM_SID **sids, uint32 **types, int *num_sids) +{ + prs_struct rbuf; + prs_struct buf; + LSA_Q_LOOKUP_NAMES q_l; + BOOL valid_response = False; + TALLOC_CTX *ctx = talloc_init(); + uint32 result; + + if (hnd == NULL || num_sids == 0 || sids == NULL) return False; + + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, ctx, False); + prs_init(&rbuf, 0, 4, ctx, True); + + /* create and send a MSRPC command with api LSA_LOOKUP_NAMES */ + + DEBUG(4, ("LSA Lookup NAMEs\n")); + + /* store the parameters */ + init_q_lookup_names(&q_l, hnd, num_names, names); + + /* turn parameters into data stream */ + if (lsa_io_q_lookup_names("", &q_l, &buf, 0) && + rpc_hnd_pipe_req(hnd, LSA_LOOKUPNAMES, &buf, &rbuf)) { + LSA_R_LOOKUP_NAMES r_l; + DOM_R_REF ref; + DOM_RID2 t_rids[MAX_LOOKUP_SIDS]; + BOOL p; + + ZERO_STRUCT(ref); + ZERO_STRUCT(t_rids); + + r_l.dom_ref = &ref; + r_l.dom_rid = t_rids; + + lsa_io_r_lookup_names("", &r_l, &rbuf, 0); + p = rbuf.data_offset != 0; + + if (p && r_l.status != 0) { + /* report error code */ + DEBUG(1, + ("LSA_LOOKUP_NAMES: %s\n", + get_nt_error_msg(r_l.status))); + p = False; + + return r_l.status; + } + + result = r_l.status; + + if (p) { + if (r_l.ptr_dom_ref != 0 && r_l.ptr_entries != 0) { + valid_response = True; + } + } + + if (num_sids != NULL && valid_response) { + (*num_sids) = r_l.num_entries; + } + + if (valid_response) { + uint32 i; + + for (i = 0; i < r_l.num_entries; i++) { + if (t_rids[i].rid_idx >= ref.num_ref_doms_1 && + t_rids[i].rid_idx != 0xffffffff) { + DEBUG(0, + ("LSA_LOOKUP_NAMES: domain index %d out of bounds\n", + t_rids[i].rid_idx)); + valid_response = False; + break; + } + } + } + + if (types != NULL && valid_response && r_l.num_entries != 0) { + (*types) = (uint32 *) malloc((*num_sids) * + sizeof(uint32)); + } + + if (sids != NULL && valid_response && r_l.num_entries != 0) { + (*sids) = (DOM_SID *) malloc((*num_sids) * + sizeof(DOM_SID)); + } + + if (sids != NULL && (*sids) != NULL) { + int i; + + /* Take each name, construct a SID */ + + for (i = 0; i < (*num_sids); i++) { + uint32 dom_idx = t_rids[i].rid_idx; + uint32 dom_rid = t_rids[i].rid; + DOM_SID *sid = &(*sids)[i]; + + if (dom_idx != 0xffffffff) { + + sid_copy(sid, + &ref.ref_dom[dom_idx]. + ref_dom.sid); + + if (dom_rid != 0xffffffff) { + sid_append_rid(sid, dom_rid); + } + + if (types != NULL && + (*types) != NULL) { + (*types)[i] = t_rids[i].type; + } + + } else { + ZERO_STRUCTP(sid); + + if (types != NULL && + (*types) != NULL) { + (*types)[i] = SID_NAME_UNKNOWN; + } + } + } + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf); + + return result; +} -- cgit