From e5a951325a6cac8567af3a66de6d2df577508ae4 Mon Sep 17 00:00:00 2001 From: "Gerald (Jerry) Carter" Date: Wed, 10 Oct 2007 15:34:30 -0500 Subject: [GLUE] Rsync SAMBA_3_2_0 SVN r25598 in order to create the v3-2-test branch. (This used to be commit 5c6c8e1fe93f340005110a7833946191659d88ab) --- source3/rpc_client/cli_lsarpc.c | 52 ++-- source3/rpc_client/cli_samr.c | 297 ++++++-------------- source3/rpc_client/cli_srvsvc.c | 585 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 693 insertions(+), 241 deletions(-) create mode 100644 source3/rpc_client/cli_srvsvc.c (limited to 'source3/rpc_client') diff --git a/source3/rpc_client/cli_lsarpc.c b/source3/rpc_client/cli_lsarpc.c index ec325e6afb..be85e49476 100644 --- a/source3/rpc_client/cli_lsarpc.c +++ b/source3/rpc_client/cli_lsarpc.c @@ -139,7 +139,7 @@ static NTSTATUS rpccli_lsa_lookup_sids_noalloc(struct rpc_pipe_client *cli, const DOM_SID *sids, char **domains, char **names, - enum lsa_SidType *types) + uint32 *types) { prs_struct qbuf, rbuf; LSA_Q_LOOKUP_SIDS q; @@ -213,7 +213,7 @@ static NTSTATUS rpccli_lsa_lookup_sids_noalloc(struct rpc_pipe_client *cli, (names)[i] = talloc_strdup(mem_ctx, name); (domains)[i] = talloc_strdup(mem_ctx, dom_name); - (types)[i] = (enum lsa_SidType)r.names.name[i].sid_name_use; + (types)[i] = r.names.name[i].sid_name_use; if (((names)[i] == NULL) || ((domains)[i] == NULL)) { DEBUG(0, ("cli_lsa_lookup_sids_noalloc(): out of memory\n")); @@ -252,7 +252,7 @@ NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli, const DOM_SID *sids, char ***domains, char ***names, - enum lsa_SidType **types) + uint32 **types) { NTSTATUS result = NT_STATUS_OK; int sids_left = 0; @@ -260,7 +260,7 @@ NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli, const DOM_SID *hunk_sids = sids; char **hunk_domains = NULL; char **hunk_names = NULL; - enum lsa_SidType *hunk_types = NULL; + uint32 *hunk_types = NULL; if (num_sids) { if (!((*domains) = TALLOC_ARRAY(mem_ctx, char *, num_sids))) { @@ -359,7 +359,7 @@ NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli, const char ***dom_names, int level, DOM_SID **sids, - enum lsa_SidType **types) + uint32 **types) { prs_struct qbuf, rbuf; LSA_Q_LOOKUP_NAMES q; @@ -407,7 +407,7 @@ NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli, goto done; } - if (!((*types = TALLOC_ARRAY(mem_ctx, enum lsa_SidType, num_names)))) { + if (!((*types = TALLOC_ARRAY(mem_ctx, uint32, num_names)))) { DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n")); result = NT_STATUS_NO_MEMORY; goto done; @@ -450,7 +450,7 @@ NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli, sid_append_rid(sid, dom_rid); } - (*types)[i] = (enum lsa_SidType)t_rids[i].type; + (*types)[i] = t_rids[i].type; if (dom_names == NULL) { continue; @@ -1375,43 +1375,43 @@ done: BOOL fetch_domain_sid( char *domain, char *remote_machine, DOM_SID *psid) { extern pstring global_myname; - struct cli_state *cli; + struct cli_state cli; NTSTATUS result; POLICY_HND lsa_pol; BOOL ret = False; ZERO_STRUCT(cli); - if((cli = cli_initialise()) == NULL) { + if(cli_initialise(&cli) == False) { DEBUG(0,("fetch_domain_sid: unable to initialize client connection.\n")); return False; } - if(!resolve_name( remote_machine, &cli->dest_ip, 0x20)) { + if(!resolve_name( remote_machine, &cli.dest_ip, 0x20)) { DEBUG(0,("fetch_domain_sid: Can't resolve address for %s\n", remote_machine)); goto done; } - if (!cli_connect(cli, remote_machine, &cli->dest_ip)) { + if (!cli_connect(&cli, remote_machine, &cli.dest_ip)) { DEBUG(0,("fetch_domain_sid: unable to connect to SMB server on \ -machine %s. Error was : %s.\n", remote_machine, cli_errstr(cli) )); +machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli) )); goto done; } - if (!attempt_netbios_session_request(cli, global_myname, remote_machine, &cli->dest_ip)) { + if (!attempt_netbios_session_request(&cli, global_myname, remote_machine, &cli.dest_ip)) { DEBUG(0,("fetch_domain_sid: machine %s rejected the NetBIOS session request.\n", remote_machine)); goto done; } - cli->protocol = PROTOCOL_NT1; + cli.protocol = PROTOCOL_NT1; - if (!cli_negprot(cli)) { + if (!cli_negprot(&cli)) { DEBUG(0,("fetch_domain_sid: machine %s rejected the negotiate protocol. \ -Error was : %s.\n", remote_machine, cli_errstr(cli) )); +Error was : %s.\n", remote_machine, cli_errstr(&cli) )); goto done; } - if (cli->protocol != PROTOCOL_NT1) { + if (cli.protocol != PROTOCOL_NT1) { DEBUG(0,("fetch_domain_sid: machine %s didn't negotiate NT protocol.\n", remote_machine)); goto done; @@ -1421,39 +1421,39 @@ Error was : %s.\n", remote_machine, cli_errstr(cli) )); * Do an anonymous session setup. */ - if (!cli_session_setup(cli, "", "", 0, "", 0, "")) { + if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) { DEBUG(0,("fetch_domain_sid: machine %s rejected the session setup. \ -Error was : %s.\n", remote_machine, cli_errstr(cli) )); +Error was : %s.\n", remote_machine, cli_errstr(&cli) )); goto done; } - if (!(cli->sec_mode & NEGOTIATE_SECURITY_USER_LEVEL)) { + if (!(cli.sec_mode & NEGOTIATE_SECURITY_USER_LEVEL)) { DEBUG(0,("fetch_domain_sid: machine %s isn't in user level security mode\n", remote_machine)); goto done; } - if (!cli_send_tconX(cli, "IPC$", "IPC", "", 1)) { + if (!cli_send_tconX(&cli, "IPC$", "IPC", "", 1)) { DEBUG(0,("fetch_domain_sid: machine %s rejected the tconX on the IPC$ share. \ -Error was : %s.\n", remote_machine, cli_errstr(cli) )); +Error was : %s.\n", remote_machine, cli_errstr(&cli) )); goto done; } /* Fetch domain sid */ - if (!cli_nt_session_open(cli, PI_LSARPC)) { + if (!cli_nt_session_open(&cli, PI_LSARPC)) { DEBUG(0, ("fetch_domain_sid: Error connecting to SAM pipe\n")); goto done; } - result = cli_lsa_open_policy(cli, cli->mem_ctx, True, SEC_RIGHTS_QUERY_VALUE, &lsa_pol); + result = cli_lsa_open_policy(&cli, cli.mem_ctx, True, SEC_RIGHTS_QUERY_VALUE, &lsa_pol); if (!NT_STATUS_IS_OK(result)) { DEBUG(0, ("fetch_domain_sid: Error opening lsa policy handle. %s\n", nt_errstr(result) )); goto done; } - result = cli_lsa_query_info_policy(cli, cli->mem_ctx, &lsa_pol, 5, domain, psid); + result = cli_lsa_query_info_policy(&cli, cli.mem_ctx, &lsa_pol, 5, domain, psid); if (!NT_STATUS_IS_OK(result)) { DEBUG(0, ("fetch_domain_sid: Error querying lsa policy handle. %s\n", nt_errstr(result) )); @@ -1464,7 +1464,7 @@ Error was : %s.\n", remote_machine, cli_errstr(cli) )); done: - cli_shutdown(cli); + cli_shutdown(&cli); return ret; } diff --git a/source3/rpc_client/cli_samr.c b/source3/rpc_client/cli_samr.c index b1b6623bcd..8eaf20aa1e 100644 --- a/source3/rpc_client/cli_samr.c +++ b/source3/rpc_client/cli_samr.c @@ -51,6 +51,9 @@ NTSTATUS rpccli_samr_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, if (NT_STATUS_IS_OK(result = r.status)) { *connect_pol = r.connect_pol; +#ifdef __INSURE__ + connect_pol->marker = malloc(1); +#endif } return result; @@ -84,6 +87,9 @@ NTSTATUS rpccli_samr_connect4(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, if (NT_STATUS_IS_OK(result = r.status)) { *connect_pol = r.connect_pol; +#ifdef __INSURE__ + connect_pol->marker = malloc(1); +#endif } return result; @@ -118,6 +124,9 @@ NTSTATUS rpccli_samr_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, /* Return output parameters */ if (NT_STATUS_IS_OK(result = r.status)) { +#ifdef __INSURE__ + SAFE_FREE(connect_pol->marker); +#endif *connect_pol = r.pol; } @@ -156,6 +165,9 @@ NTSTATUS rpccli_samr_open_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ct if (NT_STATUS_IS_OK(result = r.status)) { *domain_pol = r.domain_pol; +#ifdef __INSURE__ + domain_pol->marker = malloc(1); +#endif } return result; @@ -191,6 +203,9 @@ NTSTATUS rpccli_samr_open_user(struct rpc_pipe_client *cli, if (NT_STATUS_IS_OK(result = r.status)) { *user_pol = r.user_pol; +#ifdef __INSURE__ + user_pol->marker = malloc(1); +#endif } return result; @@ -228,6 +243,9 @@ NTSTATUS rpccli_samr_open_group(struct rpc_pipe_client *cli, if (NT_STATUS_IS_OK(result = r.status)) { *group_pol = r.pol; +#ifdef __INSURE__ + group_pol->marker = malloc(1); +#endif } return result; @@ -921,6 +939,9 @@ NTSTATUS rpccli_samr_open_alias(struct rpc_pipe_client *cli, if (NT_STATUS_IS_OK(result = r.status)) { *alias_pol = r.pol; +#ifdef __INSURE__ + alias_pol->marker = malloc(1); +#endif } return result; @@ -1196,6 +1217,11 @@ NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli, 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]; @@ -1206,8 +1232,13 @@ NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli, 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); @@ -1234,35 +1265,50 @@ NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli, SamOEMhash( new_nt_password, old_nt_hash, 516); E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc); - return rpccli_samr_chng_pswd_auth_crap(cli, mem_ctx, username, - data_blob_const(new_nt_password,sizeof(new_nt_password)), - data_blob_const(old_nt_hash_enc,sizeof(old_nt_hash_enc)), - data_blob_const(new_lm_password,sizeof(new_lm_password)), - data_blob_const(old_lanman_hash_enc,sizeof(old_lanman_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 passwd with auth crap */ +/* 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) + 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; - char *srv_name_slash; + NTSTATUS result = NT_STATUS_UNSUCCESSFUL; - if (!(srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", - cli->cli->desthost))) { - return NT_STATUS_NO_MEMORY; - } + char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost); - DEBUG(5,("rpccli_samr_chng_pswd_auth_crap on server: %s\n", - srv_name_slash)); + DEBUG(10,("rpccli_samr_chng_pswd_auth_crap\n")); ZERO_STRUCT(q); ZERO_STRUCT(r); @@ -1272,19 +1318,28 @@ NTSTATUS rpccli_samr_chng_pswd_auth_crap(struct rpc_pipe_client *cli, init_samr_q_chgpasswd_user(&q, srv_name_slash, username, new_nt_password.data, old_nt_hash_enc.data, - new_lm_password.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); + q, r, + qbuf, rbuf, + samr_io_q_chgpasswd_user, + samr_io_r_chgpasswd_user, + NT_STATUS_UNSUCCESSFUL); - return r.status; + /* Return output parameters */ + + if (!NT_STATUS_IS_OK(result = r.status)) { + goto done; + } + + done: + + return result; } + /* change password 3 */ NTSTATUS rpccli_samr_chgpasswd3(struct rpc_pipe_client *cli, @@ -1433,59 +1488,7 @@ NTSTATUS rpccli_samr_query_dispinfo(struct rpc_pipe_client *cli, /* Return output parameters */ - result = r.status; - - if (!NT_STATUS_IS_OK(result) && - NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) { - goto done; - } - - *num_entries = r.num_entries; - *start_idx += r.num_entries; /* No next_idx in this structure! */ - - done: - return result; -} - - -/* Query display info2 */ - -NTSTATUS rpccli_samr_query_dispinfo2(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_dispinfo2 for start_idx = %u\n", *start_idx)); - - ZERO_STRUCT(q); - ZERO_STRUCT(r); - - *num_entries = 0; - - /* Marshall data and send request */ - - init_samr_q_query_dispinfo(&q, domain_pol, switch_value, - *start_idx, max_entries, max_size); - - r.ctr = ctr; - - CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO2, - q, r, - qbuf, rbuf, - samr_io_q_query_dispinfo, - samr_io_r_query_dispinfo, - NT_STATUS_UNSUCCESSFUL); - - /* Return output parameters */ - - result = r.status; + result = r.status; if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) { @@ -1499,142 +1502,6 @@ NTSTATUS rpccli_samr_query_dispinfo2(struct rpc_pipe_client *cli, return result; } -/* Query display info */ - -NTSTATUS rpccli_samr_query_dispinfo3(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_dispinfo3 for start_idx = %u\n", *start_idx)); - - ZERO_STRUCT(q); - ZERO_STRUCT(r); - - *num_entries = 0; - - /* Marshall data and send request */ - - init_samr_q_query_dispinfo(&q, domain_pol, switch_value, - *start_idx, max_entries, max_size); - - r.ctr = ctr; - - CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO3, - q, r, - qbuf, rbuf, - samr_io_q_query_dispinfo, - samr_io_r_query_dispinfo, - NT_STATUS_UNSUCCESSFUL); - - /* Return output parameters */ - - result = r.status; - - if (!NT_STATUS_IS_OK(result) && - NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) { - goto done; - } - - *num_entries = r.num_entries; - *start_idx += r.num_entries; /* No next_idx in this structure! */ - - done: - return result; -} - -/* Query display info index */ - -NTSTATUS rpccli_samr_get_dispenum_index(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - POLICY_HND *domain_pol, - uint16 switch_value, - const char *name, - uint32 *idx) -{ - prs_struct qbuf, rbuf; - SAMR_Q_GET_DISPENUM_INDEX q; - SAMR_R_GET_DISPENUM_INDEX r; - NTSTATUS result = NT_STATUS_UNSUCCESSFUL; - - DEBUG(10,("cli_samr_get_dispenum_index for name = %s\n", name)); - - ZERO_STRUCT(q); - ZERO_STRUCT(r); - - /* Marshall data and send request */ - - init_samr_q_get_dispenum_index(&q, domain_pol, switch_value, name); - - CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DISPENUM_INDEX, - q, r, - qbuf, rbuf, - samr_io_q_get_dispenum_index, - samr_io_r_get_dispenum_index, - NT_STATUS_UNSUCCESSFUL); - - /* Return output parameters */ - - *idx = 0; - - result = r.status; - - if (!NT_STATUS_IS_ERR(result)) { - *idx = r.idx; - } - - return result; -} - -NTSTATUS rpccli_samr_get_dispenum_index2(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - POLICY_HND *domain_pol, - uint16 switch_value, - const char *name, - uint32 *idx) -{ - prs_struct qbuf, rbuf; - SAMR_Q_GET_DISPENUM_INDEX q; - SAMR_R_GET_DISPENUM_INDEX r; - NTSTATUS result = NT_STATUS_UNSUCCESSFUL; - - DEBUG(10,("cli_samr_get_dispenum_index2 for name = %s\n", name)); - - ZERO_STRUCT(q); - ZERO_STRUCT(r); - - /* Marshall data and send request */ - - init_samr_q_get_dispenum_index(&q, domain_pol, switch_value, name); - - CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DISPENUM_INDEX2, - q, r, - qbuf, rbuf, - samr_io_q_get_dispenum_index, - samr_io_r_get_dispenum_index, - NT_STATUS_UNSUCCESSFUL); - - /* Return output parameters */ - - *idx = 0; - - result = r.status; - - if (!NT_STATUS_IS_ERR(result)) { - *idx = r.idx; - } - - return result; -} - - /* Lookup rids. Note that NT4 seems to crash if more than ~1000 rids are looked up in one packet. */ diff --git a/source3/rpc_client/cli_srvsvc.c b/source3/rpc_client/cli_srvsvc.c new file mode 100644 index 0000000000..50a68102a3 --- /dev/null +++ b/source3/rpc_client/cli_srvsvc.c @@ -0,0 +1,585 @@ +/* + Unix SMB/CIFS implementation. + NT Domain Authentication SMB / MSRPC client + Copyright (C) Andrew Tridgell 1994-2000 + Copyright (C) Tim Potter 2001 + Copyright (C) Jim McDonough 2002 + Copyright (C) Jeremy Allison 2005. + Copyright (C) Gerald (Jerry) Carter 2006. + + + 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 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +#include "includes.h" + +WERROR rpccli_srvsvc_net_srv_get_info(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + uint32 switch_value, SRV_INFO_CTR *ctr) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_SRV_GET_INFO q; + SRV_R_NET_SRV_GET_INFO r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_srv_get_info(&q, server, switch_value); + r.ctr = ctr; + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_SRV_GET_INFO, + q, r, + qbuf, rbuf, + srv_io_q_net_srv_get_info, + srv_io_r_net_srv_get_info, + WERR_GENERAL_FAILURE); + + result = r.status; + return result; +} + +WERROR rpccli_srvsvc_net_share_enum(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, + uint32 info_level, SRV_SHARE_INFO_CTR *ctr, + int preferred_len, ENUM_HND *hnd) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_SHARE_ENUM q; + SRV_R_NET_SHARE_ENUM r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + int i; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_share_enum(&q, server, info_level, preferred_len, hnd); + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_SHARE_ENUM_ALL, + q, r, + qbuf, rbuf, + srv_io_q_net_share_enum, + srv_io_r_net_share_enum, + WERR_GENERAL_FAILURE); + + result = r.status; + + if (!W_ERROR_IS_OK(result)) + goto done; + + /* Oh yuck yuck yuck - we have to copy all the info out of the + SRV_SHARE_INFO_CTR in the SRV_R_NET_SHARE_ENUM as when we do a + prs_mem_free() it will all be invalidated. The various share + info structures suck badly too. This really is gross. */ + + ZERO_STRUCTP(ctr); + + if (!r.ctr.num_entries) + goto done; + + ctr->info_level = info_level; + ctr->num_entries = r.ctr.num_entries; + + switch(info_level) { + case 1: + ctr->share.info1 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_1, ctr->num_entries); + if (ctr->share.info1 == NULL) { + return WERR_NOMEM; + } + + memset(ctr->share.info1, 0, sizeof(SRV_SHARE_INFO_1)); + + for (i = 0; i < ctr->num_entries; i++) { + SRV_SHARE_INFO_1 *info1 = &ctr->share.info1[i]; + char *s; + + /* Copy pointer crap */ + + memcpy(&info1->info_1, &r.ctr.share.info1[i].info_1, + sizeof(SH_INFO_1)); + + /* Duplicate strings */ + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_netname); + if (s) + init_unistr2(&info1->info_1_str.uni_netname, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info1[i].info_1_str.uni_remark); + if (s) + init_unistr2(&info1->info_1_str.uni_remark, s, UNI_STR_TERMINATE); + + } + + break; + case 2: + ctr->share.info2 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_2, ctr->num_entries); + if (ctr->share.info2 == NULL) { + return WERR_NOMEM; + } + + memset(ctr->share.info2, 0, sizeof(SRV_SHARE_INFO_2)); + + for (i = 0; i < ctr->num_entries; i++) { + SRV_SHARE_INFO_2 *info2 = &ctr->share.info2[i]; + char *s; + + /* Copy pointer crap */ + + memcpy(&info2->info_2, &r.ctr.share.info2[i].info_2, + sizeof(SH_INFO_2)); + + /* Duplicate strings */ + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_netname); + if (s) + init_unistr2(&info2->info_2_str.uni_netname, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_remark); + if (s) + init_unistr2(&info2->info_2_str.uni_remark, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_path); + if (s) + init_unistr2(&info2->info_2_str.uni_path, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info2[i].info_2_str.uni_passwd); + if (s) + init_unistr2(&info2->info_2_str.uni_passwd, s, UNI_STR_TERMINATE); + } + break; + /* adding info-level 502 here */ + case 502: + ctr->share.info502 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_502, ctr->num_entries); + + if (ctr->share.info502 == NULL) { + return WERR_NOMEM; + } + + memset(ctr->share.info502, 0, sizeof(SRV_SHARE_INFO_502)); + + for (i = 0; i < ctr->num_entries; i++) { + SRV_SHARE_INFO_502 *info502 = &ctr->share.info502[i]; + char *s; + + /* Copy pointer crap */ + memcpy(&info502->info_502, &r.ctr.share.info502[i].info_502, + sizeof(SH_INFO_502)); + + /* Duplicate strings */ + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_netname); + if (s) + init_unistr2(&info502->info_502_str.uni_netname, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_remark); + if (s) + init_unistr2(&info502->info_502_str.uni_remark, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_path); + if (s) + init_unistr2(&info502->info_502_str.uni_path, s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &r.ctr.share.info502[i].info_502_str.uni_passwd); + if (s) + init_unistr2(&info502->info_502_str.uni_passwd, s, UNI_STR_TERMINATE); + + info502->info_502_str.sd = dup_sec_desc(mem_ctx, r.ctr.share.info502[i].info_502_str.sd); + } + break; + } + + done: + + return result; +} + +WERROR rpccli_srvsvc_net_share_get_info(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *sharename, + uint32 info_level, + SRV_SHARE_INFO *info) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_SHARE_GET_INFO q; + SRV_R_NET_SHARE_GET_INFO r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_share_get_info(&q, server, sharename, info_level); + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_SHARE_GET_INFO, + q, r, + qbuf, rbuf, + srv_io_q_net_share_get_info, + srv_io_r_net_share_get_info, + WERR_GENERAL_FAILURE); + + result = r.status; + + if (!W_ERROR_IS_OK(result)) + goto done; + + ZERO_STRUCTP(info); + + info->switch_value = info_level; + + switch(info_level) { + case 1: + { + SRV_SHARE_INFO_1 *info1 = &info->share.info1; + SH_INFO_1_STR *info1_str = &info1->info_1_str; + + char *s; + + info->share.info1 = r.info.share.info1; + + /* Duplicate strings */ + + s = unistr2_tdup(mem_ctx, &info1_str->uni_netname); + if (s) + init_unistr2(&info1_str->uni_netname, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info1_str->uni_remark); + if (s) + init_unistr2(&info1_str->uni_remark, + s, UNI_STR_TERMINATE); + + break; + } + case 2: + { + SRV_SHARE_INFO_2 *info2 = &info->share.info2; + SH_INFO_2_STR *info2_str = &info2->info_2_str; + + char *s; + + info->share.info2 = r.info.share.info2; + + /* Duplicate strings */ + + s = unistr2_tdup(mem_ctx, &info2_str->uni_netname); + if (s) + init_unistr2(&info2_str->uni_netname, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info2_str->uni_remark); + if (s) + init_unistr2(&info2_str->uni_remark, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info2_str->uni_path); + if (s) + init_unistr2(&info2_str->uni_path, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info2_str->uni_passwd); + if (s) + init_unistr2(&info2_str->uni_passwd, + s, UNI_STR_TERMINATE); + + + break; + } + case 502: + { + SRV_SHARE_INFO_502 *info502 = &info->share.info502; + SH_INFO_502_STR *info502_str = &info502->info_502_str; + + char *s; + + info->share.info502 = r.info.share.info502; + + /* Duplicate strings */ + + s = unistr2_tdup(mem_ctx, &info502_str->uni_netname); + if (s) + init_unistr2(&info502_str->uni_netname, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info502_str->uni_remark); + if (s) + init_unistr2(&info502_str->uni_remark, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info502_str->uni_path); + if (s) + init_unistr2(&info502_str->uni_path, + s, UNI_STR_TERMINATE); + + s = unistr2_tdup(mem_ctx, &info502_str->uni_passwd); + if (s) + init_unistr2(&info502_str->uni_passwd, + s, UNI_STR_TERMINATE); + + info502_str->sd = dup_sec_desc(mem_ctx, info502_str->sd); + break; + } + default: + DEBUG(0,("unimplemented info-level: %d\n", info_level)); + break; + } + + done: + + return result; +} + +WERROR rpccli_srvsvc_net_share_set_info(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *sharename, + uint32 info_level, + SRV_SHARE_INFO *info) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_SHARE_SET_INFO q; + SRV_R_NET_SHARE_SET_INFO r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_share_set_info(&q, server, sharename, info_level, info); + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_SHARE_SET_INFO, + q, r, + qbuf, rbuf, + srv_io_q_net_share_set_info, + srv_io_r_net_share_set_info, + WERR_GENERAL_FAILURE); + + result = r.status; + return result; +} + +WERROR rpccli_srvsvc_net_share_del(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, + const char *sharename) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_SHARE_DEL q; + SRV_R_NET_SHARE_DEL r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_share_del(&q, server, sharename); + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_SHARE_DEL, + q, r, + qbuf, rbuf, + srv_io_q_net_share_del, + srv_io_r_net_share_del, + WERR_GENERAL_FAILURE); + + result = r.status; + return result; +} + +WERROR rpccli_srvsvc_net_share_add(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, + const char *netname, uint32 type, + const char *remark, uint32 perms, + uint32 max_uses, uint32 num_uses, + const char *path, const char *passwd, + int level, SEC_DESC *sd) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_SHARE_ADD q; + SRV_R_NET_SHARE_ADD r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_share_add(&q,server, netname, type, remark, + perms, max_uses, num_uses, path, passwd, + level, sd); + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_SHARE_ADD, + q, r, + qbuf, rbuf, + srv_io_q_net_share_add, + srv_io_r_net_share_add, + WERR_GENERAL_FAILURE); + + result = r.status; + return result; +} + +WERROR rpccli_srvsvc_net_remote_tod(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, + char *server, TIME_OF_DAY_INFO *tod) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_REMOTE_TOD q; + SRV_R_NET_REMOTE_TOD r; + WERROR result = W_ERROR(ERRgeneral); + fstring server_slash; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server_slash, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server_slash); + + init_srv_q_net_remote_tod(&q, server_slash); + r.tod = tod; + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_REMOTE_TOD, + q, r, + qbuf, rbuf, + srv_io_q_net_remote_tod, + srv_io_r_net_remote_tod, + WERR_GENERAL_FAILURE); + + result = r.status; + return result; +} + +WERROR rpccli_srvsvc_net_file_enum(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, + uint32 file_level, const char *user_name, + SRV_FILE_INFO_CTR *ctr, int preferred_len, + ENUM_HND *hnd) +{ + prs_struct qbuf, rbuf; + SRV_Q_NET_FILE_ENUM q; + SRV_R_NET_FILE_ENUM r; + WERROR result = W_ERROR(ERRgeneral); + fstring server; + int i; + + ZERO_STRUCT(q); + ZERO_STRUCT(r); + + /* Initialise input parameters */ + + slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost); + strupper_m(server); + + init_srv_q_net_file_enum(&q, server, NULL, user_name, + file_level, ctr, preferred_len, hnd); + + /* Marshall data and send request */ + + CLI_DO_RPC_WERR(cli, mem_ctx, PI_SRVSVC, SRV_NET_FILE_ENUM, + q, r, + qbuf, rbuf, + srv_io_q_net_file_enum, + srv_io_r_net_file_enum, + WERR_GENERAL_FAILURE); + + result = r.status; + + if (!W_ERROR_IS_OK(result)) + goto done; + + /* copy the data over to the ctr */ + + ZERO_STRUCTP(ctr); + + ctr->level = file_level; + + ctr->num_entries = ctr->num_entries2 = r.ctr.num_entries; + + switch(file_level) { + case 3: + if (ctr->num_entries) { + if ( (ctr->file.info3 = TALLOC_ARRAY(mem_ctx, FILE_INFO_3, ctr->num_entries)) == NULL ) { + return WERR_NOMEM; + } + + memset(ctr->file.info3, 0, sizeof(FILE_INFO_3) * ctr->num_entries); + } else { + ctr->file.info3 = NULL; + } + + for (i = 0; i < r.ctr.num_entries; i++) { + FILE_INFO_3 *info3 = &ctr->file.info3[i]; + char *s; + + /* Copy pointer crap */ + + memcpy(info3, &r.ctr.file.info3[i], sizeof(FILE_INFO_3)); + + /* Duplicate strings */ + + if ( (s = unistr2_tdup(mem_ctx, r.ctr.file.info3[i].path)) != NULL ) { + info3->path = TALLOC_P( mem_ctx, UNISTR2 ); + init_unistr2(info3->path, s, UNI_STR_TERMINATE); + } + + if ( (s = unistr2_tdup(mem_ctx, r.ctr.file.info3[i].user)) != NULL ) { + info3->user = TALLOC_P( mem_ctx, UNISTR2 ); + init_unistr2(info3->user, s, UNI_STR_TERMINATE); + } + + } + + break; + } + + done: + return result; +} + -- cgit