Samba Unix/Linux SMB implementation
RPC backend for the registry library
Copyright (C) 2003-2007 Jelmer Vernooij, jelmer@samba.org
+ Copyright (C) 2008 Matthias Dieter Wallnöfer, mwallnoefer@yahoo.de
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
#include "includes.h"
#include "registry.h"
#include "librpc/gen_ndr/ndr_winreg_c.h"
-#include "param/param.h"
+
+#define MAX_NAMESIZE 512
+#define MAX_VALSIZE 32768
struct rpc_key {
struct registry_key key;
struct policy_handle pol;
- struct dcerpc_pipe *pipe;
-
- uint32_t num_values;
+ struct dcerpc_binding_handle *binding_handle;
+ const char* classname;
uint32_t num_subkeys;
+ uint32_t max_subkeylen;
+ uint32_t max_classlen;
+ uint32_t num_values;
uint32_t max_valnamelen;
- uint32_t max_valdatalen;
- uint32_t max_subkeynamelen;
+ uint32_t max_valbufsize;
+ uint32_t secdescsize;
+ NTTIME last_changed_time;
};
struct rpc_registry_context {
struct registry_context context;
struct dcerpc_pipe *pipe;
+ struct dcerpc_binding_handle *binding_handle;
};
static struct registry_operations reg_backend_rpc;
* This is the RPC backend for the registry library.
*/
-/*
- * Converts a SAMBA (UNIX) string into a WINREG (UTF16) string
- */
-static void chars_to_winreg_String(TALLOC_CTX *mem_ctx, struct winreg_String
- *winregStr, const char *str)
-{
- winregStr->name = NULL;
- winregStr->name_len = 0;
- if (str != NULL)
- winregStr->name_len = convert_string_talloc(mem_ctx,
- lp_iconv_convenience(global_loadparm), CH_UNIX,
- CH_UTF16, (void *) str, strlen(str),
- (void **) &winregStr->name);
- winregStr->name_size = winregStr->name_len;
-}
-
-/*
- * Converts a WINREG (UTF16) string into a SAMBA (UNIX) string
- */
-static void winreg_String_to_chars(TALLOC_CTX *mem_ctx, const char **str,
- struct winreg_String *winregStr)
-{
- *str = NULL;
- if (winregStr->name != NULL)
- convert_string_talloc(mem_ctx,
- lp_iconv_convenience(global_loadparm), CH_UTF16,
- CH_UNIX, (void *) winregStr->name, winregStr->name_len,
- (void **) str);
-}
-
-/*
- * Converts a SAMBA (UNIX) string into a WINREG (UTF16) string buffer
- */
-static void chars_to_winreg_StringBuf(TALLOC_CTX *mem_ctx, struct winreg_StringBuf
- *winregStrBuf, const char *str, uint16_t size)
-{
- winregStrBuf->name = NULL;
- winregStrBuf->length = 0;
- if (str != NULL)
- winregStrBuf->length = convert_string_talloc(mem_ctx,
- lp_iconv_convenience(global_loadparm), CH_UNIX,
- CH_UTF16, (void *) str, strlen(str),
- (void **) &winregStrBuf->name);
- winregStrBuf->size = size;
-}
-
-/*
- * Converts a WINREG (UTF16) string buffer into a SAMBA (UNIX) string
- */
-static void winreg_StringBuf_to_chars(TALLOC_CTX *mem_ctx, const char **str,
- struct winreg_StringBuf *winregStrBuf)
-{
- *str = NULL;
- if (winregStrBuf->name != NULL)
- convert_string_talloc(mem_ctx,
- lp_iconv_convenience(global_loadparm), CH_UTF16,
- CH_UNIX, (void *) winregStrBuf->name,
- winregStrBuf->length, (void **) str);
-}
-
-#define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
+#define openhive(u) static WERROR open_ ## u(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
{ \
struct winreg_Open ## u r; \
NTSTATUS status; \
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED; \
r.out.handle = hnd;\
\
- status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
+ status = dcerpc_winreg_Open ## u ## _r(b, mem_ctx, &r); \
\
if (!NT_STATUS_IS_OK(status)) { \
DEBUG(1, ("OpenHive failed - %s\n", nt_errstr(status))); \
static struct {
uint32_t hkey;
- WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *,
+ WERROR (*open) (struct dcerpc_binding_handle *b, TALLOC_CTX *,
struct policy_handle *h);
} known_hives[] = {
{ HKEY_LOCAL_MACHINE, open_HKLM },
{ 0, NULL }
};
-static WERROR rpc_query_key(const struct registry_key *k);
+static WERROR rpc_query_key(TALLOC_CTX *mem_ctx, const struct registry_key *k);
static WERROR rpc_get_predefined_key(struct registry_context *ctx,
uint32_t hkey_type,
}
mykeydata = talloc_zero(ctx, struct rpc_key);
+ W_ERROR_HAVE_NO_MEMORY(mykeydata);
mykeydata->key.context = ctx;
- mykeydata->pipe = talloc_reference(mykeydata, rctx->pipe);
+ mykeydata->binding_handle = rctx->binding_handle;
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
*k = (struct registry_key *)mykeydata;
- return known_hives[n].open(mykeydata->pipe, mykeydata, &(mykeydata->pol));
+ return known_hives[n].open(mykeydata->binding_handle, mykeydata, &mykeydata->pol);
}
#if 0
struct winreg_OpenKey r;
struct rpc_key_data *mykeydata;
- k->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data);
+ k->backend_data = mykeydata = talloc_zero(mem_ctx, struct rpc_key_data);
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
ZERO_STRUCT(r);
r.in.handle = &(((struct rpc_key_data *)k->hive->root->backend_data)->pol);
- chars_to_winreg_String(mem_ctx, &r.in.keyname, k->path);
+ r.in.keyname.name = k->path;
r.in.unknown = 0x00000000;
r.in.access_mask = 0x02000000;
r.out.handle = &mykeydata->pol;
struct winreg_OpenKey r;
NTSTATUS status;
- mykeydata = talloc(mem_ctx, struct rpc_key);
-
+ mykeydata = talloc_zero(mem_ctx, struct rpc_key);
+ W_ERROR_HAVE_NO_MEMORY(mykeydata);
mykeydata->key.context = parentkeydata->key.context;
- mykeydata->pipe = talloc_reference(mykeydata, parentkeydata->pipe);
+ mykeydata->binding_handle = parentkeydata->binding_handle;
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
*key = (struct registry_key *)mykeydata;
/* Then, open the handle using the hive */
ZERO_STRUCT(r);
r.in.parent_handle = &parentkeydata->pol;
- chars_to_winreg_String(mem_ctx, &r.in.keyname, name);
- r.in.unknown = 0x00000000;
+ r.in.keyname.name = name;
+ r.in.options = 0x00000000;
r.in.access_mask = 0x02000000;
r.out.handle = &mykeydata->pol;
- status = dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r);
+ status = dcerpc_winreg_OpenKey_r(mykeydata->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("OpenKey failed - %s\n", nt_errstr(status)));
{
struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
struct winreg_EnumValue r;
- struct winreg_StringBuf name;
+ struct winreg_ValNameBuf name;
uint8_t value;
- uint32_t zero = 0, zero2 = 0;
+ uint32_t val_size = MAX_VALSIZE;
+ uint32_t zero = 0;
WERROR error;
NTSTATUS status;
if (mykeydata->num_values == -1) {
- error = rpc_query_key(parent);
+ error = rpc_query_key(mem_ctx, parent);
if(!W_ERROR_IS_OK(error)) return error;
}
- chars_to_winreg_StringBuf(mem_ctx, &name, "", 1024);
+ name.name = "";
+ name.size = MAX_NAMESIZE;
ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
r.in.enum_index = n;
r.in.name = &name;
- r.in.type = type;
+ r.in.type = (enum winreg_Type *) type;
r.in.value = &value;
- r.in.size = &mykeydata->max_valdatalen;
+ r.in.size = &val_size;
r.in.length = &zero;
r.out.name = &name;
- r.out.type = type;
+ r.out.type = (enum winreg_Type *) type;
r.out.value = &value;
- r.out.size = &zero2;
+ r.out.size = &val_size;
r.out.length = &zero;
- status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r);
+ status = dcerpc_winreg_EnumValue_r(mykeydata->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("EnumValue failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
- winreg_StringBuf_to_chars(mem_ctx, value_name, r.out.name);
+ *value_name = talloc_steal(mem_ctx, r.out.name->name);
*type = *(r.out.type);
*data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length);
return r.out.result;
}
+static WERROR rpc_get_value_by_name(TALLOC_CTX *mem_ctx,
+ const struct registry_key *parent,
+ const char *value_name,
+ uint32_t *type,
+ DATA_BLOB *data)
+{
+ struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
+ struct winreg_QueryValue r;
+ struct winreg_String name;
+ uint8_t value;
+ uint32_t val_size = MAX_VALSIZE;
+ uint32_t zero = 0;
+ WERROR error;
+ NTSTATUS status;
+
+ if (mykeydata->num_values == -1) {
+ error = rpc_query_key(mem_ctx, parent);
+ if(!W_ERROR_IS_OK(error)) return error;
+ }
+
+ name.name = value_name;
+
+ ZERO_STRUCT(r);
+ r.in.handle = &mykeydata->pol;
+ r.in.value_name = &name;
+ r.in.type = (enum winreg_Type *) type;
+ r.in.data = &value;
+ r.in.data_size = &val_size;
+ r.in.data_length = &zero;
+ r.out.type = (enum winreg_Type *) type;
+ r.out.data = &value;
+ r.out.data_size = &val_size;
+ r.out.data_length = &zero;
+
+ status = dcerpc_winreg_QueryValue_r(mykeydata->binding_handle, mem_ctx, &r);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("QueryValue failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
+ }
+
+ *type = *(r.out.type);
+ *data = data_blob_talloc(mem_ctx, r.out.data, *r.out.data_length);
+
+ return r.out.result;
+}
+
+static WERROR rpc_set_value(struct registry_key *key, const char *value_name,
+ uint32_t type, const DATA_BLOB data)
+{
+ struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key);
+ struct winreg_SetValue r;
+ struct winreg_String name;
+ NTSTATUS status;
+
+ name = (struct winreg_String) { .name = value_name };
+
+ ZERO_STRUCT(r);
+ r.in.handle = &mykeydata->pol;
+ r.in.name = name;
+ r.in.type = (enum winreg_Type)type;
+ r.in.data = data.data;
+ r.in.size = data.length;
+
+ status = dcerpc_winreg_SetValue_r(mykeydata->binding_handle, key, &r);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("SetValue failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
+ }
+
+ return r.out.result;
+}
+
+static WERROR rpc_del_value(TALLOC_CTX *mem_ctx, struct registry_key *key,
+ const char *value_name)
+{
+ struct rpc_key *mykeydata = talloc_get_type(key, struct rpc_key);
+ struct winreg_DeleteValue r;
+ struct winreg_String name;
+ NTSTATUS status;
+
+ name.name = value_name;
+
+ ZERO_STRUCT(r);
+ r.in.handle = &mykeydata->pol;
+ r.in.value = name;
+
+ status = dcerpc_winreg_DeleteValue_r(mykeydata->binding_handle,
+ mem_ctx, &r);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("DeleteValue failed - %s\n", nt_errstr(status)));
+ return ntstatus_to_werror(status);
+ }
+
+ return r.out.result;
+}
+
static WERROR rpc_get_subkey_by_index(TALLOC_CTX *mem_ctx,
const struct registry_key *parent,
uint32_t n,
NTTIME change_time = 0;
NTSTATUS status;
- chars_to_winreg_StringBuf(mem_ctx, &namebuf, "", 1024);
- chars_to_winreg_StringBuf(mem_ctx, &classbuf, NULL, 0);
+ namebuf.name = "";
+ namebuf.size = MAX_NAMESIZE;
+ classbuf.name = NULL;
+ classbuf.size = 0;
ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
r.out.keyclass = &classbuf;
r.out.last_changed_time = &change_time;
- status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r);
+ status = dcerpc_winreg_EnumKey_r(mykeydata->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("EnumKey failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
- winreg_StringBuf_to_chars(mem_ctx, name, r.out.name);
- winreg_StringBuf_to_chars(mem_ctx, keyclass, r.out.keyclass);
+ if (name != NULL)
+ *name = talloc_steal(mem_ctx, r.out.name->name);
+ if (keyclass != NULL)
+ *keyclass = talloc_steal(mem_ctx, r.out.keyclass->name);
+ if (last_changed_time != NULL)
+ *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,
+ struct registry_key *parent, const char *path,
const char *key_class,
struct security_descriptor *sec,
struct registry_key **key)
{
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);
+ struct rpc_key *rpck = talloc_zero(mem_ctx, struct rpc_key);
NTSTATUS status;
+ if (rpck == NULL) {
+ return WERR_NOT_ENOUGH_MEMORY;
+ }
+
+ rpck->key.context = parentkd->key.context;
+ rpck->binding_handle = parentkd->binding_handle;
+ rpck->num_values = -1;
+ rpck->num_subkeys = -1;
+
ZERO_STRUCT(r);
r.in.handle = &parentkd->pol;
- chars_to_winreg_String(mem_ctx, &r.in.name, name);
- chars_to_winreg_String(mem_ctx, &r.in.keyclass, NULL);
+ r.in.name.name = path;
+ r.in.keyclass.name = NULL;
r.in.options = 0;
- r.in.access_mask = SEC_STD_ALL;
+ r.in.access_mask = 0x02000000;
r.in.secdesc = NULL;
r.in.action_taken = NULL;
r.out.new_handle = &rpck->pol;
r.out.action_taken = NULL;
- status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r);
+ status = dcerpc_winreg_CreateKey_r(parentkd->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(rpck);
return ntstatus_to_werror(status);
}
- rpck->pipe = talloc_reference(rpck, parentkd->pipe);
+ rpck->binding_handle = parentkd->binding_handle;
*key = (struct registry_key *)rpck;
return r.out.result;
}
-static WERROR rpc_query_key(const struct registry_key *k)
+static WERROR rpc_query_key(TALLOC_CTX *mem_ctx, 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 secdescsize;
- NTTIME last_changed_time;
+ struct winreg_String classname;
NTSTATUS status;
+ classname.name = NULL;
+
ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
- chars_to_winreg_String(mem_ctx, r.in.classname, NULL);
+ r.in.classname = &classname;
+ r.out.classname = &classname;
r.out.num_subkeys = &mykeydata->num_subkeys;
- 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.max_subkeylen = &mykeydata->max_subkeylen;
+ r.out.max_classlen = &mykeydata->max_classlen;
r.out.num_values = &mykeydata->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);
-
- status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r);
+ r.out.max_valnamelen = &mykeydata->max_valnamelen;
+ r.out.max_valbufsize = &mykeydata->max_valbufsize;
+ r.out.secdescsize = &mykeydata->secdescsize;
+ r.out.last_changed_time = &mykeydata->last_changed_time;
- talloc_free(mem_ctx);
+ status = dcerpc_winreg_QueryInfoKey_r(mykeydata->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status)));
return ntstatus_to_werror(status);
}
+ mykeydata->classname = talloc_steal(mem_ctx, r.out.classname->name);
+
return r.out.result;
}
-static WERROR rpc_del_key(struct registry_key *parent, const char *name)
+static WERROR rpc_del_key(TALLOC_CTX *mem_ctx, 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");
ZERO_STRUCT(r);
r.in.handle = &mykeydata->pol;
- chars_to_winreg_String(mem_ctx, &r.in.key, name);
+ r.in.key.name = name;
- status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r);
-
- talloc_free(mem_ctx);
+ status = dcerpc_winreg_DeleteKey_r(mykeydata->binding_handle, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("DeleteKey failed - %s\n", nt_errstr(status)));
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 *num_subkeys,
+ uint32_t *num_values,
NTTIME *last_changed_time,
- uint32_t *max_subkeynamelen,
+ uint32_t *max_subkeylen,
uint32_t *max_valnamelen,
uint32_t *max_valbufsize)
{
WERROR error;
if (mykeydata->num_values == -1) {
- error = rpc_query_key(key);
+ error = rpc_query_key(mem_ctx, 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 */
+ if (classname != NULL)
+ *classname = mykeydata->classname;
+
+ if (num_subkeys != NULL)
+ *num_subkeys = mykeydata->num_subkeys;
+
+ if (num_values != NULL)
+ *num_values = mykeydata->num_values;
- if (numvalue != NULL)
- *numvalue = mykeydata->num_values;
+ if (last_changed_time != NULL)
+ *last_changed_time = mykeydata->last_changed_time;
- if (numsubkeys != NULL)
- *numsubkeys = mykeydata->num_subkeys;
+ if (max_subkeylen != NULL)
+ *max_subkeylen = mykeydata->max_subkeylen;
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;
+ *max_valbufsize = mykeydata->max_valbufsize;
return WERR_OK;
}
.get_predefined_key = rpc_get_predefined_key,
.enum_key = rpc_get_subkey_by_index,
.enum_value = rpc_get_value_by_index,
+ .get_value = rpc_get_value_by_name,
+ .set_value = rpc_set_value,
+ .delete_value = rpc_del_value,
.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,
+_PUBLIC_ WERROR reg_open_remote(TALLOC_CTX *mem_ctx,
+ 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)
+ const char *location, struct tevent_context *ev)
{
NTSTATUS status;
struct dcerpc_pipe *p;
dcerpc_init();
- rctx = talloc(NULL, struct rpc_registry_context);
+ rctx = talloc(mem_ctx, struct rpc_registry_context);
+ W_ERROR_HAVE_NO_MEMORY(rctx);
/* Default to local smbd if no connection is specified */
if (!location) {
status = dcerpc_pipe_connect(rctx /* TALLOC_CTX */,
&p, location,
- &ndr_table_winreg,
+ &ndr_table_winreg,
credentials, ev, lp_ctx);
- rctx->pipe = p;
-
if(NT_STATUS_IS_ERR(status)) {
DEBUG(1, ("Unable to open '%s': %s\n", location,
nt_errstr(status)));
return ntstatus_to_werror(status);
}
+ rctx->pipe = p;
+ rctx->binding_handle = p->binding_handle;
+
*ctx = (struct registry_context *)rctx;
(*ctx)->ops = ®_backend_rpc;
git.samba.org / metze / samba / wip.git / blobdiff