From b409d4120f9ae451f93a2322267c0f346531d9f3 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sun, 26 Aug 2007 15:16:40 +0000 Subject: r24667: Finally merge the registry improvements that Wilco Baan Hofman and I have been working on for at least half a year now. Contains the following improvements: * proper layering (finally!) for the registry library. Distinction is now made between 'real' backends (local, remote, wine, etc) and the low-level hive backends (regf, creg, ldb, ...) that are only used by the local registry backend * tests for all important hive and registry operations * re-enable RPC-WINREG tests (still needs more work though, as some return values aren't checked yet) * write support for REGF files * dir backend now supports setting/reading values, creating keys * support for storing security descriptors * remove CREG backend as it was incomplete, didn't match the data model and wasn't used at all anyway * support for parsing ADM files as used by the policy editor (see lib/policy) * support for parsing PREG files (format used by .POL files) * new streaming interface for registry diffs (improves speed and memory usage for regdiff/regpatch significantly) ... and fixes a large number of bugs in the registry code (This used to be commit 7a1eec6358bc863dfc671c542b7185d3e39d7b5a) --- source4/lib/registry/rpc.c | 399 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 source4/lib/registry/rpc.c (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c new file mode 100644 index 0000000000..59d41d591a --- /dev/null +++ b/source4/lib/registry/rpc.c @@ -0,0 +1,399 @@ +/* + Samba Unix/Linux SMB implementation + RPC backend for the registry library + Copyright (C) 2003-2007 Jelmer Vernooij, jelmer@samba.org + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "includes.h" +#include "registry.h" +#include "librpc/gen_ndr/ndr_winreg_c.h" + +struct rpc_key { + struct registry_key key; + struct policy_handle pol; + struct dcerpc_pipe *pipe; + + uint32_t num_values; + uint32_t num_subkeys; + uint32_t max_valnamelen; + uint32_t max_valdatalen; +}; + +struct rpc_registry_context { + struct registry_context context; + struct dcerpc_pipe *pipe; +}; + +static struct registry_operations reg_backend_rpc; + +/** + * This is the RPC backend for the registry library. + */ + +static void init_winreg_String(struct winreg_String *name, const char *s) +{ + name->name = s; +} + + +#define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \ +{ \ + struct winreg_Open ## u r; \ + NTSTATUS status; \ + \ + r.in.system_name = NULL; \ + r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED; \ + r.out.handle = hnd;\ + \ + status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \ + if (NT_STATUS_IS_ERR(status)) {\ + DEBUG(0,("Error executing open\n"));\ + return ntstatus_to_werror(status);\ + }\ +\ + return r.out.result;\ +} + +openhive(HKLM) +openhive(HKCU) +openhive(HKPD) +openhive(HKU) +openhive(HKCR) +openhive(HKDD) +openhive(HKCC) + +static struct { + uint32_t hkey; + WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, struct policy_handle *h); +} known_hives[] = { + { HKEY_LOCAL_MACHINE, open_HKLM }, + { HKEY_CURRENT_USER, open_HKCU }, + { HKEY_CLASSES_ROOT, open_HKCR }, + { HKEY_PERFORMANCE_DATA, open_HKPD }, + { HKEY_USERS, open_HKU }, + { HKEY_DYN_DATA, open_HKDD }, + { HKEY_CURRENT_CONFIG, open_HKCC }, + { 0, NULL } +}; + +static WERROR rpc_query_key(const struct registry_key *k); + +static WERROR rpc_get_predefined_key(struct registry_context *ctx, + uint32_t hkey_type, + struct registry_key **k) +{ + int n; + struct rpc_registry_context *rctx = talloc_get_type(ctx, + struct rpc_registry_context); + struct rpc_key *mykeydata; + + for(n = 0; known_hives[n].hkey; n++) { + if(known_hives[n].hkey == hkey_type) + break; + } + + if (known_hives[n].open == NULL) { + DEBUG(1, ("No such hive %d\n", hkey_type)); + return WERR_NO_MORE_ITEMS; + } + + mykeydata = talloc(ctx, struct rpc_key); + mykeydata->pipe = rctx->pipe; + mykeydata->num_values = -1; + mykeydata->num_subkeys = -1; + return known_hives[n].open(mykeydata->pipe, *k, &(mykeydata->pol)); +} + +#if 0 +static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k) +{ + struct winreg_OpenKey r; + struct rpc_key_data *mykeydata; + + k->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data); + mykeydata->num_values = -1; + mykeydata->num_subkeys = -1; + + /* Then, open the handle using the hive */ + + memset(&r, 0, sizeof(struct winreg_OpenKey)); + r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol); + init_winreg_String(&r.in.keyname, k->path); + r.in.unknown = 0x00000000; + r.in.access_mask = 0x02000000; + r.out.handle = &mykeydata->pol; + + dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r); + + return r.out.result; +} +#endif + +static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_key *h, + const char *name, struct registry_key **key) +{ + struct rpc_key *mykeydata = talloc_get_type(h, struct rpc_key), + *newkeydata; + struct winreg_OpenKey r; + + mykeydata = talloc(mem_ctx, struct rpc_key); + + /* Then, open the handle using the hive */ + memset(&r, 0, sizeof(struct winreg_OpenKey)); + r.in.parent_handle = &mykeydata->pol; + init_winreg_String(&r.in.keyname, name); + r.in.unknown = 0x00000000; + r.in.access_mask = 0x02000000; + r.out.handle = &newkeydata->pol; + + dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r); + + return r.out.result; +} + +static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, + const struct registry_key *parent, + uint32_t n, + const char **value_name, + uint32_t *type, + DATA_BLOB *data) +{ + struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); + WERROR error; + struct winreg_EnumValue r; + uint32_t len1, zero = 0; + NTSTATUS status; + struct winreg_StringBuf name; + uint8_t u8; + + if (mykeydata->num_values == -1) { + error = rpc_query_key(parent); + if(!W_ERROR_IS_OK(error)) return error; + } + + len1 = mykeydata->max_valdatalen; + + name.length = 0; + name.size = mykeydata->max_valnamelen * 2; + name.name = ""; + + r.in.handle = &mykeydata->pol; + r.in.enum_index = n; + r.in.name = &name; + r.in.type = type; + r.in.value = &u8; + r.in.length = &zero; + r.in.size = &len1; + r.out.name = &name; + + status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r); + if(NT_STATUS_IS_ERR(status)) { + DEBUG(0, ("Error in EnumValue: %s\n", nt_errstr(status))); + return WERR_GENERAL_FAILURE; + } + + if(NT_STATUS_IS_OK(status) && + W_ERROR_IS_OK(r.out.result) && r.out.length) { + *value_name = talloc_strdup(mem_ctx, r.out.name->name); + *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length); + return WERR_OK; + } + + return r.out.result; +} + +static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, + const struct registry_key *parent, + uint32_t n, + const char **name, + const char **keyclass, + NTTIME *last_changed_time) +{ + struct winreg_EnumKey r; + struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); + NTSTATUS status; + struct winreg_StringBuf namebuf, classbuf; + NTTIME change_time = 0; + + namebuf.length = 0; + namebuf.size = 1024; + namebuf.name = NULL; + classbuf.length = 0; + classbuf.size = 0; + classbuf.name = NULL; + + r.in.handle = &mykeydata->pol; + r.in.enum_index = n; + r.in.name = &namebuf; + r.in.keyclass = &classbuf; + r.in.last_changed_time = &change_time; + r.out.name = &namebuf; + + status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r); + if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) { + *name = talloc_strdup(mem_ctx, r.out.name->name); + *keyclass = talloc_strdup(mem_ctx, r.out.keyclass->name); + *last_changed_time = *r.out.last_changed_time; + } + + return r.out.result; +} + +static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, + struct registry_key *parent, const char *name, + const char *key_class, + struct security_descriptor *sec, + struct registry_key **key) +{ + NTSTATUS status; + struct winreg_CreateKey r; + struct rpc_key *parentkd = talloc_get_type(parent, struct rpc_key); + struct rpc_key *rpck = talloc(mem_ctx, struct rpc_key); + + init_winreg_String(&r.in.name, name); + init_winreg_String(&r.in.keyclass, NULL); + + r.in.handle = &parentkd->pol; + r.out.new_handle = &rpck->pol; + r.in.options = 0; + r.in.access_mask = SEC_STD_ALL; + r.in.secdesc = NULL; + + status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r); + + if (!NT_STATUS_IS_OK(status)) { + talloc_free(rpck); + DEBUG(1, ("CreateKey failed - %s\n", nt_errstr(status))); + return ntstatus_to_werror(status); + } + + if (W_ERROR_IS_OK(r.out.result)) { + rpck->pipe = talloc_reference(rpck, parentkd->pipe); + *key = (struct registry_key *)rpck; + } + + return r.out.result; +} + +static WERROR rpc_query_key(const struct registry_key *k) +{ + NTSTATUS status; + struct winreg_QueryInfoKey r; + struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key); + TALLOC_CTX *mem_ctx = talloc_init("query_key"); + + r.in.classname = talloc(mem_ctx, struct winreg_String); + init_winreg_String(r.in.classname, NULL); + r.in.handle = &mykeydata->pol; + + status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r); + talloc_free(mem_ctx); + + if (!NT_STATUS_IS_OK(status)) { + DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status))); + return ntstatus_to_werror(status); + } + + if (W_ERROR_IS_OK(r.out.result)) { + mykeydata->num_subkeys = *r.out.num_subkeys; + mykeydata->num_values = *r.out.num_values; + mykeydata->max_valnamelen = *r.out.max_valnamelen; + mykeydata->max_valdatalen = *r.out.max_valbufsize; + } + + return r.out.result; +} + +static WERROR rpc_del_key(struct registry_key *parent, const char *name) +{ + NTSTATUS status; + struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); + struct winreg_DeleteKey r; + TALLOC_CTX *mem_ctx = talloc_init("del_key"); + + r.in.handle = &mykeydata->pol; + init_winreg_String(&r.in.key, name); + + status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r); + + talloc_free(mem_ctx); + + return r.out.result; +} + +static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, + const char **classname, + uint32_t *numsubkeys, + uint32_t *numvalue) +{ + struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key); + WERROR error; + + if(mykeydata->num_values == -1) { + error = rpc_query_key(key); + if(!W_ERROR_IS_OK(error)) return error; + } + + /* FIXME: *classname = talloc_strdup(mem_ctx, mykeydata->classname); */ + *numvalue = mykeydata->num_values; + *numsubkeys = mykeydata->num_subkeys; + return WERR_OK; +} + +static struct registry_operations reg_backend_rpc = { + .name = "rpc", + .open_key = rpc_open_key, + .enum_key = rpc_get_subkey_by_index, + .enum_value = rpc_get_value_by_index, + .create_key = rpc_add_key, + .delete_key = rpc_del_key, + .get_key_info = rpc_get_info, +}; + +_PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, + struct auth_session_info *session_info, + struct cli_credentials *credentials, + const char *location, struct event_context *ev) +{ + NTSTATUS status; + struct dcerpc_pipe *p; + struct rpc_registry_context *rctx; + + dcerpc_init(); + + rctx = talloc(NULL, struct rpc_registry_context); + + /* Default to local smbd if no connection is specified */ + if (!location) { + location = talloc_strdup(ctx, "ncalrpc:"); + } + + status = dcerpc_pipe_connect(*ctx /* TALLOC_CTX */, + &p, location, + &ndr_table_winreg, + credentials, ev); + rctx->pipe = p; + + if(NT_STATUS_IS_ERR(status)) { + DEBUG(1, ("Unable to open '%s': %s\n", location, nt_errstr(status))); + talloc_free(*ctx); + *ctx = NULL; + return ntstatus_to_werror(status); + } + + *ctx = (struct registry_context *)rctx; + + return WERR_OK; +} -- cgit From 616c45f16a56527f54d428a7fbeabcc9952459f5 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 27 Aug 2007 18:56:46 +0000 Subject: r24718: Fix some compiler warnings. (This used to be commit 08f7389ab7312d350e056b1ba98da86d80944424) --- source4/lib/registry/rpc.c | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c index 59d41d591a..e4157fe424 100644 --- a/source4/lib/registry/rpc.c +++ b/source4/lib/registry/rpc.c @@ -90,7 +90,7 @@ static struct { static WERROR rpc_query_key(const struct registry_key *k); -static WERROR rpc_get_predefined_key(struct registry_context *ctx, +static WERROR rpc_get_predefined_key(const struct registry_context *ctx, uint32_t hkey_type, struct registry_key **k) { @@ -336,7 +336,8 @@ static WERROR rpc_del_key(struct registry_key *parent, const char *name) static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, const char **classname, uint32_t *numsubkeys, - uint32_t *numvalue) + uint32_t *numvalue, + NTTIME *last_changed_time) { struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key); WERROR error; @@ -347,8 +348,14 @@ static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, } /* FIXME: *classname = talloc_strdup(mem_ctx, mykeydata->classname); */ - *numvalue = mykeydata->num_values; - *numsubkeys = mykeydata->num_subkeys; + /* FIXME: *last_changed_time = mykeydata->last_changed_time */ + + if (numvalue != NULL) + *numvalue = mykeydata->num_values; + + if (numsubkeys != NULL) + *numsubkeys = mykeydata->num_subkeys; + return WERR_OK; } @@ -360,6 +367,7 @@ static struct registry_operations reg_backend_rpc = { .create_key = rpc_add_key, .delete_key = rpc_del_key, .get_key_info = rpc_get_info, + .get_predefined_key = rpc_get_predefined_key, }; _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, @@ -394,6 +402,7 @@ _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, } *ctx = (struct registry_context *)rctx; + (*ctx)->ops = ®_backend_rpc; return WERR_OK; } -- cgit From cc8f4eb3cd9b3bc4e3f3d61bfad240147e8a4e5e Mon Sep 17 00:00:00 2001 From: Günther Deschner Date: Sat, 6 Oct 2007 00:17:44 +0000 Subject: r25544: Cleanup some more indents in lib/registry. Guenther (This used to be commit 0d9826dc54057db2cfebcb806e5442c4dcf60daa) --- source4/lib/registry/rpc.c | 175 +++++++++++++++++++++++---------------------- 1 file changed, 89 insertions(+), 86 deletions(-) (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c index e4157fe424..c694223909 100644 --- a/source4/lib/registry/rpc.c +++ b/source4/lib/registry/rpc.c @@ -7,15 +7,15 @@ it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program. If not, see . */ - + #include "includes.h" #include "registry.h" #include "librpc/gen_ndr/ndr_winreg_c.h" @@ -76,7 +76,8 @@ openhive(HKCC) static struct { uint32_t hkey; - WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, struct policy_handle *h); + WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *, + struct policy_handle *h); } known_hives[] = { { HKEY_LOCAL_MACHINE, open_HKLM }, { HKEY_CURRENT_USER, open_HKCU }, @@ -90,20 +91,20 @@ static struct { static WERROR rpc_query_key(const struct registry_key *k); -static WERROR rpc_get_predefined_key(const struct registry_context *ctx, - uint32_t hkey_type, - struct registry_key **k) +static WERROR rpc_get_predefined_key(const struct registry_context *ctx, + uint32_t hkey_type, + struct registry_key **k) { int n; - struct rpc_registry_context *rctx = talloc_get_type(ctx, - struct rpc_registry_context); + struct rpc_registry_context *rctx = talloc_get_type(ctx, + struct rpc_registry_context); struct rpc_key *mykeydata; for(n = 0; known_hives[n].hkey; n++) { - if(known_hives[n].hkey == hkey_type) + if(known_hives[n].hkey == hkey_type) break; } - + if (known_hives[n].open == NULL) { DEBUG(1, ("No such hive %d\n", hkey_type)); return WERR_NO_MORE_ITEMS; @@ -119,7 +120,7 @@ static WERROR rpc_get_predefined_key(const struct registry_context *ctx, #if 0 static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k) { - struct winreg_OpenKey r; + struct winreg_OpenKey r; struct rpc_key_data *mykeydata; k->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data); @@ -129,46 +130,47 @@ static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k) /* Then, open the handle using the hive */ memset(&r, 0, sizeof(struct winreg_OpenKey)); - r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol); - init_winreg_String(&r.in.keyname, k->path); - r.in.unknown = 0x00000000; - r.in.access_mask = 0x02000000; - r.out.handle = &mykeydata->pol; + r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol); + init_winreg_String(&r.in.keyname, k->path); + r.in.unknown = 0x00000000; + r.in.access_mask = 0x02000000; + r.out.handle = &mykeydata->pol; - dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->hive->backend_data, mem_ctx, &r); + dcerpc_winreg_OpenKey((struct dcerpc_pipe *)k->hive->backend_data, + mem_ctx, &r); return r.out.result; } #endif -static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_key *h, - const char *name, struct registry_key **key) +static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_key *h, + const char *name, struct registry_key **key) { struct rpc_key *mykeydata = talloc_get_type(h, struct rpc_key), - *newkeydata; - struct winreg_OpenKey r; + *newkeydata; + struct winreg_OpenKey r; mykeydata = talloc(mem_ctx, struct rpc_key); /* Then, open the handle using the hive */ memset(&r, 0, sizeof(struct winreg_OpenKey)); - r.in.parent_handle = &mykeydata->pol; - init_winreg_String(&r.in.keyname, name); - r.in.unknown = 0x00000000; - r.in.access_mask = 0x02000000; - r.out.handle = &newkeydata->pol; + r.in.parent_handle = &mykeydata->pol; + init_winreg_String(&r.in.keyname, name); + r.in.unknown = 0x00000000; + r.in.access_mask = 0x02000000; + r.out.handle = &newkeydata->pol; - dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r); + dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r); return r.out.result; } -static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, - const struct registry_key *parent, - uint32_t n, - const char **value_name, - uint32_t *type, - DATA_BLOB *data) +static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, + const struct registry_key *parent, + uint32_t n, + const char **value_name, + uint32_t *type, + DATA_BLOB *data) { struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); WERROR error; @@ -177,14 +179,14 @@ static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, NTSTATUS status; struct winreg_StringBuf name; uint8_t u8; - + if (mykeydata->num_values == -1) { error = rpc_query_key(parent); if(!W_ERROR_IS_OK(error)) return error; } len1 = mykeydata->max_valdatalen; - + name.length = 0; name.size = mykeydata->max_valnamelen * 2; name.name = ""; @@ -197,29 +199,29 @@ static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, r.in.length = &zero; r.in.size = &len1; r.out.name = &name; - + status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r); if(NT_STATUS_IS_ERR(status)) { DEBUG(0, ("Error in EnumValue: %s\n", nt_errstr(status))); return WERR_GENERAL_FAILURE; } - - if(NT_STATUS_IS_OK(status) && + + if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result) && r.out.length) { *value_name = talloc_strdup(mem_ctx, r.out.name->name); *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length); return WERR_OK; } - + return r.out.result; } -static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, - const struct registry_key *parent, - uint32_t n, - const char **name, - const char **keyclass, - NTTIME *last_changed_time) +static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, + const struct registry_key *parent, + uint32_t n, + const char **name, + const char **keyclass, + NTTIME *last_changed_time) { struct winreg_EnumKey r; struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); @@ -242,7 +244,7 @@ static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, r.out.name = &namebuf; status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r); - if(NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) { + if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) { *name = talloc_strdup(mem_ctx, r.out.name->name); *keyclass = talloc_strdup(mem_ctx, r.out.keyclass->name); *last_changed_time = *r.out.last_changed_time; @@ -251,11 +253,11 @@ static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, return r.out.result; } -static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, - struct registry_key *parent, const char *name, - const char *key_class, - struct security_descriptor *sec, - struct registry_key **key) +static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, + struct registry_key *parent, const char *name, + const char *key_class, + struct security_descriptor *sec, + struct registry_key **key) { NTSTATUS status; struct winreg_CreateKey r; @@ -273,11 +275,11 @@ static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r); - if (!NT_STATUS_IS_OK(status)) { + if (!NT_STATUS_IS_OK(status)) { talloc_free(rpck); - DEBUG(1, ("CreateKey failed - %s\n", nt_errstr(status))); - return ntstatus_to_werror(status); - } + DEBUG(1, ("CreateKey failed - %s\n", nt_errstr(status))); + return ntstatus_to_werror(status); + } if (W_ERROR_IS_OK(r.out.result)) { rpck->pipe = talloc_reference(rpck, parentkd->pipe); @@ -289,29 +291,29 @@ static WERROR rpc_add_key(TALLOC_CTX *mem_ctx, static WERROR rpc_query_key(const struct registry_key *k) { - NTSTATUS status; - struct winreg_QueryInfoKey r; - struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key); + NTSTATUS status; + struct winreg_QueryInfoKey r; + struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key); TALLOC_CTX *mem_ctx = talloc_init("query_key"); r.in.classname = talloc(mem_ctx, struct winreg_String); - init_winreg_String(r.in.classname, NULL); - r.in.handle = &mykeydata->pol; - - status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r); + init_winreg_String(r.in.classname, NULL); + r.in.handle = &mykeydata->pol; + + status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r); talloc_free(mem_ctx); - if (!NT_STATUS_IS_OK(status)) { - DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status))); - return ntstatus_to_werror(status); - } - - if (W_ERROR_IS_OK(r.out.result)) { + if (!NT_STATUS_IS_OK(status)) { + DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status))); + return ntstatus_to_werror(status); + } + + if (W_ERROR_IS_OK(r.out.result)) { mykeydata->num_subkeys = *r.out.num_subkeys; mykeydata->num_values = *r.out.num_values; mykeydata->max_valnamelen = *r.out.max_valnamelen; mykeydata->max_valdatalen = *r.out.max_valbufsize; - } + } return r.out.result; } @@ -322,11 +324,11 @@ static WERROR rpc_del_key(struct registry_key *parent, const char *name) struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); struct winreg_DeleteKey r; TALLOC_CTX *mem_ctx = talloc_init("del_key"); - - r.in.handle = &mykeydata->pol; - init_winreg_String(&r.in.key, name); - - status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r); + + r.in.handle = &mykeydata->pol; + init_winreg_String(&r.in.key, name); + + status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r); talloc_free(mem_ctx); @@ -334,19 +336,19 @@ static WERROR rpc_del_key(struct registry_key *parent, const char *name) } static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, - const char **classname, + const char **classname, uint32_t *numsubkeys, uint32_t *numvalue, NTTIME *last_changed_time) { struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key); WERROR error; - - if(mykeydata->num_values == -1) { + + if (mykeydata->num_values == -1) { error = rpc_query_key(key); if(!W_ERROR_IS_OK(error)) return error; } - + /* FIXME: *classname = talloc_strdup(mem_ctx, mykeydata->classname); */ /* FIXME: *last_changed_time = mykeydata->last_changed_time */ @@ -370,10 +372,10 @@ static struct registry_operations reg_backend_rpc = { .get_predefined_key = rpc_get_predefined_key, }; -_PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, - struct auth_session_info *session_info, - struct cli_credentials *credentials, - const char *location, struct event_context *ev) +_PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, + struct auth_session_info *session_info, + struct cli_credentials *credentials, + const char *location, struct event_context *ev) { NTSTATUS status; struct dcerpc_pipe *p; @@ -388,14 +390,15 @@ _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, location = talloc_strdup(ctx, "ncalrpc:"); } - status = dcerpc_pipe_connect(*ctx /* TALLOC_CTX */, - &p, location, + status = dcerpc_pipe_connect(*ctx /* TALLOC_CTX */, + &p, location, &ndr_table_winreg, credentials, ev); rctx->pipe = p; if(NT_STATUS_IS_ERR(status)) { - DEBUG(1, ("Unable to open '%s': %s\n", location, nt_errstr(status))); + DEBUG(1, ("Unable to open '%s': %s\n", location, + nt_errstr(status))); talloc_free(*ctx); *ctx = NULL; return ntstatus_to_werror(status); -- cgit From 4c4323009fa83f00ed319de59a3aad48fcd65994 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 7 Dec 2007 02:37:04 +0100 Subject: r26327: Explicit loadparm_context for RPC client functions. (This used to be commit eeb2251d22b3d6e0379444a73af69d1014692b07) --- source4/lib/registry/rpc.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c index c694223909..ac0eecd0ac 100644 --- a/source4/lib/registry/rpc.c +++ b/source4/lib/registry/rpc.c @@ -375,6 +375,7 @@ static struct registry_operations reg_backend_rpc = { _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, struct auth_session_info *session_info, struct cli_credentials *credentials, + struct loadparm_context *lp_ctx, const char *location, struct event_context *ev) { NTSTATUS status; @@ -393,7 +394,7 @@ _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, status = dcerpc_pipe_connect(*ctx /* TALLOC_CTX */, &p, location, &ndr_table_winreg, - credentials, ev); + credentials, ev, lp_ctx); rctx->pipe = p; if(NT_STATUS_IS_ERR(status)) { -- cgit From 45015eda2421253f858f0a4500a57c2855f9686c Mon Sep 17 00:00:00 2001 From: Kai Blin Date: Fri, 14 Dec 2007 10:38:26 +0100 Subject: r26451: Janitorial: fix warnings in lib/registry/ This does not fix the discarded qualifier warnings in tests, as the test data is currently passed as const. Jelmer wants to provide a test function that passes non-const test data, thus allowing for a cleaner way to fix those warnings. (This used to be commit 46dfa63d4f7381c5c6ce3f4b8b0bd9aa9e16950c) --- source4/lib/registry/rpc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c index ac0eecd0ac..7f800b786e 100644 --- a/source4/lib/registry/rpc.c +++ b/source4/lib/registry/rpc.c @@ -91,7 +91,7 @@ static struct { static WERROR rpc_query_key(const struct registry_key *k); -static WERROR rpc_get_predefined_key(const struct registry_context *ctx, +static WERROR rpc_get_predefined_key(struct registry_context *ctx, uint32_t hkey_type, struct registry_key **k) { -- cgit From 7f8276b06d5000d12c0d64167853a033b924af32 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 7 Jan 2008 14:11:25 -0600 Subject: r26688: Fix listing remote predefined keys and subkeys. This fixes bug 3431. (This used to be commit 846876ad32dc86fe7c367db084e76c670c61b389) --- source4/lib/registry/rpc.c | 89 ++++++++++++++++++++++++++++++---------------- 1 file changed, 59 insertions(+), 30 deletions(-) (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c index 7f800b786e..2a6cabc3b8 100644 --- a/source4/lib/registry/rpc.c +++ b/source4/lib/registry/rpc.c @@ -96,9 +96,10 @@ static WERROR rpc_get_predefined_key(struct registry_context *ctx, struct registry_key **k) { int n; - struct rpc_registry_context *rctx = talloc_get_type(ctx, - struct rpc_registry_context); struct rpc_key *mykeydata; + struct rpc_registry_context *rctx = talloc_get_type(ctx, struct rpc_registry_context); + + *k = NULL; for(n = 0; known_hives[n].hkey; n++) { if(known_hives[n].hkey == hkey_type) @@ -110,11 +111,13 @@ static WERROR rpc_get_predefined_key(struct registry_context *ctx, return WERR_NO_MORE_ITEMS; } - mykeydata = talloc(ctx, struct rpc_key); - mykeydata->pipe = rctx->pipe; + mykeydata = talloc_zero(ctx, struct rpc_key); + mykeydata->key.context = ctx; + mykeydata->pipe = talloc_reference(mykeydata, rctx->pipe); mykeydata->num_values = -1; mykeydata->num_subkeys = -1; - return known_hives[n].open(mykeydata->pipe, *k, &(mykeydata->pol)); + *k = (struct registry_key *)mykeydata; + return known_hives[n].open(mykeydata->pipe, mykeydata, &(mykeydata->pol)); } #if 0 @@ -146,21 +149,32 @@ static WERROR rpc_key_put_rpc_data(TALLOC_CTX *mem_ctx, struct registry_key *k) static WERROR rpc_open_key(TALLOC_CTX *mem_ctx, struct registry_key *h, const char *name, struct registry_key **key) { - struct rpc_key *mykeydata = talloc_get_type(h, struct rpc_key), - *newkeydata; + struct rpc_key *parentkeydata = talloc_get_type(h, struct rpc_key), + *mykeydata; struct winreg_OpenKey r; + NTSTATUS status; mykeydata = talloc(mem_ctx, struct rpc_key); + mykeydata->key.context = parentkeydata->key.context; + mykeydata->pipe = talloc_reference(mykeydata, parentkeydata->pipe); + mykeydata->num_values = -1; + mykeydata->num_subkeys = -1; + *key = (struct registry_key *)mykeydata; + /* Then, open the handle using the hive */ - memset(&r, 0, sizeof(struct winreg_OpenKey)); - r.in.parent_handle = &mykeydata->pol; + ZERO_STRUCT(r); + r.in.parent_handle = &parentkeydata->pol; init_winreg_String(&r.in.keyname, name); r.in.unknown = 0x00000000; r.in.access_mask = 0x02000000; - r.out.handle = &newkeydata->pol; + r.out.handle = &mykeydata->pol; - dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r); + status = dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + DEBUG(0,("Error executing openkey: %s\n", nt_errstr(status))); + return ntstatus_to_werror(status); + } return r.out.result; } @@ -175,29 +189,29 @@ static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key); WERROR error; struct winreg_EnumValue r; - uint32_t len1, zero = 0; + uint32_t in_type = 0; NTSTATUS status; struct winreg_StringBuf name; - uint8_t u8; + uint32_t zero = 0; + + ZERO_STRUCT(r); if (mykeydata->num_values == -1) { error = rpc_query_key(parent); if(!W_ERROR_IS_OK(error)) return error; } - len1 = mykeydata->max_valdatalen; - name.length = 0; - name.size = mykeydata->max_valnamelen * 2; - name.name = ""; + name.size = mykeydata->max_valnamelen * 2+1; + name.name = NULL; r.in.handle = &mykeydata->pol; r.in.enum_index = n; r.in.name = &name; - r.in.type = type; - r.in.value = &u8; + r.in.type = &in_type; + r.in.value = talloc_zero_array(mem_ctx, uint8_t, 0); r.in.length = &zero; - r.in.size = &len1; + r.in.size = &mykeydata->max_valdatalen; r.out.name = &name; status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r); @@ -229,6 +243,8 @@ static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, struct winreg_StringBuf namebuf, classbuf; NTTIME change_time = 0; + ZERO_STRUCT(r); + namebuf.length = 0; namebuf.size = 1024; namebuf.name = NULL; @@ -241,13 +257,14 @@ static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx, r.in.name = &namebuf; r.in.keyclass = &classbuf; r.in.last_changed_time = &change_time; + r.out.name = &namebuf; status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r); if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) { *name = talloc_strdup(mem_ctx, r.out.name->name); - *keyclass = talloc_strdup(mem_ctx, r.out.keyclass->name); - *last_changed_time = *r.out.last_changed_time; + if (keyclass != NULL) + *keyclass = talloc_strdup(mem_ctx, r.out.keyclass->name); } return r.out.result; @@ -295,8 +312,23 @@ static WERROR rpc_query_key(const struct registry_key *k) struct winreg_QueryInfoKey r; struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key); TALLOC_CTX *mem_ctx = talloc_init("query_key"); + uint32_t max_subkeysize; + uint32_t num_values; + uint32_t secdescsize; + NTTIME last_changed_time; + + ZERO_STRUCT(r.out); - r.in.classname = talloc(mem_ctx, struct winreg_String); + r.out.num_subkeys = &mykeydata->num_subkeys; + r.out.max_subkeylen = &mykeydata->num_values; + r.out.max_valnamelen = &mykeydata->max_valnamelen; + r.out.max_valbufsize = &mykeydata->max_valdatalen; + r.out.max_subkeysize = &max_subkeysize; + r.out.num_values = &num_values; + r.out.secdescsize = &secdescsize; + r.out.last_changed_time = &last_changed_time; + + r.out.classname = r.in.classname = talloc_zero(mem_ctx, struct winreg_String); init_winreg_String(r.in.classname, NULL); r.in.handle = &mykeydata->pol; @@ -309,10 +341,6 @@ static WERROR rpc_query_key(const struct registry_key *k) } if (W_ERROR_IS_OK(r.out.result)) { - mykeydata->num_subkeys = *r.out.num_subkeys; - mykeydata->num_values = *r.out.num_values; - mykeydata->max_valnamelen = *r.out.max_valnamelen; - mykeydata->max_valdatalen = *r.out.max_valbufsize; } return r.out.result; @@ -364,6 +392,7 @@ static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, static struct registry_operations reg_backend_rpc = { .name = "rpc", .open_key = rpc_open_key, + .get_predefined_key = rpc_get_predefined_key, .enum_key = rpc_get_subkey_by_index, .enum_value = rpc_get_value_by_index, .create_key = rpc_add_key, @@ -388,10 +417,10 @@ _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, /* Default to local smbd if no connection is specified */ if (!location) { - location = talloc_strdup(ctx, "ncalrpc:"); + location = talloc_strdup(rctx, "ncalrpc:"); } - status = dcerpc_pipe_connect(*ctx /* TALLOC_CTX */, + status = dcerpc_pipe_connect(rctx /* TALLOC_CTX */, &p, location, &ndr_table_winreg, credentials, ev, lp_ctx); @@ -400,7 +429,7 @@ _PUBLIC_ WERROR reg_open_remote(struct registry_context **ctx, if(NT_STATUS_IS_ERR(status)) { DEBUG(1, ("Unable to open '%s': %s\n", location, nt_errstr(status))); - talloc_free(*ctx); + talloc_free(rctx); *ctx = NULL; return ntstatus_to_werror(status); } -- cgit From 47f6bbf8cf5bdd03c72c59d00e3e1eab8895590e Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Mon, 7 Jan 2008 14:11:29 -0600 Subject: r26689: registry: Return max_subkeynamelen, max_valnamelen and max_valbufsize in getkeyinfo(). (This used to be commit b06896d2378e536f5044dbe500a5232a89d6d0b5) --- source4/lib/registry/rpc.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) (limited to 'source4/lib/registry/rpc.c') diff --git a/source4/lib/registry/rpc.c b/source4/lib/registry/rpc.c index 2a6cabc3b8..18b7607713 100644 --- a/source4/lib/registry/rpc.c +++ b/source4/lib/registry/rpc.c @@ -29,6 +29,7 @@ struct rpc_key { uint32_t num_subkeys; uint32_t max_valnamelen; uint32_t max_valdatalen; + uint32_t max_subkeynamelen; }; struct rpc_registry_context { @@ -202,7 +203,7 @@ static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, } name.length = 0; - name.size = mykeydata->max_valnamelen * 2+1; + name.size = mykeydata->max_valnamelen * 2; name.name = NULL; r.in.handle = &mykeydata->pol; @@ -213,6 +214,7 @@ static WERROR rpc_get_value_by_index(TALLOC_CTX *mem_ctx, r.in.length = &zero; r.in.size = &mykeydata->max_valdatalen; r.out.name = &name; + r.out.type = type; status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r); if(NT_STATUS_IS_ERR(status)) { @@ -313,18 +315,17 @@ static WERROR rpc_query_key(const struct registry_key *k) struct rpc_key *mykeydata = talloc_get_type(k, struct rpc_key); TALLOC_CTX *mem_ctx = talloc_init("query_key"); uint32_t max_subkeysize; - uint32_t num_values; uint32_t secdescsize; NTTIME last_changed_time; ZERO_STRUCT(r.out); r.out.num_subkeys = &mykeydata->num_subkeys; - r.out.max_subkeylen = &mykeydata->num_values; + r.out.max_subkeylen = &mykeydata->max_subkeynamelen; r.out.max_valnamelen = &mykeydata->max_valnamelen; r.out.max_valbufsize = &mykeydata->max_valdatalen; r.out.max_subkeysize = &max_subkeysize; - r.out.num_values = &num_values; + r.out.num_values = &mykeydata->num_values; r.out.secdescsize = &secdescsize; r.out.last_changed_time = &last_changed_time; @@ -367,7 +368,10 @@ static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, const char **classname, uint32_t *numsubkeys, uint32_t *numvalue, - NTTIME *last_changed_time) + NTTIME *last_changed_time, + uint32_t *max_subkeynamelen, + uint32_t *max_valnamelen, + uint32_t *max_valbufsize) { struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key); WERROR error; @@ -386,6 +390,15 @@ static WERROR rpc_get_info(TALLOC_CTX *mem_ctx, const struct registry_key *key, if (numsubkeys != NULL) *numsubkeys = mykeydata->num_subkeys; + if (max_valnamelen != NULL) + *max_valnamelen = mykeydata->max_valnamelen; + + if (max_valbufsize != NULL) + *max_valbufsize = mykeydata->max_valdatalen; + + if (max_subkeynamelen != NULL) + *max_subkeynamelen = mykeydata->max_subkeynamelen; + return WERR_OK; } -- cgit