From 748fe7a383e50079493648839cf0ab69aa2223a0 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Mon, 9 Nov 1998 16:40:38 +0000 Subject: split socket util functions into util_sock.c. util.c NOT committed and util_sock.c NOT included in Makefile.in. registry commands added to rpcclient. waiting for 2_0_0 split before committing modified files. these files are new modules, and are not referenced in the Makefile.in (This used to be commit 373f60256fc6dc800f73d88ea9a302933a4a3246) --- source3/rpc_client/cli_reg.c | 645 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 645 insertions(+) create mode 100644 source3/rpc_client/cli_reg.c (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c new file mode 100644 index 0000000000..2f04facffd --- /dev/null +++ b/source3/rpc_client/cli_reg.c @@ -0,0 +1,645 @@ + +/* + * Unix SMB/Netbios implementation. + * Version 1.9. + * RPC Pipe client / server routines + * Copyright (C) Andrew Tridgell 1992-1997, + * Copyright (C) Luke Kenneth Casson Leighton 1996-1997, + * Copyright (C) Paul Ashton 1997. + * + * 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 + * (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, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#ifdef SYSLOG +#undef SYSLOG +#endif + +#include "includes.h" + +extern int DEBUGLEVEL; + + +/**************************************************************************** +do a REG Open Policy +****************************************************************************/ +BOOL do_reg_open_policy(struct cli_state *cli, uint16 unknown_0, uint32 level, + POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_OPEN_POLICY q_o; + BOOL valid_pol = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_OPEN_POLICY */ + + DEBUG(4,("REG Open Policy\n")); + + make_reg_q_open_pol(&q_o, unknown_0, level); + + /* turn parameters into data stream */ + reg_io_q_open_policy("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_OPEN_POLICY, &buf, &rbuf)) + { + REG_R_OPEN_POLICY r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_open_policy("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_OPEN_POLICY: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + /* ok, at last: we're happy. return the policy handle */ + memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + valid_pol = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_pol; +} + +/**************************************************************************** +do a REG Open Unknown 4 +****************************************************************************/ +BOOL do_reg_open_unk_4(struct cli_state *cli, uint16 unknown_0, uint32 level, + POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_OPEN_UNK_4 q_o; + BOOL valid_pol = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_OPEN_UNK_4 */ + + DEBUG(4,("REG Open Unknown4\n")); + + make_reg_q_open_unk_4(&q_o, unknown_0, level); + + /* turn parameters into data stream */ + reg_io_q_open_unk_4("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_OPEN_UNK_4, &buf, &rbuf)) + { + REG_R_OPEN_UNK_4 r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_open_unk_4("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_OPEN_UNK_4: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + /* ok, at last: we're happy. return the policy handle */ + memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + valid_pol = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_pol; +} + +/**************************************************************************** +do a REG Query Unknown 10 +****************************************************************************/ +BOOL do_reg_query_unk_10(struct cli_state *cli, POLICY_HND *hnd, + uint32 *unknown_0, uint32 *unknown_1, + uint32 *num_subkeys, uint32 *max_subkeylen, + uint32 *unknown_4, uint32 *num_values, + uint32 *max_valnamelen, uint32 *max_valbufsize, + uint32 *unknown_8, NTTIME *mod_time) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_QUERY_UNK_10 q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_QUERY_UNK_10 */ + + DEBUG(4,("REG Query Unknown 10\n")); + + make_reg_q_query_unk_10(&q_o, hnd); + + /* turn parameters into data stream */ + reg_io_q_query_unk_10("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_QUERY_UNK_10, &buf, &rbuf)) + { + REG_R_QUERY_UNK_10 r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_query_unk_10("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_QUERY_UNK_10: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_query = True; + + *unknown_0 = r_o.unknown_0 ; + *unknown_1 = r_o.unknown_1 ; + *num_subkeys = r_o.num_subkeys ; + *max_subkeylen = r_o.max_subkeylen ; + *unknown_4 = r_o.unknown_4 ; + *num_values = r_o.num_values ; + *max_valnamelen = r_o.max_valnamelen; + *max_valbufsize = r_o.max_valbufsize; + *unknown_8 = r_o.unknown_8 ; + *mod_time = r_o.mod_time ; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + +/**************************************************************************** +do a REG Unknown 1A +****************************************************************************/ +BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_UNK_1A q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_UNKNOWN_1A */ + + DEBUG(4,("REG Unknown 1a\n")); + + make_reg_q_unk_1a(&q_o, hnd); + + /* turn parameters into data stream */ + reg_io_q_unk_1a("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf)) + { + REG_R_UNK_1A r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_unk_1a("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_query = True; + (*unk) = r_o.unknown; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + +/**************************************************************************** +do a REG Query Info +****************************************************************************/ +BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, + char *type, uint32 *unk_0, uint32 *unk_1) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_INFO q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_INFO */ + + DEBUG(4,("REG Query Info\n")); + + make_reg_q_info(&q_o, hnd, "ProductType", time(NULL), 4, 1); + + /* turn parameters into data stream */ + reg_io_q_info("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf)) + { + REG_R_INFO r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_info("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_query = True; + fstrcpy(type, buffer2_to_str(&r_o.uni_type)); + (*unk_0) = r_o.unknown_0; + (*unk_1) = r_o.unknown_1; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + +/**************************************************************************** +do a REG Query Key Security +****************************************************************************/ +BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, + uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_GET_KEY_SEC q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_GET_KEY_SEC */ + + DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size)); + + make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, sec_buf); + + /* turn parameters into data stream */ + reg_io_q_get_key_sec("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf)) + { + REG_R_GET_KEY_SEC r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + r_o.data = sec_buf; + reg_io_r_get_key_sec("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status == 0x0000007a) + { + /* + * get the maximum buffer size: it was too small + */ + (*sec_buf_size) = r_o.hdr_sec.buf_max_len; + DEBUG(5,("sec_buf_size too small. use %d\n", *sec_buf_size)); + valid_query = True; + } + else if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + else + { + valid_query = True; + (*sec_buf_size) = r_o.data->len; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + +/**************************************************************************** +do a REG Enum Key +****************************************************************************/ +BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, + int key_index, char *key_name, + uint32 *unk_1, uint32 *unk_2, + time_t *mod_time) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_ENUM_KEY q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_ENUM_KEY */ + + DEBUG(4,("REG Enum Key\n")); + + make_reg_q_enum_key(&q_o, hnd, key_index); + + /* turn parameters into data stream */ + reg_io_q_enum_key("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) + { + REG_R_ENUM_KEY r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_enum_key("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_query = True; + (*unk_1) = r_o.unknown_1; + (*unk_2) = r_o.unknown_2; + fstrcpy(key_name, unistr2(r_o.key_name.str.buffer)); + (*mod_time) = nt_time_to_unix(&r_o.time); + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + +/**************************************************************************** +do a REG Enum Value +****************************************************************************/ +BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, + int val_index, int max_valnamelen, int max_valbufsize, + fstring val_name, + uint32 *val_type, BUFFER2 *value) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_ENUM_VALUE q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_ENUM_VALUE */ + + DEBUG(4,("REG Enum Value\n")); + + make_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize); + + /* turn parameters into data stream */ + reg_io_q_enum_val("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) + { + REG_R_ENUM_VALUE r_o; + BOOL p; + + ZERO_STRUCT(r_o); + r_o.buf_value = value; + + reg_io_r_enum_val("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_query = True; + (*val_type) = r_o.type; + fstrcpy(val_name, unistr2_to_str(&r_o.uni_name)); + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + +/**************************************************************************** +do a REG Open Key +****************************************************************************/ +BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, + char *key_name, uint32 unk_0, + POLICY_HND *key_hnd) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_OPEN_ENTRY q_o; + BOOL valid_pol = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_OPEN_ENTRY */ + + DEBUG(4,("REG Open Entry\n")); + + make_reg_q_open_entry(&q_o, hnd, key_name, unk_0); + + /* turn parameters into data stream */ + reg_io_q_open_entry("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) + { + REG_R_OPEN_ENTRY r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_open_entry("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_pol = True; + memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data)); + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_pol; +} + +/**************************************************************************** +do a REG Close +****************************************************************************/ +BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_CLOSE q_c; + BOOL valid_close = False; + + if (hnd == NULL) return False; + + /* create and send a MSRPC command with api REG_CLOSE */ + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + DEBUG(4,("REG Close\n")); + + /* store the parameters */ + make_reg_q_close(&q_c, hnd); + + /* turn parameters into data stream */ + reg_io_q_close("", &q_c, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) + { + REG_R_CLOSE r_c; + BOOL p; + + ZERO_STRUCT(r_c); + + reg_io_r_close("", &r_c, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_c.status != 0) + { + /* report error code */ + DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status))); + p = False; + } + + if (p) + { + /* check that the returned policy handle is all zeros */ + int i; + valid_close = True; + + for (i = 0; i < sizeof(r_c.pol.data); i++) + { + if (r_c.pol.data[i] != 0) + { + valid_close = False; + break; + } + } + if (!valid_close) + { + DEBUG(0,("REG_CLOSE: non-zero handle returned\n")); + } + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_close; +} + + -- cgit From 1e1c2ec93c204e6fd3ebba6dfb11e4fbc136e10c Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Tue, 10 Nov 1998 19:05:00 +0000 Subject: rpcclient registry commands. (This used to be commit 36fcb4a6e643a05d06a2a273d74318fee7f2c647) --- source3/rpc_client/cli_reg.c | 152 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 133 insertions(+), 19 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 2f04facffd..da92ab90bb 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -147,18 +147,18 @@ BOOL do_reg_open_unk_4(struct cli_state *cli, uint16 unknown_0, uint32 level, } /**************************************************************************** -do a REG Query Unknown 10 +do a REG Query Key ****************************************************************************/ -BOOL do_reg_query_unk_10(struct cli_state *cli, POLICY_HND *hnd, - uint32 *unknown_0, uint32 *unknown_1, +BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, + char *class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, - uint32 *unknown_4, uint32 *num_values, + uint32 *max_subkeysize, uint32 *num_values, uint32 *max_valnamelen, uint32 *max_valbufsize, - uint32 *unknown_8, NTTIME *mod_time) + uint32 *sec_desc, NTTIME *mod_time) { prs_struct rbuf; prs_struct buf; - REG_Q_QUERY_UNK_10 q_o; + REG_Q_QUERY_KEY q_o; BOOL valid_query = False; if (hnd == NULL) return False; @@ -166,30 +166,30 @@ BOOL do_reg_query_unk_10(struct cli_state *cli, POLICY_HND *hnd, prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); - /* create and send a MSRPC command with api REG_QUERY_UNK_10 */ + /* create and send a MSRPC command with api REG_QUERY_KEY */ - DEBUG(4,("REG Query Unknown 10\n")); + DEBUG(4,("REG Query Key\n")); - make_reg_q_query_unk_10(&q_o, hnd); + make_reg_q_query_key(&q_o, hnd, *class_len); /* turn parameters into data stream */ - reg_io_q_query_unk_10("", &q_o, &buf, 0); + reg_io_q_query_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_QUERY_UNK_10, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf)) { - REG_R_QUERY_UNK_10 r_o; + REG_R_QUERY_KEY r_o; BOOL p; ZERO_STRUCT(r_o); - reg_io_r_query_unk_10("", &r_o, &rbuf, 0); + reg_io_r_query_key("", &r_o, &rbuf, 0); p = rbuf.offset != 0; if (p && r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_QUERY_UNK_10: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status))); p = False; } @@ -197,16 +197,16 @@ BOOL do_reg_query_unk_10(struct cli_state *cli, POLICY_HND *hnd, { valid_query = True; - *unknown_0 = r_o.unknown_0 ; - *unknown_1 = r_o.unknown_1 ; + *class_len = r_o.hdr_class.uni_max_len; + fstrcpy(class, unistr2_to_str(&r_o.uni_class)); *num_subkeys = r_o.num_subkeys ; *max_subkeylen = r_o.max_subkeylen ; - *unknown_4 = r_o.unknown_4 ; + *max_subkeysize = r_o.max_subkeysize; *num_values = r_o.num_values ; *max_valnamelen = r_o.max_valnamelen; *max_valbufsize = r_o.max_valbufsize; - *unknown_8 = r_o.unknown_8 ; - *mod_time = r_o.mod_time ; + *sec_desc = r_o.sec_desc ; + *mod_time = r_o.mod_time ; } } @@ -394,6 +394,65 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, return valid_query; } +/**************************************************************************** +do a REG Create Key +****************************************************************************/ +BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, + char *key_name, char *key_class, + SEC_INFO *sam_access, + POLICY_HND *key) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_CREATE_KEY q_o; + BOOL valid_create = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_CREATE_KEY */ + + DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, + sam_access != NULL ? sam_access->perms : 0)); + + make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access); + + /* turn parameters into data stream */ + reg_io_q_create_key("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) + { + REG_R_CREATE_KEY r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_create_key("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_create = True; + memcpy(key, r_o.key_pol.data, sizeof(key->data)); + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_create; +} + /**************************************************************************** do a REG Enum Key ****************************************************************************/ @@ -455,6 +514,61 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, return valid_query; } +/**************************************************************************** +do a REG Create Value +****************************************************************************/ +BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, + char *val_name, uint32 type, BUFFER3 *data) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_CREATE_VALUE q_o; + BOOL valid_create = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_CREATE_VALUE */ + + DEBUG(4,("REG Create Value: %s\n", val_name)); + + make_reg_q_create_val(&q_o, hnd, val_name, type, data); + + /* turn parameters into data stream */ + reg_io_q_create_val("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) + { + REG_R_CREATE_VALUE r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_create_val("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_create = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_create; +} + /**************************************************************************** do a REG Enum Value ****************************************************************************/ -- cgit From c098e44df44e3c6ace3ce00d28140329821e8f3d Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Tue, 10 Nov 1998 22:03:34 +0000 Subject: registry modification requires a "sync" or "refresh" on the parent key. opcode 0xb added to do this. a likely candidate name is "RegFlushKey". (This used to be commit 5e9567e3c7d4ee8624a448fcccfcd8003913dbbf) --- source3/rpc_client/cli_reg.c | 56 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index da92ab90bb..459a865fc0 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -146,6 +146,62 @@ BOOL do_reg_open_unk_4(struct cli_state *cli, uint16 unknown_0, uint32 level, return valid_pol; } +/**************************************************************************** +do a REG Unknown 0xB command. sent after a create key or create value. +this might be some sort of "sync" or "refresh" command, sent after +modification of the registry... +****************************************************************************/ +BOOL do_reg_unk_b(struct cli_state *cli, POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_UNK_B q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_UNK_B */ + + DEBUG(4,("REG Unknown 0xB\n")); + + make_reg_q_unk_b(&q_o, hnd); + + /* turn parameters into data stream */ + reg_io_q_unk_b("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_UNK_B, &buf, &rbuf)) + { + REG_R_UNK_B r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_unk_b("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_UNK_B: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_query = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + /**************************************************************************** do a REG Query Key ****************************************************************************/ -- cgit From 75ca9df787b4fe51032bca71f228fd8526e81fdf Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Tue, 10 Nov 1998 22:14:05 +0000 Subject: rpcclient registry key delete command: "regdeletekey". (This used to be commit 20987b6105d42f3404ff009cc27e73a1823cd495) --- source3/rpc_client/cli_reg.c | 54 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 459a865fc0..3acd8281de 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -450,6 +450,60 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, return valid_query; } +/**************************************************************************** +do a REG Delete Key +****************************************************************************/ +BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_DELETE_KEY q_o; + BOOL valid_delete = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_DELETE_KEY */ + + DEBUG(4,("REG Delete Key: %s\n", key_name)); + + make_reg_q_delete_key(&q_o, hnd, key_name); + + /* turn parameters into data stream */ + reg_io_q_delete_key("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf)) + { + REG_R_DELETE_KEY r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_delete_key("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_delete = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_delete; +} + /**************************************************************************** do a REG Create Key ****************************************************************************/ -- cgit From 07eb9133efc76b141b963fce0e157d7fbbdd939f Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 11 Nov 1998 00:36:15 +0000 Subject: - renamed open_policy to open_hklm. - renamed open_unk_4 to open_hku - fixed createkey issue spotted by phil cox (This used to be commit 7df85b956787f02d022b34ef8cfc13fc967ae89c) --- source3/rpc_client/cli_reg.c | 99 ++++++++++++++++++++++++++++++++++---------- 1 file changed, 78 insertions(+), 21 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 3acd8281de..a38be4149d 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -35,12 +35,69 @@ extern int DEBUGLEVEL; /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_open_policy(struct cli_state *cli, uint16 unknown_0, uint32 level, +BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, + POLICY_HND *reg_hnd, + POLICY_HND *key_hnd) +{ + fstring key_name; + char *srch; + BOOL res1; + BOOL res; + BOOL hklm = False; + BOOL hku = False; + + if (full_keyname == NULL) + { + return False; + } + + srch = "HKLM"; + if (strnequal(full_keyname, srch, strlen(srch))) + { + full_keyname += strlen(srch); + if (*full_keyname == '\\') + { + full_keyname++; + fstrcpy(key_name, full_keyname); + } + else if (*full_keyname != 0) + { + return False; + } + } + + /* open registry receive a policy handle */ + + if (hklm) + { + res = res ? do_reg_open_hklm(cli, + 0x84E0, 0x02000000, + reg_hnd) : False; + } + + if (hku) + { + res = res ? do_reg_open_hku(cli, + 0x84E0, 0x02000000, + reg_hnd) : False; + } + + /* open an entry */ + res1 = res ? do_reg_open_entry(cli, reg_hnd, + key_name, 0x02000000, key_hnd) : False; + + return res1 && res; +} + +/**************************************************************************** +do a REG Open Policy +****************************************************************************/ +BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; - REG_Q_OPEN_POLICY q_o; + REG_Q_OPEN_HKLM q_o; BOOL valid_pol = False; if (hnd == NULL) return False; @@ -48,30 +105,30 @@ BOOL do_reg_open_policy(struct cli_state *cli, uint16 unknown_0, uint32 level, prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); - /* create and send a MSRPC command with api REG_OPEN_POLICY */ + /* create and send a MSRPC command with api REG_OPEN_HKLM */ - DEBUG(4,("REG Open Policy\n")); + DEBUG(4,("REG Open HKLM\n")); - make_reg_q_open_pol(&q_o, unknown_0, level); + make_reg_q_open_hklm(&q_o, unknown_0, level); /* turn parameters into data stream */ - reg_io_q_open_policy("", &q_o, &buf, 0); + reg_io_q_open_hklm("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_OPEN_POLICY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, REG_OPEN_HKLM, &buf, &rbuf)) { - REG_R_OPEN_POLICY r_o; + REG_R_OPEN_HKLM r_o; BOOL p; ZERO_STRUCT(r_o); - reg_io_r_open_policy("", &r_o, &rbuf, 0); + reg_io_r_open_hklm("", &r_o, &rbuf, 0); p = rbuf.offset != 0; if (p && r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_OPEN_POLICY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_OPEN_HKLM: %s\n", get_nt_error_msg(r_o.status))); p = False; } @@ -90,14 +147,14 @@ BOOL do_reg_open_policy(struct cli_state *cli, uint16 unknown_0, uint32 level, } /**************************************************************************** -do a REG Open Unknown 4 +do a REG Open HKU ****************************************************************************/ -BOOL do_reg_open_unk_4(struct cli_state *cli, uint16 unknown_0, uint32 level, +BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; - REG_Q_OPEN_UNK_4 q_o; + REG_Q_OPEN_HKU q_o; BOOL valid_pol = False; if (hnd == NULL) return False; @@ -105,30 +162,30 @@ BOOL do_reg_open_unk_4(struct cli_state *cli, uint16 unknown_0, uint32 level, prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); - /* create and send a MSRPC command with api REG_OPEN_UNK_4 */ + /* create and send a MSRPC command with api REG_OPEN_HKU */ - DEBUG(4,("REG Open Unknown4\n")); + DEBUG(4,("REG Open HKU\n")); - make_reg_q_open_unk_4(&q_o, unknown_0, level); + make_reg_q_open_hku(&q_o, unknown_0, level); /* turn parameters into data stream */ - reg_io_q_open_unk_4("", &q_o, &buf, 0); + reg_io_q_open_hku("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_OPEN_UNK_4, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, REG_OPEN_HKU, &buf, &rbuf)) { - REG_R_OPEN_UNK_4 r_o; + REG_R_OPEN_HKU r_o; BOOL p; ZERO_STRUCT(r_o); - reg_io_r_open_unk_4("", &r_o, &rbuf, 0); + reg_io_r_open_hku("", &r_o, &rbuf, 0); p = rbuf.offset != 0; if (p && r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_OPEN_UNK_4: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_OPEN_HKU: %s\n", get_nt_error_msg(r_o.status))); p = False; } -- cgit From edf630c85ea6a1d4bfa74427190e27c3a97085ea Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 11 Nov 1998 00:43:41 +0000 Subject: renamed unk_1b to flush_key (This used to be commit ddfdb6534671a0e9bbbefe555a92925d41abaddf) --- source3/rpc_client/cli_reg.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index a38be4149d..e1872bbd79 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -208,11 +208,11 @@ do a REG Unknown 0xB command. sent after a create key or create value. this might be some sort of "sync" or "refresh" command, sent after modification of the registry... ****************************************************************************/ -BOOL do_reg_unk_b(struct cli_state *cli, POLICY_HND *hnd) +BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; - REG_Q_UNK_B q_o; + REG_Q_FLUSH_KEY q_o; BOOL valid_query = False; if (hnd == NULL) return False; @@ -220,30 +220,30 @@ BOOL do_reg_unk_b(struct cli_state *cli, POLICY_HND *hnd) prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); - /* create and send a MSRPC command with api REG_UNK_B */ + /* create and send a MSRPC command with api REG_FLUSH_KEY */ DEBUG(4,("REG Unknown 0xB\n")); - make_reg_q_unk_b(&q_o, hnd); + make_reg_q_flush_key(&q_o, hnd); /* turn parameters into data stream */ - reg_io_q_unk_b("", &q_o, &buf, 0); + reg_io_q_flush_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_UNK_B, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, REG_FLUSH_KEY, &buf, &rbuf)) { - REG_R_UNK_B r_o; + REG_R_FLUSH_KEY r_o; BOOL p; ZERO_STRUCT(r_o); - reg_io_r_unk_b("", &r_o, &rbuf, 0); + reg_io_r_flush_key("", &r_o, &rbuf, 0); p = rbuf.offset != 0; if (p && r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_UNK_B: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_FLUSH_KEY: %s\n", get_nt_error_msg(r_o.status))); p = False; } -- cgit From 58cbefdaafcf8dc9389235928eadd17863130bd4 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 11 Nov 1998 00:57:13 +0000 Subject: registry delete value command: "regdeleteval". this is just so unbelievably simple to do... (This used to be commit c05254a15076711d382a58b85b5f08bf81cb1560) --- source3/rpc_client/cli_reg.c | 54 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index e1872bbd79..9ded3c4e67 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -507,6 +507,60 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, return valid_query; } +/**************************************************************************** +do a REG Delete Value +****************************************************************************/ +BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_DELETE_VALUE q_o; + BOOL valid_delete = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_DELETE_VALUE */ + + DEBUG(4,("REG Delete Value: %s\n", val_name)); + + make_reg_q_delete_val(&q_o, hnd, val_name); + + /* turn parameters into data stream */ + reg_io_q_delete_val("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf)) + { + REG_R_DELETE_VALUE r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_delete_val("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_delete = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_delete; +} + /**************************************************************************** do a REG Delete Key ****************************************************************************/ -- cgit From b94520e424bc6e348dcb380ff8285583bbb18a34 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 11 Nov 1998 01:33:57 +0000 Subject: Makefile.in: Added target for makeyodldocs - not used by default. rpc_client/cli_reg.c: The perils of cut-n-paste coding include using variables before they are initialised :-). script/makeyodldocs.sh: Remove the intermediate files. Jeremy. (This used to be commit 88031bca5c528157ef2fe1d976a245b186ff8959) --- source3/rpc_client/cli_reg.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 9ded3c4e67..240a1fbb67 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -42,7 +42,7 @@ BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, fstring key_name; char *srch; BOOL res1; - BOOL res; + BOOL res = False; BOOL hklm = False; BOOL hku = False; @@ -70,16 +70,16 @@ BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, if (hklm) { - res = res ? do_reg_open_hklm(cli, + res = do_reg_open_hklm(cli, 0x84E0, 0x02000000, - reg_hnd) : False; + reg_hnd); } if (hku) { - res = res ? do_reg_open_hku(cli, + res = do_reg_open_hku(cli, 0x84E0, 0x02000000, - reg_hnd) : False; + reg_hnd); } /* open an entry */ -- cgit From 9f14f281ff7efa1af0242a1dd1f5220d5cfdbf49 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 11 Nov 1998 14:23:55 +0000 Subject: changed syntax of registry commands so keys can start with HKLM or HKU. sorted lookupsids command (This used to be commit 13a0ee851fe0ce9acddfe57f9aba19fc78085c39) --- source3/rpc_client/cli_reg.c | 71 ++++++++++++++++++++------------------------ 1 file changed, 33 insertions(+), 38 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 240a1fbb67..27c1c8e760 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -31,62 +31,57 @@ extern int DEBUGLEVEL; - /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, - POLICY_HND *reg_hnd, - POLICY_HND *key_hnd) +BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, + POLICY_HND *reg_hnd) { - fstring key_name; - char *srch; - BOOL res1; - BOOL res = False; - BOOL hklm = False; - BOOL hku = False; + BOOL res = True; + uint32 reg_type = 0; if (full_keyname == NULL) { return False; } - srch = "HKLM"; - if (strnequal(full_keyname, srch, strlen(srch))) + ZERO_STRUCTP(reg_hnd); + + /* + * open registry receive a policy handle + */ + + if (!reg_split_key(full_keyname, ®_type, key_name)) + { + DEBUG(0,("do_reg_connect: unrecognised key name %s\n", full_keyname)); + return False; + } + + switch (reg_type) { - full_keyname += strlen(srch); - if (*full_keyname == '\\') + case HKEY_LOCAL_MACHINE: { - full_keyname++; - fstrcpy(key_name, full_keyname); + res = res ? do_reg_open_hklm(cli, + 0x84E0, 0x02000000, + reg_hnd) : False; + break; } - else if (*full_keyname != 0) + + case HKEY_USERS: { + res = res ? do_reg_open_hku(cli, + 0x84E0, 0x02000000, + reg_hnd) : False; + break; + } + default: + { + DEBUG(0,("do_reg_connect: unrecognised hive key\n")); return False; } } - /* open registry receive a policy handle */ - - if (hklm) - { - res = do_reg_open_hklm(cli, - 0x84E0, 0x02000000, - reg_hnd); - } - - if (hku) - { - res = do_reg_open_hku(cli, - 0x84E0, 0x02000000, - reg_hnd); - } - - /* open an entry */ - res1 = res ? do_reg_open_entry(cli, reg_hnd, - key_name, 0x02000000, key_hnd) : False; - - return res1 && res; + return res; } /**************************************************************************** -- cgit From 60a91a1dca12e675e4498062f33ed773ddd5600a Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 11 Nov 1998 19:22:08 +0000 Subject: clearing up security descriptor (This used to be commit abdc9d790b7d27b70aaf88451f5c82c99c94ca6e) --- source3/rpc_client/cli_reg.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 27c1c8e760..69982a8d44 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -471,6 +471,10 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, ZERO_STRUCT(r_o); r_o.data = sec_buf; + if (*sec_buf_size != 0) + { + sec_buf->sec = (SEC_DESC*)malloc(*sec_buf_size); + } reg_io_r_get_key_sec("", &r_o, &rbuf, 0); p = rbuf.offset != 0; -- cgit From 5b863af4c0179f0bee17e77690d99a54cc762531 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Thu, 12 Nov 1998 16:07:00 +0000 Subject: cleaning up conflicts between group code not yet committed and changes from yesterday by me, jeremy and andrew. jeremy, your ACB_PWNOTREQ mod would have caused a crash if the user didn't exist (first check should be for smb_pass != NULL) (This used to be commit cbac0f165d351ba9497c222e55e453d781376e58) --- source3/rpc_client/cli_reg.c | 54 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 51 insertions(+), 3 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 69982a8d44..5eccdc7826 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -3,9 +3,9 @@ * Unix SMB/Netbios implementation. * Version 1.9. * RPC Pipe client / server routines - * Copyright (C) Andrew Tridgell 1992-1997, - * Copyright (C) Luke Kenneth Casson Leighton 1996-1997, - * Copyright (C) Paul Ashton 1997. + * Copyright (C) Andrew Tridgell 1992-1998, + * Copyright (C) Luke Kenneth Casson Leighton 1996-1998, + * Copyright (C) Paul Ashton 1997-1998. * * 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 @@ -437,6 +437,54 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, return valid_query; } +/**************************************************************************** +do a REG Set Key Security +****************************************************************************/ +BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, + uint32 sec_buf_size, SEC_DESC *sec_buf) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_SET_KEY_SEC q_o; + BOOL valid_query = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_SET_KEY_SEC */ + + DEBUG(4,("REG Set Key security.\n")); + + make_reg_q_set_key_sec(&q_o, hnd, sec_buf_size, sec_buf); + + /* turn parameters into data stream */ + reg_io_q_set_key_sec("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, REG_SET_KEY_SEC, &buf, &rbuf)) + { + REG_R_SET_KEY_SEC r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_set_key_sec("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + valid_query = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_query; +} + /**************************************************************************** do a REG Query Key Security ****************************************************************************/ -- cgit From 2c7f6da1fa95ff77d6c60fcd109205847519434f Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Thu, 12 Nov 1998 23:35:05 +0000 Subject: security descriptors. kanji const char* warnings. (This used to be commit 06abdfd68e1d7fa8741afc3f56ec7a13b5fa4ccc) --- source3/rpc_client/cli_reg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 5eccdc7826..dc6f45ed86 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -667,7 +667,7 @@ do a REG Create Key ****************************************************************************/ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name, char *key_class, - SEC_INFO *sam_access, + SEC_ACCESS *sam_access, POLICY_HND *key) { prs_struct rbuf; @@ -683,7 +683,7 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, /* create and send a MSRPC command with api REG_CREATE_KEY */ DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, - sam_access != NULL ? sam_access->perms : 0)); + sam_access != NULL ? sam_access->mask : 0)); make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access); -- cgit From cb265dbb8b73a177d9e7fd52e53f1eba487b94d4 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Fri, 13 Nov 1998 01:38:41 +0000 Subject: security descriptors (This used to be commit 9412edfd4c11a26e4ef290839375e3959cf70a7e) --- source3/rpc_client/cli_reg.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index dc6f45ed86..61e38a8d96 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -674,6 +674,13 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, prs_struct buf; REG_Q_CREATE_KEY q_o; BOOL valid_create = False; + SEC_DESC sec; + SEC_DESC_BUF sec_buf; + int sec_len; + + ZERO_STRUCT(sec); + ZERO_STRUCT(sec_buf); + ZERO_STRUCT(q_o); if (hnd == NULL) return False; @@ -685,7 +692,13 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, sam_access != NULL ? sam_access->mask : 0)); - make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access); + sec_len = make_sec_desc(&sec, 1, SEC_DESC_SELF_RELATIVE, + NULL, NULL, NULL, NULL); + + DEBUG(10,("make_sec_desc: len = %d\n", sec_len)); + + make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, + &sec_buf, sec_len, &sec); /* turn parameters into data stream */ reg_io_q_create_key("", &q_o, &buf, 0); @@ -715,6 +728,8 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, } } + free_sec_desc(&sec); + prs_mem_free(&rbuf); prs_mem_free(&buf ); -- cgit From 9c848ec329a6ce86cffb2304746590116d9292f0 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Mon, 7 Dec 1998 20:23:41 +0000 Subject: removed nt_pipe_fnum from struct cli_state. need to be able to call LsaLookupSids etc from within SamrQueryAliasMembers, for example. fnum is now a parameter to client functions. thanks to mike black for starting the ball rolling. (This used to be commit bee8f7fa6b0f7f995f71303f4e14a4aaed0c2437) --- source3/rpc_client/cli_reg.c | 70 ++++++++++++++++++++++---------------------- 1 file changed, 35 insertions(+), 35 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 61e38a8d96..b3d2f6e864 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -34,7 +34,7 @@ extern int DEBUGLEVEL; /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, +BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, char *full_keyname, char *key_name, POLICY_HND *reg_hnd) { BOOL res = True; @@ -61,7 +61,7 @@ BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, { case HKEY_LOCAL_MACHINE: { - res = res ? do_reg_open_hklm(cli, + res = res ? do_reg_open_hklm(cli, fnum, 0x84E0, 0x02000000, reg_hnd) : False; break; @@ -69,7 +69,7 @@ BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, case HKEY_USERS: { - res = res ? do_reg_open_hku(cli, + res = res ? do_reg_open_hku(cli, fnum, 0x84E0, 0x02000000, reg_hnd) : False; break; @@ -87,7 +87,7 @@ BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, +BOOL do_reg_open_hklm(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; @@ -110,7 +110,7 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, reg_io_q_open_hklm("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_OPEN_HKLM, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_OPEN_HKLM, &buf, &rbuf)) { REG_R_OPEN_HKLM r_o; BOOL p; @@ -144,7 +144,7 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, /**************************************************************************** do a REG Open HKU ****************************************************************************/ -BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, +BOOL do_reg_open_hku(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; @@ -167,7 +167,7 @@ BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, reg_io_q_open_hku("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_OPEN_HKU, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_OPEN_HKU, &buf, &rbuf)) { REG_R_OPEN_HKU r_o; BOOL p; @@ -203,7 +203,7 @@ do a REG Unknown 0xB command. sent after a create key or create value. this might be some sort of "sync" or "refresh" command, sent after modification of the registry... ****************************************************************************/ -BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) +BOOL do_reg_flush_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; @@ -225,7 +225,7 @@ BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) reg_io_q_flush_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_FLUSH_KEY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_FLUSH_KEY, &buf, &rbuf)) { REG_R_FLUSH_KEY r_o; BOOL p; @@ -257,7 +257,7 @@ BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) /**************************************************************************** do a REG Query Key ****************************************************************************/ -BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, uint32 *max_subkeysize, uint32 *num_values, @@ -284,7 +284,7 @@ BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_query_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_QUERY_KEY, &buf, &rbuf)) { REG_R_QUERY_KEY r_o; BOOL p; @@ -327,7 +327,7 @@ BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Unknown 1A ****************************************************************************/ -BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) +BOOL do_reg_unknown_1a(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, uint32 *unk) { prs_struct rbuf; prs_struct buf; @@ -349,7 +349,7 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) reg_io_q_unk_1a("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_UNK_1A, &buf, &rbuf)) { REG_R_UNK_1A r_o; BOOL p; @@ -382,7 +382,7 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) /**************************************************************************** do a REG Query Info ****************************************************************************/ -BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *type, uint32 *unk_0, uint32 *unk_1) { prs_struct rbuf; @@ -405,7 +405,7 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_info("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_INFO, &buf, &rbuf)) { REG_R_INFO r_o; BOOL p; @@ -440,7 +440,7 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Set Key Security ****************************************************************************/ -BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, uint32 sec_buf_size, SEC_DESC *sec_buf) { prs_struct rbuf; @@ -463,7 +463,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_set_key_sec("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_SET_KEY_SEC, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_SET_KEY_SEC, &buf, &rbuf)) { REG_R_SET_KEY_SEC r_o; BOOL p; @@ -488,7 +488,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Query Key Security ****************************************************************************/ -BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) { prs_struct rbuf; @@ -511,7 +511,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_get_key_sec("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_GET_KEY_SEC, &buf, &rbuf)) { REG_R_GET_KEY_SEC r_o; BOOL p; @@ -557,7 +557,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Delete Value ****************************************************************************/ -BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) +BOOL do_reg_delete_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *val_name) { prs_struct rbuf; prs_struct buf; @@ -579,7 +579,7 @@ BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) reg_io_q_delete_val("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_DELETE_VALUE, &buf, &rbuf)) { REG_R_DELETE_VALUE r_o; BOOL p; @@ -611,7 +611,7 @@ BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) /**************************************************************************** do a REG Delete Key ****************************************************************************/ -BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) +BOOL do_reg_delete_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *key_name) { prs_struct rbuf; prs_struct buf; @@ -633,7 +633,7 @@ BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) reg_io_q_delete_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_DELETE_KEY, &buf, &rbuf)) { REG_R_DELETE_KEY r_o; BOOL p; @@ -665,7 +665,7 @@ BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) /**************************************************************************** do a REG Create Key ****************************************************************************/ -BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *key_name, char *key_class, SEC_ACCESS *sam_access, POLICY_HND *key) @@ -704,7 +704,7 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_create_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_CREATE_KEY, &buf, &rbuf)) { REG_R_CREATE_KEY r_o; BOOL p; @@ -739,7 +739,7 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Enum Key ****************************************************************************/ -BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_enum_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, int key_index, char *key_name, uint32 *unk_1, uint32 *unk_2, time_t *mod_time) @@ -764,7 +764,7 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_enum_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_ENUM_KEY, &buf, &rbuf)) { REG_R_ENUM_KEY r_o; BOOL p; @@ -800,7 +800,7 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Create Value ****************************************************************************/ -BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_create_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *val_name, uint32 type, BUFFER3 *data) { prs_struct rbuf; @@ -823,7 +823,7 @@ BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_create_val("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_CREATE_VALUE, &buf, &rbuf)) { REG_R_CREATE_VALUE r_o; BOOL p; @@ -855,7 +855,7 @@ BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Enum Value ****************************************************************************/ -BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_enum_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, int val_index, int max_valnamelen, int max_valbufsize, fstring val_name, uint32 *val_type, BUFFER2 *value) @@ -880,7 +880,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_enum_val("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_ENUM_VALUE, &buf, &rbuf)) { REG_R_ENUM_VALUE r_o; BOOL p; @@ -915,7 +915,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Open Key ****************************************************************************/ -BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, +BOOL do_reg_open_entry(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *key_name, uint32 unk_0, POLICY_HND *key_hnd) { @@ -939,7 +939,7 @@ BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, reg_io_q_open_entry("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_OPEN_ENTRY, &buf, &rbuf)) { REG_R_OPEN_ENTRY r_o; BOOL p; @@ -972,7 +972,7 @@ BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, /**************************************************************************** do a REG Close ****************************************************************************/ -BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) +BOOL do_reg_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; @@ -995,7 +995,7 @@ BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) reg_io_q_close("", &q_c, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) + if (rpc_api_pipe_req(cli, fnum, REG_CLOSE, &buf, &rbuf)) { REG_R_CLOSE r_c; BOOL p; -- cgit From fd96929ec1fa27e0affd4c4e9ba307c4ee30b978 Mon Sep 17 00:00:00 2001 From: Matthew Chapman Date: Fri, 12 Feb 1999 00:16:09 +0000 Subject: UNICODE cleanup (see lib/util_unistr.c). No more ugly static library buffers and all functions take a destination string length (especially unistrcpy was rather dangerous; we were only saved by the fact that datagrams are limited in size). (This used to be commit a1d39af1ce1d451b811dbd7c2ba391214851b87e) --- source3/rpc_client/cli_reg.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index b3d2f6e864..6fe48599d5 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -306,7 +306,7 @@ BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, valid_query = True; *class_len = r_o.hdr_class.uni_max_len; - fstrcpy(class, unistr2_to_str(&r_o.uni_class)); + unistr2_to_ascii(class, &r_o.uni_class, sizeof(class)); *num_subkeys = r_o.num_subkeys ; *max_subkeylen = r_o.max_subkeylen ; *max_subkeysize = r_o.max_subkeysize; @@ -425,7 +425,8 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, if (p) { valid_query = True; - fstrcpy(type, buffer2_to_str(&r_o.uni_type)); + unistr_to_ascii(type, r_o.uni_type.buffer, + MIN(r_o.uni_type.buf_len, sizeof(type))); (*unk_0) = r_o.unknown_0; (*unk_1) = r_o.unknown_1; } @@ -786,7 +787,8 @@ BOOL do_reg_enum_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, valid_query = True; (*unk_1) = r_o.unknown_1; (*unk_2) = r_o.unknown_2; - fstrcpy(key_name, unistr2(r_o.key_name.str.buffer)); + unistr_to_ascii(key_name, r_o.key_name.str.buffer, + sizeof(key_name)); (*mod_time) = nt_time_to_unix(&r_o.time); } } @@ -902,7 +904,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, { valid_query = True; (*val_type) = r_o.type; - fstrcpy(val_name, unistr2_to_str(&r_o.uni_name)); + unistr2_to_ascii(val_name, &r_o.uni_name, sizeof(val_name)); } } -- cgit From 2737f26ad64ee32d6ef7365dcce0a3eb881f99db Mon Sep 17 00:00:00 2001 From: Matthew Chapman Date: Mon, 15 Feb 1999 05:33:30 +0000 Subject: Always null-terminate strings. Also some string length and sizeof(pointer) corrections. (This used to be commit ce24191939b82985d09eabe945199f38b0fea486) --- source3/rpc_client/cli_reg.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 6fe48599d5..166617ff37 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -306,7 +306,7 @@ BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, valid_query = True; *class_len = r_o.hdr_class.uni_max_len; - unistr2_to_ascii(class, &r_o.uni_class, sizeof(class)); + unistr2_to_ascii(class, &r_o.uni_class, sizeof(fstring)-1); *num_subkeys = r_o.num_subkeys ; *max_subkeylen = r_o.max_subkeylen ; *max_subkeysize = r_o.max_subkeysize; @@ -426,7 +426,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, { valid_query = True; unistr_to_ascii(type, r_o.uni_type.buffer, - MIN(r_o.uni_type.buf_len, sizeof(type))); + MIN(r_o.uni_type.buf_len, sizeof(fstring)-1)); (*unk_0) = r_o.unknown_0; (*unk_1) = r_o.unknown_1; } @@ -788,7 +788,7 @@ BOOL do_reg_enum_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, (*unk_1) = r_o.unknown_1; (*unk_2) = r_o.unknown_2; unistr_to_ascii(key_name, r_o.key_name.str.buffer, - sizeof(key_name)); + sizeof(fstring)-1); (*mod_time) = nt_time_to_unix(&r_o.time); } } @@ -904,7 +904,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, { valid_query = True; (*val_type) = r_o.type; - unistr2_to_ascii(val_name, &r_o.uni_name, sizeof(val_name)); + unistr2_to_ascii(val_name, &r_o.uni_name, sizeof(fstring)-1); } } -- cgit From 52fb07aea26cc3041e571fafdc843622f1741a19 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Tue, 16 Feb 1999 18:04:21 +0000 Subject: rpcclient shutdown command (This used to be commit 59f081069a58f6a070ed6016c06153d5e695da93) --- source3/rpc_client/cli_reg.c | 55 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 166617ff37..fc7f6a5b53 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -1041,4 +1041,59 @@ BOOL do_reg_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) return valid_close; } +/**************************************************************************** +do a REG Shutdown Server +****************************************************************************/ +BOOL do_reg_shutdown(struct cli_state *cli, uint16 fnum, + char *msg, uint32 timeout, uint16 flags) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_SHUTDOWN q_o; + BOOL valid_shutdown = False; + + if (msg == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_SHUTDOWN */ + + DEBUG(4,("REG Shutdown: (timeout: %d secs) %s\n", timeout, msg)); + + make_reg_q_shutdown(&q_o, msg, timeout, flags); + + /* turn parameters into data stream */ + reg_io_q_shutdown("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, fnum, REG_SHUTDOWN, &buf, &rbuf)) + { + REG_R_SHUTDOWN r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_shutdown("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_SHUTDOWN: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + valid_shutdown = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_shutdown; +} + -- cgit From 1e71ecdcb21f24e70ee5edbbc05de0284fa588f4 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Tue, 23 Feb 1999 22:39:54 +0000 Subject: added jeremy's new c++-like code for parsing of security descriptors. (This used to be commit ec1b7000fd88c5a08e438c7033f60e49b9ec44a8) --- source3/rpc_client/cli_reg.c | 44 ++++++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 16 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index fc7f6a5b53..04b1fdc650 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -442,7 +442,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, do a REG Set Key Security ****************************************************************************/ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, - uint32 sec_buf_size, SEC_DESC *sec_buf) + SEC_DESC_BUF *sec_buf) { prs_struct rbuf; prs_struct buf; @@ -458,7 +458,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG Set Key security.\n")); - make_reg_q_set_key_sec(&q_o, hnd, sec_buf_size, sec_buf); + make_reg_q_set_key_sec(&q_o, hnd, sec_buf); /* turn parameters into data stream */ reg_io_q_set_key_sec("", &q_o, &buf, 0); @@ -486,11 +486,13 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, return valid_query; } + /**************************************************************************** do a REG Query Key Security ****************************************************************************/ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, - uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) + uint32 *sec_buf_size, + SEC_DESC_BUF **ppsec_desc_buf) { prs_struct rbuf; prs_struct buf; @@ -506,7 +508,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size)); - make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, sec_buf); + make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, NULL); /* turn parameters into data stream */ reg_io_q_get_key_sec("", &q_o, &buf, 0); @@ -519,11 +521,6 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, ZERO_STRUCT(r_o); - r_o.data = sec_buf; - if (*sec_buf_size != 0) - { - sec_buf->sec = (SEC_DESC*)malloc(*sec_buf_size); - } reg_io_r_get_key_sec("", &r_o, &rbuf, 0); p = rbuf.offset != 0; @@ -546,6 +543,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, { valid_query = True; (*sec_buf_size) = r_o.data->len; + *ppsec_desc_buf = r_o.data; } } @@ -675,9 +673,9 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, prs_struct buf; REG_Q_CREATE_KEY q_o; BOOL valid_create = False; - SEC_DESC sec; - SEC_DESC_BUF sec_buf; - int sec_len; + SEC_DESC *sec; + SEC_DESC_BUF *sec_buf; + size_t sec_len; ZERO_STRUCT(sec); ZERO_STRUCT(sec_buf); @@ -693,13 +691,27 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, sam_access != NULL ? sam_access->mask : 0)); - sec_len = make_sec_desc(&sec, 1, SEC_DESC_SELF_RELATIVE, - NULL, NULL, NULL, NULL); + sec = make_sec_desc(1, SEC_DESC_SELF_RELATIVE, + NULL, NULL, NULL, NULL, &sec_len); + if (sec == NULL) + { + DEBUG(0,("make_sec_desc : malloc fail.\n")); + return False; + } DEBUG(10,("make_sec_desc: len = %d\n", sec_len)); + sec_buf = make_sec_desc_buf( (int)sec_len, sec); + if (sec_buf == NULL) + { + DEBUG(0,("make_sec_desc : malloc fail (1)\n")); + free_sec_desc(&sec); + return False; + } + free_sec_desc(&sec); + make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, - &sec_buf, sec_len, &sec); + sec_buf); /* turn parameters into data stream */ reg_io_q_create_key("", &q_o, &buf, 0); @@ -729,7 +741,7 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, } } - free_sec_desc(&sec); + free_sec_desc_buf(&sec_buf); prs_mem_free(&rbuf); prs_mem_free(&buf ); -- cgit From 373ea639e03e72bef8242133abbf678cf90ed0d9 Mon Sep 17 00:00:00 2001 From: Matthew Chapman Date: Thu, 8 Apr 1999 05:36:15 +0000 Subject: Mainly BDC-related changes. * Added SEC_CHAN_BDC * Propagate sec_chan into the various functions which change trust account passwords, so they can be used for domain control and inter-domain trusts. * Fix for endianness problem reported by Edan Idzerda . A BUFFER2 is really a "unibuf" in my terminology and we should treat it as such. * Added some more common NT structures (BIGINT, BUFHDR2, BUFFER4). * Added NET_SAM_SYNC (-> NetDatabaseSync2) RPC for account replication. Still experimental and incomplete, with a few too many NULL security descriptors lying around (must go look at Jeremy's SD code). Haven't worked out password encryption yet either. However, the XXX_INFO structures I've added to rpc_netlogon.h are quite nice as they give some insight into how these objects are stored in the SAM. (This used to be commit 7b830350eb54dc9d357c115e12ddf9a0633527ac) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 04b1fdc650..c467d8abaa 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -425,7 +425,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, if (p) { valid_query = True; - unistr_to_ascii(type, r_o.uni_type.buffer, + unibuf_to_ascii(type, r_o.uni_type.buffer, MIN(r_o.uni_type.buf_len, sizeof(fstring)-1)); (*unk_0) = r_o.unknown_0; (*unk_1) = r_o.unknown_1; -- cgit From 8598bf2a7f0f71ae7a023aac054c4df42b969ce6 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Tue, 3 Aug 1999 20:30:25 +0000 Subject: reverted jeremy's c++-like security descriptor modifications as the simplest method to get rpcclient's reggetsec command working. the buffers passed as arguments in do_reg_get_key_sec() do need to be locally allocated not dynamically allocated, as two calls to reg_get_key_sec() are needed. on the first, the server fills in the size of the security descriptor buffer needed. on the second, the server fills in the security descriptor buffer. (This used to be commit b2d9cbef6f65bb696df8d8f49aa0c240e0bb1f50) --- source3/rpc_client/cli_reg.c | 43 ++++++++++++++++--------------------------- 1 file changed, 16 insertions(+), 27 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index c467d8abaa..89284e9743 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -442,7 +442,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, do a REG Set Key Security ****************************************************************************/ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, - SEC_DESC_BUF *sec_buf) + uint32 sec_buf_size, SEC_DESC *sec_buf) { prs_struct rbuf; prs_struct buf; @@ -458,7 +458,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG Set Key security.\n")); - make_reg_q_set_key_sec(&q_o, hnd, sec_buf); + make_reg_q_set_key_sec(&q_o, hnd, sec_buf_size, sec_buf); /* turn parameters into data stream */ reg_io_q_set_key_sec("", &q_o, &buf, 0); @@ -491,8 +491,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, do a REG Query Key Security ****************************************************************************/ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, - uint32 *sec_buf_size, - SEC_DESC_BUF **ppsec_desc_buf) + uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) { prs_struct rbuf; prs_struct buf; @@ -508,7 +507,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size)); - make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, NULL); + make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, sec_buf); /* turn parameters into data stream */ reg_io_q_get_key_sec("", &q_o, &buf, 0); @@ -521,6 +520,11 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, ZERO_STRUCT(r_o); + r_o.data = sec_buf; + if (*sec_buf_size != 0) + { + sec_buf->sec = (SEC_DESC*)malloc(*sec_buf_size); + } reg_io_r_get_key_sec("", &r_o, &rbuf, 0); p = rbuf.offset != 0; @@ -543,7 +547,6 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, { valid_query = True; (*sec_buf_size) = r_o.data->len; - *ppsec_desc_buf = r_o.data; } } @@ -673,9 +676,9 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, prs_struct buf; REG_Q_CREATE_KEY q_o; BOOL valid_create = False; - SEC_DESC *sec; - SEC_DESC_BUF *sec_buf; - size_t sec_len; + SEC_DESC sec; + SEC_DESC_BUF sec_buf; + int sec_len; ZERO_STRUCT(sec); ZERO_STRUCT(sec_buf); @@ -691,27 +694,13 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, sam_access != NULL ? sam_access->mask : 0)); - sec = make_sec_desc(1, SEC_DESC_SELF_RELATIVE, - NULL, NULL, NULL, NULL, &sec_len); - if (sec == NULL) - { - DEBUG(0,("make_sec_desc : malloc fail.\n")); - return False; - } + sec_len = make_sec_desc(&sec, 1, SEC_DESC_SELF_RELATIVE, + NULL, NULL, NULL, NULL); DEBUG(10,("make_sec_desc: len = %d\n", sec_len)); - sec_buf = make_sec_desc_buf( (int)sec_len, sec); - if (sec_buf == NULL) - { - DEBUG(0,("make_sec_desc : malloc fail (1)\n")); - free_sec_desc(&sec); - return False; - } - free_sec_desc(&sec); - make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, - sec_buf); + &sec_buf, sec_len, &sec); /* turn parameters into data stream */ reg_io_q_create_key("", &q_o, &buf, 0); @@ -741,7 +730,7 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, } } - free_sec_desc_buf(&sec_buf); + free_sec_desc(&sec); prs_mem_free(&rbuf); prs_mem_free(&buf ); -- cgit From 65df690dcd78ce240e1e1789822e3d3f1c6ac36c Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Fri, 15 Oct 1999 19:23:48 +0000 Subject: renamed "class" local variable to avoid global clash (This used to be commit 134cb4cdff43192a3039a6cce23f331c80fd1990) --- source3/rpc_client/cli_reg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 89284e9743..c6466f4b4f 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -258,7 +258,7 @@ BOOL do_reg_flush_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) do a REG Query Key ****************************************************************************/ BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, - char *class, uint32 *class_len, + char *key_class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, uint32 *max_subkeysize, uint32 *num_values, uint32 *max_valnamelen, uint32 *max_valbufsize, @@ -306,7 +306,7 @@ BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, valid_query = True; *class_len = r_o.hdr_class.uni_max_len; - unistr2_to_ascii(class, &r_o.uni_class, sizeof(fstring)-1); + unistr2_to_ascii(key_class, &r_o.uni_class, sizeof(fstring)-1); *num_subkeys = r_o.num_subkeys ; *max_subkeylen = r_o.max_subkeylen ; *max_subkeysize = r_o.max_subkeysize; -- cgit From 56128244261f8e4c6e1144da66c736fbc2104665 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Mon, 25 Oct 1999 19:03:27 +0000 Subject: - typecast malloc / Realloc issues. - signed / unsigned issues. (This used to be commit c8fd555179314baf1672a23db34dc8ad9f2d02bf) --- source3/rpc_client/cli_reg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index c6466f4b4f..cbbd6e57bf 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -425,7 +425,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, if (p) { valid_query = True; - unibuf_to_ascii(type, r_o.uni_type.buffer, + unibuf_to_ascii(type, (const char*)r_o.uni_type.buffer, MIN(r_o.uni_type.buf_len, sizeof(fstring)-1)); (*unk_0) = r_o.unknown_0; (*unk_1) = r_o.unknown_1; @@ -1018,7 +1018,7 @@ BOOL do_reg_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) if (p) { /* check that the returned policy handle is all zeros */ - int i; + uint32 i; valid_close = True; for (i = 0; i < sizeof(r_c.pol.data); i++) -- cgit From 3d096e1b8f5a253b61cbfa6155b0a16a5394c847 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Fri, 29 Oct 1999 16:24:11 +0000 Subject: added HKEY_CLASSES_ROOT MSRPC open call. reg_open_hkcr etc. supported in rpcclient, regenum HKEY_CLASSES_ROOT or regenum HKCR to test. (This used to be commit b0aa933ef4c0b58840430cf3b3cb3cbeb5c7f704) --- source3/rpc_client/cli_reg.c | 65 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index cbbd6e57bf..49423beaa5 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -59,6 +59,14 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, char *full_keyname, char switch (reg_type) { + case HKEY_CLASSES_ROOT: + { + res = res ? do_reg_open_hkcr(cli, fnum, + 0x5428, 0x02000000, + reg_hnd) : False; + break; + } + case HKEY_LOCAL_MACHINE: { res = res ? do_reg_open_hklm(cli, fnum, @@ -84,6 +92,63 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, char *full_keyname, char return res; } +/**************************************************************************** +do a REG Open Policy +****************************************************************************/ +BOOL do_reg_open_hkcr(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint32 level, + POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct buf; + REG_Q_OPEN_HKCR q_o; + BOOL valid_pol = False; + + if (hnd == NULL) return False; + + prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); + prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + + /* create and send a MSRPC command with api REG_OPEN_HKCR */ + + DEBUG(4,("REG Open HKCR\n")); + + make_reg_q_open_hkcr(&q_o, unknown_0, level); + + /* turn parameters into data stream */ + reg_io_q_open_hkcr("", &q_o, &buf, 0); + + /* send the data on \PIPE\ */ + if (rpc_api_pipe_req(cli, fnum, REG_OPEN_HKCR, &buf, &rbuf)) + { + REG_R_OPEN_HKCR r_o; + BOOL p; + + ZERO_STRUCT(r_o); + + reg_io_r_open_hkcr("", &r_o, &rbuf, 0); + p = rbuf.offset != 0; + + if (p && r_o.status != 0) + { + /* report error code */ + DEBUG(0,("REG_OPEN_HKCR: %s\n", get_nt_error_msg(r_o.status))); + p = False; + } + + if (p) + { + /* ok, at last: we're happy. return the policy handle */ + memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + valid_pol = True; + } + } + + prs_mem_free(&rbuf); + prs_mem_free(&buf ); + + return valid_pol; +} + /**************************************************************************** do a REG Open Policy ****************************************************************************/ -- cgit From bcf1c3182670f20f4705cfe73e27d1e2e9f8eedf Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Fri, 29 Oct 1999 20:24:18 +0000 Subject: rpcclient regenum key client code rewritten to use higher order functions. (This used to be commit 6a759c57dcb851aa19d1d4156249a3df112aefd0) --- source3/rpc_client/cli_reg.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 49423beaa5..38d7e6ebc8 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -34,7 +34,9 @@ extern int DEBUGLEVEL; /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, char *full_keyname, char *key_name, +BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, + const char *full_keyname, + char *key_name, POLICY_HND *reg_hnd) { BOOL res = True; -- cgit From ccc8585567804d6a7e6f684a97d58871e2fd9f8a Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Thu, 18 Nov 1999 00:26:11 +0000 Subject: added regqueryval command (experimental) to get reg_io_q_info() and reg_io_r_info() working properly. previously they weren't well understood (well, they were the first of the registry functions i did, back in december 97, ok??? :-) set ntversion to 0x1 in SAMQUERY, so that we reply same as NT4 srv. (This used to be commit 98ddeaf442cb30972cb281bf0489a6e5f7eb2883) --- source3/rpc_client/cli_reg.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 38d7e6ebc8..53d17bdefa 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -450,7 +450,8 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, uint do a REG Query Info ****************************************************************************/ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, - char *type, uint32 *unk_0, uint32 *unk_1) + const char* val_name, + char *type) { prs_struct rbuf; prs_struct buf; @@ -466,7 +467,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG Query Info\n")); - make_reg_q_info(&q_o, hnd, "ProductType", time(NULL), 4, 1); + make_reg_q_info(&q_o, hnd, val_name, 4, 0); /* turn parameters into data stream */ reg_io_q_info("", &q_o, &buf, 0); @@ -494,8 +495,6 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, valid_query = True; unibuf_to_ascii(type, (const char*)r_o.uni_type.buffer, MIN(r_o.uni_type.buf_len, sizeof(fstring)-1)); - (*unk_0) = r_o.unknown_0; - (*unk_1) = r_o.unknown_1; } } -- cgit From a394a4a8fa2c4c0ff03fbc5bc4ea925245ec1fed Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Thu, 18 Nov 1999 17:57:21 +0000 Subject: updating reg_value_info() parsing code to take BUFFER2 instead of just a char*. now copes with multiple types. (This used to be commit 3df7c903c5b70f336294a95ad864aedbacf544b0) --- source3/rpc_client/cli_reg.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 53d17bdefa..dbdf98dcf7 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -451,7 +451,7 @@ do a REG Query Info ****************************************************************************/ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, const char* val_name, - char *type) + uint32 *type, BUFFER2 *buffer) { prs_struct rbuf; prs_struct buf; @@ -480,6 +480,9 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, ZERO_STRUCT(r_o); + r_o.type = type; + r_o.uni_type = buffer; + reg_io_r_info("", &r_o, &rbuf, 0); p = rbuf.offset != 0; @@ -493,8 +496,6 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, if (p) { valid_query = True; - unibuf_to_ascii(type, (const char*)r_o.uni_type.buffer, - MIN(r_o.uni_type.buf_len, sizeof(fstring)-1)); } } -- cgit From d7889cd22347e7acd4effb7682d442eef7a666e4 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 24 Nov 1999 18:09:33 +0000 Subject: rewrote policy handle code to be generic (it's needed for client-side too) attempted to fix regsetsec command (This used to be commit eaac0923e0e5e3f4c3d944272a71f3235ac2a741) --- source3/rpc_client/cli_reg.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index dbdf98dcf7..1bad3e16a4 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -509,6 +509,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, do a REG Set Key Security ****************************************************************************/ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, + uint32 sec_info, uint32 sec_buf_size, SEC_DESC *sec_buf) { prs_struct rbuf; @@ -525,7 +526,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG Set Key security.\n")); - make_reg_q_set_key_sec(&q_o, hnd, sec_buf_size, sec_buf); + make_reg_q_set_key_sec(&q_o, hnd, sec_info, sec_buf_size, sec_buf); /* turn parameters into data stream */ reg_io_q_set_key_sec("", &q_o, &buf, 0); @@ -558,6 +559,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, do a REG Query Key Security ****************************************************************************/ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, + uint32 sec_info, uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) { prs_struct rbuf; @@ -574,7 +576,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size)); - make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, sec_buf); + make_reg_q_get_key_sec(&q_o, hnd, sec_info, *sec_buf_size, sec_buf); /* turn parameters into data stream */ reg_io_q_get_key_sec("", &q_o, &buf, 0); -- cgit From ac4dd24140074a43f880c59e61770ef4e7c6523b Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 24 Nov 1999 23:40:20 +0000 Subject: registry API moved over to new format. reg_connect() is the top-level function, which takes \\server_name. tested a _few_ functions. found that regcreatekey receives a Fault PDU. (This used to be commit 45e92258e7df84c21d23c0be7e1d85457ccac551) --- source3/rpc_client/cli_reg.c | 202 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 175 insertions(+), 27 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 1bad3e16a4..46ab55dcab 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -34,7 +34,7 @@ extern int DEBUGLEVEL; /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, +BOOL reg_connect( const char* srv_name, const char *full_keyname, char *key_name, POLICY_HND *reg_hnd) @@ -42,20 +42,29 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, BOOL res = True; uint32 reg_type = 0; - if (full_keyname == NULL) + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_init(srv_name, PIPE_WINREG, &cli, &fnum)) { return False; } ZERO_STRUCTP(reg_hnd); + if (full_keyname == NULL) + { + return False; + } + /* * open registry receive a policy handle */ if (!reg_split_key(full_keyname, ®_type, key_name)) { - DEBUG(0,("do_reg_connect: unrecognised key name %s\n", full_keyname)); + DEBUG(0,("reg_connect: unrecognised key name %s\n", + full_keyname)); return False; } @@ -63,7 +72,7 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, { case HKEY_CLASSES_ROOT: { - res = res ? do_reg_open_hkcr(cli, fnum, + res = res ? reg_open_hkcr(cli, fnum, 0x5428, 0x02000000, reg_hnd) : False; break; @@ -71,7 +80,7 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, case HKEY_LOCAL_MACHINE: { - res = res ? do_reg_open_hklm(cli, fnum, + res = res ? reg_open_hklm(cli, fnum, 0x84E0, 0x02000000, reg_hnd) : False; break; @@ -79,14 +88,25 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, case HKEY_USERS: { - res = res ? do_reg_open_hku(cli, fnum, + res = res ? reg_open_hku(cli, fnum, 0x84E0, 0x02000000, reg_hnd) : False; break; } default: { - DEBUG(0,("do_reg_connect: unrecognised hive key\n")); + DEBUG(0,("reg_connect: unrecognised hive key\n")); + return False; + } + } + + if (res) + { + if (!register_policy_hnd(reg_hnd) || + !set_policy_cli_state(reg_hnd, cli, fnum, + cli_state_free)) + { + cli_state_free(cli, fnum); return False; } } @@ -97,7 +117,8 @@ BOOL do_reg_connect(struct cli_state *cli, uint16 fnum, /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_open_hkcr(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint32 level, +BOOL reg_open_hkcr( struct cli_state *cli, uint16 fnum, + uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; @@ -154,7 +175,8 @@ BOOL do_reg_open_hkcr(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL do_reg_open_hklm(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint32 level, +BOOL reg_open_hklm( struct cli_state *cli, uint16 fnum, + uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; @@ -211,7 +233,8 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint /**************************************************************************** do a REG Open HKU ****************************************************************************/ -BOOL do_reg_open_hku(struct cli_state *cli, uint16 fnum, uint16 unknown_0, uint32 level, +BOOL reg_open_hku( struct cli_state *cli, uint16 fnum, + uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; @@ -270,13 +293,21 @@ do a REG Unknown 0xB command. sent after a create key or create value. this might be some sort of "sync" or "refresh" command, sent after modification of the registry... ****************************************************************************/ -BOOL do_reg_flush_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) +BOOL reg_flush_key( POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; REG_Q_FLUSH_KEY q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -324,7 +355,7 @@ BOOL do_reg_flush_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) /**************************************************************************** do a REG Query Key ****************************************************************************/ -BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_query_key( POLICY_HND *hnd, char *key_class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, uint32 *max_subkeysize, uint32 *num_values, @@ -336,6 +367,14 @@ BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_QUERY_KEY q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -394,13 +433,21 @@ BOOL do_reg_query_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Unknown 1A ****************************************************************************/ -BOOL do_reg_unknown_1a(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, uint32 *unk) +BOOL reg_unknown_1a( POLICY_HND *hnd, uint32 *unk) { prs_struct rbuf; prs_struct buf; REG_Q_UNK_1A q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -449,7 +496,7 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, uint /**************************************************************************** do a REG Query Info ****************************************************************************/ -BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_query_info( POLICY_HND *hnd, const char* val_name, uint32 *type, BUFFER2 *buffer) { @@ -458,6 +505,14 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_INFO q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -508,7 +563,7 @@ BOOL do_reg_query_info(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Set Key Security ****************************************************************************/ -BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_set_key_sec( POLICY_HND *hnd, uint32 sec_info, uint32 sec_buf_size, SEC_DESC *sec_buf) { @@ -517,6 +572,14 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_SET_KEY_SEC q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -558,7 +621,7 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Query Key Security ****************************************************************************/ -BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_get_key_sec( POLICY_HND *hnd, uint32 sec_info, uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) { @@ -567,6 +630,14 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_GET_KEY_SEC q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -628,13 +699,21 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Delete Value ****************************************************************************/ -BOOL do_reg_delete_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *val_name) +BOOL reg_delete_val( POLICY_HND *hnd, char *val_name) { prs_struct rbuf; prs_struct buf; REG_Q_DELETE_VALUE q_o; BOOL valid_delete = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -682,13 +761,21 @@ BOOL do_reg_delete_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char /**************************************************************************** do a REG Delete Key ****************************************************************************/ -BOOL do_reg_delete_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char *key_name) +BOOL reg_delete_key( POLICY_HND *hnd, char *key_name) { prs_struct rbuf; prs_struct buf; REG_Q_DELETE_KEY q_o; BOOL valid_delete = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -736,7 +823,7 @@ BOOL do_reg_delete_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, char /**************************************************************************** do a REG Create Key ****************************************************************************/ -BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_create_key( POLICY_HND *hnd, char *key_name, char *key_class, SEC_ACCESS *sam_access, POLICY_HND *key) @@ -749,6 +836,14 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, SEC_DESC_BUF sec_buf; int sec_len; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + ZERO_STRUCT(sec); ZERO_STRUCT(sec_buf); ZERO_STRUCT(q_o); @@ -810,7 +905,7 @@ BOOL do_reg_create_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Enum Key ****************************************************************************/ -BOOL do_reg_enum_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_enum_key( POLICY_HND *hnd, int key_index, char *key_name, uint32 *unk_1, uint32 *unk_2, time_t *mod_time) @@ -820,6 +915,14 @@ BOOL do_reg_enum_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_ENUM_KEY q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -872,7 +975,7 @@ BOOL do_reg_enum_key(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Create Value ****************************************************************************/ -BOOL do_reg_create_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_create_val( POLICY_HND *hnd, char *val_name, uint32 type, BUFFER3 *data) { prs_struct rbuf; @@ -880,6 +983,14 @@ BOOL do_reg_create_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_CREATE_VALUE q_o; BOOL valid_create = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -927,7 +1038,7 @@ BOOL do_reg_create_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Enum Value ****************************************************************************/ -BOOL do_reg_enum_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_enum_val( POLICY_HND *hnd, int val_index, int max_valnamelen, int max_valbufsize, fstring val_name, uint32 *val_type, BUFFER2 *value) @@ -937,6 +1048,14 @@ BOOL do_reg_enum_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_ENUM_VALUE q_o; BOOL valid_query = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -987,7 +1106,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Open Key ****************************************************************************/ -BOOL do_reg_open_entry(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, +BOOL reg_open_entry( POLICY_HND *hnd, char *key_name, uint32 unk_0, POLICY_HND *key_hnd) { @@ -996,6 +1115,14 @@ BOOL do_reg_open_entry(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, REG_Q_OPEN_ENTRY q_o; BOOL valid_pol = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -1030,8 +1157,9 @@ BOOL do_reg_open_entry(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, if (p) { - valid_pol = True; memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data)); + valid_pol = register_policy_hnd(key_hnd) && + set_policy_cli_state(key_hnd, cli, fnum, NULL); } } @@ -1044,13 +1172,21 @@ BOOL do_reg_open_entry(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd, /**************************************************************************** do a REG Close ****************************************************************************/ -BOOL do_reg_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) +BOOL reg_close( POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; REG_Q_CLOSE q_c; BOOL valid_close = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + if (hnd == NULL) return False; /* create and send a MSRPC command with api REG_CLOSE */ @@ -1108,20 +1244,30 @@ BOOL do_reg_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd) prs_mem_free(&rbuf); prs_mem_free(&buf ); + close_policy_hnd(hnd); + return valid_close; } /**************************************************************************** do a REG Shutdown Server ****************************************************************************/ -BOOL do_reg_shutdown(struct cli_state *cli, uint16 fnum, - char *msg, uint32 timeout, uint16 flags) +BOOL reg_shutdown(const char *srv_name, + const char *msg, uint32 timeout, uint16 flags) { prs_struct rbuf; prs_struct buf; REG_Q_SHUTDOWN q_o; BOOL valid_shutdown = False; + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_init(srv_name, PIPE_WINREG, &cli, &fnum)) + { + return False; + } + if (msg == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -1163,6 +1309,8 @@ BOOL do_reg_shutdown(struct cli_state *cli, uint16 fnum, prs_mem_free(&rbuf); prs_mem_free(&buf ); + cli_state_free(cli, fnum); + return valid_shutdown; } -- cgit From 75bc1009438c2ff1696205ab0ee5667ec3ef3062 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Thu, 25 Nov 1999 05:26:48 +0000 Subject: cool! completed a samr* API that _would_ look like an msdn samr* api... if microsoft bothered to publish it. actually, there are good reasons for not publishing it: people might write programs for it, and then those programs wouldn't work on nt5, for example... (This used to be commit 8ce93b80d3b4e1c1e28aa1dde38cdef184eff3c1) --- source3/rpc_client/cli_reg.c | 153 +++++++------------------------------------ 1 file changed, 24 insertions(+), 129 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 46ab55dcab..9242d5587c 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -300,14 +300,6 @@ BOOL reg_flush_key( POLICY_HND *hnd) REG_Q_FLUSH_KEY q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -323,7 +315,7 @@ BOOL reg_flush_key( POLICY_HND *hnd) reg_io_q_flush_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_FLUSH_KEY, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_FLUSH_KEY, &buf, &rbuf)) { REG_R_FLUSH_KEY r_o; BOOL p; @@ -367,14 +359,6 @@ BOOL reg_query_key( POLICY_HND *hnd, REG_Q_QUERY_KEY q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -390,7 +374,7 @@ BOOL reg_query_key( POLICY_HND *hnd, reg_io_q_query_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_QUERY_KEY, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_QUERY_KEY, &buf, &rbuf)) { REG_R_QUERY_KEY r_o; BOOL p; @@ -440,14 +424,6 @@ BOOL reg_unknown_1a( POLICY_HND *hnd, uint32 *unk) REG_Q_UNK_1A q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -463,7 +439,7 @@ BOOL reg_unknown_1a( POLICY_HND *hnd, uint32 *unk) reg_io_q_unk_1a("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_UNK_1A, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_UNK_1A, &buf, &rbuf)) { REG_R_UNK_1A r_o; BOOL p; @@ -505,14 +481,6 @@ BOOL reg_query_info( POLICY_HND *hnd, REG_Q_INFO q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -528,7 +496,7 @@ BOOL reg_query_info( POLICY_HND *hnd, reg_io_q_info("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_INFO, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_INFO, &buf, &rbuf)) { REG_R_INFO r_o; BOOL p; @@ -572,14 +540,6 @@ BOOL reg_set_key_sec( POLICY_HND *hnd, REG_Q_SET_KEY_SEC q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -595,7 +555,7 @@ BOOL reg_set_key_sec( POLICY_HND *hnd, reg_io_q_set_key_sec("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_SET_KEY_SEC, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_SET_KEY_SEC, &buf, &rbuf)) { REG_R_SET_KEY_SEC r_o; BOOL p; @@ -630,14 +590,6 @@ BOOL reg_get_key_sec( POLICY_HND *hnd, REG_Q_GET_KEY_SEC q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -653,7 +605,7 @@ BOOL reg_get_key_sec( POLICY_HND *hnd, reg_io_q_get_key_sec("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_GET_KEY_SEC, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_GET_KEY_SEC, &buf, &rbuf)) { REG_R_GET_KEY_SEC r_o; BOOL p; @@ -706,14 +658,6 @@ BOOL reg_delete_val( POLICY_HND *hnd, char *val_name) REG_Q_DELETE_VALUE q_o; BOOL valid_delete = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -729,7 +673,7 @@ BOOL reg_delete_val( POLICY_HND *hnd, char *val_name) reg_io_q_delete_val("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_DELETE_VALUE, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_DELETE_VALUE, &buf, &rbuf)) { REG_R_DELETE_VALUE r_o; BOOL p; @@ -768,14 +712,6 @@ BOOL reg_delete_key( POLICY_HND *hnd, char *key_name) REG_Q_DELETE_KEY q_o; BOOL valid_delete = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -791,7 +727,7 @@ BOOL reg_delete_key( POLICY_HND *hnd, char *key_name) reg_io_q_delete_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_DELETE_KEY, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_DELETE_KEY, &buf, &rbuf)) { REG_R_DELETE_KEY r_o; BOOL p; @@ -836,14 +772,6 @@ BOOL reg_create_key( POLICY_HND *hnd, SEC_DESC_BUF sec_buf; int sec_len; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - ZERO_STRUCT(sec); ZERO_STRUCT(sec_buf); ZERO_STRUCT(q_o); @@ -870,7 +798,7 @@ BOOL reg_create_key( POLICY_HND *hnd, reg_io_q_create_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_CREATE_KEY, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_CREATE_KEY, &buf, &rbuf)) { REG_R_CREATE_KEY r_o; BOOL p; @@ -915,14 +843,6 @@ BOOL reg_enum_key( POLICY_HND *hnd, REG_Q_ENUM_KEY q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -938,7 +858,7 @@ BOOL reg_enum_key( POLICY_HND *hnd, reg_io_q_enum_key("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_ENUM_KEY, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_ENUM_KEY, &buf, &rbuf)) { REG_R_ENUM_KEY r_o; BOOL p; @@ -983,14 +903,6 @@ BOOL reg_create_val( POLICY_HND *hnd, REG_Q_CREATE_VALUE q_o; BOOL valid_create = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -1006,7 +918,7 @@ BOOL reg_create_val( POLICY_HND *hnd, reg_io_q_create_val("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_CREATE_VALUE, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_CREATE_VALUE, &buf, &rbuf)) { REG_R_CREATE_VALUE r_o; BOOL p; @@ -1048,14 +960,6 @@ BOOL reg_enum_val( POLICY_HND *hnd, REG_Q_ENUM_VALUE q_o; BOOL valid_query = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -1071,7 +975,7 @@ BOOL reg_enum_val( POLICY_HND *hnd, reg_io_q_enum_val("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_ENUM_VALUE, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_ENUM_VALUE, &buf, &rbuf)) { REG_R_ENUM_VALUE r_o; BOOL p; @@ -1115,14 +1019,6 @@ BOOL reg_open_entry( POLICY_HND *hnd, REG_Q_OPEN_ENTRY q_o; BOOL valid_pol = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); @@ -1138,7 +1034,7 @@ BOOL reg_open_entry( POLICY_HND *hnd, reg_io_q_open_entry("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_OPEN_ENTRY, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_OPEN_ENTRY, &buf, &rbuf)) { REG_R_OPEN_ENTRY r_o; BOOL p; @@ -1157,9 +1053,16 @@ BOOL reg_open_entry( POLICY_HND *hnd, if (p) { + struct cli_state *cli = NULL; + uint16 fnum = 0xffff; + + if (!cli_state_get(hnd, &cli, &fnum)) + { + return False; + } + memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data)); - valid_pol = register_policy_hnd(key_hnd) && - set_policy_cli_state(key_hnd, cli, fnum, NULL); + valid_pol = cli_pol_link(key_hnd, hnd); } } @@ -1179,14 +1082,6 @@ BOOL reg_close( POLICY_HND *hnd) REG_Q_CLOSE q_c; BOOL valid_close = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; - - if (!cli_state_get(hnd, &cli, &fnum)) - { - return False; - } - if (hnd == NULL) return False; /* create and send a MSRPC command with api REG_CLOSE */ @@ -1203,7 +1098,7 @@ BOOL reg_close( POLICY_HND *hnd) reg_io_q_close("", &q_c, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_CLOSE, &buf, &rbuf)) + if (rpc_hnd_pipe_req(hnd, REG_CLOSE, &buf, &rbuf)) { REG_R_CLOSE r_c; BOOL p; @@ -1263,7 +1158,7 @@ BOOL reg_shutdown(const char *srv_name, struct cli_state *cli = NULL; uint16 fnum = 0xffff; - if (!cli_state_init(srv_name, PIPE_WINREG, &cli, &fnum)) + if (!cli_state_init(srv_name, PIPE_LSARPC, &cli, &fnum)) { return False; } -- cgit From 3fc5ec73be6009d50ec1e8e83505572ad16c1943 Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Sat, 27 Nov 1999 21:50:11 +0000 Subject: further abstraction involving client states. main client-side code is pretty much independent of SMB client states, which will make it easier to add other transports. (This used to be commit a1ff7e8fc3129ba4a04722f977bc2d3725d13624) --- source3/rpc_client/cli_reg.c | 43 ++++++++++++++++++++----------------------- 1 file changed, 20 insertions(+), 23 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 9242d5587c..4f1c28a701 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -42,10 +42,9 @@ BOOL reg_connect( const char* srv_name, BOOL res = True; uint32 reg_type = 0; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; + struct cli_connection *con = NULL; - if (!cli_state_init(srv_name, PIPE_WINREG, &cli, &fnum)) + if (!cli_connection_init(srv_name, PIPE_WINREG, &con)) { return False; } @@ -72,7 +71,7 @@ BOOL reg_connect( const char* srv_name, { case HKEY_CLASSES_ROOT: { - res = res ? reg_open_hkcr(cli, fnum, + res = res ? reg_open_hkcr(con, 0x5428, 0x02000000, reg_hnd) : False; break; @@ -80,7 +79,7 @@ BOOL reg_connect( const char* srv_name, case HKEY_LOCAL_MACHINE: { - res = res ? reg_open_hklm(cli, fnum, + res = res ? reg_open_hklm(con, 0x84E0, 0x02000000, reg_hnd) : False; break; @@ -88,7 +87,7 @@ BOOL reg_connect( const char* srv_name, case HKEY_USERS: { - res = res ? reg_open_hku(cli, fnum, + res = res ? reg_open_hku(con, 0x84E0, 0x02000000, reg_hnd) : False; break; @@ -103,10 +102,10 @@ BOOL reg_connect( const char* srv_name, if (res) { if (!register_policy_hnd(reg_hnd) || - !set_policy_cli_state(reg_hnd, cli, fnum, - cli_state_free)) + !set_policy_con(reg_hnd, con, + cli_connection_unlink)) { - cli_state_free(cli, fnum); + cli_connection_unlink(con); return False; } } @@ -117,7 +116,7 @@ BOOL reg_connect( const char* srv_name, /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL reg_open_hkcr( struct cli_state *cli, uint16 fnum, +BOOL reg_open_hkcr( struct cli_connection *con, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { @@ -141,7 +140,7 @@ BOOL reg_open_hkcr( struct cli_state *cli, uint16 fnum, reg_io_q_open_hkcr("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_OPEN_HKCR, &buf, &rbuf)) + if (rpc_con_pipe_req(con, REG_OPEN_HKCR, &buf, &rbuf)) { REG_R_OPEN_HKCR r_o; BOOL p; @@ -175,7 +174,7 @@ BOOL reg_open_hkcr( struct cli_state *cli, uint16 fnum, /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL reg_open_hklm( struct cli_state *cli, uint16 fnum, +BOOL reg_open_hklm( struct cli_connection *con, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { @@ -199,7 +198,7 @@ BOOL reg_open_hklm( struct cli_state *cli, uint16 fnum, reg_io_q_open_hklm("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_OPEN_HKLM, &buf, &rbuf)) + if (rpc_con_pipe_req(con, REG_OPEN_HKLM, &buf, &rbuf)) { REG_R_OPEN_HKLM r_o; BOOL p; @@ -233,7 +232,7 @@ BOOL reg_open_hklm( struct cli_state *cli, uint16 fnum, /**************************************************************************** do a REG Open HKU ****************************************************************************/ -BOOL reg_open_hku( struct cli_state *cli, uint16 fnum, +BOOL reg_open_hku( struct cli_connection *con, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { @@ -257,7 +256,7 @@ BOOL reg_open_hku( struct cli_state *cli, uint16 fnum, reg_io_q_open_hku("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_OPEN_HKU, &buf, &rbuf)) + if (rpc_con_pipe_req(con, REG_OPEN_HKU, &buf, &rbuf)) { REG_R_OPEN_HKU r_o; BOOL p; @@ -1053,10 +1052,9 @@ BOOL reg_open_entry( POLICY_HND *hnd, if (p) { - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; + struct cli_connection *con = NULL; - if (!cli_state_get(hnd, &cli, &fnum)) + if (!cli_connection_get(hnd, &con)) { return False; } @@ -1155,10 +1153,9 @@ BOOL reg_shutdown(const char *srv_name, REG_Q_SHUTDOWN q_o; BOOL valid_shutdown = False; - struct cli_state *cli = NULL; - uint16 fnum = 0xffff; + struct cli_connection *con = NULL; - if (!cli_state_init(srv_name, PIPE_LSARPC, &cli, &fnum)) + if (!cli_connection_init(srv_name, PIPE_LSARPC, &con)) { return False; } @@ -1178,7 +1175,7 @@ BOOL reg_shutdown(const char *srv_name, reg_io_q_shutdown("", &q_o, &buf, 0); /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, fnum, REG_SHUTDOWN, &buf, &rbuf)) + if (rpc_con_pipe_req(con, REG_SHUTDOWN, &buf, &rbuf)) { REG_R_SHUTDOWN r_o; BOOL p; @@ -1204,7 +1201,7 @@ BOOL reg_shutdown(const char *srv_name, prs_mem_free(&rbuf); prs_mem_free(&buf ); - cli_state_free(cli, fnum); + cli_connection_unlink(con); return valid_shutdown; } -- cgit From 3db52feb1f3b2c07ce0b06ad4a7099fa6efe3fc7 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Mon, 13 Dec 1999 13:27:58 +0000 Subject: first pass at updating head branch to be to be the same as the SAMBA_2_0 branch (This used to be commit 453a822a76780063dff23526c35408866d0c0154) --- source3/rpc_client/cli_reg.c | 1233 +++++++++++++++++++----------------------- 1 file changed, 555 insertions(+), 678 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 4f1c28a701..b5e9cbb2ac 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -6,6 +6,7 @@ * Copyright (C) Andrew Tridgell 1992-1998, * Copyright (C) Luke Kenneth Casson Leighton 1996-1998, * Copyright (C) Paul Ashton 1997-1998. + * Copyright (C) Jeremy Allison 1999. * * 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 @@ -34,80 +35,38 @@ extern int DEBUGLEVEL; /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL reg_connect( const char* srv_name, - const char *full_keyname, - char *key_name, +BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, POLICY_HND *reg_hnd) { BOOL res = True; uint32 reg_type = 0; - struct cli_connection *con = NULL; - - if (!cli_connection_init(srv_name, PIPE_WINREG, &con)) - { + if (full_keyname == NULL) return False; - } ZERO_STRUCTP(reg_hnd); - if (full_keyname == NULL) - { - return False; - } - /* * open registry receive a policy handle */ - if (!reg_split_key(full_keyname, ®_type, key_name)) - { - DEBUG(0,("reg_connect: unrecognised key name %s\n", - full_keyname)); + if (!reg_split_key(full_keyname, ®_type, key_name)) { + DEBUG(0,("do_reg_connect: unrecognised key name %s\n", full_keyname)); return False; } - switch (reg_type) - { - case HKEY_CLASSES_ROOT: - { - res = res ? reg_open_hkcr(con, - 0x5428, 0x02000000, - reg_hnd) : False; - break; - } + switch (reg_type) { + case HKEY_LOCAL_MACHINE: + res = res ? do_reg_open_hklm(cli, 0x84E0, 0x02000000, reg_hnd) : False; + break; - case HKEY_LOCAL_MACHINE: - { - res = res ? reg_open_hklm(con, - 0x84E0, 0x02000000, - reg_hnd) : False; - break; - } - - case HKEY_USERS: - { - res = res ? reg_open_hku(con, - 0x84E0, 0x02000000, - reg_hnd) : False; - break; - } - default: - { - DEBUG(0,("reg_connect: unrecognised hive key\n")); - return False; - } - } + case HKEY_USERS: + res = res ? do_reg_open_hku(cli, 0x84E0, 0x02000000, reg_hnd) : False; + break; - if (res) - { - if (!register_policy_hnd(reg_hnd) || - !set_policy_con(reg_hnd, con, - cli_connection_unlink)) - { - cli_connection_unlink(con); - return False; - } + default: + DEBUG(0,("do_reg_connect: unrecognised hive key\n")); + return False; } return res; @@ -116,175 +75,123 @@ BOOL reg_connect( const char* srv_name, /**************************************************************************** do a REG Open Policy ****************************************************************************/ -BOOL reg_open_hkcr( struct cli_connection *con, - uint16 unknown_0, uint32 level, - POLICY_HND *hnd) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_OPEN_HKCR q_o; - BOOL valid_pol = False; - - if (hnd == NULL) return False; - - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); - - /* create and send a MSRPC command with api REG_OPEN_HKCR */ - - DEBUG(4,("REG Open HKCR\n")); - - make_reg_q_open_hkcr(&q_o, unknown_0, level); - - /* turn parameters into data stream */ - reg_io_q_open_hkcr("", &q_o, &buf, 0); - - /* send the data on \PIPE\ */ - if (rpc_con_pipe_req(con, REG_OPEN_HKCR, &buf, &rbuf)) - { - REG_R_OPEN_HKCR r_o; - BOOL p; - - ZERO_STRUCT(r_o); - - reg_io_r_open_hkcr("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; - - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_OPEN_HKCR: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } - - if (p) - { - /* ok, at last: we're happy. return the policy handle */ - memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); - valid_pol = True; - } - } - - prs_mem_free(&rbuf); - prs_mem_free(&buf ); - - return valid_pol; -} - -/**************************************************************************** -do a REG Open Policy -****************************************************************************/ -BOOL reg_open_hklm( struct cli_connection *con, - uint16 unknown_0, uint32 level, +BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; REG_Q_OPEN_HKLM q_o; - BOOL valid_pol = False; + REG_R_OPEN_HKLM r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_HKLM */ DEBUG(4,("REG Open HKLM\n")); - make_reg_q_open_hklm(&q_o, unknown_0, level); + init_reg_q_open_hklm(&q_o, unknown_0, level); /* turn parameters into data stream */ - reg_io_q_open_hklm("", &q_o, &buf, 0); + if(!reg_io_q_open_hklm("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_con_pipe_req(con, REG_OPEN_HKLM, &buf, &rbuf)) - { - REG_R_OPEN_HKLM r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_OPEN_HKLM, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_open_hklm("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_OPEN_HKLM: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_open_hklm("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - /* ok, at last: we're happy. return the policy handle */ - memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); - valid_pol = True; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_OPEN_HKLM: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + /* ok, at last: we're happy. return the policy handle */ + memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_pol; + return True; } /**************************************************************************** do a REG Open HKU ****************************************************************************/ -BOOL reg_open_hku( struct cli_connection *con, - uint16 unknown_0, uint32 level, +BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; REG_Q_OPEN_HKU q_o; - BOOL valid_pol = False; + REG_R_OPEN_HKU r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_HKU */ DEBUG(4,("REG Open HKU\n")); - make_reg_q_open_hku(&q_o, unknown_0, level); + init_reg_q_open_hku(&q_o, unknown_0, level); /* turn parameters into data stream */ - reg_io_q_open_hku("", &q_o, &buf, 0); + if(!reg_io_q_open_hku("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_con_pipe_req(con, REG_OPEN_HKU, &buf, &rbuf)) - { - REG_R_OPEN_HKU r_o; - BOOL p; + if (rpc_api_pipe_req(cli, REG_OPEN_HKU, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_open_hku("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_OPEN_HKU: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_open_hku("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - /* ok, at last: we're happy. return the policy handle */ - memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); - valid_pol = True; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_OPEN_HKU: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + /* ok, at last: we're happy. return the policy handle */ + memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_pol; + return True; } /**************************************************************************** @@ -292,62 +199,65 @@ do a REG Unknown 0xB command. sent after a create key or create value. this might be some sort of "sync" or "refresh" command, sent after modification of the registry... ****************************************************************************/ -BOOL reg_flush_key( POLICY_HND *hnd) +BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; REG_Q_FLUSH_KEY q_o; - BOOL valid_query = False; + REG_R_FLUSH_KEY r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_FLUSH_KEY */ DEBUG(4,("REG Unknown 0xB\n")); - make_reg_q_flush_key(&q_o, hnd); + init_reg_q_flush_key(&q_o, hnd); /* turn parameters into data stream */ - reg_io_q_flush_key("", &q_o, &buf, 0); + if(!reg_io_q_flush_key("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_FLUSH_KEY, &buf, &rbuf)) - { - REG_R_FLUSH_KEY r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_FLUSH_KEY, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_flush_key("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_FLUSH_KEY: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_flush_key("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_query = True; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_FLUSH_KEY: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Query Key ****************************************************************************/ -BOOL reg_query_key( POLICY_HND *hnd, - char *key_class, uint32 *class_len, +BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, + char *class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, uint32 *max_subkeysize, uint32 *num_values, uint32 *max_valnamelen, uint32 *max_valbufsize, @@ -356,409 +266,427 @@ BOOL reg_query_key( POLICY_HND *hnd, prs_struct rbuf; prs_struct buf; REG_Q_QUERY_KEY q_o; - BOOL valid_query = False; + REG_R_QUERY_KEY r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_QUERY_KEY */ DEBUG(4,("REG Query Key\n")); - make_reg_q_query_key(&q_o, hnd, *class_len); + init_reg_q_query_key(&q_o, hnd, *class_len); /* turn parameters into data stream */ - reg_io_q_query_key("", &q_o, &buf, 0); + if(!reg_io_q_query_key("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_QUERY_KEY, &buf, &rbuf)) - { - REG_R_QUERY_KEY r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_query_key("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_query_key("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_query = True; - - *class_len = r_o.hdr_class.uni_max_len; - unistr2_to_ascii(key_class, &r_o.uni_class, sizeof(fstring)-1); - *num_subkeys = r_o.num_subkeys ; - *max_subkeylen = r_o.max_subkeylen ; - *max_subkeysize = r_o.max_subkeysize; - *num_values = r_o.num_values ; - *max_valnamelen = r_o.max_valnamelen; - *max_valbufsize = r_o.max_valbufsize; - *sec_desc = r_o.sec_desc ; - *mod_time = r_o.mod_time ; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + *class_len = r_o.hdr_class.uni_max_len; + fstrcpy(class, dos_unistr2_to_str(&r_o.uni_class)); + *num_subkeys = r_o.num_subkeys ; + *max_subkeylen = r_o.max_subkeylen ; + *max_subkeysize = r_o.max_subkeysize; + *num_values = r_o.num_values ; + *max_valnamelen = r_o.max_valnamelen; + *max_valbufsize = r_o.max_valbufsize; + *sec_desc = r_o.sec_desc ; + *mod_time = r_o.mod_time ; + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Unknown 1A ****************************************************************************/ -BOOL reg_unknown_1a( POLICY_HND *hnd, uint32 *unk) +BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) { prs_struct rbuf; prs_struct buf; REG_Q_UNK_1A q_o; - BOOL valid_query = False; + REG_R_UNK_1A r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_UNKNOWN_1A */ DEBUG(4,("REG Unknown 1a\n")); - make_reg_q_unk_1a(&q_o, hnd); + init_reg_q_unk_1a(&q_o, hnd); /* turn parameters into data stream */ - reg_io_q_unk_1a("", &q_o, &buf, 0); + if(!reg_io_q_unk_1a("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_UNK_1A, &buf, &rbuf)) - { - REG_R_UNK_1A r_o; - BOOL p; + if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_unk_1a("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_unk_1a("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_query = True; - (*unk) = r_o.unknown; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + (*unk) = r_o.unknown; + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Query Info ****************************************************************************/ -BOOL reg_query_info( POLICY_HND *hnd, - const char* val_name, - uint32 *type, BUFFER2 *buffer) +BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, + char *type, uint32 *unk_0, uint32 *unk_1) { prs_struct rbuf; prs_struct buf; REG_Q_INFO q_o; - BOOL valid_query = False; + REG_R_INFO r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_INFO */ DEBUG(4,("REG Query Info\n")); - make_reg_q_info(&q_o, hnd, val_name, 4, 0); + init_reg_q_info(&q_o, hnd, "ProductType", time(NULL), 4, 1); /* turn parameters into data stream */ - reg_io_q_info("", &q_o, &buf, 0); + if(!reg_io_q_info("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_INFO, &buf, &rbuf)) - { - REG_R_INFO r_o; - BOOL p; - - ZERO_STRUCT(r_o); + if (!rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - r_o.type = type; - r_o.uni_type = buffer; + prs_mem_free(&buf); - reg_io_r_info("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_info("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_query = True; - } + if ( r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + fstrcpy(type, dos_buffer2_to_str(&r_o.uni_type)); + (*unk_0) = r_o.unknown_0; + (*unk_1) = r_o.unknown_1; + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Set Key Security ****************************************************************************/ -BOOL reg_set_key_sec( POLICY_HND *hnd, - uint32 sec_info, - uint32 sec_buf_size, SEC_DESC *sec_buf) +BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *sec_desc_buf) { prs_struct rbuf; prs_struct buf; REG_Q_SET_KEY_SEC q_o; - BOOL valid_query = False; + REG_R_SET_KEY_SEC r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_SET_KEY_SEC */ DEBUG(4,("REG Set Key security.\n")); - make_reg_q_set_key_sec(&q_o, hnd, sec_info, sec_buf_size, sec_buf); + init_reg_q_set_key_sec(&q_o, hnd, sec_desc_buf); /* turn parameters into data stream */ - reg_io_q_set_key_sec("", &q_o, &buf, 0); + if(!reg_io_q_set_key_sec("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_SET_KEY_SEC, &buf, &rbuf)) - { - REG_R_SET_KEY_SEC r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_SET_KEY_SEC, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_set_key_sec("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - valid_query = True; - } + if(!reg_io_r_set_key_sec("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } + + if (r_o.status != 0) { + prs_mem_free(&rbuf); + return False; } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } - /**************************************************************************** do a REG Query Key Security ****************************************************************************/ -BOOL reg_get_key_sec( POLICY_HND *hnd, - uint32 sec_info, - uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) + +BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_size, SEC_DESC_BUF **ppsec_desc_buf) { prs_struct rbuf; prs_struct buf; REG_Q_GET_KEY_SEC q_o; - BOOL valid_query = False; + REG_R_GET_KEY_SEC r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_GET_KEY_SEC */ DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size)); - make_reg_q_get_key_sec(&q_o, hnd, sec_info, *sec_buf_size, sec_buf); + init_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, NULL); /* turn parameters into data stream */ - reg_io_q_get_key_sec("", &q_o, &buf, 0); + if(!reg_io_q_get_key_sec("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_GET_KEY_SEC, &buf, &rbuf)) - { - REG_R_GET_KEY_SEC r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - r_o.data = sec_buf; - if (*sec_buf_size != 0) - { - sec_buf->sec = (SEC_DESC*)malloc(*sec_buf_size); - } - reg_io_r_get_key_sec("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; - - if (p && r_o.status == 0x0000007a) - { - /* - * get the maximum buffer size: it was too small - */ - (*sec_buf_size) = r_o.hdr_sec.buf_max_len; - DEBUG(5,("sec_buf_size too small. use %d\n", *sec_buf_size)); - valid_query = True; - } - else if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } - else - { - valid_query = True; - (*sec_buf_size) = r_o.data->len; - } + ZERO_STRUCT(r_o); + + if(!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } + + if (r_o.status == 0x0000007a) { + /* + * get the maximum buffer size: it was too small + */ + (*sec_buf_size) = r_o.hdr_sec.buf_max_len; + DEBUG(5,("sec_buf_size too small. use %d\n", *sec_buf_size)); + } else if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; + } else { + (*sec_buf_size) = r_o.data->len; + *ppsec_desc_buf = r_o.data; } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Delete Value ****************************************************************************/ -BOOL reg_delete_val( POLICY_HND *hnd, char *val_name) +BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) { prs_struct rbuf; prs_struct buf; REG_Q_DELETE_VALUE q_o; - BOOL valid_delete = False; + REG_R_DELETE_VALUE r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_DELETE_VALUE */ DEBUG(4,("REG Delete Value: %s\n", val_name)); - make_reg_q_delete_val(&q_o, hnd, val_name); + init_reg_q_delete_val(&q_o, hnd, val_name); /* turn parameters into data stream */ - reg_io_q_delete_val("", &q_o, &buf, 0); + if(!reg_io_q_delete_val("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_DELETE_VALUE, &buf, &rbuf)) - { - REG_R_DELETE_VALUE r_o; - BOOL p; + if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_delete_val("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_delete_val("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_delete = True; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_delete; + return True; } /**************************************************************************** do a REG Delete Key ****************************************************************************/ -BOOL reg_delete_key( POLICY_HND *hnd, char *key_name) +BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) { prs_struct rbuf; prs_struct buf; REG_Q_DELETE_KEY q_o; - BOOL valid_delete = False; + REG_R_DELETE_KEY r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_DELETE_KEY */ DEBUG(4,("REG Delete Key: %s\n", key_name)); - make_reg_q_delete_key(&q_o, hnd, key_name); + init_reg_q_delete_key(&q_o, hnd, key_name); /* turn parameters into data stream */ - reg_io_q_delete_key("", &q_o, &buf, 0); + if(!reg_io_q_delete_key("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_DELETE_KEY, &buf, &rbuf)) - { - REG_R_DELETE_KEY r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_delete_key("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_delete_key("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_delete = True; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_delete; + return True; } /**************************************************************************** do a REG Create Key ****************************************************************************/ -BOOL reg_create_key( POLICY_HND *hnd, +BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name, char *key_class, SEC_ACCESS *sam_access, POLICY_HND *key) @@ -766,73 +694,84 @@ BOOL reg_create_key( POLICY_HND *hnd, prs_struct rbuf; prs_struct buf; REG_Q_CREATE_KEY q_o; - BOOL valid_create = False; - SEC_DESC sec; - SEC_DESC_BUF sec_buf; - int sec_len; + REG_R_CREATE_KEY r_o; + SEC_DESC *sec = NULL; + SEC_DESC_BUF *sec_buf = NULL; + size_t sec_len; - ZERO_STRUCT(sec); - ZERO_STRUCT(sec_buf); ZERO_STRUCT(q_o); - if (hnd == NULL) return False; - - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + if (hnd == NULL) + return False; /* create and send a MSRPC command with api REG_CREATE_KEY */ DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, sam_access != NULL ? sam_access->mask : 0)); - sec_len = make_sec_desc(&sec, 1, SEC_DESC_SELF_RELATIVE, - NULL, NULL, NULL, NULL); + if((sec = make_sec_desc( 1, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, NULL, &sec_len)) == NULL) { + DEBUG(0,("make_sec_desc : malloc fail.\n")); + return False; + } + + DEBUG(10,("make_sec_desc: len = %d\n", (int)sec_len)); + + if((sec_buf = make_sec_desc_buf( (int)sec_len, sec)) == NULL) { + DEBUG(0,("make_sec_desc : malloc fail (1)\n")); + free_sec_desc(&sec); + return False; + } + free_sec_desc(&sec); - DEBUG(10,("make_sec_desc: len = %d\n", sec_len)); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); - make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, - &sec_buf, sec_len, &sec); + init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf); /* turn parameters into data stream */ - reg_io_q_create_key("", &q_o, &buf, 0); + if(!reg_io_q_create_key("", &q_o, &buf, 0)) { + free_sec_desc_buf(&sec_buf); + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_CREATE_KEY, &buf, &rbuf)) - { - REG_R_CREATE_KEY r_o; - BOOL p; + if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) { + free_sec_desc_buf(&sec_buf); + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + free_sec_desc_buf(&sec_buf); + prs_mem_free(&buf); - reg_io_r_create_key("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_create_key("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_create = True; - memcpy(key, r_o.key_pol.data, sizeof(key->data)); - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } - free_sec_desc(&sec); + memcpy(key, r_o.key_pol.data, sizeof(key->data)); prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_create; + return True; } /**************************************************************************** do a REG Enum Key ****************************************************************************/ -BOOL reg_enum_key( POLICY_HND *hnd, +BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, int key_index, char *key_name, uint32 *unk_1, uint32 *unk_2, time_t *mod_time) @@ -840,116 +779,122 @@ BOOL reg_enum_key( POLICY_HND *hnd, prs_struct rbuf; prs_struct buf; REG_Q_ENUM_KEY q_o; - BOOL valid_query = False; + REG_R_ENUM_KEY r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_ENUM_KEY */ DEBUG(4,("REG Enum Key\n")); - make_reg_q_enum_key(&q_o, hnd, key_index); + init_reg_q_enum_key(&q_o, hnd, key_index); /* turn parameters into data stream */ - reg_io_q_enum_key("", &q_o, &buf, 0); + if(!reg_io_q_enum_key("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_ENUM_KEY, &buf, &rbuf)) - { - REG_R_ENUM_KEY r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_enum_key("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_enum_key("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_query = True; - (*unk_1) = r_o.unknown_1; - (*unk_2) = r_o.unknown_2; - unistr_to_ascii(key_name, r_o.key_name.str.buffer, - sizeof(fstring)-1); - (*mod_time) = nt_time_to_unix(&r_o.time); - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + (*unk_1) = r_o.unknown_1; + (*unk_2) = r_o.unknown_2; + fstrcpy(key_name, dos_unistr2(r_o.key_name.str.buffer)); + (*mod_time) = nt_time_to_unix(&r_o.time); + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Create Value ****************************************************************************/ -BOOL reg_create_val( POLICY_HND *hnd, +BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name, uint32 type, BUFFER3 *data) { prs_struct rbuf; prs_struct buf; REG_Q_CREATE_VALUE q_o; - BOOL valid_create = False; + REG_R_CREATE_VALUE r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_CREATE_VALUE */ DEBUG(4,("REG Create Value: %s\n", val_name)); - make_reg_q_create_val(&q_o, hnd, val_name, type, data); + init_reg_q_create_val(&q_o, hnd, val_name, type, data); /* turn parameters into data stream */ - reg_io_q_create_val("", &q_o, &buf, 0); + if(!reg_io_q_create_val("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_CREATE_VALUE, &buf, &rbuf)) - { - REG_R_CREATE_VALUE r_o; - BOOL p; + if (!rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - ZERO_STRUCT(r_o); + prs_mem_free(&buf); - reg_io_r_create_val("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + ZERO_STRUCT(r_o); - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if(!reg_io_r_create_val("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_create = True; - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_create; + return True; } /**************************************************************************** do a REG Enum Value ****************************************************************************/ -BOOL reg_enum_val( POLICY_HND *hnd, +BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, int val_index, int max_valnamelen, int max_valbufsize, fstring val_name, uint32 *val_type, BUFFER2 *value) @@ -957,253 +902,185 @@ BOOL reg_enum_val( POLICY_HND *hnd, prs_struct rbuf; prs_struct buf; REG_Q_ENUM_VALUE q_o; - BOOL valid_query = False; + REG_R_ENUM_VALUE r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_ENUM_VALUE */ DEBUG(4,("REG Enum Value\n")); - make_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize); + init_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize); /* turn parameters into data stream */ - reg_io_q_enum_val("", &q_o, &buf, 0); + if(!reg_io_q_enum_val("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_ENUM_VALUE, &buf, &rbuf)) - { - REG_R_ENUM_VALUE r_o; - BOOL p; - - ZERO_STRUCT(r_o); - r_o.buf_value = value; - - reg_io_r_enum_val("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; - - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + if (!rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - if (p) - { - valid_query = True; - (*val_type) = r_o.type; - unistr2_to_ascii(val_name, &r_o.uni_name, sizeof(fstring)-1); - } + prs_mem_free(&buf); + + ZERO_STRUCT(r_o); + r_o.buf_value = value; + + if(!reg_io_r_enum_val("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } + + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + (*val_type) = r_o.type; + fstrcpy(val_name, dos_unistr2_to_str(&r_o.uni_name)); + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_query; + return True; } /**************************************************************************** do a REG Open Key ****************************************************************************/ -BOOL reg_open_entry( POLICY_HND *hnd, +BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, char *key_name, uint32 unk_0, POLICY_HND *key_hnd) { prs_struct rbuf; prs_struct buf; REG_Q_OPEN_ENTRY q_o; - BOOL valid_pol = False; + REG_R_OPEN_ENTRY r_o; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_ENTRY */ DEBUG(4,("REG Open Entry\n")); - make_reg_q_open_entry(&q_o, hnd, key_name, unk_0); + init_reg_q_open_entry(&q_o, hnd, key_name, unk_0); /* turn parameters into data stream */ - reg_io_q_open_entry("", &q_o, &buf, 0); + if(!reg_io_q_open_entry("", &q_o, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_OPEN_ENTRY, &buf, &rbuf)) - { - REG_R_OPEN_ENTRY r_o; - BOOL p; - - ZERO_STRUCT(r_o); - - reg_io_r_open_entry("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + if (!rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + prs_mem_free(&buf); - if (p) - { - struct cli_connection *con = NULL; + ZERO_STRUCT(r_o); - if (!cli_connection_get(hnd, &con)) - { - return False; - } + if(!reg_io_r_open_entry("", &r_o, &rbuf, 0)) { + prs_mem_free(&rbuf); + return False; + } - memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data)); - valid_pol = cli_pol_link(key_hnd, hnd); - } + if (r_o.status != 0) { + /* report error code */ + DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status))); + prs_mem_free(&rbuf); + return False; } + memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data)); + prs_mem_free(&rbuf); - prs_mem_free(&buf ); - return valid_pol; + return True; } /**************************************************************************** do a REG Close ****************************************************************************/ -BOOL reg_close( POLICY_HND *hnd) +BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) { prs_struct rbuf; prs_struct buf; REG_Q_CLOSE q_c; - BOOL valid_close = False; + REG_R_CLOSE r_c; + int i; - if (hnd == NULL) return False; + if (hnd == NULL) + return False; /* create and send a MSRPC command with api REG_CLOSE */ - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); + prs_init(&rbuf, 0, 4, UNMARSHALL); DEBUG(4,("REG Close\n")); /* store the parameters */ - make_reg_q_close(&q_c, hnd); + init_reg_q_close(&q_c, hnd); /* turn parameters into data stream */ - reg_io_q_close("", &q_c, &buf, 0); + if(!reg_io_q_close("", &q_c, &buf, 0)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; + } /* send the data on \PIPE\ */ - if (rpc_hnd_pipe_req(hnd, REG_CLOSE, &buf, &rbuf)) - { - REG_R_CLOSE r_c; - BOOL p; - - ZERO_STRUCT(r_c); - - reg_io_r_close("", &r_c, &rbuf, 0); - p = rbuf.offset != 0; - - if (p && r_c.status != 0) - { - /* report error code */ - DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status))); - p = False; - } - - if (p) - { - /* check that the returned policy handle is all zeros */ - uint32 i; - valid_close = True; - - for (i = 0; i < sizeof(r_c.pol.data); i++) - { - if (r_c.pol.data[i] != 0) - { - valid_close = False; - break; - } - } - if (!valid_close) - { - DEBUG(0,("REG_CLOSE: non-zero handle returned\n")); - } - } + if (!rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) { + prs_mem_free(&buf); + prs_mem_free(&rbuf); + return False; } - prs_mem_free(&rbuf); - prs_mem_free(&buf ); - - close_policy_hnd(hnd); - - return valid_close; -} - -/**************************************************************************** -do a REG Shutdown Server -****************************************************************************/ -BOOL reg_shutdown(const char *srv_name, - const char *msg, uint32 timeout, uint16 flags) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_SHUTDOWN q_o; - BOOL valid_shutdown = False; + prs_mem_free(&buf); - struct cli_connection *con = NULL; + ZERO_STRUCT(r_c); - if (!cli_connection_init(srv_name, PIPE_LSARPC, &con)) - { + if(!reg_io_r_close("", &r_c, &rbuf, 0)) { + prs_mem_free(&rbuf); return False; } - if (msg == NULL) return False; - - prs_init(&buf , 1024, 4, SAFETY_MARGIN, False); - prs_init(&rbuf, 0 , 4, SAFETY_MARGIN, True ); - - /* create and send a MSRPC command with api REG_SHUTDOWN */ - - DEBUG(4,("REG Shutdown: (timeout: %d secs) %s\n", timeout, msg)); - - make_reg_q_shutdown(&q_o, msg, timeout, flags); - - /* turn parameters into data stream */ - reg_io_q_shutdown("", &q_o, &buf, 0); - - /* send the data on \PIPE\ */ - if (rpc_con_pipe_req(con, REG_SHUTDOWN, &buf, &rbuf)) - { - REG_R_SHUTDOWN r_o; - BOOL p; - - ZERO_STRUCT(r_o); - - reg_io_r_shutdown("", &r_o, &rbuf, 0); - p = rbuf.offset != 0; + if (r_c.status != 0) { + /* report error code */ + DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status))); + prs_mem_free(&rbuf); + return False; + } - if (p && r_o.status != 0) - { - /* report error code */ - DEBUG(0,("REG_SHUTDOWN: %s\n", get_nt_error_msg(r_o.status))); - p = False; - } + /* check that the returned policy handle is all zeros */ - if (p) - { - valid_shutdown = True; + for (i = 0; i < sizeof(r_c.pol.data); i++) { + if (r_c.pol.data[i] != 0) { + prs_mem_free(&rbuf); + DEBUG(0,("REG_CLOSE: non-zero handle returned\n")); + return False; } - } + } prs_mem_free(&rbuf); - prs_mem_free(&buf ); - - cli_connection_unlink(con); - return valid_shutdown; + return True; } - - -- cgit From b89b75a368c5245c38ebe467b2d3820b3df59c6a Mon Sep 17 00:00:00 2001 From: Luke Leighton Date: Wed, 22 Mar 2000 10:26:09 +0000 Subject: added the following message to all dce/rpc client/server code, except the spoolss code (it's cut from TNG) and the smb-dce/rpc interface code that jeremy has been working up to TNG-functionality. i also want this message to go into SAMBA_2_0 and SAMBA_2_0_RELEASE, because it is intolerable that potentially good modifications be made to code that is going to be thrown away, and people waste their time fixing bugs and adding enhancements that have already been carried out already, up to two years ago in the TNG branch. /* * THIS CODE IS OUT-OF-DATE BY TWO YEARS, IS LEGACY DESIGN AND VERY, VERY, * INCOMPLETE. PLEASE DO NOT MAKE ANY FURTHER ENHANCEMENTS TO THIS CODE * UNLESS THEY ARE ALSO CARRIED OUT IN THE SAMBA_TNG BRANCH. * * PLEASE DO NOT TREAT THIS CODE AS AUTHORITATIVE IN *ANY* WAY. * * REPEAT, PLEASE DO NOT MAKE ANY MODIFICATIONS TO THIS CODE WITHOUT * FIRST CHECKING THE EQUIVALENT MODULE IN SAMBA_TNG, UPDATING THAT * FIRST, *THEN* CONSIDER MAKING THE SAME MODIFICATION IN THIS BRANCH * * YOU WILL, ALMOST GUARANTEED, FIND THAT THE BUG-FIX OR ENHANCEMENT THAT * YOU THINK IS NECESSARY, HAS ALREADY BEEN IMPLEMENTED IN SAMBA_TNG. * IF IT HAS NOT, YOUR BUG-FIX OR ENHANCEMENT *MUST* GO INTO SAMBA_TNG * AS THE SAMBA_TNG CODE WILL REPLACE THIS MODULE WITHOUT REFERENCE TO * ANYTHING IN IT, WITH THE POSSIBLE RISK THAT THE BUG-FIX OR ENHANCEMENT * MAY BE LOST. * * PLEASE OBSERVE AND RESPECT THIS SIMPLE REQUEST. * * THANK YOU. * * lkcl@samba.org */ (This used to be commit cfaea90529be222f8df0e20a7ca1289f99c29e09) --- source3/rpc_client/cli_reg.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index b5e9cbb2ac..3ee201a430 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -1,4 +1,29 @@ +/* + * THIS CODE IS OUT-OF-DATE BY TWO YEARS, IS LEGACY DESIGN AND VERY, VERY, + * INCOMPLETE. PLEASE DO NOT MAKE ANY FURTHER ENHANCEMENTS TO THIS CODE + * UNLESS THEY ARE ALSO CARRIED OUT IN THE SAMBA_TNG BRANCH. + * + * PLEASE DO NOT TREAT THIS CODE AS AUTHORITATIVE IN *ANY* WAY. + * + * REPEAT, PLEASE DO NOT MAKE ANY MODIFICATIONS TO THIS CODE WITHOUT + * FIRST CHECKING THE EQUIVALENT MODULE IN SAMBA_TNG, UPDATING THAT + * FIRST, *THEN* CONSIDER MAKING THE SAME MODIFICATION IN THIS BRANCH + * + * YOU WILL, ALMOST GUARANTEED, FIND THAT THE BUG-FIX OR ENHANCEMENT THAT + * YOU THINK IS NECESSARY, HAS ALREADY BEEN IMPLEMENTED IN SAMBA_TNG. + * IF IT HAS NOT, YOUR BUG-FIX OR ENHANCEMENT *MUST* GO INTO SAMBA_TNG + * AS THE SAMBA_TNG CODE WILL REPLACE THIS MODULE WITHOUT REFERENCE TO + * ANYTHING IN IT, WITH THE POSSIBLE RISK THAT THE BUG-FIX OR ENHANCEMENT + * MAY BE LOST. + * + * PLEASE OBSERVE AND RESPECT THIS SIMPLE REQUEST. + * + * THANK YOU. + * + * lkcl@samba.org + */ + /* * Unix SMB/Netbios implementation. * Version 1.9. -- cgit From 8f1620125dcb9c29c223f4efb6485528ece70f11 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 22 Mar 2000 19:03:12 +0000 Subject: acconfig.h configure configure.in: Added check for UT_SYSLEN for utmp code. include/byteorder.h: Added alignment macros. include/nameserv.h: Added defines for msg_type field options - from rfc1002. lib/time.c: Typo fix. lib/util_unistr.c: Updates from UNICODE branch. printing/nt_printing.c: bzero -> memset. smbd/connection.c: Added check for UT_SYSLEN for utmp code. Other fixes : Rollback of unapproved commit from Luke. Please *ask* next time before doing large changes to HEAD. Jeremy. (This used to be commit f02999dbf7971b4ea05050d7206205d7737a78b2) --- source3/rpc_client/cli_reg.c | 25 ------------------------- 1 file changed, 25 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 3ee201a430..b5e9cbb2ac 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -1,29 +1,4 @@ -/* - * THIS CODE IS OUT-OF-DATE BY TWO YEARS, IS LEGACY DESIGN AND VERY, VERY, - * INCOMPLETE. PLEASE DO NOT MAKE ANY FURTHER ENHANCEMENTS TO THIS CODE - * UNLESS THEY ARE ALSO CARRIED OUT IN THE SAMBA_TNG BRANCH. - * - * PLEASE DO NOT TREAT THIS CODE AS AUTHORITATIVE IN *ANY* WAY. - * - * REPEAT, PLEASE DO NOT MAKE ANY MODIFICATIONS TO THIS CODE WITHOUT - * FIRST CHECKING THE EQUIVALENT MODULE IN SAMBA_TNG, UPDATING THAT - * FIRST, *THEN* CONSIDER MAKING THE SAME MODIFICATION IN THIS BRANCH - * - * YOU WILL, ALMOST GUARANTEED, FIND THAT THE BUG-FIX OR ENHANCEMENT THAT - * YOU THINK IS NECESSARY, HAS ALREADY BEEN IMPLEMENTED IN SAMBA_TNG. - * IF IT HAS NOT, YOUR BUG-FIX OR ENHANCEMENT *MUST* GO INTO SAMBA_TNG - * AS THE SAMBA_TNG CODE WILL REPLACE THIS MODULE WITHOUT REFERENCE TO - * ANYTHING IN IT, WITH THE POSSIBLE RISK THAT THE BUG-FIX OR ENHANCEMENT - * MAY BE LOST. - * - * PLEASE OBSERVE AND RESPECT THIS SIMPLE REQUEST. - * - * THANK YOU. - * - * lkcl@samba.org - */ - /* * Unix SMB/Netbios implementation. * Version 1.9. -- cgit From a71519cf0c75ec26f762d88681a6175a40e36813 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 17 May 2000 02:08:55 +0000 Subject: Cutover from 2.2.x - missed in merge. Jeremy. (This used to be commit 87c4d46abe82855dd23c94397c3fc8e245b3778a) --- source3/rpc_client/cli_reg.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index b5e9cbb2ac..c92f3f3857 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -406,7 +406,7 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, DEBUG(4,("REG Query Info\n")); - init_reg_q_info(&q_o, hnd, "ProductType", time(NULL), 4, 1); + init_reg_q_info(&q_o, hnd, "ProductType"); /* turn parameters into data stream */ if(!reg_io_q_info("", &q_o, &buf, 0)) { @@ -438,9 +438,7 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, return False; } - fstrcpy(type, dos_buffer2_to_str(&r_o.uni_type)); - (*unk_0) = r_o.unknown_0; - (*unk_1) = r_o.unknown_1; + fstrcpy(type, dos_buffer2_to_str(r_o.uni_val)); prs_mem_free(&rbuf); -- cgit From 74d677ec591a715e28dba29a33ee40e1b1c2f830 Mon Sep 17 00:00:00 2001 From: Shirish Kalele Date: Thu, 18 May 2000 18:43:53 +0000 Subject: Added the NETDFS pipe to allow remote administration of the msdfs symlinks on the samba server. (This used to be commit 15e7d8f6c5cddf6ce409ee2505744250d181ec34) --- source3/rpc_client/cli_reg.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index c92f3f3857..d8b6931b42 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -389,7 +389,7 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) do a REG Query Info ****************************************************************************/ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, - char *type, uint32 *unk_0, uint32 *unk_1) + char *key_value, uint32* key_type) { prs_struct rbuf; prs_struct buf; @@ -438,7 +438,8 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, return False; } - fstrcpy(type, dos_buffer2_to_str(r_o.uni_val)); + fstrcpy(key_value, dos_buffer2_to_str(r_o.uni_val)); + *key_type = r_o.type; prs_mem_free(&rbuf); -- cgit From 5ec1642809d9de83da8c88c65d6595c6eb0270f5 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 27 Jul 2000 00:47:19 +0000 Subject: Ok - this is a *BIG* change - but it fixes the problems with static strings in the RPC code. This change was prompted by trying to save a long (>256) character comment in the printer properties page. The new system associates a TALLOC_CTX with the pipe struct, and frees the pool on return of a complete PDU. A global TALLOC_CTX is used for the odd buffer allocated in the BUFFERxx code, and is freed in the main loop. This code works with insure, and seems to be free of memory leaks and crashes (so far) but there are probably the occasional problem with code that uses UNISTRxx structs on the stack and expects them to contain storage without doing a init_unistrXX(). This means that rpcclient will probably be horribly broken. A TALLOC_CTX also needed associating with the struct cli_state also, to make the prs_xx code there work. The main interface change is the addition of a TALLOC_CTX to the prs_init calls - used for dynamic allocation in the prs_XXX calls. Now this is in place it should make dynamic allocation of all RPC memory on unmarshall *much* easier to fix. Jeremy. (This used to be commit 0ff2ce543ee54f7364e6d839db6d06e7ef1edcf4) --- source3/rpc_client/cli_reg.c | 64 ++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 32 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index d8b6931b42..13a9b26515 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -86,8 +86,8 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_HKLM */ @@ -147,8 +147,8 @@ BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_HKU */ @@ -209,8 +209,8 @@ BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_FLUSH_KEY */ @@ -271,8 +271,8 @@ BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_QUERY_KEY */ @@ -339,8 +339,8 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_UNKNOWN_1A */ @@ -399,8 +399,8 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_INFO */ @@ -459,8 +459,8 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *se if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_SET_KEY_SEC */ @@ -515,8 +515,8 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_ if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_GET_KEY_SEC */ @@ -581,8 +581,8 @@ BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_DELETE_VALUE */ @@ -638,8 +638,8 @@ BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_DELETE_KEY */ @@ -722,8 +722,8 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, } free_sec_desc(&sec); - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf); @@ -783,8 +783,8 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_ENUM_KEY */ @@ -846,8 +846,8 @@ BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_CREATE_VALUE */ @@ -906,8 +906,8 @@ BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_ENUM_VALUE */ @@ -969,8 +969,8 @@ BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_ENTRY */ @@ -1031,8 +1031,8 @@ BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) /* create and send a MSRPC command with api REG_CLOSE */ - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, MARSHALL); - prs_init(&rbuf, 0, 4, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); DEBUG(4,("REG Close\n")); -- cgit From 0e494d7ec6793968337c753fc312b6e56efa2114 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Mon, 4 Dec 2000 01:58:22 +0000 Subject: no longer pass the type to make_sec_desc(), instead the type is derived from the other arguments (This used to be commit 9ec4b1fa48fbae937fdf78db06005a7b0cd52d89) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 13a9b26515..b45ac0d033 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -708,7 +708,7 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, sam_access != NULL ? sam_access->mask : 0)); - if((sec = make_sec_desc( 1, SEC_DESC_SELF_RELATIVE, NULL, NULL, NULL, NULL, &sec_len)) == NULL) { + if((sec = make_sec_desc( 1, NULL, NULL, NULL, NULL, &sec_len)) == NULL) { DEBUG(0,("make_sec_desc : malloc fail.\n")); return False; } -- cgit From 0f2799aaf1e33aa474a12b9389728d57af926cb3 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 28 Feb 2001 00:51:02 +0000 Subject: Move to talloc control of SPOOL_XXX structs. Move to talloc control of security descriptors and pointers. Syncup with 2.2 tree. Jeremy. (This used to be commit 14d5997dc841e78a619e865288486d50c245896d) --- source3/rpc_client/cli_reg.c | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index b45ac0d033..96e27c5ce6 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -708,19 +708,17 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, sam_access != NULL ? sam_access->mask : 0)); - if((sec = make_sec_desc( 1, NULL, NULL, NULL, NULL, &sec_len)) == NULL) { + if((sec = make_sec_desc( cli->mem_ctx, 1, NULL, NULL, NULL, NULL, &sec_len)) == NULL) { DEBUG(0,("make_sec_desc : malloc fail.\n")); return False; } DEBUG(10,("make_sec_desc: len = %d\n", (int)sec_len)); - if((sec_buf = make_sec_desc_buf( (int)sec_len, sec)) == NULL) { + if((sec_buf = make_sec_desc_buf( cli->mem_ctx, (int)sec_len, sec)) == NULL) { DEBUG(0,("make_sec_desc : malloc fail (1)\n")); - free_sec_desc(&sec); return False; } - free_sec_desc(&sec); prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); @@ -729,7 +727,6 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, /* turn parameters into data stream */ if(!reg_io_q_create_key("", &q_o, &buf, 0)) { - free_sec_desc_buf(&sec_buf); prs_mem_free(&buf); prs_mem_free(&rbuf); return False; @@ -737,13 +734,11 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, /* send the data on \PIPE\ */ if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) { - free_sec_desc_buf(&sec_buf); prs_mem_free(&buf); prs_mem_free(&rbuf); return False; } - free_sec_desc_buf(&sec_buf); prs_mem_free(&buf); ZERO_STRUCT(r_o); -- cgit From 393bede7db6af546431cd5255e465b7b7b0e7c81 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 7 Mar 2001 23:59:13 +0000 Subject: Sync up handle creation with 2.2 branch. We can now join AS/U domains and authenticate against them. Big/little endian issues fixed. Jeremy. (This used to be commit 0e6a34510ed598eaec7fe71a9c91fda528a4675c) --- source3/rpc_client/cli_reg.c | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 96e27c5ce6..32439e9b5d 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -126,7 +126,7 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, } /* ok, at last: we're happy. return the policy handle */ - memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + *hnd = r_o.pol; prs_mem_free(&rbuf); @@ -187,7 +187,7 @@ BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, } /* ok, at last: we're happy. return the policy handle */ - memcpy(hnd, r_o.pol.data, sizeof(hnd->data)); + *hnd = r_o.pol; prs_mem_free(&rbuf); @@ -755,7 +755,7 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, return False; } - memcpy(key, r_o.key_pol.data, sizeof(key->data)); + *key = r_o.key_pol; prs_mem_free(&rbuf); @@ -1003,7 +1003,7 @@ BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, return False; } - memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data)); + *key_hnd = r_o.pol; prs_mem_free(&rbuf); @@ -1019,7 +1019,6 @@ BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) prs_struct buf; REG_Q_CLOSE q_c; REG_R_CLOSE r_c; - int i; if (hnd == NULL) return False; @@ -1066,12 +1065,11 @@ BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) /* check that the returned policy handle is all zeros */ - for (i = 0; i < sizeof(r_c.pol.data); i++) { - if (r_c.pol.data[i] != 0) { + if (IVAL(&r_c.pol.data1,0) || IVAL(&r_c.pol.data2,0) || SVAL(&r_c.pol.data3,0) || + SVAL(&r_c.pol.data4,0) || IVAL(r_c.pol.data5,0) || IVAL(r_c.pol.data5,4) ) { prs_mem_free(&rbuf); DEBUG(0,("REG_CLOSE: non-zero handle returned\n")); return False; - } } prs_mem_free(&rbuf); -- cgit From 00ab9021b0cc5fe2667d383eb9cc2973072cdaaa Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 9 Mar 2001 23:48:58 +0000 Subject: Serious (and I *mean* serious) attempt to fix little/bigendian RPC issues. We were reading the endainness in the RPC header and then never propagating it to the internal parse_structs used to parse the data. Also removed the "align" argument to prs_init as it was *always* set to 4, and if needed can be set differently on a case by case basis. Now ready for AS/U testing when Herb gets it set up :-). Jeremy. (This used to be commit 0cd37c831d79a12a10e479bf4fa89ffe64c1292a) --- source3/rpc_client/cli_reg.c | 64 ++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 32 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 32439e9b5d..dc547801df 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -86,8 +86,8 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_HKLM */ @@ -147,8 +147,8 @@ BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_HKU */ @@ -209,8 +209,8 @@ BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_FLUSH_KEY */ @@ -271,8 +271,8 @@ BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_QUERY_KEY */ @@ -339,8 +339,8 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_UNKNOWN_1A */ @@ -399,8 +399,8 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_INFO */ @@ -459,8 +459,8 @@ BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *se if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_SET_KEY_SEC */ @@ -515,8 +515,8 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_ if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_GET_KEY_SEC */ @@ -581,8 +581,8 @@ BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_DELETE_VALUE */ @@ -638,8 +638,8 @@ BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) if (hnd == NULL) return False; - prs_init(&buf , MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_DELETE_KEY */ @@ -720,8 +720,8 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, return False; } - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf); @@ -778,8 +778,8 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_ENUM_KEY */ @@ -841,8 +841,8 @@ BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_CREATE_VALUE */ @@ -901,8 +901,8 @@ BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_ENUM_VALUE */ @@ -964,8 +964,8 @@ BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, if (hnd == NULL) return False; - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); /* create and send a MSRPC command with api REG_OPEN_ENTRY */ @@ -1025,8 +1025,8 @@ BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) /* create and send a MSRPC command with api REG_CLOSE */ - prs_init(&buf, MAX_PDU_FRAG_LEN, 4, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, 4, cli->mem_ctx, UNMARSHALL); + prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); + prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); DEBUG(4,("REG Close\n")); -- cgit From 87fbb7092b8f8b2f0db0f361c3d625e19de57cd9 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Wed, 4 Jul 2001 07:15:53 +0000 Subject: The big character set handling changeover! This commit gets rid of all our old codepage handling and replaces it with iconv. All internal strings in Samba are now in "unix" charset, which may be multi-byte. See internals.doc and my posting to samba-technical for a more complete explanation. (This used to be commit debb471267960e56005a741817ebd227ecfc512a) --- source3/rpc_client/cli_reg.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index dc547801df..2e71d5a18f 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -311,7 +311,7 @@ BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, } *class_len = r_o.hdr_class.uni_max_len; - fstrcpy(class, dos_unistr2_to_str(&r_o.uni_class)); + rpcstr_pull(class, &r_o.uni_class, -1, -1, 0); *num_subkeys = r_o.num_subkeys ; *max_subkeylen = r_o.max_subkeylen ; *max_subkeysize = r_o.max_subkeysize; @@ -438,7 +438,8 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, return False; } - fstrcpy(key_value, dos_buffer2_to_str(r_o.uni_val)); + /*fstrcpy(key_value, dos_buffer2_to_str(r_o.uni_val));*/ + rpcstr_pull(key_value, r_o.uni_val->buffer, sizeof(fstring), r_o.uni_val->buf_len, 0); *key_type = r_o.type; prs_mem_free(&rbuf); @@ -819,7 +820,7 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, (*unk_1) = r_o.unknown_1; (*unk_2) = r_o.unknown_2; - fstrcpy(key_name, dos_unistr2(r_o.key_name.str.buffer)); + rpcstr_pull(key_name, r_o.key_name.str.buffer, -1, -1, 0); (*mod_time) = nt_time_to_unix(&r_o.time); prs_mem_free(&rbuf); @@ -942,7 +943,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, } (*val_type) = r_o.type; - fstrcpy(val_name, dos_unistr2_to_str(&r_o.uni_name)); + rpcstr_pull(val_name, &r_o.uni_name, -1, -1, 0); prs_mem_free(&rbuf); -- cgit From dc1fc3ee8ec2199bc73bb5d7ec711c6800f61d65 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Tue, 2 Oct 2001 04:29:50 +0000 Subject: Removed 'extern int DEBUGLEVEL' as it is now in the smb.h header. (This used to be commit 2d0922b0eabfdc0aaf1d0797482fef47ed7fde8e) --- source3/rpc_client/cli_reg.c | 3 --- 1 file changed, 3 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 2e71d5a18f..229b82db52 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -1,4 +1,3 @@ - /* * Unix SMB/Netbios implementation. * Version 1.9. @@ -30,8 +29,6 @@ #include "includes.h" -extern int DEBUGLEVEL; - /**************************************************************************** do a REG Open Policy ****************************************************************************/ -- cgit From a689b24db14436ab1faa2f2f79b9f27b777b1fdb Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Sun, 14 Oct 2001 12:10:29 +0000 Subject: the next step in the intl changeover. This should get us compiling agian, and also completes the switch to lang_tdb.c. SWAT should now work with a po file in the lib/ directory also removed useless SYSLOG defines in many files (This used to be commit 5296b20ad85d7519c870768455cb4d8df048c55a) --- source3/rpc_client/cli_reg.c | 4 ---- 1 file changed, 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 229b82db52..cc433ab566 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -23,10 +23,6 @@ */ -#ifdef SYSLOG -#undef SYSLOG -#endif - #include "includes.h" /**************************************************************************** -- cgit From cd68afe31256ad60748b34f7318a180cfc2127cc Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Wed, 30 Jan 2002 06:08:46 +0000 Subject: Removed version number from file header. Changed "SMB/Netbios" to "SMB/CIFS" in file header. (This used to be commit 6a58c9bd06d0d7502a24bf5ce5a2faf0a146edfa) --- source3/rpc_client/cli_reg.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index cc433ab566..64fd908314 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -1,6 +1,5 @@ /* - * Unix SMB/Netbios implementation. - * Version 1.9. + * Unix SMB/CIFS implementation. * RPC Pipe client / server routines * Copyright (C) Andrew Tridgell 1992-1998, * Copyright (C) Luke Kenneth Casson Leighton 1996-1998, -- cgit From ab13654dc9ac23872e4d1384e1c54e336f113009 Mon Sep 17 00:00:00 2001 From: Tim Potter Date: Sun, 17 Mar 2002 04:36:35 +0000 Subject: Renamed get_nt_error_msg() to nt_errstr(). (This used to be commit 1f007d3ed41c1b71a89fa6be7d173e67e927c302) --- source3/rpc_client/cli_reg.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 64fd908314..628cd576a8 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -112,7 +112,7 @@ BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_OPEN_HKLM: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_OPEN_HKLM: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -173,7 +173,7 @@ BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_OPEN_HKU: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_OPEN_HKU: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -235,7 +235,7 @@ BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_FLUSH_KEY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_FLUSH_KEY: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -297,7 +297,7 @@ BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_QUERY_KEY: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -365,7 +365,7 @@ BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_UNK_1A: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -425,7 +425,7 @@ BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, if ( r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_INFO: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -548,7 +548,7 @@ BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_ DEBUG(5,("sec_buf_size too small. use %d\n", *sec_buf_size)); } else if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_GET_KEY_SEC: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } else { @@ -608,7 +608,7 @@ BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_DELETE_VALUE: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -665,7 +665,7 @@ BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_DELETE_KEY: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -743,7 +743,7 @@ BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_CREATE_KEY: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -805,7 +805,7 @@ BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_ENUM_KEY: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -868,7 +868,7 @@ BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_CREATE_VALUE: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -929,7 +929,7 @@ BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_ENUM_VALUE: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -991,7 +991,7 @@ BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, if (r_o.status != 0) { /* report error code */ - DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status))); + DEBUG(0,("REG_OPEN_ENTRY: %s\n", nt_errstr(r_o.status))); prs_mem_free(&rbuf); return False; } @@ -1051,7 +1051,7 @@ BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) if (r_c.status != 0) { /* report error code */ - DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status))); + DEBUG(0,("REG_CLOSE: %s\n", nt_errstr(r_c.status))); prs_mem_free(&rbuf); return False; } -- cgit From e90b65284812aaa5ff9e9935ce9bbad7791cbbcd Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Mon, 15 Jul 2002 10:35:28 +0000 Subject: updated the 3.0 branch from the head branch - ready for alpha18 (This used to be commit 03ac082dcb375b6f3ca3d810a6a6367542bc23ce) --- source3/rpc_client/cli_reg.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 628cd576a8..07001f13bd 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -24,6 +24,9 @@ #include "includes.h" +#undef DBGC_CLASS +#define DBGC_CLASS DBGC_RPC_CLI + /**************************************************************************** do a REG Open Policy ****************************************************************************/ -- cgit From 1f7d18a99c6db90b2c5efb740af02ca279b9445d Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 17 Aug 2002 16:05:44 +0000 Subject: Sync 3.0 branch with HEAD (This used to be commit 3823a2ff5a3c6edf325e2ac31bab50175420f0b1) --- source3/rpc_client/cli_reg.c | 1118 +++--------------------------------------- 1 file changed, 73 insertions(+), 1045 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 07001f13bd..aaf18882f7 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -1,1074 +1,102 @@ /* - * Unix SMB/CIFS implementation. - * RPC Pipe client / server routines - * Copyright (C) Andrew Tridgell 1992-1998, - * Copyright (C) Luke Kenneth Casson Leighton 1996-1998, - * Copyright (C) Paul Ashton 1997-1998. - * Copyright (C) Jeremy Allison 1999. - * - * 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 - * (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, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - + Unix SMB/CIFS implementation. + RPC Pipe client + + Copyright (C) Andrew Tridgell 1992-1998, + Copyright (C) Luke Kenneth Casson Leighton 1996-1998, + Copyright (C) Paul Ashton 1997-1998. + Copyright (C) Jeremy Allison 1999. + Copyright (C) Simo Sorce 2001 + + 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 + (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, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ #include "includes.h" -#undef DBGC_CLASS -#define DBGC_CLASS DBGC_RPC_CLI - -/**************************************************************************** -do a REG Open Policy -****************************************************************************/ -BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name, - POLICY_HND *reg_hnd) -{ - BOOL res = True; - uint32 reg_type = 0; - - if (full_keyname == NULL) - return False; - - ZERO_STRUCTP(reg_hnd); - - /* - * open registry receive a policy handle - */ - - if (!reg_split_key(full_keyname, ®_type, key_name)) { - DEBUG(0,("do_reg_connect: unrecognised key name %s\n", full_keyname)); - return False; - } - - switch (reg_type) { - case HKEY_LOCAL_MACHINE: - res = res ? do_reg_open_hklm(cli, 0x84E0, 0x02000000, reg_hnd) : False; - break; - - case HKEY_USERS: - res = res ? do_reg_open_hku(cli, 0x84E0, 0x02000000, reg_hnd) : False; - break; - - default: - DEBUG(0,("do_reg_connect: unrecognised hive key\n")); - return False; - } - - return res; -} - -/**************************************************************************** -do a REG Open Policy -****************************************************************************/ -BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level, - POLICY_HND *hnd) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_OPEN_HKLM q_o; - REG_R_OPEN_HKLM r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_OPEN_HKLM */ - - DEBUG(4,("REG Open HKLM\n")); - - init_reg_q_open_hklm(&q_o, unknown_0, level); - - /* turn parameters into data stream */ - if(!reg_io_q_open_hklm("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_OPEN_HKLM, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_open_hklm("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_OPEN_HKLM: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - /* ok, at last: we're happy. return the policy handle */ - *hnd = r_o.pol; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Open HKU -****************************************************************************/ -BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level, - POLICY_HND *hnd) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_OPEN_HKU q_o; - REG_R_OPEN_HKU r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_OPEN_HKU */ - - DEBUG(4,("REG Open HKU\n")); - - init_reg_q_open_hku(&q_o, unknown_0, level); - - /* turn parameters into data stream */ - if(!reg_io_q_open_hku("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_OPEN_HKU, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_open_hku("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_OPEN_HKU: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - /* ok, at last: we're happy. return the policy handle */ - *hnd = r_o.pol; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Unknown 0xB command. sent after a create key or create value. -this might be some sort of "sync" or "refresh" command, sent after -modification of the registry... -****************************************************************************/ -BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_FLUSH_KEY q_o; - REG_R_FLUSH_KEY r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_FLUSH_KEY */ - - DEBUG(4,("REG Unknown 0xB\n")); - - init_reg_q_flush_key(&q_o, hnd); - - /* turn parameters into data stream */ - if(!reg_io_q_flush_key("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_FLUSH_KEY, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_flush_key("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_FLUSH_KEY: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Query Key -****************************************************************************/ -BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd, - char *class, uint32 *class_len, - uint32 *num_subkeys, uint32 *max_subkeylen, - uint32 *max_subkeysize, uint32 *num_values, - uint32 *max_valnamelen, uint32 *max_valbufsize, - uint32 *sec_desc, NTTIME *mod_time) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_QUERY_KEY q_o; - REG_R_QUERY_KEY r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_QUERY_KEY */ - - DEBUG(4,("REG Query Key\n")); - - init_reg_q_query_key(&q_o, hnd, *class_len); - - /* turn parameters into data stream */ - if(!reg_io_q_query_key("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_query_key("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_QUERY_KEY: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - *class_len = r_o.hdr_class.uni_max_len; - rpcstr_pull(class, &r_o.uni_class, -1, -1, 0); - *num_subkeys = r_o.num_subkeys ; - *max_subkeylen = r_o.max_subkeylen ; - *max_subkeysize = r_o.max_subkeysize; - *num_values = r_o.num_values ; - *max_valnamelen = r_o.max_valnamelen; - *max_valbufsize = r_o.max_valbufsize; - *sec_desc = r_o.sec_desc ; - *mod_time = r_o.mod_time ; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Unknown 1A -****************************************************************************/ -BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_UNK_1A q_o; - REG_R_UNK_1A r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_UNKNOWN_1A */ - - DEBUG(4,("REG Unknown 1a\n")); - - init_reg_q_unk_1a(&q_o, hnd); - - /* turn parameters into data stream */ - if(!reg_io_q_unk_1a("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_unk_1a("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_UNK_1A: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - (*unk) = r_o.unknown; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Query Info -****************************************************************************/ -BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd, - char *key_value, uint32* key_type) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_INFO q_o; - REG_R_INFO r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_INFO */ - - DEBUG(4,("REG Query Info\n")); - - init_reg_q_info(&q_o, hnd, "ProductType"); - - /* turn parameters into data stream */ - if(!reg_io_q_info("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_info("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if ( r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_INFO: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - /*fstrcpy(key_value, dos_buffer2_to_str(r_o.uni_val));*/ - rpcstr_pull(key_value, r_o.uni_val->buffer, sizeof(fstring), r_o.uni_val->buf_len, 0); - *key_type = r_o.type; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Set Key Security -****************************************************************************/ -BOOL do_reg_set_key_sec(struct cli_state *cli, POLICY_HND *hnd, SEC_DESC_BUF *sec_desc_buf) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_SET_KEY_SEC q_o; - REG_R_SET_KEY_SEC r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_SET_KEY_SEC */ - - DEBUG(4,("REG Set Key security.\n")); - - init_reg_q_set_key_sec(&q_o, hnd, sec_desc_buf); - - /* turn parameters into data stream */ - if(!reg_io_q_set_key_sec("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_SET_KEY_SEC, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_set_key_sec("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Query Key Security -****************************************************************************/ - -BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd, uint32 *sec_buf_size, SEC_DESC_BUF **ppsec_desc_buf) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_GET_KEY_SEC q_o; - REG_R_GET_KEY_SEC r_o; - - if (hnd == NULL) - return False; +/* Shutdown a server */ - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_GET_KEY_SEC */ - - DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size)); - - init_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, NULL); - - /* turn parameters into data stream */ - if(!reg_io_q_get_key_sec("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status == 0x0000007a) { - /* - * get the maximum buffer size: it was too small - */ - (*sec_buf_size) = r_o.hdr_sec.buf_max_len; - DEBUG(5,("sec_buf_size too small. use %d\n", *sec_buf_size)); - } else if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_GET_KEY_SEC: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } else { - (*sec_buf_size) = r_o.data->len; - *ppsec_desc_buf = r_o.data; - } - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Delete Value -****************************************************************************/ -BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_DELETE_VALUE q_o; - REG_R_DELETE_VALUE r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_DELETE_VALUE */ - - DEBUG(4,("REG Delete Value: %s\n", val_name)); - - init_reg_q_delete_val(&q_o, hnd, val_name); - - /* turn parameters into data stream */ - if(!reg_io_q_delete_val("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_delete_val("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_DELETE_VALUE: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Delete Key -****************************************************************************/ -BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_DELETE_KEY q_o; - REG_R_DELETE_KEY r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_DELETE_KEY */ - - DEBUG(4,("REG Delete Key: %s\n", key_name)); - - init_reg_q_delete_key(&q_o, hnd, key_name); - - /* turn parameters into data stream */ - if(!reg_io_q_delete_key("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_delete_key("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_DELETE_KEY: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Create Key -****************************************************************************/ -BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd, - char *key_name, char *key_class, - SEC_ACCESS *sam_access, - POLICY_HND *key) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_CREATE_KEY q_o; - REG_R_CREATE_KEY r_o; - SEC_DESC *sec = NULL; - SEC_DESC_BUF *sec_buf = NULL; - size_t sec_len; - - ZERO_STRUCT(q_o); - - if (hnd == NULL) - return False; - - /* create and send a MSRPC command with api REG_CREATE_KEY */ - - DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class, - sam_access != NULL ? sam_access->mask : 0)); - - if((sec = make_sec_desc( cli->mem_ctx, 1, NULL, NULL, NULL, NULL, &sec_len)) == NULL) { - DEBUG(0,("make_sec_desc : malloc fail.\n")); - return False; - } - - DEBUG(10,("make_sec_desc: len = %d\n", (int)sec_len)); - - if((sec_buf = make_sec_desc_buf( cli->mem_ctx, (int)sec_len, sec)) == NULL) { - DEBUG(0,("make_sec_desc : malloc fail (1)\n")); - return False; - } - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - init_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access, sec_buf); - - /* turn parameters into data stream */ - if(!reg_io_q_create_key("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_create_key("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_CREATE_KEY: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - *key = r_o.key_pol; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Enum Key -****************************************************************************/ -BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd, - int key_index, char *key_name, - uint32 *unk_1, uint32 *unk_2, - time_t *mod_time) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_ENUM_KEY q_o; - REG_R_ENUM_KEY r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_ENUM_KEY */ - - DEBUG(4,("REG Enum Key\n")); - - init_reg_q_enum_key(&q_o, hnd, key_index); - - /* turn parameters into data stream */ - if(!reg_io_q_enum_key("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_enum_key("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_ENUM_KEY: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - (*unk_1) = r_o.unknown_1; - (*unk_2) = r_o.unknown_2; - rpcstr_pull(key_name, r_o.key_name.str.buffer, -1, -1, 0); - (*mod_time) = nt_time_to_unix(&r_o.time); - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Create Value -****************************************************************************/ -BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd, - char *val_name, uint32 type, BUFFER3 *data) +NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, + const char *msg, uint32 timeout, uint16 flags) { - prs_struct rbuf; - prs_struct buf; - REG_Q_CREATE_VALUE q_o; - REG_R_CREATE_VALUE r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_CREATE_VALUE */ - - DEBUG(4,("REG Create Value: %s\n", val_name)); - - init_reg_q_create_val(&q_o, hnd, val_name, type, data); - - /* turn parameters into data stream */ - if(!reg_io_q_create_val("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - - if(!reg_io_r_create_val("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_CREATE_VALUE: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Enum Value -****************************************************************************/ -BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd, - int val_index, int max_valnamelen, int max_valbufsize, - fstring val_name, - uint32 *val_type, BUFFER2 *value) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_ENUM_VALUE q_o; - REG_R_ENUM_VALUE r_o; + prs_struct qbuf; + prs_struct rbuf; + REG_Q_SHUTDOWN q_s; + REG_R_SHUTDOWN r_s; + NTSTATUS result = NT_STATUS_UNSUCCESSFUL; - if (hnd == NULL) - return False; + if (msg == NULL) return NT_STATUS_INVALID_PARAMETER; - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); + ZERO_STRUCT (q_s); + ZERO_STRUCT (r_s); - /* create and send a MSRPC command with api REG_ENUM_VALUE */ + prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - DEBUG(4,("REG Enum Value\n")); + /* Marshall data and send request */ - init_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize); + init_reg_q_shutdown(&q_s, msg, timeout, flags); - /* turn parameters into data stream */ - if(!reg_io_q_enum_val("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - r_o.buf_value = value; - - if(!reg_io_r_enum_val("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_ENUM_VALUE: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - (*val_type) = r_o.type; - rpcstr_pull(val_name, &r_o.uni_name, -1, -1, 0); + if (!reg_io_q_shutdown("", &q_s, &qbuf, 0) || + !rpc_api_pipe_req(cli, REG_SHUTDOWN, &qbuf, &rbuf)) + goto done; + + /* Unmarshall response */ + + if(reg_io_r_shutdown("", &r_s, &rbuf, 0)) + result = r_s.status; +done: prs_mem_free(&rbuf); + prs_mem_free(&qbuf); - return True; + return result; } -/**************************************************************************** -do a REG Open Key -****************************************************************************/ -BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd, - char *key_name, uint32 unk_0, - POLICY_HND *key_hnd) -{ - prs_struct rbuf; - prs_struct buf; - REG_Q_OPEN_ENTRY q_o; - REG_R_OPEN_ENTRY r_o; - - if (hnd == NULL) - return False; - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); - - /* create and send a MSRPC command with api REG_OPEN_ENTRY */ - - DEBUG(4,("REG Open Entry\n")); - - init_reg_q_open_entry(&q_o, hnd, key_name, unk_0); - - /* turn parameters into data stream */ - if(!reg_io_q_open_entry("", &q_o, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_o); - if(!reg_io_r_open_entry("", &r_o, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } +/* Abort a server shutdown */ - if (r_o.status != 0) { - /* report error code */ - DEBUG(0,("REG_OPEN_ENTRY: %s\n", nt_errstr(r_o.status))); - prs_mem_free(&rbuf); - return False; - } - - *key_hnd = r_o.pol; - - prs_mem_free(&rbuf); - - return True; -} - -/**************************************************************************** -do a REG Close -****************************************************************************/ -BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd) +NTSTATUS cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) { prs_struct rbuf; - prs_struct buf; - REG_Q_CLOSE q_c; - REG_R_CLOSE r_c; - - if (hnd == NULL) - return False; - - /* create and send a MSRPC command with api REG_CLOSE */ - - prs_init(&buf, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL); - prs_init(&rbuf, 0, cli->mem_ctx, UNMARSHALL); + prs_struct qbuf; + REG_Q_ABORT_SHUTDOWN q_s; + REG_R_ABORT_SHUTDOWN r_s; + NTSTATUS result = NT_STATUS_UNSUCCESSFUL; - DEBUG(4,("REG Close\n")); + ZERO_STRUCT (q_s); + ZERO_STRUCT (r_s); - /* store the parameters */ - init_reg_q_close(&q_c, hnd); - - /* turn parameters into data stream */ - if(!reg_io_q_close("", &q_c, &buf, 0)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - /* send the data on \PIPE\ */ - if (!rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf)) { - prs_mem_free(&buf); - prs_mem_free(&rbuf); - return False; - } - - prs_mem_free(&buf); - - ZERO_STRUCT(r_c); - - if(!reg_io_r_close("", &r_c, &rbuf, 0)) { - prs_mem_free(&rbuf); - return False; - } - - if (r_c.status != 0) { - /* report error code */ - DEBUG(0,("REG_CLOSE: %s\n", nt_errstr(r_c.status))); - prs_mem_free(&rbuf); - return False; - } + prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ - /* check that the returned policy handle is all zeros */ + init_reg_q_abort_shutdown(&q_s); - if (IVAL(&r_c.pol.data1,0) || IVAL(&r_c.pol.data2,0) || SVAL(&r_c.pol.data3,0) || - SVAL(&r_c.pol.data4,0) || IVAL(r_c.pol.data5,0) || IVAL(r_c.pol.data5,4) ) { - prs_mem_free(&rbuf); - DEBUG(0,("REG_CLOSE: non-zero handle returned\n")); - return False; - } + if (!reg_io_q_abort_shutdown("", &q_s, &qbuf, 0) || + !rpc_api_pipe_req(cli, REG_ABORT_SHUTDOWN, &qbuf, &rbuf)) + goto done; + + /* Unmarshall response */ + + if (reg_io_r_abort_shutdown("", &r_s, &rbuf, 0)) + result = r_s.status; +done: prs_mem_free(&rbuf); + prs_mem_free(&qbuf ); - return True; + return result; } -- cgit From b327f5ba53788f6ef758af57a8845a44abba69d3 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Sat, 4 Jan 2003 07:50:04 +0000 Subject: Merge from HEAD - idra's fix for the fact that the shutdown command takes two 1 byte boolean flags, not a 16 bit bitmask. Andrew Bartlett (This used to be commit a4f7777ca08c732ace2ba60bc0ecffbea1239fc3) --- source3/rpc_client/cli_reg.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index aaf18882f7..1e83295414 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -28,7 +28,8 @@ /* Shutdown a server */ NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, - const char *msg, uint32 timeout, uint16 flags) + const char *msg, uint32 timeout, BOOL reboot, + BOOL force) { prs_struct qbuf; prs_struct rbuf; @@ -46,7 +47,7 @@ NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, /* Marshall data and send request */ - init_reg_q_shutdown(&q_s, msg, timeout, flags); + init_reg_q_shutdown(&q_s, msg, timeout, reboot, force); if (!reg_io_q_shutdown("", &q_s, &qbuf, 0) || !rpc_api_pipe_req(cli, REG_SHUTDOWN, &qbuf, &rbuf)) -- cgit From 16925589eb1f12ebe6e493774fd4306a827feb73 Mon Sep 17 00:00:00 2001 From: Richard Sharpe Date: Mon, 13 Jan 2003 20:04:40 +0000 Subject: Now that I am running config.developer, I decided to get rif of some warnings: 1. reboot in parse_reg and cli_reg was shadowing a definition on FreeBSD 4.3 from system includes. 2. Added a bit of const to places. 3. Made sure internal functions were declared where needed. (This used to be commit fd847aa93690eb72f0437a8d22c03b222eb2a016) --- source3/rpc_client/cli_reg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 1e83295414..5cfbf68fb3 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -28,7 +28,7 @@ /* Shutdown a server */ NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, - const char *msg, uint32 timeout, BOOL reboot, + const char *msg, uint32 timeout, BOOL do_reboot, BOOL force) { prs_struct qbuf; @@ -47,7 +47,7 @@ NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, /* Marshall data and send request */ - init_reg_q_shutdown(&q_s, msg, timeout, reboot, force); + init_reg_q_shutdown(&q_s, msg, timeout, do_reboot, force); if (!reg_io_q_shutdown("", &q_s, &qbuf, 0) || !rpc_api_pipe_req(cli, REG_SHUTDOWN, &qbuf, &rbuf)) -- cgit From f4ec52a0978dca900942e6001947e3b3d58eccd2 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Thu, 6 Jan 2005 11:42:40 +0000 Subject: r4561: This looks a lot larger than it is, this is to reduce the clutter on future patches. Pass down the pipe_idx down to all functions in cli_pipe where nt_pipe_fnum is referenced. First step towards having multiple pipes on a cli_struct. The idea is to not have a single nt_pipe_fnum but an array for the pipes we support. Volker (This used to be commit 93eab050201d4e55096a8820226749f001597b5d) --- source3/rpc_client/cli_reg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 5cfbf68fb3..6ed0496030 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -50,7 +50,7 @@ NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, init_reg_q_shutdown(&q_s, msg, timeout, do_reboot, force); if (!reg_io_q_shutdown("", &q_s, &qbuf, 0) || - !rpc_api_pipe_req(cli, REG_SHUTDOWN, &qbuf, &rbuf)) + !rpc_api_pipe_req(cli, PI_WINREG, REG_SHUTDOWN, &qbuf, &rbuf)) goto done; /* Unmarshall response */ @@ -87,7 +87,7 @@ NTSTATUS cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) init_reg_q_abort_shutdown(&q_s); if (!reg_io_q_abort_shutdown("", &q_s, &qbuf, 0) || - !rpc_api_pipe_req(cli, REG_ABORT_SHUTDOWN, &qbuf, &rbuf)) + !rpc_api_pipe_req(cli, PI_WINREG, REG_ABORT_SHUTDOWN, &qbuf, &rbuf)) goto done; /* Unmarshall response */ -- cgit From bd22606da04bffd3b4966c17ad2c98e6dc8b5e35 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 10 Jan 2005 20:33:41 +0000 Subject: r4656: Convert the winreg pipe to use WERROR returns (as it should). Also fix return of NT_STATUS_NO_MORE_ENTRIES should be ERROR_NO_MORE_ITEMS reported by "Marcin Porwit" . Jeremy. (This used to be commit 511cdec60d431d767fb02f68ca5ddd4ddb59e64a) --- source3/rpc_client/cli_reg.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 6ed0496030..25f56085ba 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -27,7 +27,7 @@ /* Shutdown a server */ -NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, +WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, const char *msg, uint32 timeout, BOOL do_reboot, BOOL force) { @@ -35,9 +35,9 @@ NTSTATUS cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, prs_struct rbuf; REG_Q_SHUTDOWN q_s; REG_R_SHUTDOWN r_s; - NTSTATUS result = NT_STATUS_UNSUCCESSFUL; + WERROR result = WERR_GENERAL_FAILURE; - if (msg == NULL) return NT_STATUS_INVALID_PARAMETER; + if (msg == NULL) return WERR_INVALID_PARAM; ZERO_STRUCT (q_s); ZERO_STRUCT (r_s); @@ -68,13 +68,13 @@ done: /* Abort a server shutdown */ -NTSTATUS cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) +WERROR cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) { prs_struct rbuf; prs_struct qbuf; REG_Q_ABORT_SHUTDOWN q_s; REG_R_ABORT_SHUTDOWN r_s; - NTSTATUS result = NT_STATUS_UNSUCCESSFUL; + WERROR result = WERR_GENERAL_FAILURE; ZERO_STRUCT (q_s); ZERO_STRUCT (r_s); -- cgit From 5d1cb8e79edea9e8581d3c2c9dd297310cd9a98c Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Wed, 23 Mar 2005 23:26:33 +0000 Subject: r6014: rather large change set.... pulling back all recent rpc changes from trunk into 3.0. I've tested a compile and so don't think I've missed any files. But if so, just mail me and I'll clean backup in a couple of hours. Changes include \winreg, \eventlog, \svcctl, and general parse_misc.c updates. I am planning on bracketing the event code with an #ifdef ENABLE_EVENTLOG until I finish merging Marcin's changes (very soon). (This used to be commit 4e0ac63c36527cd8c52ef720cae17e84f67e7221) --- source3/rpc_client/cli_reg.c | 721 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 717 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 25f56085ba..773144742b 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -2,11 +2,12 @@ Unix SMB/CIFS implementation. RPC Pipe client - Copyright (C) Andrew Tridgell 1992-1998, - Copyright (C) Luke Kenneth Casson Leighton 1996-1998, - Copyright (C) Paul Ashton 1997-1998. + Copyright (C) Andrew Tridgell 1992-2000, + Copyright (C) Luke Kenneth Casson Leighton 1996-2000, + Copyright (C) Paul Ashton 1997-2000. Copyright (C) Jeremy Allison 1999. Copyright (C) Simo Sorce 2001 + Copyright (C) Jeremy Cooper 2004 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 @@ -27,6 +28,51 @@ /* Shutdown a server */ +/* internal connect to a registry hive root (open a registry policy) */ + +static WERROR cli_reg_open_hive_int(struct cli_state *cli, + TALLOC_CTX *mem_ctx, uint16 op_code, + const char *op_name, + uint32 access_mask, POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_OPEN_HIVE q_o; + REG_R_OPEN_HIVE r_o; + WERROR result = WERR_GENERAL_FAILURE; + + ZERO_STRUCT(q_o); + ZERO_STRUCT(r_o); + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + init_reg_q_open_hive(&q_o, access_mask); + + /* Marshall the query parameters */ + if (!reg_io_q_open_hive("", &q_o, &qbuf, 0)) + goto done; + + /* Send the request, receive the response */ + if (!rpc_api_pipe_req(cli, PI_WINREG, op_code, &qbuf, &rbuf)) + goto done; + + /* Unmarshall the response */ + if (!reg_io_r_open_hive("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) + *hnd = r_o.pol; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + + WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, const char *msg, uint32 timeout, BOOL do_reboot, BOOL force) @@ -90,7 +136,7 @@ WERROR cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) !rpc_api_pipe_req(cli, PI_WINREG, REG_ABORT_SHUTDOWN, &qbuf, &rbuf)) goto done; - /* Unmarshall response */ + /* Unmarshall response */ if (reg_io_r_abort_shutdown("", &r_s, &rbuf, 0)) result = r_s.status; @@ -101,3 +147,670 @@ done: return result; } + +/* connect to a registry hive root (open a registry policy) */ + +WERROR cli_reg_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, + uint32 reg_type, uint32 access_mask, + POLICY_HND *reg_hnd) +{ uint16 op_code; + const char *op_name; + + ZERO_STRUCTP(reg_hnd); + + switch (reg_type) + { + case HKEY_CLASSES_ROOT: + op_code = REG_OPEN_HKCR; + op_name = "REG_OPEN_HKCR"; + break; + case HKEY_LOCAL_MACHINE: + op_code = REG_OPEN_HKLM; + op_name = "REG_OPEN_HKLM"; + break; + case HKEY_USERS: + op_code = REG_OPEN_HKU; + op_name = "REG_OPEN_HKU"; + break; + case HKEY_PERFORMANCE_DATA: + op_code = REG_OPEN_HKPD; + op_name = "REG_OPEN_HKPD"; + break; + default: + return WERR_INVALID_PARAM; + } + + return cli_reg_open_hive_int(cli, mem_ctx, op_code, op_name, + access_mask, reg_hnd); +} + +/**************************************************************************** +do a REG Unknown 0xB command. sent after a create key or create value. +this might be some sort of "sync" or "refresh" command, sent after +modification of the registry... +****************************************************************************/ +WERROR cli_reg_flush_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_FLUSH_KEY q_o; + REG_R_FLUSH_KEY r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_flush_key(&q_o, hnd); + + if (!reg_io_q_flush_key("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_FLUSH_KEY, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (reg_io_r_flush_key("", &r_o, &rbuf, 0)) + result = r_o.status; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Query Key +****************************************************************************/ +WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, + char *key_class, uint32 *class_len, + uint32 *num_subkeys, uint32 *max_subkeylen, + uint32 *max_classlen, uint32 *num_values, + uint32 *max_valnamelen, uint32 *max_valbufsize, + uint32 *sec_desc, NTTIME *mod_time) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_QUERY_KEY q_o; + REG_R_QUERY_KEY r_o; + uint32 saved_class_len = *class_len; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_query_key( &q_o, hnd, key_class ); + + if (!reg_io_q_query_key("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_QUERY_KEY, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (!reg_io_r_query_key("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_EQUAL(result, ERROR_INSUFFICIENT_BUFFER)) { + *class_len = r_o.class.string->uni_max_len; + goto done; + } else if (!NT_STATUS_IS_OK(result)) + goto done; + + *class_len = r_o.class.string->uni_max_len; + unistr2_to_ascii(key_class, r_o.class.string, saved_class_len-1); + *num_subkeys = r_o.num_subkeys ; + *max_subkeylen = r_o.max_subkeylen ; + *num_values = r_o.num_values ; + *max_valnamelen = r_o.max_valnamelen; + *max_valbufsize = r_o.max_valbufsize; + *sec_desc = r_o.sec_desc ; + *mod_time = r_o.mod_time ; + /* Maybe: *max_classlen = r_o.reserved; */ + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Unknown 1A +****************************************************************************/ +WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, uint32 *unk) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_GETVERSION q_o; + REG_R_GETVERSION r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_getversion(&q_o, hnd); + + if (!reg_io_q_getversion("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_GETVERSION, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (!reg_io_r_getversion("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) + if (unk != NULL) + *unk = r_o.unknown; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Query Info +****************************************************************************/ +WERROR cli_reg_query_info(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, const char *val_name, + uint32 *type, REGVAL_BUFFER *buffer) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_INFO q_o; + REG_R_INFO r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_info(&q_o, hnd, val_name, buffer); + + if (!reg_io_q_info("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_INFO, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (!reg_io_r_info("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) { + *type = *r_o.type; + *buffer = *r_o.value; + } + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Set Key Security +****************************************************************************/ +WERROR cli_reg_set_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, uint32 sec_info, + size_t secdesc_size, SEC_DESC *sec_desc) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_SET_KEY_SEC q_o; + REG_R_SET_KEY_SEC r_o; + SEC_DESC_BUF *sec_desc_buf; + WERROR result = WERR_GENERAL_FAILURE; + + /* + * Flatten the security descriptor. + */ + sec_desc_buf = make_sec_desc_buf(mem_ctx, secdesc_size, sec_desc); + if (sec_desc_buf == NULL) + goto done; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_set_key_sec(&q_o, hnd, sec_info, sec_desc_buf); + + if (!reg_io_q_set_key_sec("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_SET_KEY_SEC, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (reg_io_r_set_key_sec("", &r_o, &rbuf, 0)) + result = r_o.status; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + + +/**************************************************************************** +do a REG Query Key Security +****************************************************************************/ +WERROR cli_reg_get_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, uint32 sec_info, + uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_GET_KEY_SEC q_o; + REG_R_GET_KEY_SEC r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_get_key_sec(&q_o, hnd, sec_info, *sec_buf_size, sec_buf); + + if (!reg_io_q_get_key_sec("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_GET_KEY_SEC, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + r_o.data = sec_buf; + + if (*sec_buf_size != 0) + { + sec_buf->sec = (SEC_DESC*)talloc(mem_ctx, *sec_buf_size); + } + + if (!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) + (*sec_buf_size) = r_o.data->len; + else if (NT_STATUS_EQUAL(result, ERROR_INSUFFICIENT_BUFFER)) + { + /* + * get the maximum buffer size: it was too small + */ + (*sec_buf_size) = r_o.hdr_sec.buf_max_len; + } + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Delete Value +****************************************************************************/ +WERROR cli_reg_delete_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, char *val_name) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_DELETE_VALUE q_o; + REG_R_DELETE_VALUE r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_delete_val(&q_o, hnd, val_name); + + if (!reg_io_q_delete_val("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_DELETE_VALUE, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (reg_io_r_delete_val("", &r_o, &rbuf, 0)) + result = r_o.status; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Delete Key +****************************************************************************/ +WERROR cli_reg_delete_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, char *key_name) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_DELETE_KEY q_o; + REG_R_DELETE_KEY r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_delete_key(&q_o, hnd, key_name); + + if (!reg_io_q_delete_key("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_DELETE_KEY, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (reg_io_r_delete_key("", &r_o, &rbuf, 0)) + result = r_o.status; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Create Key +****************************************************************************/ +WERROR cli_reg_create_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, char *key_name, char *key_class, + uint32 access_desired, POLICY_HND *key) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_CREATE_KEY q_o; + REG_R_CREATE_KEY r_o; + SEC_DESC *sec; + SEC_DESC_BUF *sec_buf; + size_t sec_len; + WERROR result = WERR_GENERAL_FAILURE; + + ZERO_STRUCT(q_o); + + if ((sec = make_sec_desc(mem_ctx, 1, SEC_DESC_SELF_RELATIVE, + NULL, NULL, NULL, NULL, &sec_len)) == NULL) + goto done; + + if ((sec_buf = make_sec_desc_buf(mem_ctx, sec_len, sec)) == NULL) + goto done; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_create_key(&q_o, hnd, key_name, key_class, access_desired, sec_buf); + + if (!reg_io_q_create_key("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_CREATE_KEY, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (!reg_io_r_create_key("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) + *key = r_o.key_pol; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Enum Key +****************************************************************************/ +WERROR cli_reg_enum_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, int key_index, fstring key_name, + uint32 *unk_1, uint32 *unk_2, time_t *mod_time) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_ENUM_KEY q_o; + REG_R_ENUM_KEY r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_enum_key(&q_o, hnd, key_index); + + if (!reg_io_q_enum_key("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_ENUM_KEY, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (!reg_io_r_enum_key("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) { + (*unk_1) = r_o.unknown_1; + (*unk_2) = r_o.unknown_2; + unistr3_to_ascii(key_name, &r_o.key_name, + sizeof(fstring)-1); + (*mod_time) = nt_time_to_unix(&r_o.time); + } + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Create Value +****************************************************************************/ +WERROR cli_reg_create_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, char *val_name, uint32 type, + BUFFER3 *data) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_CREATE_VALUE q_o; + REG_R_CREATE_VALUE r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_create_val(&q_o, hnd, val_name, type, data); + + if (!reg_io_q_create_val("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_CREATE_VALUE, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshal response */ + + if (reg_io_r_create_val("", &r_o, &rbuf, 0)) + result = r_o.status; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Enum Value +****************************************************************************/ +WERROR cli_reg_enum_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, int val_index, int max_valnamelen, + int max_valbufsize, fstring val_name, + uint32 *val_type, REGVAL_BUFFER *value) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_ENUM_VALUE q_o; + REG_R_ENUM_VALUE r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_enum_val(&q_o, hnd, val_index, val_name, max_valbufsize); + + if (!reg_io_q_enum_val("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_ENUM_VALUE, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarshall response */ + + if (!reg_io_r_enum_val("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result) || + NT_STATUS_EQUAL(result, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + (*val_type) = *r_o.type; + unistr2_to_ascii(val_name, r_o.name.string, sizeof(fstring)-1); + *value = *r_o.value; + } + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Open Key +****************************************************************************/ +WERROR cli_reg_open_entry(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, char *key_name, + uint32 access_desired, POLICY_HND *key_hnd) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_OPEN_ENTRY q_o; + REG_R_OPEN_ENTRY r_o; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_open_entry(&q_o, hnd, key_name, access_desired); + + /* turn parameters into data stream */ + if (!reg_io_q_open_entry("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_OPEN_ENTRY, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_o); + + /* Unmarsall response */ + + if (!reg_io_r_open_entry("", &r_o, &rbuf, 0)) + goto done; + + result = r_o.status; + if (NT_STATUS_IS_OK(result)) + *key_hnd = r_o.pol; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + +/**************************************************************************** +do a REG Close +****************************************************************************/ +WERROR cli_reg_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd) +{ + prs_struct rbuf; + prs_struct qbuf; + REG_Q_CLOSE q_c; + REG_R_CLOSE r_c; + WERROR result = WERR_GENERAL_FAILURE; + + prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); + prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + + /* Marshall data and send request */ + + init_reg_q_close(&q_c, hnd); + + if (!reg_io_q_close("", &q_c, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_CLOSE, &qbuf, &rbuf)) + goto done; + + ZERO_STRUCT(r_c); + + /* Unmarshall response */ + + if (reg_io_r_close("", &r_c, &rbuf, 0)) + result = r_c.status; + +done: + prs_mem_free(&rbuf); + prs_mem_free(&qbuf); + + return result; +} + + -- cgit From 466a825ce7a3c9a40a694608523f47e580c78415 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Thu, 7 Apr 2005 04:58:38 +0000 Subject: r6232: more cleanups; remove BUFFER3; rename BUFFER4 -> RPC_DATA_BLOB; rename REG_CREATE_VALE -> REG_SET_VALUE (This used to be commit 28d433351cf813c7fb57ebac0e0f4973c85f73e8) --- source3/rpc_client/cli_reg.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 773144742b..0d7d194850 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -651,14 +651,14 @@ done: /**************************************************************************** do a REG Create Value ****************************************************************************/ -WERROR cli_reg_create_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR cli_reg_set_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *val_name, uint32 type, - BUFFER3 *data) + RPC_DATA_BLOB *data) { prs_struct rbuf; prs_struct qbuf; - REG_Q_CREATE_VALUE q_o; - REG_R_CREATE_VALUE r_o; + REG_Q_SET_VALUE q_o; + REG_R_SET_VALUE r_o; WERROR result = WERR_GENERAL_FAILURE; prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); @@ -666,17 +666,17 @@ WERROR cli_reg_create_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, /* Marshall data and send request */ - init_reg_q_create_val(&q_o, hnd, val_name, type, data); + init_reg_q_set_val(&q_o, hnd, val_name, type, data); - if (!reg_io_q_create_val("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_CREATE_VALUE, &qbuf, &rbuf)) + if (!reg_io_q_set_val("", &q_o, &qbuf, 0) || + !rpc_api_pipe_req(cli, PI_WINREG, REG_SET_VALUE, &qbuf, &rbuf)) goto done; ZERO_STRUCT(r_o); /* Unmarshal response */ - if (reg_io_r_create_val("", &r_o, &rbuf, 0)) + if (reg_io_r_set_val("", &r_o, &rbuf, 0)) result = r_o.status; done: -- cgit From 2e0cac8e3eb021aa8f5cad4ce8b72f98036af639 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Sat, 23 Apr 2005 18:07:01 +0000 Subject: r6445: Make us survive the PARANOID_MALLOC_CHECKER. Should we enable that for --enable-developer=yes? Volker (This used to be commit 61d40ac60dd9c8c9bbcf92e4fc57fe1d706bc721) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 0d7d194850..87b41d248e 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -449,7 +449,7 @@ WERROR cli_reg_get_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, if (*sec_buf_size != 0) { - sec_buf->sec = (SEC_DESC*)talloc(mem_ctx, *sec_buf_size); + sec_buf->sec = TALLOC(mem_ctx, *sec_buf_size); } if (!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) -- cgit From f0c650a38286c07b9f3e83139c15bfbadc70ad5f Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Mon, 23 May 2005 16:25:31 +0000 Subject: r6942: * merging the registry changes back to the 3.0 tree * removing the testprns tool (This used to be commit 81ffb0dbbbd244623507880c323a3c37e2b8dc4d) --- source3/rpc_client/cli_reg.c | 999 +++++++++++++++++++------------------------ 1 file changed, 441 insertions(+), 558 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 87b41d248e..164bdd3129 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -8,6 +8,7 @@ Copyright (C) Jeremy Allison 1999. Copyright (C) Simo Sorce 2001 Copyright (C) Jeremy Cooper 2004 + Copyright (C) Gerald (Jerry) Carter 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 @@ -25,130 +26,46 @@ */ #include "includes.h" +#include "rpc_client.h" /* Shutdown a server */ -/* internal connect to a registry hive root (open a registry policy) */ +/******************************************************************* + internal connect to a registry hive root (open a registry policy) +*******************************************************************/ static WERROR cli_reg_open_hive_int(struct cli_state *cli, TALLOC_CTX *mem_ctx, uint16 op_code, const char *op_name, uint32 access_mask, POLICY_HND *hnd) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_OPEN_HIVE q_o; - REG_R_OPEN_HIVE r_o; - WERROR result = WERR_GENERAL_FAILURE; + REG_Q_OPEN_HIVE in; + REG_R_OPEN_HIVE out; + prs_struct qbuf, rbuf; - ZERO_STRUCT(q_o); - ZERO_STRUCT(r_o); + ZERO_STRUCT(in); + ZERO_STRUCT(out); - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + init_reg_q_open_hive(&in, access_mask); - init_reg_q_open_hive(&q_o, access_mask); + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, op_code, + in, out, + qbuf, rbuf, + reg_io_q_open_hive, + reg_io_r_open_hive, + WERR_GENERAL_FAILURE ); - /* Marshall the query parameters */ - if (!reg_io_q_open_hive("", &q_o, &qbuf, 0)) - goto done; + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; - /* Send the request, receive the response */ - if (!rpc_api_pipe_req(cli, PI_WINREG, op_code, &qbuf, &rbuf)) - goto done; + memcpy( hnd, &out.pol, sizeof(POLICY_HND) ); - /* Unmarshall the response */ - if (!reg_io_r_open_hive("", &r_o, &rbuf, 0)) - goto done; - - result = r_o.status; - if (NT_STATUS_IS_OK(result)) - *hnd = r_o.pol; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; -} - - -WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, - const char *msg, uint32 timeout, BOOL do_reboot, - BOOL force) -{ - prs_struct qbuf; - prs_struct rbuf; - REG_Q_SHUTDOWN q_s; - REG_R_SHUTDOWN r_s; - WERROR result = WERR_GENERAL_FAILURE; - - if (msg == NULL) return WERR_INVALID_PARAM; - - ZERO_STRUCT (q_s); - ZERO_STRUCT (r_s); - - prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_shutdown(&q_s, msg, timeout, do_reboot, force); - - if (!reg_io_q_shutdown("", &q_s, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_SHUTDOWN, &qbuf, &rbuf)) - goto done; - - /* Unmarshall response */ - - if(reg_io_r_shutdown("", &r_s, &rbuf, 0)) - result = r_s.status; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; -} - - -/* Abort a server shutdown */ - -WERROR cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) -{ - prs_struct rbuf; - prs_struct qbuf; - REG_Q_ABORT_SHUTDOWN q_s; - REG_R_ABORT_SHUTDOWN r_s; - WERROR result = WERR_GENERAL_FAILURE; - - ZERO_STRUCT (q_s); - ZERO_STRUCT (r_s); - - prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_abort_shutdown(&q_s); - - if (!reg_io_q_abort_shutdown("", &q_s, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_ABORT_SHUTDOWN, &qbuf, &rbuf)) - goto done; - - /* Unmarshall response */ - - if (reg_io_r_abort_shutdown("", &r_s, &rbuf, 0)) - result = r_s.status; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf ); - - return result; + return out.status; } -/* connect to a registry hive root (open a registry policy) */ +/******************************************************************* + connect to a registry hive root (open a registry policy) +*******************************************************************/ WERROR cli_reg_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, uint32 reg_type, uint32 access_mask, @@ -184,43 +101,86 @@ WERROR cli_reg_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, access_mask, reg_hnd); } -/**************************************************************************** -do a REG Unknown 0xB command. sent after a create key or create value. -this might be some sort of "sync" or "refresh" command, sent after -modification of the registry... -****************************************************************************/ -WERROR cli_reg_flush_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd) + +/******************************************************************* +*******************************************************************/ + +WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, + const char *msg, uint32 timeout, BOOL do_reboot, + BOOL force) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_FLUSH_KEY q_o; - REG_R_FLUSH_KEY r_o; - WERROR result = WERR_GENERAL_FAILURE; + REG_Q_SHUTDOWN in; + REG_R_SHUTDOWN out; + prs_struct qbuf, rbuf; - prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + if (msg == NULL) + return WERR_INVALID_PARAM; + + ZERO_STRUCT (in); + ZERO_STRUCT (out); /* Marshall data and send request */ - init_reg_q_flush_key(&q_o, hnd); + init_reg_q_shutdown(&in, msg, timeout, do_reboot, force); - if (!reg_io_q_flush_key("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_FLUSH_KEY, &qbuf, &rbuf)) - goto done; + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SHUTDOWN, + in, out, + qbuf, rbuf, + reg_io_q_shutdown, + reg_io_r_shutdown, + WERR_GENERAL_FAILURE ); - ZERO_STRUCT(r_o); + return out.status; +} - /* Unmarshall response */ +/******************************************************************* +*******************************************************************/ + +WERROR cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) +{ + REG_Q_ABORT_SHUTDOWN in; + REG_R_ABORT_SHUTDOWN out; + prs_struct qbuf, rbuf; + + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ABORT_SHUTDOWN, + in, out, + qbuf, rbuf, + reg_io_q_abort_shutdown, + reg_io_r_abort_shutdown, + WERR_GENERAL_FAILURE ); + + return out.status; +} - if (reg_io_r_flush_key("", &r_o, &rbuf, 0)) - result = r_o.status; -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); +/**************************************************************************** +do a REG Unknown 0xB command. sent after a create key or create value. +this might be some sort of "sync" or "refresh" command, sent after +modification of the registry... +****************************************************************************/ +WERROR cli_reg_flush_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd) +{ + REG_Q_FLUSH_KEY in; + REG_R_FLUSH_KEY out; + prs_struct qbuf, rbuf; - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_flush_key(&in, hnd); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_FLUSH_KEY, + in, out, + qbuf, rbuf, + reg_io_q_flush_key, + reg_io_r_flush_key, + WERR_GENERAL_FAILURE ); + + return out.status; } /**************************************************************************** @@ -234,96 +194,93 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, uint32 *max_valnamelen, uint32 *max_valbufsize, uint32 *sec_desc, NTTIME *mod_time) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_QUERY_KEY q_o; - REG_R_QUERY_KEY r_o; + REG_Q_QUERY_KEY in; + REG_R_QUERY_KEY out; + prs_struct qbuf, rbuf; uint32 saved_class_len = *class_len; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_query_key( &q_o, hnd, key_class ); - if (!reg_io_q_query_key("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_QUERY_KEY, &qbuf, &rbuf)) - goto done; + ZERO_STRUCT (in); + ZERO_STRUCT (out); - ZERO_STRUCT(r_o); + init_reg_q_query_key( &in, hnd, key_class ); - /* Unmarshall response */ + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, + in, out, + qbuf, rbuf, + reg_io_q_query_key, + reg_io_r_query_key, + WERR_GENERAL_FAILURE ); - if (!reg_io_r_query_key("", &r_o, &rbuf, 0)) - goto done; + if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) { + ZERO_STRUCT (in); - result = r_o.status; - if (NT_STATUS_EQUAL(result, ERROR_INSUFFICIENT_BUFFER)) { - *class_len = r_o.class.string->uni_max_len; - goto done; - } else if (!NT_STATUS_IS_OK(result)) - goto done; + *class_len = out.class.string->uni_max_len; + if ( *class_len > saved_class_len ) + return out.status; + + /* set a string of spaces and NULL terminate */ - *class_len = r_o.class.string->uni_max_len; - unistr2_to_ascii(key_class, r_o.class.string, saved_class_len-1); - *num_subkeys = r_o.num_subkeys ; - *max_subkeylen = r_o.max_subkeylen ; - *num_values = r_o.num_values ; - *max_valnamelen = r_o.max_valnamelen; - *max_valbufsize = r_o.max_valbufsize; - *sec_desc = r_o.sec_desc ; - *mod_time = r_o.mod_time ; - /* Maybe: *max_classlen = r_o.reserved; */ + memset( key_class, (int)' ', *class_len ); + key_class[*class_len] = '\0'; + + init_reg_q_query_key( &in, hnd, key_class ); -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + ZERO_STRUCT (out); - return result; + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, + in, out, + qbuf, rbuf, + reg_io_q_query_key, + reg_io_r_query_key, + WERR_GENERAL_FAILURE ); + } + + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; + + *class_len = out.class.string->uni_max_len; + unistr2_to_ascii(key_class, out.class.string, saved_class_len-1); + *num_subkeys = out.num_subkeys ; + *max_subkeylen = out.max_subkeylen ; + *num_values = out.num_values ; + *max_valnamelen = out.max_valnamelen; + *max_valbufsize = out.max_valbufsize; + *sec_desc = out.sec_desc ; + *mod_time = out.mod_time ; + /* Maybe: *max_classlen = out.reserved; */ + + return out.status; } /**************************************************************************** -do a REG Unknown 1A ****************************************************************************/ + WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 *unk) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_GETVERSION q_o; - REG_R_GETVERSION r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf , MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ + REG_Q_GETVERSION in; + REG_R_GETVERSION out; + prs_struct qbuf, rbuf; - init_reg_q_getversion(&q_o, hnd); - - if (!reg_io_q_getversion("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_GETVERSION, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarshall response */ - - if (!reg_io_r_getversion("", &r_o, &rbuf, 0)) - goto done; - - result = r_o.status; - if (NT_STATUS_IS_OK(result)) - if (unk != NULL) - *unk = r_o.unknown; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_getversion(&in, hnd); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_GETVERSION, + in, out, + qbuf, rbuf, + reg_io_q_getversion, + reg_io_r_getversion, + WERR_GENERAL_FAILURE ); + + + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; + + *unk = out.unknown; + + return out.status; } /**************************************************************************** @@ -333,41 +290,30 @@ WERROR cli_reg_query_info(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *val_name, uint32 *type, REGVAL_BUFFER *buffer) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_INFO q_o; - REG_R_INFO r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_info(&q_o, hnd, val_name, buffer); - - if (!reg_io_q_info("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_INFO, &qbuf, &rbuf)) - goto done; + REG_Q_INFO in; + REG_R_INFO out; + prs_struct qbuf, rbuf; - ZERO_STRUCT(r_o); - - /* Unmarshall response */ - - if (!reg_io_r_info("", &r_o, &rbuf, 0)) - goto done; - - result = r_o.status; - if (NT_STATUS_IS_OK(result)) { - *type = *r_o.type; - *buffer = *r_o.value; - } - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_info(&in, hnd, val_name, buffer); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, + in, out, + qbuf, rbuf, + reg_io_q_info, + reg_io_r_info, + WERR_GENERAL_FAILURE ); + + + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; + + *type = *out.type; + *buffer = *out.value; + + return out.status; } /**************************************************************************** @@ -377,43 +323,30 @@ WERROR cli_reg_set_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 sec_info, size_t secdesc_size, SEC_DESC *sec_desc) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_SET_KEY_SEC q_o; - REG_R_SET_KEY_SEC r_o; + REG_Q_SET_KEY_SEC in; + REG_R_SET_KEY_SEC out; + prs_struct qbuf, rbuf; SEC_DESC_BUF *sec_desc_buf; - WERROR result = WERR_GENERAL_FAILURE; - - /* - * Flatten the security descriptor. - */ - sec_desc_buf = make_sec_desc_buf(mem_ctx, secdesc_size, sec_desc); - if (sec_desc_buf == NULL) - goto done; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_set_key_sec(&q_o, hnd, sec_info, sec_desc_buf); - if (!reg_io_q_set_key_sec("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_SET_KEY_SEC, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarshall response */ - - if (reg_io_r_set_key_sec("", &r_o, &rbuf, 0)) - result = r_o.status; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + /* Flatten the security descriptor */ + + if ( !(sec_desc_buf = make_sec_desc_buf(mem_ctx, secdesc_size, sec_desc)) ) + return WERR_GENERAL_FAILURE; + + init_reg_q_set_key_sec(&in, hnd, sec_info, sec_desc_buf); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SET_KEY_SEC, + in, out, + qbuf, rbuf, + reg_io_q_set_key_sec, + reg_io_r_set_key_sec, + WERR_GENERAL_FAILURE ); + + + return out.status; } @@ -424,53 +357,32 @@ WERROR cli_reg_get_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 sec_info, uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_GET_KEY_SEC q_o; - REG_R_GET_KEY_SEC r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_get_key_sec(&q_o, hnd, sec_info, *sec_buf_size, sec_buf); - - if (!reg_io_q_get_key_sec("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_GET_KEY_SEC, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); + REG_Q_GET_KEY_SEC in; + REG_R_GET_KEY_SEC out; + prs_struct qbuf, rbuf; - /* Unmarshall response */ - - r_o.data = sec_buf; - - if (*sec_buf_size != 0) - { - sec_buf->sec = TALLOC(mem_ctx, *sec_buf_size); - } - - if (!reg_io_r_get_key_sec("", &r_o, &rbuf, 0)) - goto done; - - result = r_o.status; - if (NT_STATUS_IS_OK(result)) - (*sec_buf_size) = r_o.data->len; - else if (NT_STATUS_EQUAL(result, ERROR_INSUFFICIENT_BUFFER)) - { - /* - * get the maximum buffer size: it was too small - */ - (*sec_buf_size) = r_o.hdr_sec.buf_max_len; - } + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_get_key_sec(&in, hnd, sec_info, *sec_buf_size, sec_buf); -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_GET_KEY_SEC, + in, out, + qbuf, rbuf, + reg_io_q_get_key_sec, + reg_io_r_get_key_sec, + WERR_GENERAL_FAILURE ); + - return result; + /* this might be able to return WERR_MORE_DATA, I'm not sure */ + + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; + + sec_buf = out.data; + *sec_buf_size = out.data->len; + + return out.status; } /**************************************************************************** @@ -479,35 +391,23 @@ do a REG Delete Value WERROR cli_reg_delete_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *val_name) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_DELETE_VALUE q_o; - REG_R_DELETE_VALUE r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_delete_val(&q_o, hnd, val_name); - - if (!reg_io_q_delete_val("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_DELETE_VALUE, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarshall response */ - - if (reg_io_r_delete_val("", &r_o, &rbuf, 0)) - result = r_o.status; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + REG_Q_DELETE_VALUE in; + REG_R_DELETE_VALUE out; + prs_struct qbuf, rbuf; - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_delete_val(&in, hnd, val_name); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_DELETE_VALUE, + in, out, + qbuf, rbuf, + reg_io_q_delete_val, + reg_io_r_delete_val, + WERR_GENERAL_FAILURE ); + + return out.status; } /**************************************************************************** @@ -516,35 +416,23 @@ do a REG Delete Key WERROR cli_reg_delete_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_DELETE_KEY q_o; - REG_R_DELETE_KEY r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - - init_reg_q_delete_key(&q_o, hnd, key_name); + REG_Q_DELETE_KEY in; + REG_R_DELETE_KEY out; + prs_struct qbuf, rbuf; - if (!reg_io_q_delete_key("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_DELETE_KEY, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarshall response */ - - if (reg_io_r_delete_key("", &r_o, &rbuf, 0)) - result = r_o.status; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_delete_key(&in, hnd, key_name); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_DELETE_KEY, + in, out, + qbuf, rbuf, + reg_io_q_delete_key, + reg_io_r_delete_key, + WERR_GENERAL_FAILURE ); + + return out.status; } /**************************************************************************** @@ -554,51 +442,41 @@ WERROR cli_reg_create_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name, char *key_class, uint32 access_desired, POLICY_HND *key) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_CREATE_KEY q_o; - REG_R_CREATE_KEY r_o; + REG_Q_CREATE_KEY in; + REG_R_CREATE_KEY out; + prs_struct qbuf, rbuf; SEC_DESC *sec; SEC_DESC_BUF *sec_buf; size_t sec_len; - WERROR result = WERR_GENERAL_FAILURE; - - ZERO_STRUCT(q_o); - - if ((sec = make_sec_desc(mem_ctx, 1, SEC_DESC_SELF_RELATIVE, - NULL, NULL, NULL, NULL, &sec_len)) == NULL) - goto done; - - if ((sec_buf = make_sec_desc_buf(mem_ctx, sec_len, sec)) == NULL) - goto done; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ - init_reg_q_create_key(&q_o, hnd, key_name, key_class, access_desired, sec_buf); - - if (!reg_io_q_create_key("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_CREATE_KEY, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarshall response */ - - if (!reg_io_r_create_key("", &r_o, &rbuf, 0)) - goto done; - - result = r_o.status; - if (NT_STATUS_IS_OK(result)) - *key = r_o.key_pol; - -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + if ( !(sec = make_sec_desc(mem_ctx, 1, SEC_DESC_SELF_RELATIVE, + NULL, NULL, NULL, NULL, &sec_len)) ) + { + return WERR_GENERAL_FAILURE; + } + + if ( !(sec_buf = make_sec_desc_buf(mem_ctx, sec_len, sec)) ) + return WERR_GENERAL_FAILURE; + + init_reg_q_create_key(&in, hnd, key_name, key_class, access_desired, sec_buf); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_CREATE_KEY, + in, out, + qbuf, rbuf, + reg_io_q_create_key, + reg_io_r_create_key, + WERR_GENERAL_FAILURE ); + + + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; + + memcpy( key, &out.key_pol, sizeof(POLICY_HND) ); + + return out.status; } /**************************************************************************** @@ -606,46 +484,40 @@ do a REG Enum Key ****************************************************************************/ WERROR cli_reg_enum_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, int key_index, fstring key_name, - uint32 *unk_1, uint32 *unk_2, time_t *mod_time) + fstring class_name, time_t *mod_time) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_ENUM_KEY q_o; - REG_R_ENUM_KEY r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + REG_Q_ENUM_KEY in; + REG_R_ENUM_KEY out; + prs_struct qbuf, rbuf; - /* Marshall data and send request */ - - init_reg_q_enum_key(&q_o, hnd, key_index); + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_enum_key(&in, hnd, key_index); - if (!reg_io_q_enum_key("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_ENUM_KEY, &qbuf, &rbuf)) - goto done; + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ENUM_KEY, + in, out, + qbuf, rbuf, + reg_io_q_enum_key, + reg_io_r_enum_key, + WERR_GENERAL_FAILURE ); - ZERO_STRUCT(r_o); + if ( !W_ERROR_IS_OK(out.status) ) + return out.status; - /* Unmarshall response */ + if ( out.keyname.string ) + rpcstr_pull( key_name, out.keyname.string->buffer, sizeof(fstring), -1, STR_TERMINATE ); + else + fstrcpy( key_name, "(Default)" ); - if (!reg_io_r_enum_key("", &r_o, &rbuf, 0)) - goto done; + if ( out.classname && out.classname->string ) + rpcstr_pull( class_name, out.classname->string->buffer, sizeof(fstring), -1, STR_TERMINATE ); + else + fstrcpy( class_name, "" ); - result = r_o.status; - if (NT_STATUS_IS_OK(result)) { - (*unk_1) = r_o.unknown_1; - (*unk_2) = r_o.unknown_2; - unistr3_to_ascii(key_name, &r_o.key_name, - sizeof(fstring)-1); - (*mod_time) = nt_time_to_unix(&r_o.time); - } + *mod_time = nt_time_to_unix(out.time); -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); - - return result; + return out.status; } /**************************************************************************** @@ -655,162 +527,173 @@ WERROR cli_reg_set_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *val_name, uint32 type, RPC_DATA_BLOB *data) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_SET_VALUE q_o; - REG_R_SET_VALUE r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + REG_Q_SET_VALUE in; + REG_R_SET_VALUE out; + prs_struct qbuf, rbuf; - /* Marshall data and send request */ - - init_reg_q_set_val(&q_o, hnd, val_name, type, data); - - if (!reg_io_q_set_val("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_SET_VALUE, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarshal response */ - - if (reg_io_r_set_val("", &r_o, &rbuf, 0)) - result = r_o.status; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_set_val(&in, hnd, val_name, type, data); -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SET_VALUE, + in, out, + qbuf, rbuf, + reg_io_q_set_val, + reg_io_r_set_val, + WERR_GENERAL_FAILURE ); - return result; + return out.status; } /**************************************************************************** do a REG Enum Value ****************************************************************************/ WERROR cli_reg_enum_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, int val_index, int max_valnamelen, - int max_valbufsize, fstring val_name, - uint32 *val_type, REGVAL_BUFFER *value) + POLICY_HND *hnd, int idx, + fstring val_name, uint32 *type, REGVAL_BUFFER *value) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_ENUM_VALUE q_o; - REG_R_ENUM_VALUE r_o; - WERROR result = WERR_GENERAL_FAILURE; + REG_Q_ENUM_VALUE in; + REG_R_ENUM_VALUE out; + prs_struct qbuf, rbuf; - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); - - /* Marshall data and send request */ + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_enum_val(&in, hnd, idx, 0x0100, 0x1000); - init_reg_q_enum_val(&q_o, hnd, val_index, val_name, max_valbufsize); + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, + in, out, + qbuf, rbuf, + reg_io_q_enum_val, + reg_io_r_enum_val, + WERR_GENERAL_FAILURE ); - if (!reg_io_q_enum_val("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_ENUM_VALUE, &qbuf, &rbuf)) - goto done; + if ( W_ERROR_EQUAL(out.status, WERR_MORE_DATA) ) { - ZERO_STRUCT(r_o); + ZERO_STRUCT (in); - /* Unmarshall response */ + init_reg_q_enum_val(&in, hnd, idx, 0x0100, *out.buffer_len1); - if (!reg_io_r_enum_val("", &r_o, &rbuf, 0)) - goto done; + ZERO_STRUCT (out); - result = r_o.status; - if (NT_STATUS_IS_OK(result) || - NT_STATUS_EQUAL(result, NT_STATUS_MORE_PROCESSING_REQUIRED)) { - (*val_type) = *r_o.type; - unistr2_to_ascii(val_name, r_o.name.string, sizeof(fstring)-1); - *value = *r_o.value; + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, + in, out, + qbuf, rbuf, + reg_io_q_enum_val, + reg_io_r_enum_val, + WERR_GENERAL_FAILURE ); } -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + if ( !W_ERROR_IS_OK(out.status) ) + return out.status; - return result; + unistr2_to_ascii(val_name, out.name.string, sizeof(fstring)-1); + *type = *out.type; + *value = *out.value; + + return out.status; } /**************************************************************************** -do a REG Open Key ****************************************************************************/ + WERROR cli_reg_open_entry(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name, uint32 access_desired, POLICY_HND *key_hnd) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_OPEN_ENTRY q_o; - REG_R_OPEN_ENTRY r_o; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + REG_Q_OPEN_ENTRY in; + REG_R_OPEN_ENTRY out; + prs_struct qbuf, rbuf; - /* Marshall data and send request */ - - init_reg_q_open_entry(&q_o, hnd, key_name, access_desired); - - /* turn parameters into data stream */ - if (!reg_io_q_open_entry("", &q_o, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_OPEN_ENTRY, &qbuf, &rbuf)) - goto done; - - ZERO_STRUCT(r_o); - - /* Unmarsall response */ - - if (!reg_io_r_open_entry("", &r_o, &rbuf, 0)) - goto done; + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_open_entry(&in, hnd, key_name, access_desired); - result = r_o.status; - if (NT_STATUS_IS_OK(result)) - *key_hnd = r_o.pol; + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_OPEN_ENTRY, + in, out, + qbuf, rbuf, + reg_io_q_open_entry, + reg_io_r_open_entry, + WERR_GENERAL_FAILURE ); -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + if ( !W_ERROR_IS_OK( out.status ) ) + return out.status; - return result; + memcpy( key_hnd, &out.pol, sizeof(POLICY_HND) ); + + return out.status; } /**************************************************************************** -do a REG Close ****************************************************************************/ + WERROR cli_reg_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd) { - prs_struct rbuf; - prs_struct qbuf; - REG_Q_CLOSE q_c; - REG_R_CLOSE r_c; - WERROR result = WERR_GENERAL_FAILURE; - - prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL); - prs_init(&rbuf, 0, mem_ctx, UNMARSHALL); + REG_Q_CLOSE in; + REG_R_CLOSE out; + prs_struct qbuf, rbuf; - /* Marshall data and send request */ - - init_reg_q_close(&q_c, hnd); + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_reg_q_close(&in, hnd); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_CLOSE, + in, out, + qbuf, rbuf, + reg_io_q_close, + reg_io_r_close, + WERR_GENERAL_FAILURE ); + + return out.status; +} - if (!reg_io_q_close("", &q_c, &qbuf, 0) || - !rpc_api_pipe_req(cli, PI_WINREG, REG_CLOSE, &qbuf, &rbuf)) - goto done; - ZERO_STRUCT(r_c); +/* + ################################################################# + Utility functions + ################################################################# + */ - /* Unmarshall response */ +/***************************************************************** + Splits out the start of the key (HKLM or HKU) and the rest of the key. +*****************************************************************/ - if (reg_io_r_close("", &r_c, &rbuf, 0)) - result = r_c.status; +BOOL reg_split_hive(const char *full_keyname, uint32 *reg_type, pstring key_name) +{ + pstring tmp; + + if (!next_token(&full_keyname, tmp, "\\", sizeof(tmp))) + return False; + + (*reg_type) = 0; + + DEBUG(10, ("reg_split_key: hive %s\n", tmp)); + + if (strequal(tmp, "HKLM") || strequal(tmp, "HKEY_LOCAL_MACHINE")) + (*reg_type) = HKEY_LOCAL_MACHINE; + else if (strequal(tmp, "HKCR") || strequal(tmp, "HKEY_CLASSES_ROOT")) + (*reg_type) = HKEY_CLASSES_ROOT; + else if (strequal(tmp, "HKU") || strequal(tmp, "HKEY_USERS")) + (*reg_type) = HKEY_USERS; + else if (strequal(tmp, "HKPD")||strequal(tmp, "HKEY_PERFORMANCE_DATA")) + (*reg_type) = HKEY_PERFORMANCE_DATA; + else { + DEBUG(10,("reg_split_key: unrecognised hive key %s\n", tmp)); + return False; + } + + if (next_token(&full_keyname, tmp, "\n\r", sizeof(tmp))) + pstrcpy(key_name, tmp); + else + key_name[0] = 0; -done: - prs_mem_free(&rbuf); - prs_mem_free(&qbuf); + DEBUG(10, ("reg_split_key: name %s\n", key_name)); - return result; + return True; } -- cgit From d5e79de59561e614fce79a9460c3b2caaa459673 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Thu, 26 May 2005 20:36:04 +0000 Subject: r6995: * fixing segfault when writing out registry values of zero length * add RegSaveKey() client function * add 'net rpc registry save' subcommand (This used to be commit f35e0a0a8d8df5c39e61ebd34c4aecbc5c9bb635) --- source3/rpc_client/cli_reg.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 164bdd3129..74866e4b8e 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -651,6 +651,31 @@ WERROR cli_reg_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, return out.status; } +/**************************************************************************** +do a REG Query Info +****************************************************************************/ +WERROR cli_reg_save_key( struct cli_state *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, const char *filename ) +{ + REG_Q_SAVE_KEY in; + REG_R_SAVE_KEY out; + prs_struct qbuf, rbuf; + + ZERO_STRUCT (in); + ZERO_STRUCT (out); + + init_q_reg_save_key( &in, hnd, filename ); + + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SAVE_KEY, + in, out, + qbuf, rbuf, + reg_io_q_save_key, + reg_io_r_save_key, + WERR_GENERAL_FAILURE ); + + return out.status; +} + /* ################################################################# -- cgit From bb2616d0180d21e5962a028617d274c51f5dcc63 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Thu, 16 Jun 2005 20:04:16 +0000 Subject: r7645: adding server stubs for RegCreateKey() and RegSetValue() (This used to be commit ce82566badfb907a2f72e2f7d90a7bbbe3811177) --- source3/rpc_client/cli_reg.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 74866e4b8e..d152aeecf1 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -539,8 +539,8 @@ WERROR cli_reg_set_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SET_VALUE, in, out, qbuf, rbuf, - reg_io_q_set_val, - reg_io_r_set_val, + reg_io_q_set_value, + reg_io_r_set_value, WERR_GENERAL_FAILURE ); return out.status; -- cgit From b2db8a9bd3aad8e56ab4d95b05d2db7773057e8b Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Thu, 16 Jun 2005 20:59:39 +0000 Subject: r7649: * fix compile breakage (sorry, should have done a make clean before the last checking). * rename unknown field in REG_GETVERSION * add server stubs for RegDeleteKey() and RegDeleteValue() (This used to be commit 023728c0595eaef60e357d32a25e2c4cee9e21f4) --- source3/rpc_client/cli_reg.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index d152aeecf1..9d7b909d0d 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -256,7 +256,7 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, ****************************************************************************/ WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, uint32 *unk) + POLICY_HND *hnd, uint32 *version) { REG_Q_GETVERSION in; REG_R_GETVERSION out; @@ -278,7 +278,7 @@ WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, if ( !W_ERROR_IS_OK( out.status ) ) return out.status; - *unk = out.unknown; + *version = out.win_version; return out.status; } @@ -403,8 +403,8 @@ WERROR cli_reg_delete_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_DELETE_VALUE, in, out, qbuf, rbuf, - reg_io_q_delete_val, - reg_io_r_delete_val, + reg_io_q_delete_value, + reg_io_r_delete_value, WERR_GENERAL_FAILURE ); return out.status; -- cgit From 2102f6bff9641eeec3b593529be7bf8d9ec784d4 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Fri, 17 Jun 2005 01:57:18 +0000 Subject: r7664: add access check hooks to _reg_open_entry which are passed off to the reg_XXX backend. If the backend does not define a regkey_access_check() function, we default to using the standard registry_access_check() (This used to be commit 2f08a904eee772e7d99ae6e3e4c922f74732284f) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 9d7b909d0d..3f5b7652ac 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -621,7 +621,7 @@ WERROR cli_reg_open_entry(struct cli_state *cli, TALLOC_CTX *mem_ctx, if ( !W_ERROR_IS_OK( out.status ) ) return out.status; - memcpy( key_hnd, &out.pol, sizeof(POLICY_HND) ); + memcpy( key_hnd, &out.handle, sizeof(POLICY_HND) ); return out.status; } -- cgit From 2129d3c711a109b47c3c1596a6a639520d2f72d2 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Fri, 17 Jun 2005 15:35:31 +0000 Subject: r7691: * add .gdbinit to the svn:ignore files * start adding write support to the Samba registry Flesh out the server implementations of RegCreateKey(), RegSetValue(), RegDeleteKey() and RegDeleteValue() I can create a new key using regedit.exe now but the 'New Key #1' key cannot be deleted yet. (This used to be commit e188fdbef8f0ad202b0ecf3c30be2941ebe6d5b1) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 3f5b7652ac..ca4b63c282 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -474,7 +474,7 @@ WERROR cli_reg_create_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, if ( !W_ERROR_IS_OK( out.status ) ) return out.status; - memcpy( key, &out.key_pol, sizeof(POLICY_HND) ); + memcpy( key, &out.handle, sizeof(POLICY_HND) ); return out.status; } -- cgit From 2fb7ff7d9def29e21dd87f565ccda5437c848cdd Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Fri, 24 Jun 2005 14:55:09 +0000 Subject: r7878: mostly just a rename of REG_INFO to REG_QUERY_VALUE for better clarity (This used to be commit d50f0ba07e285728605c8e8aae9d9a251a525e78) --- source3/rpc_client/cli_reg.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index ca4b63c282..6de2626dde 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -286,24 +286,24 @@ WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Query Info ****************************************************************************/ -WERROR cli_reg_query_info(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR cli_reg_query_value(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *val_name, uint32 *type, REGVAL_BUFFER *buffer) { - REG_Q_INFO in; - REG_R_INFO out; + REG_Q_QUERY_VALUE in; + REG_R_QUERY_VALUE out; prs_struct qbuf, rbuf; ZERO_STRUCT (in); ZERO_STRUCT (out); - init_reg_q_info(&in, hnd, val_name, buffer); + init_reg_q_query_value(&in, hnd, val_name, buffer); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_VALUE, in, out, qbuf, rbuf, - reg_io_q_info, - reg_io_r_info, + reg_io_q_query_value, + reg_io_r_query_value, WERR_GENERAL_FAILURE ); -- cgit From 19ca97a70f6b7b41d251eaa76e4d3c980c6eedff Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 24 Jun 2005 20:25:18 +0000 Subject: r7882: Looks like a large patch - but what it actually does is make Samba safe for using our headers and linking with C++ modules. Stops us from using C++ reserved keywords in our code. Jeremy (This used to be commit 9506b8e145982b1160a2f0aee5c9b7a54980940a) --- source3/rpc_client/cli_reg.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 6de2626dde..c3a1aba90d 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -214,7 +214,7 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) { ZERO_STRUCT (in); - *class_len = out.class.string->uni_max_len; + *class_len = out.key_class.string->uni_max_len; if ( *class_len > saved_class_len ) return out.status; @@ -238,8 +238,8 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, if ( !W_ERROR_IS_OK( out.status ) ) return out.status; - *class_len = out.class.string->uni_max_len; - unistr2_to_ascii(key_class, out.class.string, saved_class_len-1); + *class_len = out.key_class.string->uni_max_len; + unistr2_to_ascii(key_class, out.key_class.string, saved_class_len-1); *num_subkeys = out.num_subkeys ; *max_subkeylen = out.max_subkeylen ; *num_values = out.num_values ; -- cgit From 270b90e25f2ec5fcb1283588a9e605b7228e0e41 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Wed, 29 Jun 2005 16:35:32 +0000 Subject: r7995: * privileges are local except when they're *not* printmig.exe assumes that the LUID of the SeBackupPrivlege on the target server matches the LUID of the privilege on the local client. Even though an LUID is never guaranteed to be the same across reboots. How *awful*! My cat could write better code! (more on my cat later....) * Set the privelege LUID in the global PRIVS[] array * Rename RegCreateKey() to RegCreateKeyEx() to better match MSDN * Rename the unknown field in RegCreateKeyEx() to disposition (guess according to MSDN) * Add the capability to define REG_TDB_ONLY for using the reg_db.c functions and stress the RegXXX() rpc functions. (This used to be commit 0d6352da4800aabc04dfd7c65a6afe6af7cd2d4b) --- source3/rpc_client/cli_reg.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index c3a1aba90d..97ae8b29e7 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -438,12 +438,12 @@ WERROR cli_reg_delete_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Create Key ****************************************************************************/ -WERROR cli_reg_create_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR cli_reg_create_key_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name, char *key_class, uint32 access_desired, POLICY_HND *key) { - REG_Q_CREATE_KEY in; - REG_R_CREATE_KEY out; + REG_Q_CREATE_KEY_EX in; + REG_R_CREATE_KEY_EX out; prs_struct qbuf, rbuf; SEC_DESC *sec; SEC_DESC_BUF *sec_buf; @@ -461,13 +461,13 @@ WERROR cli_reg_create_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, if ( !(sec_buf = make_sec_desc_buf(mem_ctx, sec_len, sec)) ) return WERR_GENERAL_FAILURE; - init_reg_q_create_key(&in, hnd, key_name, key_class, access_desired, sec_buf); + init_reg_q_create_key_ex(&in, hnd, key_name, key_class, access_desired, sec_buf); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_CREATE_KEY, + CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_CREATE_KEY_EX, in, out, qbuf, rbuf, - reg_io_q_create_key, - reg_io_r_create_key, + reg_io_q_create_key_ex, + reg_io_r_create_key_ex, WERR_GENERAL_FAILURE ); -- cgit From 54abd2aa66069e6baf7769c496f46d9dba18db39 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Fri, 30 Sep 2005 17:13:37 +0000 Subject: r10656: BIG merge from trunk. Features not copied over * \PIPE\unixinfo * winbindd's {group,alias}membership new functions * winbindd's lookupsids() functionality * swat (trunk changes to be reverted as per discussion with Deryck) (This used to be commit 939c3cb5d78e3a2236209b296aa8aba8bdce32d3) --- source3/rpc_client/cli_reg.c | 101 +++++++++++++++++++++++-------------------- 1 file changed, 54 insertions(+), 47 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 97ae8b29e7..87ab5dc9da 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -3,9 +3,7 @@ RPC Pipe client Copyright (C) Andrew Tridgell 1992-2000, - Copyright (C) Luke Kenneth Casson Leighton 1996-2000, - Copyright (C) Paul Ashton 1997-2000. - Copyright (C) Jeremy Allison 1999. + Copyright (C) Jeremy Allison 1999 - 2005 Copyright (C) Simo Sorce 2001 Copyright (C) Jeremy Cooper 2004 Copyright (C) Gerald (Jerry) Carter 2005 @@ -34,7 +32,7 @@ internal connect to a registry hive root (open a registry policy) *******************************************************************/ -static WERROR cli_reg_open_hive_int(struct cli_state *cli, +static WERROR rpccli_reg_open_hive_int(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16 op_code, const char *op_name, uint32 access_mask, POLICY_HND *hnd) @@ -48,7 +46,7 @@ static WERROR cli_reg_open_hive_int(struct cli_state *cli, init_reg_q_open_hive(&in, access_mask); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, op_code, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, op_code, in, out, qbuf, rbuf, reg_io_q_open_hive, @@ -67,7 +65,7 @@ static WERROR cli_reg_open_hive_int(struct cli_state *cli, connect to a registry hive root (open a registry policy) *******************************************************************/ -WERROR cli_reg_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR rpccli_reg_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 reg_type, uint32 access_mask, POLICY_HND *reg_hnd) { uint16 op_code; @@ -97,7 +95,7 @@ WERROR cli_reg_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, return WERR_INVALID_PARAM; } - return cli_reg_open_hive_int(cli, mem_ctx, op_code, op_name, + return rpccli_reg_open_hive_int(cli, mem_ctx, op_code, op_name, access_mask, reg_hnd); } @@ -105,7 +103,7 @@ WERROR cli_reg_connect(struct cli_state *cli, TALLOC_CTX *mem_ctx, /******************************************************************* *******************************************************************/ -WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, +WERROR rpccli_reg_shutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *msg, uint32 timeout, BOOL do_reboot, BOOL force) { @@ -123,7 +121,7 @@ WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, init_reg_q_shutdown(&in, msg, timeout, do_reboot, force); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SHUTDOWN, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SHUTDOWN, in, out, qbuf, rbuf, reg_io_q_shutdown, @@ -136,7 +134,7 @@ WERROR cli_reg_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx, /******************************************************************* *******************************************************************/ -WERROR cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) +WERROR rpccli_reg_abort_shutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { REG_Q_ABORT_SHUTDOWN in; REG_R_ABORT_SHUTDOWN out; @@ -145,7 +143,7 @@ WERROR cli_reg_abort_shutdown(struct cli_state * cli, TALLOC_CTX *mem_ctx) ZERO_STRUCT (in); ZERO_STRUCT (out); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ABORT_SHUTDOWN, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ABORT_SHUTDOWN, in, out, qbuf, rbuf, reg_io_q_abort_shutdown, @@ -161,7 +159,8 @@ do a REG Unknown 0xB command. sent after a create key or create value. this might be some sort of "sync" or "refresh" command, sent after modification of the registry... ****************************************************************************/ -WERROR cli_reg_flush_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_flush_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd) { REG_Q_FLUSH_KEY in; @@ -173,7 +172,7 @@ WERROR cli_reg_flush_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_flush_key(&in, hnd); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_FLUSH_KEY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_FLUSH_KEY, in, out, qbuf, rbuf, reg_io_q_flush_key, @@ -186,7 +185,8 @@ WERROR cli_reg_flush_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Query Key ****************************************************************************/ -WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_query_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, @@ -204,7 +204,7 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_query_key( &in, hnd, key_class ); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, in, out, qbuf, rbuf, reg_io_q_query_key, @@ -227,7 +227,7 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, ZERO_STRUCT (out); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, in, out, qbuf, rbuf, reg_io_q_query_key, @@ -255,7 +255,7 @@ WERROR cli_reg_query_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** ****************************************************************************/ -WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR rpccli_reg_getversion(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 *version) { REG_Q_GETVERSION in; @@ -267,7 +267,7 @@ WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_getversion(&in, hnd); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_GETVERSION, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_GETVERSION, in, out, qbuf, rbuf, reg_io_q_getversion, @@ -286,7 +286,8 @@ WERROR cli_reg_getversion(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Query Info ****************************************************************************/ -WERROR cli_reg_query_value(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_query_value(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *val_name, uint32 *type, REGVAL_BUFFER *buffer) { @@ -299,7 +300,7 @@ WERROR cli_reg_query_value(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_query_value(&in, hnd, val_name, buffer); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_QUERY_VALUE, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_QUERY_VALUE, in, out, qbuf, rbuf, reg_io_q_query_value, @@ -319,7 +320,8 @@ WERROR cli_reg_query_value(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Set Key Security ****************************************************************************/ -WERROR cli_reg_set_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_set_key_sec(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 sec_info, size_t secdesc_size, SEC_DESC *sec_desc) { @@ -338,7 +340,7 @@ WERROR cli_reg_set_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_set_key_sec(&in, hnd, sec_info, sec_desc_buf); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SET_KEY_SEC, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SET_KEY_SEC, in, out, qbuf, rbuf, reg_io_q_set_key_sec, @@ -353,7 +355,8 @@ WERROR cli_reg_set_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Query Key Security ****************************************************************************/ -WERROR cli_reg_get_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_get_key_sec(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, uint32 sec_info, uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) { @@ -366,7 +369,7 @@ WERROR cli_reg_get_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_get_key_sec(&in, hnd, sec_info, *sec_buf_size, sec_buf); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_GET_KEY_SEC, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_GET_KEY_SEC, in, out, qbuf, rbuf, reg_io_q_get_key_sec, @@ -388,7 +391,8 @@ WERROR cli_reg_get_key_sec(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Delete Value ****************************************************************************/ -WERROR cli_reg_delete_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_delete_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *val_name) { REG_Q_DELETE_VALUE in; @@ -400,7 +404,7 @@ WERROR cli_reg_delete_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_delete_val(&in, hnd, val_name); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_DELETE_VALUE, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_DELETE_VALUE, in, out, qbuf, rbuf, reg_io_q_delete_value, @@ -413,7 +417,8 @@ WERROR cli_reg_delete_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Delete Key ****************************************************************************/ -WERROR cli_reg_delete_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_delete_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name) { REG_Q_DELETE_KEY in; @@ -425,7 +430,7 @@ WERROR cli_reg_delete_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_delete_key(&in, hnd, key_name); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_DELETE_KEY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_DELETE_KEY, in, out, qbuf, rbuf, reg_io_q_delete_key, @@ -438,7 +443,8 @@ WERROR cli_reg_delete_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Create Key ****************************************************************************/ -WERROR cli_reg_create_key_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_create_key_ex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name, char *key_class, uint32 access_desired, POLICY_HND *key) { @@ -453,8 +459,7 @@ WERROR cli_reg_create_key_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx, ZERO_STRUCT (out); if ( !(sec = make_sec_desc(mem_ctx, 1, SEC_DESC_SELF_RELATIVE, - NULL, NULL, NULL, NULL, &sec_len)) ) - { + NULL, NULL, NULL, NULL, &sec_len)) ) { return WERR_GENERAL_FAILURE; } @@ -463,7 +468,7 @@ WERROR cli_reg_create_key_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_create_key_ex(&in, hnd, key_name, key_class, access_desired, sec_buf); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_CREATE_KEY_EX, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_CREATE_KEY_EX, in, out, qbuf, rbuf, reg_io_q_create_key_ex, @@ -482,7 +487,8 @@ WERROR cli_reg_create_key_ex(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Enum Key ****************************************************************************/ -WERROR cli_reg_enum_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_enum_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, int key_index, fstring key_name, fstring class_name, time_t *mod_time) { @@ -495,7 +501,7 @@ WERROR cli_reg_enum_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_enum_key(&in, hnd, key_index); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ENUM_KEY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ENUM_KEY, in, out, qbuf, rbuf, reg_io_q_enum_key, @@ -523,7 +529,8 @@ WERROR cli_reg_enum_key(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Create Value ****************************************************************************/ -WERROR cli_reg_set_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_set_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *val_name, uint32 type, RPC_DATA_BLOB *data) { @@ -536,7 +543,7 @@ WERROR cli_reg_set_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_set_val(&in, hnd, val_name, type, data); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SET_VALUE, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SET_VALUE, in, out, qbuf, rbuf, reg_io_q_set_value, @@ -549,7 +556,8 @@ WERROR cli_reg_set_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Enum Value ****************************************************************************/ -WERROR cli_reg_enum_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_enum_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, int idx, fstring val_name, uint32 *type, REGVAL_BUFFER *value) { @@ -562,7 +570,7 @@ WERROR cli_reg_enum_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_enum_val(&in, hnd, idx, 0x0100, 0x1000); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, in, out, qbuf, rbuf, reg_io_q_enum_val, @@ -577,7 +585,7 @@ WERROR cli_reg_enum_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, ZERO_STRUCT (out); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, in, out, qbuf, rbuf, reg_io_q_enum_val, @@ -598,7 +606,7 @@ WERROR cli_reg_enum_val(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** ****************************************************************************/ -WERROR cli_reg_open_entry(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR rpccli_reg_open_entry(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_name, uint32 access_desired, POLICY_HND *key_hnd) { @@ -611,7 +619,7 @@ WERROR cli_reg_open_entry(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_open_entry(&in, hnd, key_name, access_desired); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_OPEN_ENTRY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_OPEN_ENTRY, in, out, qbuf, rbuf, reg_io_q_open_entry, @@ -629,7 +637,7 @@ WERROR cli_reg_open_entry(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** ****************************************************************************/ -WERROR cli_reg_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, +WERROR rpccli_reg_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd) { REG_Q_CLOSE in; @@ -641,7 +649,7 @@ WERROR cli_reg_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, init_reg_q_close(&in, hnd); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_CLOSE, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_CLOSE, in, out, qbuf, rbuf, reg_io_q_close, @@ -654,7 +662,8 @@ WERROR cli_reg_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, /**************************************************************************** do a REG Query Info ****************************************************************************/ -WERROR cli_reg_save_key( struct cli_state *cli, TALLOC_CTX *mem_ctx, + +WERROR rpccli_reg_save_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, const char *filename ) { REG_Q_SAVE_KEY in; @@ -666,7 +675,7 @@ WERROR cli_reg_save_key( struct cli_state *cli, TALLOC_CTX *mem_ctx, init_q_reg_save_key( &in, hnd, filename ); - CLI_DO_RPC( cli, mem_ctx, PI_WINREG, REG_SAVE_KEY, + CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SAVE_KEY, in, out, qbuf, rbuf, reg_io_q_save_key, @@ -720,5 +729,3 @@ BOOL reg_split_hive(const char *full_keyname, uint32 *reg_type, pstring key_name return True; } - - -- cgit From 995205fc60f87e1a02aa1c6f309db55ae18e908a Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 6 Sep 2006 18:32:20 +0000 Subject: r18188: merge 3.0-libndr branch (This used to be commit 1115745caed3093c25d6be01ffee21819fb0a675) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 87ab5dc9da..e136df753a 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -521,7 +521,7 @@ WERROR rpccli_reg_enum_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, else fstrcpy( class_name, "" ); - *mod_time = nt_time_to_unix(out.time); + *mod_time = nt_time_to_unix(*out.time); return out.status; } -- cgit From a6ddf9bf5d2258a26f6cb5d1913ebc949678f216 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Wed, 20 Sep 2006 15:58:48 +0000 Subject: r18711: Replace the following hand code client routines: * rpccli_reg_abort_shutdown() * rpccli_reg_flush_key() Remove the cmd_reg.c from rpcclient since the entire file was unused (This used to be commit c4788f0c1398feb098f131aa5c4d0398d7489527) --- source3/rpc_client/cli_reg.c | 51 -------------------------------------------- 1 file changed, 51 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index e136df753a..6a544bba64 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -131,57 +131,6 @@ WERROR rpccli_reg_shutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, return out.status; } -/******************************************************************* -*******************************************************************/ - -WERROR rpccli_reg_abort_shutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) -{ - REG_Q_ABORT_SHUTDOWN in; - REG_R_ABORT_SHUTDOWN out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ABORT_SHUTDOWN, - in, out, - qbuf, rbuf, - reg_io_q_abort_shutdown, - reg_io_r_abort_shutdown, - WERR_GENERAL_FAILURE ); - - return out.status; -} - - -/**************************************************************************** -do a REG Unknown 0xB command. sent after a create key or create value. -this might be some sort of "sync" or "refresh" command, sent after -modification of the registry... -****************************************************************************/ - -WERROR rpccli_reg_flush_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd) -{ - REG_Q_FLUSH_KEY in; - REG_R_FLUSH_KEY out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_flush_key(&in, hnd); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_FLUSH_KEY, - in, out, - qbuf, rbuf, - reg_io_q_flush_key, - reg_io_r_flush_key, - WERR_GENERAL_FAILURE ); - - return out.status; -} - /**************************************************************************** do a REG Query Key ****************************************************************************/ -- cgit From 4db7642caa99c1b054322a8971c4b673556487ce Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Wed, 20 Sep 2006 22:23:12 +0000 Subject: r18745: Use the Samba4 data structures for security descriptors and security descriptor buffers. Make security access masks simply a uint32 rather than a structure with a uint32 in it. (This used to be commit b41c52b9db5fc4a553b20a7a5a051a4afced9366) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 6a544bba64..0f0c642d21 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -332,7 +332,7 @@ WERROR rpccli_reg_get_key_sec(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, return out.status; sec_buf = out.data; - *sec_buf_size = out.data->len; + *sec_buf_size = out.data->sd_size; return out.status; } -- cgit From bbaa0b178d834f4962ab440dff0e1837029369df Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Tue, 26 Sep 2006 15:15:26 +0000 Subject: r18919: * Get the new rpccli_winreg_XXXX() functions into the tree There some broken functionality here that I'm still working on. * remove unneeded parsing routines (This used to be commit cbfe1a4b498593a48fc34f584754ed4a9ef72cc5) --- source3/rpc_client/cli_reg.c | 632 +++++-------------------------------------- 1 file changed, 65 insertions(+), 567 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 0f0c642d21..9b0420a4ec 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -2,11 +2,7 @@ Unix SMB/CIFS implementation. RPC Pipe client - Copyright (C) Andrew Tridgell 1992-2000, - Copyright (C) Jeremy Allison 1999 - 2005 - Copyright (C) Simo Sorce 2001 - Copyright (C) Jeremy Cooper 2004 - Copyright (C) Gerald (Jerry) Carter 2005 + Copyright (C) Gerald (Jerry) Carter 2005-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 @@ -26,619 +22,101 @@ #include "includes.h" #include "rpc_client.h" -/* Shutdown a server */ - -/******************************************************************* - internal connect to a registry hive root (open a registry policy) -*******************************************************************/ - -static WERROR rpccli_reg_open_hive_int(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, uint16 op_code, - const char *op_name, - uint32 access_mask, POLICY_HND *hnd) -{ - REG_Q_OPEN_HIVE in; - REG_R_OPEN_HIVE out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT(in); - ZERO_STRUCT(out); - - init_reg_q_open_hive(&in, access_mask); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, op_code, - in, out, - qbuf, rbuf, - reg_io_q_open_hive, - reg_io_r_open_hive, - WERR_GENERAL_FAILURE ); - - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; - - memcpy( hnd, &out.pol, sizeof(POLICY_HND) ); - - return out.status; -} - /******************************************************************* connect to a registry hive root (open a registry policy) *******************************************************************/ -WERROR rpccli_reg_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, +NTSTATUS rpccli_winreg_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 reg_type, uint32 access_mask, POLICY_HND *reg_hnd) -{ uint16 op_code; - const char *op_name; - +{ ZERO_STRUCTP(reg_hnd); switch (reg_type) { case HKEY_CLASSES_ROOT: - op_code = REG_OPEN_HKCR; - op_name = "REG_OPEN_HKCR"; - break; + return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL, + access_mask, reg_hnd ); + case HKEY_LOCAL_MACHINE: - op_code = REG_OPEN_HKLM; - op_name = "REG_OPEN_HKLM"; - break; + return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL, + access_mask, reg_hnd ); + case HKEY_USERS: - op_code = REG_OPEN_HKU; - op_name = "REG_OPEN_HKU"; - break; + return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL, + access_mask, reg_hnd ); + case HKEY_PERFORMANCE_DATA: - op_code = REG_OPEN_HKPD; - op_name = "REG_OPEN_HKPD"; - break; + return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL, + access_mask, reg_hnd ); + default: - return WERR_INVALID_PARAM; + /* fall through to end of function */ + break; } - return rpccli_reg_open_hive_int(cli, mem_ctx, op_code, op_name, - access_mask, reg_hnd); -} - - -/******************************************************************* -*******************************************************************/ - -WERROR rpccli_reg_shutdown(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - const char *msg, uint32 timeout, BOOL do_reboot, - BOOL force) -{ - REG_Q_SHUTDOWN in; - REG_R_SHUTDOWN out; - prs_struct qbuf, rbuf; - - if (msg == NULL) - return WERR_INVALID_PARAM; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - /* Marshall data and send request */ - - init_reg_q_shutdown(&in, msg, timeout, do_reboot, force); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SHUTDOWN, - in, out, - qbuf, rbuf, - reg_io_q_shutdown, - reg_io_r_shutdown, - WERR_GENERAL_FAILURE ); - - return out.status; + return NT_STATUS_INVALID_PARAMETER; } /**************************************************************************** -do a REG Query Key ****************************************************************************/ -WERROR rpccli_reg_query_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, +NTSTATUS rpccli_winreg_query_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, char *key_class, uint32 *class_len, uint32 *num_subkeys, uint32 *max_subkeylen, - uint32 *max_classlen, uint32 *num_values, + uint32 *max_subkeysize, uint32 *num_values, uint32 *max_valnamelen, uint32 *max_valbufsize, - uint32 *sec_desc, NTTIME *mod_time) -{ - REG_Q_QUERY_KEY in; - REG_R_QUERY_KEY out; - prs_struct qbuf, rbuf; - uint32 saved_class_len = *class_len; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_query_key( &in, hnd, key_class ); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, - in, out, - qbuf, rbuf, - reg_io_q_query_key, - reg_io_r_query_key, - WERR_GENERAL_FAILURE ); - - if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) { - ZERO_STRUCT (in); - - *class_len = out.key_class.string->uni_max_len; - if ( *class_len > saved_class_len ) - return out.status; - - /* set a string of spaces and NULL terminate */ - - memset( key_class, (int)' ', *class_len ); - key_class[*class_len] = '\0'; - - init_reg_q_query_key( &in, hnd, key_class ); - - ZERO_STRUCT (out); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_QUERY_KEY, - in, out, - qbuf, rbuf, - reg_io_q_query_key, - reg_io_r_query_key, - WERR_GENERAL_FAILURE ); - } - - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; - - *class_len = out.key_class.string->uni_max_len; - unistr2_to_ascii(key_class, out.key_class.string, saved_class_len-1); - *num_subkeys = out.num_subkeys ; - *max_subkeylen = out.max_subkeylen ; - *num_values = out.num_values ; - *max_valnamelen = out.max_valnamelen; - *max_valbufsize = out.max_valbufsize; - *sec_desc = out.sec_desc ; - *mod_time = out.mod_time ; - /* Maybe: *max_classlen = out.reserved; */ - - return out.status; -} - -/**************************************************************************** -****************************************************************************/ - -WERROR rpccli_reg_getversion(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, uint32 *version) -{ - REG_Q_GETVERSION in; - REG_R_GETVERSION out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_getversion(&in, hnd); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_GETVERSION, - in, out, - qbuf, rbuf, - reg_io_q_getversion, - reg_io_r_getversion, - WERR_GENERAL_FAILURE ); - - - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; - - *version = out.win_version; - - return out.status; -} - -/**************************************************************************** -do a REG Query Info -****************************************************************************/ - -WERROR rpccli_reg_query_value(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, const char *val_name, - uint32 *type, REGVAL_BUFFER *buffer) -{ - REG_Q_QUERY_VALUE in; - REG_R_QUERY_VALUE out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_query_value(&in, hnd, val_name, buffer); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_QUERY_VALUE, - in, out, - qbuf, rbuf, - reg_io_q_query_value, - reg_io_r_query_value, - WERR_GENERAL_FAILURE ); - - - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; - - *type = *out.type; - *buffer = *out.value; - - return out.status; -} - -/**************************************************************************** -do a REG Set Key Security -****************************************************************************/ - -WERROR rpccli_reg_set_key_sec(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, uint32 sec_info, - size_t secdesc_size, SEC_DESC *sec_desc) + uint32 *secdescsize, NTTIME *mod_time) { - REG_Q_SET_KEY_SEC in; - REG_R_SET_KEY_SEC out; - prs_struct qbuf, rbuf; - SEC_DESC_BUF *sec_desc_buf; + NTSTATUS status; + struct winreg_String classname_in, classname_out; - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - /* Flatten the security descriptor */ - - if ( !(sec_desc_buf = make_sec_desc_buf(mem_ctx, secdesc_size, sec_desc)) ) - return WERR_GENERAL_FAILURE; - - init_reg_q_set_key_sec(&in, hnd, sec_info, sec_desc_buf); + classname_in.name = key_class; + status = rpccli_winreg_QueryInfoKey( cli, mem_ctx, hnd, + classname_in, &classname_out, num_subkeys, + max_subkeylen, max_subkeysize, num_values, + max_valnamelen, max_valbufsize, secdescsize, + mod_time ); - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SET_KEY_SEC, - in, out, - qbuf, rbuf, - reg_io_q_set_key_sec, - reg_io_r_set_key_sec, - WERR_GENERAL_FAILURE ); - + /* The old code would check for INSUFFICIENT_BUFFER. + Will have to work this out. */ - return out.status; + return status; } /**************************************************************************** -do a REG Query Key Security ****************************************************************************/ -WERROR rpccli_reg_get_key_sec(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, uint32 sec_info, - uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf) +NTSTATUS rpccli_winreg_enum_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, + POLICY_HND *hnd, int idx, + fstring val_name, uint32 *type, REGVAL_BUFFER *value) { - REG_Q_GET_KEY_SEC in; - REG_R_GET_KEY_SEC out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_get_key_sec(&in, hnd, sec_info, *sec_buf_size, sec_buf); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_GET_KEY_SEC, - in, out, - qbuf, rbuf, - reg_io_q_get_key_sec, - reg_io_r_get_key_sec, - WERR_GENERAL_FAILURE ); - - - /* this might be able to return WERR_MORE_DATA, I'm not sure */ + NTSTATUS status = NT_STATUS_INVALID_PARAMETER; - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; + /* do rpc */ - sec_buf = out.data; - *sec_buf_size = out.data->sd_size; - return out.status; -} - -/**************************************************************************** -do a REG Delete Value -****************************************************************************/ - -WERROR rpccli_reg_delete_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, char *val_name) -{ - REG_Q_DELETE_VALUE in; - REG_R_DELETE_VALUE out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_delete_val(&in, hnd, val_name); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_DELETE_VALUE, - in, out, - qbuf, rbuf, - reg_io_q_delete_value, - reg_io_r_delete_value, - WERR_GENERAL_FAILURE ); - - return out.status; -} - -/**************************************************************************** -do a REG Delete Key -****************************************************************************/ - -WERROR rpccli_reg_delete_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, char *key_name) -{ - REG_Q_DELETE_KEY in; - REG_R_DELETE_KEY out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_delete_key(&in, hnd, key_name); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_DELETE_KEY, - in, out, - qbuf, rbuf, - reg_io_q_delete_key, - reg_io_r_delete_key, - WERR_GENERAL_FAILURE ); - - return out.status; -} - -/**************************************************************************** -do a REG Create Key -****************************************************************************/ - -WERROR rpccli_reg_create_key_ex(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, char *key_name, char *key_class, - uint32 access_desired, POLICY_HND *key) -{ - REG_Q_CREATE_KEY_EX in; - REG_R_CREATE_KEY_EX out; - prs_struct qbuf, rbuf; - SEC_DESC *sec; - SEC_DESC_BUF *sec_buf; - size_t sec_len; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - if ( !(sec = make_sec_desc(mem_ctx, 1, SEC_DESC_SELF_RELATIVE, - NULL, NULL, NULL, NULL, &sec_len)) ) { - return WERR_GENERAL_FAILURE; - } - - if ( !(sec_buf = make_sec_desc_buf(mem_ctx, sec_len, sec)) ) - return WERR_GENERAL_FAILURE; - - init_reg_q_create_key_ex(&in, hnd, key_name, key_class, access_desired, sec_buf); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_CREATE_KEY_EX, - in, out, - qbuf, rbuf, - reg_io_q_create_key_ex, - reg_io_r_create_key_ex, - WERR_GENERAL_FAILURE ); - - - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; - - memcpy( key, &out.handle, sizeof(POLICY_HND) ); - - return out.status; + return status; } /**************************************************************************** -do a REG Enum Key ****************************************************************************/ -WERROR rpccli_reg_enum_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, +NTSTATUS rpccli_winreg_enum_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hnd, int key_index, fstring key_name, fstring class_name, time_t *mod_time) { - REG_Q_ENUM_KEY in; - REG_R_ENUM_KEY out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_enum_key(&in, hnd, key_index); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ENUM_KEY, - in, out, - qbuf, rbuf, - reg_io_q_enum_key, - reg_io_r_enum_key, - WERR_GENERAL_FAILURE ); - - if ( !W_ERROR_IS_OK(out.status) ) - return out.status; - - if ( out.keyname.string ) - rpcstr_pull( key_name, out.keyname.string->buffer, sizeof(fstring), -1, STR_TERMINATE ); - else - fstrcpy( key_name, "(Default)" ); - - if ( out.classname && out.classname->string ) - rpcstr_pull( class_name, out.classname->string->buffer, sizeof(fstring), -1, STR_TERMINATE ); - else - fstrcpy( class_name, "" ); - - *mod_time = nt_time_to_unix(*out.time); - - return out.status; -} - -/**************************************************************************** -do a REG Create Value -****************************************************************************/ - -WERROR rpccli_reg_set_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, char *val_name, uint32 type, - RPC_DATA_BLOB *data) -{ - REG_Q_SET_VALUE in; - REG_R_SET_VALUE out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_set_val(&in, hnd, val_name, type, data); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SET_VALUE, - in, out, - qbuf, rbuf, - reg_io_q_set_value, - reg_io_r_set_value, - WERR_GENERAL_FAILURE ); - - return out.status; -} - -/**************************************************************************** -do a REG Enum Value -****************************************************************************/ - -WERROR rpccli_reg_enum_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, int idx, - fstring val_name, uint32 *type, REGVAL_BUFFER *value) -{ - REG_Q_ENUM_VALUE in; - REG_R_ENUM_VALUE out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_enum_val(&in, hnd, idx, 0x0100, 0x1000); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, - in, out, - qbuf, rbuf, - reg_io_q_enum_val, - reg_io_r_enum_val, - WERR_GENERAL_FAILURE ); - - if ( W_ERROR_EQUAL(out.status, WERR_MORE_DATA) ) { - - ZERO_STRUCT (in); - - init_reg_q_enum_val(&in, hnd, idx, 0x0100, *out.buffer_len1); - - ZERO_STRUCT (out); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_ENUM_VALUE, - in, out, - qbuf, rbuf, - reg_io_q_enum_val, - reg_io_r_enum_val, - WERR_GENERAL_FAILURE ); - } - - if ( !W_ERROR_IS_OK(out.status) ) - return out.status; - - unistr2_to_ascii(val_name, out.name.string, sizeof(fstring)-1); - *type = *out.type; - *value = *out.value; - - return out.status; -} - -/**************************************************************************** -****************************************************************************/ - -WERROR rpccli_reg_open_entry(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, char *key_name, - uint32 access_desired, POLICY_HND *key_hnd) -{ - REG_Q_OPEN_ENTRY in; - REG_R_OPEN_ENTRY out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_open_entry(&in, hnd, key_name, access_desired); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_OPEN_ENTRY, - in, out, - qbuf, rbuf, - reg_io_q_open_entry, - reg_io_r_open_entry, - WERR_GENERAL_FAILURE ); - - if ( !W_ERROR_IS_OK( out.status ) ) - return out.status; - - memcpy( key_hnd, &out.handle, sizeof(POLICY_HND) ); - - return out.status; -} - -/**************************************************************************** -****************************************************************************/ - -WERROR rpccli_reg_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd) -{ - REG_Q_CLOSE in; - REG_R_CLOSE out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_reg_q_close(&in, hnd); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_CLOSE, - in, out, - qbuf, rbuf, - reg_io_q_close, - reg_io_r_close, - WERR_GENERAL_FAILURE ); + NTSTATUS status = NT_STATUS_UNSUCCESSFUL; - return out.status; + return status; } -/**************************************************************************** -do a REG Query Info -****************************************************************************/ - -WERROR rpccli_reg_save_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, const char *filename ) -{ - REG_Q_SAVE_KEY in; - REG_R_SAVE_KEY out; - prs_struct qbuf, rbuf; - - ZERO_STRUCT (in); - ZERO_STRUCT (out); - - init_q_reg_save_key( &in, hnd, filename ); - - CLI_DO_RPC_WERR( cli, mem_ctx, PI_WINREG, REG_SAVE_KEY, - in, out, - qbuf, rbuf, - reg_io_q_save_key, - reg_io_r_save_key, - WERR_GENERAL_FAILURE ); - - return out.status; -} - - -/* - ################################################################# - Utility functions - ################################################################# +/* + * + * Utility functions + * */ /***************************************************************** @@ -678,3 +156,23 @@ BOOL reg_split_hive(const char *full_keyname, uint32 *reg_type, pstring key_name return True; } + +/******************************************************************* + Fill in a REGVAL_BUFFER for the data given a REGISTRY_VALUE + *******************************************************************/ + +uint32 reg_init_regval_buffer( REGVAL_BUFFER *buf2, REGISTRY_VALUE *val ) +{ + uint32 real_size = 0; + + if ( !buf2 || !val ) + return 0; + + real_size = regval_size(val); + init_regval_buffer( buf2, (unsigned char*)regval_data_p(val), real_size ); + + return real_size; +} + + + -- cgit From 49c73b5734a42b9d018dd7cfa006a1820ba08dee Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Tue, 26 Sep 2006 21:01:57 +0000 Subject: r18931: * Fix the IDL for QueryInfoKey. teh Classname in an in,out ref pointer * Clarify variable names in EnumValue IDL * Fix server code for _winreg_EnumValue() and _winreg_QueryInfoKe() (This used to be commit f520a9d0fba4cc3cfbda40dd68cb63c4c3c4ed30) --- source3/rpc_client/cli_reg.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 9b0420a4ec..42f0606ca6 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -70,11 +70,11 @@ NTSTATUS rpccli_winreg_query_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ct uint32 *secdescsize, NTTIME *mod_time) { NTSTATUS status; - struct winreg_String classname_in, classname_out; + struct winreg_String classname; - classname_in.name = key_class; + classname.name = key_class; status = rpccli_winreg_QueryInfoKey( cli, mem_ctx, hnd, - classname_in, &classname_out, num_subkeys, + &classname, num_subkeys, max_subkeylen, max_subkeysize, num_values, max_valnamelen, max_valbufsize, secdescsize, mod_time ); -- cgit From 18d417663395febe60b23f376b2e92c9869e1126 Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Thu, 28 Sep 2006 21:19:08 +0000 Subject: r18981: * cleanup some vestiges of old cli_reg.c code and mark some TODO items in cac_winreg.c * Get 'net rpc registry enumerate' to list values again * Fix winreg.idl QueryInfoKey(). The max_subkeysize is the max_classlen (we previously had this correct in Samba3") * fix valgrind error about uninitialized memory and use-before-set on size value inmemset() call * Fix key enumeration in 'net rpc registry enumerate' * regenerate gen_dir files based on local pidl patches Please note that the generated ndr files are from my local copy of pidl. If you need to regenerate, please apply the patch that I posted to the samba-technical list earlier today. (This used to be commit 5d843612a1b9d92022f76626f1c7473faebec4ba) --- source3/rpc_client/cli_reg.c | 57 +------------------------------------------- 1 file changed, 1 insertion(+), 56 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 42f0606ca6..3aadc04975 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -26,7 +26,7 @@ connect to a registry hive root (open a registry policy) *******************************************************************/ -NTSTATUS rpccli_winreg_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, +NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32 reg_type, uint32 access_mask, POLICY_HND *reg_hnd) { @@ -58,61 +58,6 @@ NTSTATUS rpccli_winreg_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, return NT_STATUS_INVALID_PARAMETER; } -/**************************************************************************** -****************************************************************************/ - -NTSTATUS rpccli_winreg_query_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, - char *key_class, uint32 *class_len, - uint32 *num_subkeys, uint32 *max_subkeylen, - uint32 *max_subkeysize, uint32 *num_values, - uint32 *max_valnamelen, uint32 *max_valbufsize, - uint32 *secdescsize, NTTIME *mod_time) -{ - NTSTATUS status; - struct winreg_String classname; - - classname.name = key_class; - status = rpccli_winreg_QueryInfoKey( cli, mem_ctx, hnd, - &classname, num_subkeys, - max_subkeylen, max_subkeysize, num_values, - max_valnamelen, max_valbufsize, secdescsize, - mod_time ); - - /* The old code would check for INSUFFICIENT_BUFFER. - Will have to work this out. */ - - return status; -} - - -/**************************************************************************** -****************************************************************************/ - -NTSTATUS rpccli_winreg_enum_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, int idx, - fstring val_name, uint32 *type, REGVAL_BUFFER *value) -{ - NTSTATUS status = NT_STATUS_INVALID_PARAMETER; - - /* do rpc */ - - - return status; -} - -/**************************************************************************** -****************************************************************************/ - -NTSTATUS rpccli_winreg_enum_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, - POLICY_HND *hnd, int key_index, fstring key_name, - fstring class_name, time_t *mod_time) -{ - NTSTATUS status = NT_STATUS_UNSUCCESSFUL; - - return status; -} - /* * * Utility functions -- cgit From c63be3a4e7909cc3f71fcad6d134a7bb2fc19529 Mon Sep 17 00:00:00 2001 From: Volker Lendecke Date: Tue, 21 Nov 2006 10:48:11 +0000 Subject: r19818: Remove reg_split_hive, make use of registry_openkey (This used to be commit 7fd1578a905d3c974cb88cc93452d43a03038d30) --- source3/rpc_client/cli_reg.c | 44 -------------------------------------------- 1 file changed, 44 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 3aadc04975..292d1d9d28 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -58,50 +58,6 @@ NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, return NT_STATUS_INVALID_PARAMETER; } -/* - * - * Utility functions - * - */ - -/***************************************************************** - Splits out the start of the key (HKLM or HKU) and the rest of the key. -*****************************************************************/ - -BOOL reg_split_hive(const char *full_keyname, uint32 *reg_type, pstring key_name) -{ - pstring tmp; - - if (!next_token(&full_keyname, tmp, "\\", sizeof(tmp))) - return False; - - (*reg_type) = 0; - - DEBUG(10, ("reg_split_key: hive %s\n", tmp)); - - if (strequal(tmp, "HKLM") || strequal(tmp, "HKEY_LOCAL_MACHINE")) - (*reg_type) = HKEY_LOCAL_MACHINE; - else if (strequal(tmp, "HKCR") || strequal(tmp, "HKEY_CLASSES_ROOT")) - (*reg_type) = HKEY_CLASSES_ROOT; - else if (strequal(tmp, "HKU") || strequal(tmp, "HKEY_USERS")) - (*reg_type) = HKEY_USERS; - else if (strequal(tmp, "HKPD")||strequal(tmp, "HKEY_PERFORMANCE_DATA")) - (*reg_type) = HKEY_PERFORMANCE_DATA; - else { - DEBUG(10,("reg_split_key: unrecognised hive key %s\n", tmp)); - return False; - } - - if (next_token(&full_keyname, tmp, "\n\r", sizeof(tmp))) - pstrcpy(key_name, tmp); - else - key_name[0] = 0; - - DEBUG(10, ("reg_split_key: name %s\n", key_name)); - - return True; -} - /******************************************************************* Fill in a REGVAL_BUFFER for the data given a REGISTRY_VALUE *******************************************************************/ -- cgit From 1052cadbae7bf71a0575b06e8ac7ff52c7fb95ee Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 20 Feb 2007 13:43:41 +0000 Subject: r21462: Fix EnumValue (?) (This used to be commit e73a418b5b0100936efb4c1133da3cfe3fcb61cd) --- source3/rpc_client/cli_reg.c | 3 --- 1 file changed, 3 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 292d1d9d28..83ff96b8b3 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -74,6 +74,3 @@ uint32 reg_init_regval_buffer( REGVAL_BUFFER *buf2, REGISTRY_VALUE *val ) return real_size; } - - - -- cgit From d824b98f80ba186030cbb70b3a1e5daf80469ecd Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Mon, 9 Jul 2007 19:25:36 +0000 Subject: r23779: Change from v2 or later to v3 or later. Jeremy. (This used to be commit 407e6e695b8366369b7c76af1ff76869b45347b3) --- source3/rpc_client/cli_reg.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 83ff96b8b3..3c18e38900 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -6,7 +6,7 @@ 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, -- cgit From 5e54558c6dea67b56bbfaba5698f3a434d3dffb6 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 10 Jul 2007 00:52:41 +0000 Subject: r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text (This used to be commit b0132e94fc5fef936aa766fb99a306b3628e9f07) --- source3/rpc_client/cli_reg.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 3c18e38900..c811529e63 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -15,8 +15,7 @@ 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 . */ #include "includes.h" -- cgit From 2fcdaae84c5ef9c355333f4069be37287f2345ad Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Tue, 25 Sep 2007 04:52:15 +0000 Subject: r25313: dd HKEY_CURRENT_USER to rpccli_winreg_Connect(). Guenther (This used to be commit eb311cafbb446abf8e29faf6501cf5b82593a36f) --- source3/rpc_client/cli_reg.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index c811529e63..693d4dd5b5 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -45,6 +45,10 @@ NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL, access_mask, reg_hnd ); + case HKEY_CURRENT_USER: + return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL, + access_mask, reg_hnd ); + case HKEY_PERFORMANCE_DATA: return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL, access_mask, reg_hnd ); -- cgit From 82089a2e84ae818c483183a866e24b4e4522058a Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Mon, 3 Dec 2007 18:21:40 +0100 Subject: Fix winreg callers. Guenther (This used to be commit 677d9e6d86997a1ae10266e9bab3b18c3fdd2890) --- source3/rpc_client/cli_reg.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source3/rpc_client/cli_reg.c') diff --git a/source3/rpc_client/cli_reg.c b/source3/rpc_client/cli_reg.c index 693d4dd5b5..ba98e25d63 100644 --- a/source3/rpc_client/cli_reg.c +++ b/source3/rpc_client/cli_reg.c @@ -35,23 +35,23 @@ NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, { case HKEY_CLASSES_ROOT: return rpccli_winreg_OpenHKCR( cli, mem_ctx, NULL, - access_mask, reg_hnd ); + access_mask, reg_hnd, NULL); case HKEY_LOCAL_MACHINE: return rpccli_winreg_OpenHKLM( cli, mem_ctx, NULL, - access_mask, reg_hnd ); + access_mask, reg_hnd, NULL); case HKEY_USERS: return rpccli_winreg_OpenHKU( cli, mem_ctx, NULL, - access_mask, reg_hnd ); + access_mask, reg_hnd, NULL); case HKEY_CURRENT_USER: return rpccli_winreg_OpenHKCU( cli, mem_ctx, NULL, - access_mask, reg_hnd ); + access_mask, reg_hnd, NULL); case HKEY_PERFORMANCE_DATA: return rpccli_winreg_OpenHKPD( cli, mem_ctx, NULL, - access_mask, reg_hnd ); + access_mask, reg_hnd, NULL); default: /* fall through to end of function */ -- cgit