-/*
+/*
Unix SMB/CIFS implementation.
Registry interface
- Copyright (C) Jelmer Vernooij 2004-2007.
-
+ Copyright (C) Jelmer Vernooij 2004-2007.
+
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 <http://www.gnu.org/licenses/>.
*/
static struct hive_operations reg_backend_dir;
-static WERROR reg_dir_add_key(TALLOC_CTX *mem_ctx,
- const struct hive_key *parent,
- const char *name, const char *classname,
- struct security_descriptor *desc,
- struct hive_key **result)
+static WERROR reg_dir_add_key(TALLOC_CTX *mem_ctx,
+ const struct hive_key *parent,
+ const char *name, const char *classname,
+ struct security_descriptor *desc,
+ struct hive_key **result)
{
struct dir_key *dk = talloc_get_type(parent, struct dir_key);
char *path;
char *child = talloc_asprintf(NULL, "%s/%s", dk->path, name);
WERROR ret;
- if (rmdir(child) == 0)
- ret = WERR_OK;
+ if (rmdir(child) == 0)
+ ret = WERR_OK;
else if (errno == ENOENT)
ret = WERR_NOT_FOUND;
else
return ret;
}
-static WERROR reg_dir_open_key(TALLOC_CTX *mem_ctx,
- const struct hive_key *parent,
- const char *name, struct hive_key **subkey)
+static WERROR reg_dir_open_key(TALLOC_CTX *mem_ctx,
+ const struct hive_key *parent,
+ const char *name, struct hive_key **subkey)
{
DIR *d;
char *fullpath;
const struct dir_key *p = talloc_get_type(parent, struct dir_key);
struct dir_key *ret;
-
+
if (name == NULL) {
DEBUG(0, ("NULL pointer passed as directory name!"));
return WERR_INVALID_PARAM;
}
-
+
fullpath = talloc_asprintf(mem_ctx, "%s/%s", p->path, name);
-
+
d = opendir(fullpath);
if (d == NULL) {
- DEBUG(3,("Unable to open '%s': %s\n", fullpath, strerror(errno)));
+ DEBUG(3,("Unable to open '%s': %s\n", fullpath,
+ strerror(errno)));
return WERR_BADFILE;
}
closedir(d);
return WERR_OK;
}
-static WERROR reg_dir_key_by_index(TALLOC_CTX *mem_ctx,
- const struct hive_key *k, uint32_t idx,
- const char **name,
- const char **classname,
- NTTIME *last_mod_time)
+static WERROR reg_dir_key_by_index(TALLOC_CTX *mem_ctx,
+ const struct hive_key *k, uint32_t idx,
+ const char **name,
+ const char **classname,
+ NTTIME *last_mod_time)
{
struct dirent *e;
const struct dir_key *dk = talloc_get_type(k, struct dir_key);
d = opendir(dk->path);
- if (d == NULL)
+ if (d == NULL)
return WERR_INVALID_PARAM;
-
+
while((e = readdir(d))) {
if(!ISDOT(e->d_name) && !ISDOTDOT(e->d_name)) {
struct stat stbuf;
char *thispath;
-
+
/* Check if file is a directory */
asprintf(&thispath, "%s/%s", dk->path, e->d_name);
stat(thispath, &stbuf);
return WERR_NO_MORE_ITEMS;
}
-WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
- const char *location, struct hive_key **key)
+WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
+ const char *location, struct hive_key **key)
{
struct dir_key *dk;
- if (location == NULL)
+ if (location == NULL)
return WERR_INVALID_PARAM;
dk = talloc(parent_ctx, struct dir_key);
return WERR_OK;
}
-WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
- const char *location, struct hive_key **key)
+WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
+ const char *location, struct hive_key **key)
{
if (mkdir(location, 0700) != 0) {
*key = NULL;
return reg_open_directory(parent_ctx, location, key);
}
-static WERROR reg_dir_get_info(TALLOC_CTX *ctx, const struct hive_key *key,
- const char **classname,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *lastmod)
+static WERROR reg_dir_get_info(TALLOC_CTX *ctx, const struct hive_key *key,
+ const char **classname,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *lastmod)
{
DIR *d;
const struct dir_key *dk = talloc_get_type(key, struct dir_key);
*classname = NULL;
d = opendir(dk->path);
- if (d == NULL)
+ if (d == NULL)
return WERR_INVALID_PARAM;
if (num_subkeys != NULL)
while((e = readdir(d))) {
if(!ISDOT(e->d_name) && !ISDOTDOT(e->d_name)) {
- char *path = talloc_asprintf(ctx, "%s/%s", dk->path, e->d_name);
+ char *path = talloc_asprintf(ctx, "%s/%s",
+ dk->path, e->d_name);
if (stat(path, &st) < 0) {
- DEBUG(0, ("Error statting %s: %s\n", path, strerror(errno)));
+ DEBUG(0, ("Error statting %s: %s\n", path,
+ strerror(errno)));
continue;
}
return WERR_OK;
}
-static WERROR reg_dir_set_value (struct hive_key *key, const char *name,
- uint32_t type, const DATA_BLOB data)
+static WERROR reg_dir_set_value(struct hive_key *key, const char *name,
+ uint32_t type, const DATA_BLOB data)
{
const struct dir_key *dk = talloc_get_type(key, struct dir_key);
char *path = talloc_asprintf(dk, "%s/%s", dk->path, name);
return WERR_OK;
}
-static WERROR reg_dir_get_value (TALLOC_CTX *mem_ctx,
- struct hive_key *key, const char *name,
- uint32_t *type, DATA_BLOB *data)
+static WERROR reg_dir_get_value(TALLOC_CTX *mem_ctx,
+ struct hive_key *key, const char *name,
+ uint32_t *type, DATA_BLOB *data)
{
const struct dir_key *dk = talloc_get_type(key, struct dir_key);
char *path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
contents = file_load(path, &size, mem_ctx);
talloc_free(path);
- if (contents == NULL)
+ if (contents == NULL)
return WERR_NOT_FOUND;
if (type != NULL)
return WERR_OK;
}
-
-static WERROR reg_dir_enum_value (TALLOC_CTX *mem_ctx,
- const struct hive_key *key, int idx,
- const char **name,
- uint32_t *type, DATA_BLOB *data)
+
+static WERROR reg_dir_enum_value(TALLOC_CTX *mem_ctx,
+ const struct hive_key *key, int idx,
+ const char **name,
+ uint32_t *type, DATA_BLOB *data)
{
const struct dir_key *dk = talloc_get_type(key, struct dir_key);
DIR *d;
d = opendir(dk->path);
if (d == NULL) {
- DEBUG(3,("Unable to open '%s': %s\n", dk->path, strerror(errno)));
+ DEBUG(3,("Unable to open '%s': %s\n", dk->path,
+ strerror(errno)));
return WERR_BADFILE;
}
i = 0;
while((e = readdir(d))) {
- if (ISDOT(e->d_name) || ISDOTDOT(e->d_name))
+ if (ISDOT(e->d_name) || ISDOTDOT(e->d_name))
continue;
if (i == idx) {
if (name != NULL)
*name = talloc_strdup(mem_ctx, e->d_name);
- W_ERROR_NOT_OK_RETURN(reg_dir_get_value(mem_ctx, key, *name, type, data));
+ W_ERROR_NOT_OK_RETURN(reg_dir_get_value(mem_ctx, key,
+ *name, type,
+ data));
return WERR_OK;
}
return WERR_GENERAL_FAILURE;
}
talloc_free(path);
-
+
return WERR_OK;
}
-/*
+/*
Unix SMB/CIFS implementation.
Registry hive interface
- Copyright (C) Jelmer Vernooij 2003-2007.
-
+ Copyright (C) Jelmer Vernooij 2003-2007.
+
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 "system/filesys.h"
/** Open a registry file/host/etc */
-_PUBLIC_ WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials,
- struct hive_key **root)
+_PUBLIC_ WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials,
+ struct hive_key **root)
{
int fd, num;
char peek[20];
return reg_open_regf_file(parent_ctx, location, root);
} else if (!strncmp(peek, "TDB file", 8)) {
close(fd);
- return reg_open_ldb_file(parent_ctx, location, session_info, credentials, root);
+ return reg_open_ldb_file(parent_ctx, location, session_info,
+ credentials, root);
}
return WERR_BADFILE;
}
-_PUBLIC_ WERROR hive_key_get_info(TALLOC_CTX *mem_ctx, const struct hive_key *key,
- const char **classname, uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time)
+_PUBLIC_ WERROR hive_key_get_info(TALLOC_CTX *mem_ctx,
+ const struct hive_key *key,
+ const char **classname, uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time)
{
- return key->ops->get_key_info(mem_ctx, key, classname, num_subkeys,
- num_values, last_change_time);
+ return key->ops->get_key_info(mem_ctx, key, classname, num_subkeys,
+ num_values, last_change_time);
}
-_PUBLIC_ WERROR hive_key_add_name(TALLOC_CTX *ctx, const struct hive_key *parent_key,
- const char *name, const char *classname, struct security_descriptor *desc,
- struct hive_key **key)
+_PUBLIC_ WERROR hive_key_add_name(TALLOC_CTX *ctx,
+ const struct hive_key *parent_key,
+ const char *name, const char *classname,
+ struct security_descriptor *desc,
+ struct hive_key **key)
{
SMB_ASSERT(strchr(name, '\\') == NULL);
- return parent_key->ops->add_key(ctx, parent_key, name, classname, desc, key);
+ return parent_key->ops->add_key(ctx, parent_key, name, classname,
+ desc, key);
}
_PUBLIC_ WERROR hive_key_del(const struct hive_key *key, const char *name)
}
_PUBLIC_ WERROR hive_get_key_by_name(TALLOC_CTX *mem_ctx,
- const struct hive_key *key, const char *name,
- struct hive_key **subkey)
+ const struct hive_key *key,
+ const char *name,
+ struct hive_key **subkey)
{
return key->ops->get_key_by_name(mem_ctx, key, name, subkey);
}
WERROR hive_enum_key(TALLOC_CTX *mem_ctx,
- const struct hive_key *key, uint32_t idx,
- const char **name,
- const char **classname,
- NTTIME *last_mod_time)
+ const struct hive_key *key, uint32_t idx,
+ const char **name,
+ const char **classname,
+ NTTIME *last_mod_time)
{
- return key->ops->enum_key(mem_ctx, key, idx, name, classname,
- last_mod_time);
+ return key->ops->enum_key(mem_ctx, key, idx, name, classname,
+ last_mod_time);
}
WERROR hive_set_value(struct hive_key *key, const char *name, uint32_t type,
return key->ops->set_value(key, name, type, data);
}
-WERROR hive_get_value (TALLOC_CTX *mem_ctx,
- struct hive_key *key, const char *name,
- uint32_t *type, DATA_BLOB *data)
+WERROR hive_get_value(TALLOC_CTX *mem_ctx,
+ struct hive_key *key, const char *name,
+ uint32_t *type, DATA_BLOB *data)
{
if (key->ops->get_value_by_name == NULL)
return WERR_NOT_SUPPORTED;
return key->ops->get_value_by_name(mem_ctx, key, name, type, data);
}
-WERROR hive_get_value_by_index (TALLOC_CTX *mem_ctx,
- struct hive_key *key, uint32_t idx, const char **name,
- uint32_t *type, DATA_BLOB *data)
+WERROR hive_get_value_by_index(TALLOC_CTX *mem_ctx,
+ struct hive_key *key, uint32_t idx,
+ const char **name,
+ uint32_t *type, DATA_BLOB *data)
{
if (key->ops->enum_value == NULL)
return WERR_NOT_SUPPORTED;
}
-WERROR hive_del_value (struct hive_key *key, const char *name)
+WERROR hive_del_value(struct hive_key *key, const char *name)
{
if (key->ops->delete_value == NULL)
return WERR_NOT_SUPPORTED;
-/*
+/*
Unix SMB/CIFS implementation.
Registry hive interface
Copyright (C) Jelmer Vernooij 2003-2007.
-
+
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 "libcli/util/ntstatus.h"
/**
- * This file contains the hive API. This API is generally used for
- * reading a specific file that contains just one hive.
+ * This file contains the hive API. This API is generally used for
+ * reading a specific file that contains just one hive.
*
* Good examples are .DAT (NTUSER.DAT) files.
*
- * This API does not have any notification support (that
- * should be provided by the registry implementation), nor
+ * This API does not have any notification support (that
+ * should be provided by the registry implementation), nor
* does it understand what predefined keys are.
*/
};
struct hive_operations {
- const char *name;
+ const char *name;
/**
* Open a specific subkey
*/
WERROR (*enum_key) (TALLOC_CTX *mem_ctx,
- const struct hive_key *key, uint32_t idx,
- const char **name,
- const char **classname,
- NTTIME *last_mod_time);
+ const struct hive_key *key, uint32_t idx,
+ const char **name,
+ const char **classname,
+ NTTIME *last_mod_time);
/**
* Open a subkey by name
*/
WERROR (*get_key_by_name) (TALLOC_CTX *mem_ctx,
- const struct hive_key *key, const char *name,
- struct hive_key **subkey);
-
+ const struct hive_key *key, const char *name,
+ struct hive_key **subkey);
+
/**
* Add a new key.
*/
WERROR (*add_key) (TALLOC_CTX *ctx,
- const struct hive_key *parent_key, const char *name,
- const char *classname, struct security_descriptor *desc,
- struct hive_key **key);
+ const struct hive_key *parent_key, const char *name,
+ const char *classname,
+ struct security_descriptor *desc,
+ struct hive_key **key);
/**
* Remove an existing key.
*/
* Retrieve a registry value with a specific index.
*/
WERROR (*enum_value) (TALLOC_CTX *mem_ctx,
- const struct hive_key *key, int idx,
- const char **name, uint32_t *type,
- DATA_BLOB *data);
+ const struct hive_key *key, int idx,
+ const char **name, uint32_t *type,
+ DATA_BLOB *data);
/**
* Retrieve a registry value with the specified name
*/
- WERROR (*get_value_by_name) (TALLOC_CTX *mem_ctx,
- struct hive_key *key, const char *name,
- uint32_t *type, DATA_BLOB *data);
-
+ WERROR (*get_value_by_name) (TALLOC_CTX *mem_ctx,
+ struct hive_key *key, const char *name,
+ uint32_t *type, DATA_BLOB *data);
+
/**
* Set a value on the specified registry key.
*/
- WERROR (*set_value) (struct hive_key *key, const char *name,
- uint32_t type, const DATA_BLOB data);
+ WERROR (*set_value) (struct hive_key *key, const char *name,
+ uint32_t type, const DATA_BLOB data);
/**
* Remove a value.
/**
* Change the security descriptor on a registry key.
*
- * This should return WERR_NOT_SUPPORTED if the underlying
- * format does not have a mechanism for storing
+ * This should return WERR_NOT_SUPPORTED if the underlying
+ * format does not have a mechanism for storing
* security descriptors.
*/
- WERROR (*set_sec_desc) (struct hive_key *key,
- const struct security_descriptor *desc);
+ WERROR (*set_sec_desc) (struct hive_key *key,
+ const struct security_descriptor *desc);
/**
* Retrieve the security descriptor on a registry key.
*
- * This should return WERR_NOT_SUPPORTED if the underlying
- * format does not have a mechanism for storing
+ * This should return WERR_NOT_SUPPORTED if the underlying
+ * format does not have a mechanism for storing
* security descriptors.
*/
WERROR (*get_sec_desc) (TALLOC_CTX *ctx,
- const struct hive_key *key,
- struct security_descriptor **desc);
-
+ const struct hive_key *key,
+ struct security_descriptor **desc);
+
/**
* Retrieve general information about a key.
*/
WERROR (*get_key_info) (TALLOC_CTX *mem_ctx,
- const struct hive_key *key,
- const char **classname,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time);
+ const struct hive_key *key,
+ const char **classname,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time);
};
struct cli_credentials;
struct auth_session_info;
-WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials,
- struct hive_key **root);
+WERROR reg_open_hive(TALLOC_CTX *parent_ctx, const char *location,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials,
+ struct hive_key **root);
WERROR hive_key_get_info(TALLOC_CTX *mem_ctx, const struct hive_key *key,
- const char **classname, uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time);
+ const char **classname, uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time);
WERROR hive_key_add_name(TALLOC_CTX *ctx, const struct hive_key *parent_key,
- const char *name, const char *classname, struct security_descriptor *desc,
- struct hive_key **key);
+ const char *name, const char *classname,
+ struct security_descriptor *desc,
+ struct hive_key **key);
WERROR hive_key_del(const struct hive_key *key, const char *name);
WERROR hive_get_key_by_name(TALLOC_CTX *mem_ctx,
- const struct hive_key *key, const char *name,
- struct hive_key **subkey);
+ const struct hive_key *key, const char *name,
+ struct hive_key **subkey);
WERROR hive_enum_key(TALLOC_CTX *mem_ctx,
- const struct hive_key *key, uint32_t idx,
- const char **name,
- const char **classname,
- NTTIME *last_mod_time);
+ const struct hive_key *key, uint32_t idx,
+ const char **name,
+ const char **classname,
+ NTTIME *last_mod_time);
-WERROR hive_set_value (struct hive_key *key, const char *name,
- uint32_t type, const DATA_BLOB data);
+WERROR hive_set_value(struct hive_key *key, const char *name,
+ uint32_t type, const DATA_BLOB data);
-WERROR hive_get_value (TALLOC_CTX *mem_ctx,
- struct hive_key *key, const char *name,
- uint32_t *type, DATA_BLOB *data);
-WERROR hive_get_value_by_index (TALLOC_CTX *mem_ctx,
- struct hive_key *key, uint32_t idx, const char **name,
- uint32_t *type, DATA_BLOB *data);
+WERROR hive_get_value(TALLOC_CTX *mem_ctx,
+ struct hive_key *key, const char *name,
+ uint32_t *type, DATA_BLOB *data);
+WERROR hive_get_value_by_index(TALLOC_CTX *mem_ctx,
+ struct hive_key *key, uint32_t idx,
+ const char **name,
+ uint32_t *type, DATA_BLOB *data);
-WERROR hive_del_value (struct hive_key *key, const char *name);
+WERROR hive_del_value(struct hive_key *key, const char *name);
WERROR hive_key_flush(struct hive_key *key);
/* Individual backends */
-WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
- const char *location, struct hive_key **key);
-WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
- const char *location, struct hive_key **key);
-WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials,
- struct hive_key **k);
-
-
-WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
- const char *location, struct hive_key **key);
-WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
- const char *location,
- int major_version,
- struct hive_key **key);
+WERROR reg_open_directory(TALLOC_CTX *parent_ctx,
+ const char *location, struct hive_key **key);
+WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
+ const char *location, struct hive_key **key);
+WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials,
+ struct hive_key **k);
+
+
+WERROR reg_create_directory(TALLOC_CTX *parent_ctx,
+ const char *location, struct hive_key **key);
+WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
+ const char *location,
+ int major_version,
+ struct hive_key **key);
#endif /* __REGISTRY_HIVE_H__ */
-/*
+/*
Unix SMB/CIFS implementation.
Transparent registry backend handling
Copyright (C) Jelmer Vernooij 2003-2007.
{
int i;
for (i = 0; reg_predefined_keys[i].name; i++) {
- if (reg_predefined_keys[i].handle == hkey)
+ if (reg_predefined_keys[i].handle == hkey)
return reg_predefined_keys[i].name;
}
}
/** Get predefined key by name. */
-_PUBLIC_ WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
- const char *name,
- struct registry_key **key)
+_PUBLIC_ WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
+ const char *name,
+ struct registry_key **key)
{
int i;
-
+
for (i = 0; reg_predefined_keys[i].name; i++) {
- if (!strcasecmp(reg_predefined_keys[i].name, name))
- return reg_get_predefined_key(ctx, reg_predefined_keys[i].handle,
- key);
+ if (!strcasecmp(reg_predefined_keys[i].name, name))
+ return reg_get_predefined_key(ctx,
+ reg_predefined_keys[i].handle,
+ key);
}
DEBUG(1, ("No predefined key with name '%s'\n", name));
-
+
return WERR_BADFILE;
}
/** Get predefined key by id. */
-_PUBLIC_ WERROR reg_get_predefined_key(const struct registry_context *ctx,
- uint32_t hkey, struct registry_key **key)
+_PUBLIC_ WERROR reg_get_predefined_key(const struct registry_context *ctx,
+ uint32_t hkey, struct registry_key **key)
{
return ctx->ops->get_predefined_key(ctx, hkey, key);
}
/**
- * Open a key
+ * Open a key
* First tries to use the open_key function from the backend
- * then falls back to get_subkey_by_name and later get_subkey_by_index
+ * then falls back to get_subkey_by_name and later get_subkey_by_index
*/
-_PUBLIC_ WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
- const char *name, struct registry_key **result)
+_PUBLIC_ WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
+ const char *name, struct registry_key **result)
{
if (parent == NULL) {
- DEBUG(0, ("Invalid parent key specified for open of '%s'\n", name));
+ DEBUG(0, ("Invalid parent key specified for open of '%s'\n",
+ name));
return WERR_INVALID_PARAM;
}
/**
* Get value by index
*/
-_PUBLIC_ WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
+_PUBLIC_ WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
uint32_t idx, const char **name,
uint32_t *type, DATA_BLOB *data)
{
- if (key == NULL)
+ if (key == NULL)
return WERR_INVALID_PARAM;
if (key->context->ops->enum_value == NULL)
return WERR_NOT_SUPPORTED;
- return key->context->ops->enum_value(mem_ctx, key, idx, name, type,
- data);
+ return key->context->ops->enum_value(mem_ctx, key, idx, name,
+ type, data);
}
-/**
+/**
* Get the number of subkeys.
*/
-_PUBLIC_ WERROR reg_key_get_info(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char **classname,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time)
+_PUBLIC_ WERROR reg_key_get_info(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ const char **classname,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time)
{
- if (key == NULL)
+ if (key == NULL)
return WERR_INVALID_PARAM;
-
+
if (key->context->ops->get_key_info == NULL)
return WERR_NOT_SUPPORTED;
return key->context->ops->get_key_info(mem_ctx,
- key, classname, num_subkeys,
- num_values, last_change_time);
+ key, classname, num_subkeys,
+ num_values, last_change_time);
}
/**
* Get subkey by index.
*/
-_PUBLIC_ WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
- const struct registry_key *key, int idx, const char **name,
- const char **keyclass, NTTIME *last_changed_time)
+_PUBLIC_ WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ int idx, const char **name,
+ const char **keyclass,
+ NTTIME *last_changed_time)
{
- if (key == NULL)
+ if (key == NULL)
return WERR_INVALID_PARAM;
if (key->context->ops->enum_key == NULL)
return WERR_NOT_SUPPORTED;
return key->context->ops->enum_key(mem_ctx, key, idx, name,
- keyclass, last_changed_time);
+ keyclass, last_changed_time);
}
/**
* Get value by name.
*/
-_PUBLIC_ WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char *name,
- uint32_t *type,
- DATA_BLOB *data)
+_PUBLIC_ WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ const char *name,
+ uint32_t *type,
+ DATA_BLOB *data)
{
- if (key == NULL)
+ if (key == NULL)
return WERR_INVALID_PARAM;
if (key->context->ops->get_value == NULL)
*/
_PUBLIC_ WERROR reg_key_del(struct registry_key *parent, const char *name)
{
- if (parent == NULL)
+ if (parent == NULL)
return WERR_INVALID_PARAM;
-
+
if (parent->context->ops->delete_key == NULL)
return WERR_NOT_SUPPORTED;
-
+
return parent->context->ops->delete_key(parent, name);
}
/**
* Add a key.
*/
-_PUBLIC_ WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
- struct registry_key *parent,
- const char *name, const char *key_class,
- struct security_descriptor *desc,
- struct registry_key **newkey)
+_PUBLIC_ WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
+ struct registry_key *parent,
+ const char *name, const char *key_class,
+ struct security_descriptor *desc,
+ struct registry_key **newkey)
{
- if (parent == NULL)
+ if (parent == NULL)
return WERR_INVALID_PARAM;
-
+
if (parent->context->ops->create_key == NULL) {
- DEBUG(1, ("Backend '%s' doesn't support method add_key\n",
+ DEBUG(1, ("Backend '%s' doesn't support method add_key\n",
parent->context->ops->name));
return WERR_NOT_SUPPORTED;
}
- return parent->context->ops->create_key(mem_ctx, parent, name,
- key_class, desc, newkey);
+ return parent->context->ops->create_key(mem_ctx, parent, name,
+ key_class, desc, newkey);
}
/**
* Set a value.
*/
-_PUBLIC_ WERROR reg_val_set(struct registry_key *key, const char *value,
- uint32_t type, const DATA_BLOB data)
+_PUBLIC_ WERROR reg_val_set(struct registry_key *key, const char *value,
+ uint32_t type, const DATA_BLOB data)
{
if (key == NULL)
return WERR_INVALID_PARAM;
/* A 'real' set function has preference */
if (key->context->ops->set_value == NULL) {
- DEBUG(1, ("Backend '%s' doesn't support method set_value\n",
+ DEBUG(1, ("Backend '%s' doesn't support method set_value\n",
key->context->ops->name));
return WERR_NOT_SUPPORTED;
}
/**
* Get the security descriptor on a key.
*/
-_PUBLIC_ WERROR reg_get_sec_desc(TALLOC_CTX *ctx,
- const struct registry_key *key,
- struct security_descriptor **secdesc)
+_PUBLIC_ WERROR reg_get_sec_desc(TALLOC_CTX *ctx,
+ const struct registry_key *key,
+ struct security_descriptor **secdesc)
{
if (key == NULL)
return WERR_INVALID_PARAM;
/* A 'real' set function has preference */
- if (key->context->ops->get_security == NULL)
+ if (key->context->ops->get_security == NULL)
return WERR_NOT_SUPPORTED;
return key->context->ops->get_security(ctx, key, secdesc);
{
if (key == NULL)
return WERR_INVALID_PARAM;
-
+
if (key->context->ops->flush_key == NULL)
return WERR_NOT_SUPPORTED;
return key->context->ops->flush_key(key);
}
-_PUBLIC_ WERROR reg_get_security(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- struct security_descriptor **security)
+_PUBLIC_ WERROR reg_get_security(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ struct security_descriptor **security)
{
if (key == NULL)
return WERR_INVALID_PARAM;
-
+
if (key->context->ops->get_security == NULL)
return WERR_NOT_SUPPORTED;
return key->context->ops->get_security(mem_ctx, key, security);
}
-_PUBLIC_ WERROR reg_set_security(struct registry_key *key,
- struct security_descriptor *security)
+_PUBLIC_ WERROR reg_set_security(struct registry_key *key,
+ struct security_descriptor *security)
{
if (key == NULL)
return WERR_INVALID_PARAM;
-
+
if (key->context->ops->set_security == NULL)
return WERR_NOT_SUPPORTED;
-/*
+/*
Unix SMB/CIFS implementation.
Registry interface
Copyright (C) Jelmer Vernooij 2004-2007.
-
+
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 <http://www.gnu.org/licenses/>.
*/
static struct hive_operations reg_backend_ldb;
-struct ldb_key_data
+struct ldb_key_data
{
struct hive_key key;
struct ldb_context *ldb;
int subkey_count, value_count;
};
-static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, struct ldb_message *msg, const char **name,
- uint32_t *type, DATA_BLOB *data)
+static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, struct ldb_message *msg,
+ const char **name, uint32_t *type,
+ DATA_BLOB *data)
{
const struct ldb_val *val;
if (name != NULL)
- *name = talloc_strdup(mem_ctx, ldb_msg_find_attr_as_string(msg, "value", NULL));
+ *name = talloc_strdup(mem_ctx,
+ ldb_msg_find_attr_as_string(msg, "value",
+ NULL));
if (type != NULL)
*type = ldb_msg_find_attr_as_uint(msg, "type", 0);
{
case REG_SZ:
case REG_EXPAND_SZ:
- data->length = convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16,
- val->data, val->length, (void **)&data->data);
+ data->length = convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16,
+ val->data, val->length,
+ (void **)&data->data);
break;
case REG_DWORD: {
}
}
-static struct ldb_message *reg_ldb_pack_value(struct ldb_context *ctx,
- TALLOC_CTX *mem_ctx, const char *name,
- uint32_t type, DATA_BLOB data)
+static struct ldb_message *reg_ldb_pack_value(struct ldb_context *ctx,
+ TALLOC_CTX *mem_ctx,
+ const char *name,
+ uint32_t type, DATA_BLOB data)
{
struct ldb_val val;
struct ldb_message *msg = talloc_zero(mem_ctx, struct ldb_message);
switch (type) {
case REG_SZ:
case REG_EXPAND_SZ:
- val.length = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
- (void *)data.data, data.length, (void **)&val.data);
+ val.length = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
+ (void *)data.data,
+ data.length,
+ (void **)&val.data);
ldb_msg_add_value(msg, "data", &val, NULL);
break;
case REG_DWORD:
- ldb_msg_add_string(msg, "data", talloc_asprintf(mem_ctx, "0x%x", IVAL(data.data, 0)));
+ ldb_msg_add_string(msg, "data",
+ talloc_asprintf(mem_ctx, "0x%x",
+ IVAL(data.data, 0)));
break;
default:
ldb_msg_add_value(msg, "data", &data, NULL);
type_s = talloc_asprintf(mem_ctx, "%u", type);
- ldb_msg_add_string(msg, "type", type_s);
+ ldb_msg_add_string(msg, "type", type_s);
return msg;
}
static int reg_close_ldb_key(struct ldb_key_data *key)
{
if (key->subkeys != NULL) {
- talloc_free(key->subkeys);
+ talloc_free(key->subkeys);
key->subkeys = NULL;
}
if (key->values != NULL) {
- talloc_free(key->values);
+ talloc_free(key->values);
key->values = NULL;
}
return 0;
}
-static struct ldb_dn *reg_path_to_ldb(TALLOC_CTX *mem_ctx,
- const struct hive_key *from,
- const char *path, const char *add)
+static struct ldb_dn *reg_path_to_ldb(TALLOC_CTX *mem_ctx,
+ const struct hive_key *from,
+ const char *path, const char *add)
{
TALLOC_CTX *local_ctx;
struct ldb_dn *ret;
ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(key=*)", NULL, &res);
if (ret != LDB_SUCCESS) {
- DEBUG(0, ("Error getting subkeys for '%s': %s\n", ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
+ DEBUG(0, ("Error getting subkeys for '%s': %s\n",
+ ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
return WERR_FOOBAR;
}
struct ldb_result *res;
int ret;
- ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(value=*)", NULL, &res);
+ ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL,
+ "(value=*)", NULL, &res);
if (ret != LDB_SUCCESS) {
- DEBUG(0, ("Error getting values for '%s': %s\n", ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
+ DEBUG(0, ("Error getting values for '%s': %s\n",
+ ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
return WERR_FOOBAR;
}
kd->value_count = res->count;
}
-static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx,
- const struct hive_key *k, uint32_t idx,
- const char **name,
- const char **classname,
- NTTIME *last_mod_time)
+static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx,
+ const struct hive_key *k, uint32_t idx,
+ const char **name,
+ const char **classname,
+ NTTIME *last_mod_time)
{
struct ldb_message_element *el;
struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
/* Do a search if necessary */
if (kd->subkeys == NULL) {
W_ERROR_NOT_OK_RETURN(cache_subkeys(kd));
- }
+ }
- if (idx >= kd->subkey_count)
+ if (idx >= kd->subkey_count)
return WERR_NO_MORE_ITEMS;
el = ldb_msg_find_element(kd->subkeys[idx], "key");
SMB_ASSERT(el != NULL);
SMB_ASSERT(el->num_values != 0);
-
+
if (name != NULL)
*name = talloc_strdup(mem_ctx, (char *)el->values[0].data);
if (classname != NULL)
*classname = NULL; /* TODO: Store properly */
-
+
if (last_mod_time != NULL)
*last_mod_time = 0; /* TODO: we need to add this to the
ldb backend properly */
return WERR_OK;
}
-static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, const struct hive_key *k, int idx,
- const char **name, uint32_t *data_type, DATA_BLOB *data)
+static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, const struct hive_key *k,
+ int idx, const char **name,
+ uint32_t *data_type, DATA_BLOB *data)
{
struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
W_ERROR_NOT_OK_RETURN(cache_values(kd));
}
- if(idx >= kd->value_count) return WERR_NO_MORE_ITEMS;
+ if (idx >= kd->value_count)
+ return WERR_NO_MORE_ITEMS;
- reg_ldb_unpack_value(mem_ctx, kd->values[idx],
- name, data_type, data);
+ reg_ldb_unpack_value(mem_ctx, kd->values[idx],
+ name, data_type, data);
return WERR_OK;
}
-static WERROR ldb_get_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
- const char *name, uint32_t *data_type, DATA_BLOB *data)
+static WERROR ldb_get_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
+ const char *name, uint32_t *data_type,
+ DATA_BLOB *data)
{
struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
struct ldb_context *c = kd->ldb;
talloc_free(query);
if (ret != LDB_SUCCESS) {
- DEBUG(0, ("Error getting values for '%s': %s\n", ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
+ DEBUG(0, ("Error getting values for '%s': %s\n",
+ ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
return WERR_FOOBAR;
}
return WERR_OK;
}
-static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, const struct hive_key *h,
- const char *name, struct hive_key **key)
+static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, const struct hive_key *h,
+ const char *name, struct hive_key **key)
{
struct ldb_result *res;
struct ldb_dn *ldap_path;
ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "(key=*)", NULL, &res);
if (ret != LDB_SUCCESS) {
- DEBUG(3, ("Error opening key '%s': %s\n",
- ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
+ DEBUG(3, ("Error opening key '%s': %s\n",
+ ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
return WERR_FOOBAR;
} else if (res->count == 0) {
- DEBUG(3, ("Key '%s' not found\n", ldb_dn_get_linearized(ldap_path)));
+ DEBUG(3, ("Key '%s' not found\n",
+ ldb_dn_get_linearized(ldap_path)));
talloc_free(res);
return WERR_NOT_FOUND;
}
newkd = talloc_zero(mem_ctx, struct ldb_key_data);
newkd->key.ops = ®_backend_ldb;
newkd->ldb = talloc_reference(newkd, kd->ldb);
- newkd->dn = ldb_dn_copy(mem_ctx, res->msgs[0]->dn);
+ newkd->dn = ldb_dn_copy(mem_ctx, res->msgs[0]->dn);
*key = (struct hive_key *)newkd;
return WERR_OK;
}
-WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
+WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
struct auth_session_info *session_info,
struct cli_credentials *credentials,
struct hive_key **k)
struct ldb_key_data *kd;
struct ldb_context *wrap;
- if (location == NULL)
+ if (location == NULL)
return WERR_INVALID_PARAM;
- wrap = ldb_wrap_connect(parent_ctx, global_loadparm,
+ wrap = ldb_wrap_connect(parent_ctx, global_loadparm,
location, session_info, credentials, 0, NULL);
if (wrap == NULL) {
return WERR_OK;
}
-static WERROR ldb_add_key (TALLOC_CTX *mem_ctx, const struct hive_key *parent,
- const char *name, const char *classname,
- struct security_descriptor *sd,
- struct hive_key **newkey)
+static WERROR ldb_add_key(TALLOC_CTX *mem_ctx, const struct hive_key *parent,
+ const char *name, const char *classname,
+ struct security_descriptor *sd,
+ struct hive_key **newkey)
{
const struct ldb_key_data *parentkd = (const struct ldb_key_data *)parent;
struct ldb_message *msg;
ldb_msg_add_string(msg, "key", talloc_strdup(mem_ctx, name));
if (classname != NULL)
- ldb_msg_add_string(msg, "classname", talloc_strdup(mem_ctx, classname));
+ ldb_msg_add_string(msg, "classname",
+ talloc_strdup(mem_ctx, classname));
ret = ldb_add(parentkd->ldb, msg);
if (ret < 0) {
DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(parentkd->ldb)));
return WERR_FOOBAR;
- }
+ }
DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(msg->dn)));
return WERR_OK;
}
-static WERROR ldb_del_key (const struct hive_key *key, const char *child)
+static WERROR ldb_del_key(const struct hive_key *key, const char *child)
{
int ret;
struct ldb_key_data *parentkd = talloc_get_type(key, struct ldb_key_data);
return WERR_OK;
}
-static WERROR ldb_set_value(struct hive_key *parent,
- const char *name, uint32_t type,
- const DATA_BLOB data)
+static WERROR ldb_set_value(struct hive_key *parent,
+ const char *name, uint32_t type,
+ const DATA_BLOB data)
{
struct ldb_message *msg;
struct ldb_key_data *kd = talloc_get_type(parent, struct ldb_key_data);
return WERR_FOOBAR;
}
}
-
+
talloc_free(mem_ctx);
return WERR_OK;
}
-static WERROR ldb_get_key_info(TALLOC_CTX *mem_ctx,
- const struct hive_key *key,
- const char **classname,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time)
+static WERROR ldb_get_key_info(TALLOC_CTX *mem_ctx,
+ const struct hive_key *key,
+ const char **classname,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time)
{
struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
-/*
+/*
Unix SMB/CIFS implementation.
Transparent registry backend handling
Copyright (C) Jelmer Vernooij 2003-2007.
struct mountpoint *prev, *next;
} *mountpoints;
- struct auth_session_info *session_info;
+ struct auth_session_info *session_info;
struct cli_credentials *credentials;
};
};
-struct registry_key *reg_import_hive_key(struct registry_context *ctx,
- struct hive_key *hive,
- uint32_t predefined_key,
+struct registry_key *reg_import_hive_key(struct registry_context *ctx,
+ struct hive_key *hive,
+ uint32_t predefined_key,
const char **elements)
{
struct local_key *local_key;
static WERROR local_open_key(TALLOC_CTX *mem_ctx,
- struct registry_key *parent,
- const char *path,
- struct registry_key **result)
+ struct registry_key *parent,
+ const char *path,
+ struct registry_key **result)
{
char *orig = talloc_strdup(mem_ctx, path),
- *curbegin = orig,
+ *curbegin = orig,
*curend = strchr(orig, '\\');
- struct local_key *local_parent = talloc_get_type(parent, struct local_key);
+ struct local_key *local_parent = talloc_get_type(parent,
+ struct local_key);
struct hive_key *curkey = local_parent->hive_key;
WERROR error;
const char **elements = NULL;
int el;
if (local_parent->path.elements != NULL) {
- elements = talloc_array(mem_ctx, const char *,
- str_list_length(local_parent->path.elements) + 1);
+ elements = talloc_array(mem_ctx, const char *,
+ str_list_length(local_parent->path.elements) + 1);
for (el = 0; local_parent->path.elements[el] != NULL; el++) {
- elements[el] = talloc_reference(elements,
- local_parent->path.elements[el]);
+ elements[el] = talloc_reference(elements,
+ local_parent->path.elements[el]);
}
elements[el] = NULL;
} else {
elements[el] = talloc_strdup(elements, curbegin);
el++;
elements[el] = NULL;
- error = hive_get_key_by_name(mem_ctx, curkey, curbegin, &curkey);
+ error = hive_get_key_by_name(mem_ctx, curkey,
+ curbegin, &curkey);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(2, ("Opening key %s failed: %s\n", curbegin, win_errstr(error)));
+ DEBUG(2, ("Opening key %s failed: %s\n", curbegin,
+ win_errstr(error)));
talloc_free(orig);
return error;
}
- if (curend == NULL)
+ if (curend == NULL)
break;
curbegin = curend + 1;
curend = strchr(curbegin, '\\');
}
talloc_free(orig);
- *result = reg_import_hive_key(local_parent->global.context, curkey,
- local_parent->path.predefined_key,
- talloc_steal(curkey, elements));
-
+ *result = reg_import_hive_key(local_parent->global.context, curkey,
+ local_parent->path.predefined_key,
+ talloc_steal(curkey, elements));
+
return WERR_OK;
}
-WERROR local_get_predefined_key (const struct registry_context *ctx,
- uint32_t key_id, struct registry_key **key)
-{
- struct registry_local *rctx = talloc_get_type(ctx,
+WERROR local_get_predefined_key(const struct registry_context *ctx,
+ uint32_t key_id, struct registry_key **key)
+{
+ struct registry_local *rctx = talloc_get_type(ctx,
struct registry_local);
struct mountpoint *mp;
for (mp = rctx->mountpoints; mp != NULL; mp = mp->next) {
- if (mp->path.predefined_key == key_id &&
+ if (mp->path.predefined_key == key_id &&
mp->path.elements == NULL)
break;
}
if (mp == NULL)
return WERR_NOT_FOUND;
-
- *key = reg_import_hive_key(ctx, mp->key,
- mp->path.predefined_key,
+
+ *key = reg_import_hive_key(ctx, mp->key,
+ mp->path.predefined_key,
mp->path.elements);
return WERR_OK;
}
static WERROR local_enum_key(TALLOC_CTX *mem_ctx,
- const struct registry_key *key, uint32_t idx,
- const char **name,
- const char **keyclass,
- NTTIME *last_changed_time)
+ const struct registry_key *key, uint32_t idx,
+ const char **name,
+ const char **keyclass,
+ NTTIME *last_changed_time)
{
const struct local_key *local = (const struct local_key *)key;
- return hive_enum_key(mem_ctx, local->hive_key, idx, name, keyclass,
- last_changed_time);
+ return hive_enum_key(mem_ctx, local->hive_key, idx, name, keyclass,
+ last_changed_time);
}
-static WERROR local_create_key (TALLOC_CTX *mem_ctx,
- struct registry_key *parent_key,
- const char *name,
- const char *key_class,
- struct security_descriptor *security,
- struct registry_key **key)
+static WERROR local_create_key(TALLOC_CTX *mem_ctx,
+ struct registry_key *parent_key,
+ const char *name,
+ const char *key_class,
+ struct security_descriptor *security,
+ struct registry_key **key)
{
const struct local_key *local_parent;
struct hive_key *hivekey;
last_part = name;
local_parent = (const struct local_key *)parent_key;
} else {
- W_ERROR_NOT_OK_RETURN(reg_open_key(mem_ctx, parent_key,
- talloc_strndup(mem_ctx, name, last_part-name),
- &local_parent));
+ W_ERROR_NOT_OK_RETURN(reg_open_key(mem_ctx, parent_key,
+ talloc_strndup(mem_ctx, name, last_part-name),
+ &local_parent));
last_part++;
}
- W_ERROR_NOT_OK_RETURN(hive_key_add_name(mem_ctx, local_parent->hive_key,
- last_part, key_class, security, &hivekey));
+ W_ERROR_NOT_OK_RETURN(hive_key_add_name(mem_ctx, local_parent->hive_key,
+ last_part, key_class, security,
+ &hivekey));
if (local_parent->path.elements != NULL) {
- elements = talloc_array(hivekey, const char *,
- str_list_length(local_parent->path.elements)+2);
+ elements = talloc_array(hivekey, const char *,
+ str_list_length(local_parent->path.elements)+2);
for (i = 0; local_parent->path.elements[i] != NULL; i++) {
- elements[i] = talloc_reference(elements,
- local_parent->path.elements[i]);
+ elements[i] = talloc_reference(elements,
+ local_parent->path.elements[i]);
}
} else {
elements = talloc_array(hivekey, const char *, 2);
elements[i] = talloc_strdup(elements, name);
elements[i+1] = NULL;
- *key = reg_import_hive_key(local_parent->global.context, hivekey,
- local_parent->path.predefined_key,
- elements);
+ *key = reg_import_hive_key(local_parent->global.context, hivekey,
+ local_parent->path.predefined_key,
+ elements);
return WERR_OK;
}
-static WERROR local_set_value (struct registry_key *key, const char *name,
- uint32_t type, const DATA_BLOB data)
+static WERROR local_set_value(struct registry_key *key, const char *name,
+ uint32_t type, const DATA_BLOB data)
{
struct local_key *local = (struct local_key *)key;
return hive_set_value(local->hive_key, name, type, data);
}
-static WERROR local_get_value (TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char *name, uint32_t *type, DATA_BLOB *data)
+static WERROR local_get_value(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ const char *name, uint32_t *type, DATA_BLOB *data)
{
const struct local_key *local = (const struct local_key *)key;
return hive_get_value(mem_ctx, local->hive_key, name, type, data);
}
-static WERROR local_enum_value (TALLOC_CTX *mem_ctx,
- const struct registry_key *key, uint32_t idx,
- const char **name,
- uint32_t *type,
- DATA_BLOB *data)
+static WERROR local_enum_value(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key, uint32_t idx,
+ const char **name,
+ uint32_t *type,
+ DATA_BLOB *data)
{
const struct local_key *local = (const struct local_key *)key;
- return hive_get_value_by_index(mem_ctx, local->hive_key, idx,
- name, type, data);
+ return hive_get_value_by_index(mem_ctx, local->hive_key, idx,
+ name, type, data);
}
-static WERROR local_delete_key (struct registry_key *key, const char *name)
+static WERROR local_delete_key(struct registry_key *key, const char *name)
{
const struct local_key *local = (const struct local_key *)key;
return hive_key_del(local->hive_key, name);
}
-static WERROR local_delete_value (struct registry_key *key, const char *name)
+static WERROR local_delete_value(struct registry_key *key, const char *name)
{
const struct local_key *local = (const struct local_key *)key;
return hive_del_value(local->hive_key, name);
}
-static WERROR local_flush_key (struct registry_key *key)
+static WERROR local_flush_key(struct registry_key *key)
{
const struct local_key *local = (const struct local_key *)key;
return hive_key_flush(local->hive_key);
}
-static WERROR local_get_key_info (TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char **classname,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time)
+static WERROR local_get_key_info(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ const char **classname,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time)
{
const struct local_key *local = (const struct local_key *)key;
- return hive_key_get_info(mem_ctx, local->hive_key,
- classname, num_subkeys, num_values,
- last_change_time);
+ return hive_key_get_info(mem_ctx, local->hive_key,
+ classname, num_subkeys, num_values,
+ last_change_time);
}
const static struct registry_operations local_ops = {
.get_key_info = local_get_key_info,
};
-WERROR reg_open_local(TALLOC_CTX *mem_ctx, struct registry_context **ctx,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials)
+WERROR reg_open_local(TALLOC_CTX *mem_ctx, struct registry_context **ctx,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials)
{
- struct registry_local *ret = talloc_zero(mem_ctx, struct registry_local);
+ struct registry_local *ret = talloc_zero(mem_ctx,
+ struct registry_local);
W_ERROR_HAVE_NO_MEMORY(ret);
ret->credentials = credentials;
*ctx = (struct registry_context *)ret;
-
+
return WERR_OK;
}
-WERROR reg_mount_hive(struct registry_context *rctx,
- struct hive_key *hive_key,
- uint32_t key_id,
- const char **elements)
+WERROR reg_mount_hive(struct registry_context *rctx,
+ struct hive_key *hive_key,
+ uint32_t key_id,
+ const char **elements)
{
- struct registry_local *reg_local = talloc_get_type(rctx, struct registry_local);
+ struct registry_local *reg_local = talloc_get_type(rctx,
+ struct registry_local);
struct mountpoint *mp = talloc(rctx, struct mountpoint);
int i = 0;
mp->prev = mp->next = NULL;
mp->key = hive_key;
if (elements != NULL) {
- mp->path.elements = talloc_array(mp, const char *,
- str_list_length(elements));
+ mp->path.elements = talloc_array(mp, const char *,
+ str_list_length(elements));
for (i = 0; elements[i] != NULL; i++) {
- mp->path.elements[i] = talloc_reference(mp->path.elements,
- elements[i]);
+ mp->path.elements[i] = talloc_reference(mp->path.elements,
+ elements[i]);
}
mp->path.elements[i] = NULL;
} else {
-/*
+/*
Unix SMB/CIFS implementation.
Reading registry patch files
-
+
Copyright (C) Jelmer Vernooij 2004-2007
Copyright (C) Wilco Baan Hofman 2006
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 <http://www.gnu.org/licenses/>.
*/
#include "system/filesys.h"
-_PUBLIC_ WERROR reg_preg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data);
+_PUBLIC_ WERROR reg_preg_diff_load(int fd,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data);
-_PUBLIC_ WERROR reg_dotreg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data);
+_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data);
/*
* Generate difference between two keys
*/
-WERROR reg_generate_diff_key(struct registry_key *oldkey,
- struct registry_key *newkey,
- const char *path,
- const struct reg_diff_callbacks *callbacks,
- void *callback_data)
+WERROR reg_generate_diff_key(struct registry_key *oldkey,
+ struct registry_key *newkey,
+ const char *path,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data)
{
int i;
struct registry_key *t1, *t2;
new_num_subkeys, new_num_values;
if (oldkey != NULL) {
- error = reg_key_get_info(mem_ctx, oldkey, NULL, &old_num_subkeys, &old_num_values,
- NULL);
+ error = reg_key_get_info(mem_ctx, oldkey, NULL,
+ &old_num_subkeys, &old_num_values,
+ NULL);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error occured while getting key info: %s\n",
- win_errstr(error)));
+ DEBUG(0, ("Error occured while getting key info: %s\n",
+ win_errstr(error)));
return error;
}
} else {
/* Subkeys that were deleted */
for (i = 0; i < old_num_subkeys; i++) {
- error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i, &keyname1,
- NULL, NULL);
+ error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i,
+ &keyname1,
+ NULL, NULL);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Error occured while getting subkey by index: %s\n",
- win_errstr(error2)));
+ DEBUG(0, ("Error occured while getting subkey by index: %s\n",
+ win_errstr(error2)));
continue;
}
}
if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
- DEBUG(0, ("Error occured while getting subkey by name: %s\n",
- win_errstr(error2)));
+ DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+ win_errstr(error2)));
talloc_free(mem_ctx);
return error2;
}
/* newkey didn't have such a subkey, add del diff */
tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
callbacks->del_key(callback_data, tmppath);
- talloc_free(tmppath);
+ talloc_free(tmppath);
}
if (newkey != NULL) {
- error = reg_key_get_info(mem_ctx, newkey, NULL, &new_num_subkeys, &new_num_values,
- NULL);
+ error = reg_key_get_info(mem_ctx, newkey, NULL,
+ &new_num_subkeys, &new_num_values,
+ NULL);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error occured while getting key info: %s\n",
- win_errstr(error)));
+ DEBUG(0, ("Error occured while getting key info: %s\n",
+ win_errstr(error)));
return error;
}
} else {
/* Subkeys that were added */
for(i = 0; i < new_num_subkeys; i++) {
- error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i, &keyname1,
- NULL, NULL);
+ error1 = reg_key_get_subkey_by_index(mem_ctx, newkey,
+ i, &keyname1,
+ NULL, NULL);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Error occured while getting subkey by index: %s\n",
- win_errstr(error1)));
+ DEBUG(0, ("Error occured while getting subkey by index: %s\n",
+ win_errstr(error1)));
talloc_free(mem_ctx);
return error1;
}
if (oldkey != NULL) {
error2 = reg_open_key(mem_ctx, oldkey, keyname1, &t1);
-
+
if (W_ERROR_IS_OK(error2))
continue;
} else {
t1 = NULL;
error2 = WERR_DEST_NOT_FOUND;
}
-
+
if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
- DEBUG(0, ("Error occured while getting subkey by name: %s\n",
- win_errstr(error2)));
+ DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+ win_errstr(error2)));
talloc_free(mem_ctx);
return error2;
}
W_ERROR_NOT_OK_RETURN(
reg_open_key(mem_ctx, newkey, keyname1, &t2));
- reg_generate_diff_key(t1, t2, tmppath, callbacks, callback_data);
+ reg_generate_diff_key(t1, t2, tmppath,
+ callbacks, callback_data);
talloc_free(tmppath);
}
uint32_t type1, type2;
DATA_BLOB contents1, contents2;
- error1 = reg_key_get_value_by_index(mem_ctx, newkey, i,
- &name, &type1, &contents1);
+ error1 = reg_key_get_value_by_index(mem_ctx, newkey, i,
+ &name, &type1, &contents1);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Unable to get key by index: %s\n",
- win_errstr(error1)));
+ DEBUG(0, ("Unable to get key by index: %s\n",
+ win_errstr(error1)));
talloc_free(mem_ctx);
return error1;
}
if (oldkey != NULL) {
- error2 = reg_key_get_value_by_name(mem_ctx, oldkey, name,
- &type2, &contents2);
- } else
+ error2 = reg_key_get_value_by_name(mem_ctx, oldkey,
+ name, &type2,
+ &contents2);
+ } else
error2 = WERR_DEST_NOT_FOUND;
-
- if(!W_ERROR_IS_OK(error2) &&
+
+ if(!W_ERROR_IS_OK(error2) &&
!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
- DEBUG(0, ("Error occured while getting value by name: %s\n",
- win_errstr(error2)));
+ DEBUG(0, ("Error occured while getting value by name: %s\n",
+ win_errstr(error2)));
talloc_free(mem_ctx);
return error2;
}
- if (W_ERROR_IS_OK(error2) && data_blob_cmp(&contents1, &contents2) == 0)
+ if (W_ERROR_IS_OK(error2) &&
+ data_blob_cmp(&contents1, &contents2) == 0)
continue;
- callbacks->set_value(callback_data, path, name, type1, contents1);
+ callbacks->set_value(callback_data, path, name,
+ type1, contents1);
}
/* Values that were deleted */
for (i = 0; i < old_num_values; i++) {
const char *name;
- error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name,
- NULL, NULL);
+ error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name,
+ NULL, NULL);
if (!W_ERROR_IS_OK(error1)) {
- DEBUG(0, ("Error ocurred getting value by index: %s\n",
- win_errstr(error1)));
+ DEBUG(0, ("Error ocurred getting value by index: %s\n",
+ win_errstr(error1)));
talloc_free(mem_ctx);
return error1;
}
- error2 = reg_key_get_value_by_name(mem_ctx, newkey, name, NULL,
- NULL);
+ error2 = reg_key_get_value_by_name(mem_ctx, newkey, name, NULL,
+ NULL);
if (W_ERROR_IS_OK(error2))
continue;
if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
- DEBUG(0, ("Error occured while getting value by name: %s\n",
- win_errstr(error2)));
+ DEBUG(0, ("Error occured while getting value by name: %s\n",
+ win_errstr(error2)));
return error2;
}
}
/**
- * Generate diff between two registry contexts
+ * Generate diff between two registry contexts
*/
-_PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
- struct registry_context *ctx2,
+_PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
+ struct registry_context *ctx2,
const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
for(i = HKEY_FIRST; i <= HKEY_LAST; i++) {
struct registry_key *r1 = NULL, *r2 = NULL;
error = reg_get_predefined_key(ctx1, i, &r1);
- if (!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
- DEBUG(0, ("Unable to open hive %s for backend 1\n", reg_get_predef_name(i)));
+ if (!W_ERROR_IS_OK(error) &&
+ !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
+ DEBUG(0, ("Unable to open hive %s for backend 1\n",
+ reg_get_predef_name(i)));
}
-
+
error = reg_get_predefined_key(ctx2, i, &r2);
- if (!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
- DEBUG(0, ("Unable to open hive %s for backend 2\n", reg_get_predef_name(i)));
+ if (!W_ERROR_IS_OK(error) &&
+ !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
+ DEBUG(0, ("Unable to open hive %s for backend 2\n",
+ reg_get_predef_name(i)));
}
if (r1 == NULL && r2 == NULL)
continue;
- error = reg_generate_diff_key(r1, r2, reg_get_predef_name(i), callbacks, callback_data);
+ error = reg_generate_diff_key(r1, r2, reg_get_predef_name(i),
+ callbacks, callback_data);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Unable to determine diff: %s\n", win_errstr(error)));
+ DEBUG(0, ("Unable to determine diff: %s\n",
+ win_errstr(error)));
return error;
}
}
/**
* Load diff file
*/
-_PUBLIC_ WERROR reg_diff_load(const char *filename,
- const struct reg_diff_callbacks *callbacks,
+_PUBLIC_ WERROR reg_diff_load(const char *filename,
+ const struct reg_diff_callbacks *callbacks,
void *callback_data)
{
int fd;
char hdr[4];
-
+
fd = open(filename, O_RDONLY, 0);
if (fd == -1) {
- DEBUG(0, ("Error opening registry patch file `%s'\n", filename));
+ DEBUG(0, ("Error opening registry patch file `%s'\n",
+ filename));
return WERR_GENERAL_FAILURE;
}
if (read(fd, &hdr, 4) != 4) {
- DEBUG(0, ("Error reading registry patch file `%s'\n", filename));
+ DEBUG(0, ("Error reading registry patch file `%s'\n",
+ filename));
return WERR_GENERAL_FAILURE;
}
} else if (strncmp(hdr, "regf", 4) == 0) {
/* Must be a REGF NTConfig.pol file */
return reg_regf_diff_load(diff, fd);
- } else
-#endif
+ } else
+#endif
if (strncmp(hdr, "PReg", 4) == 0) {
/* Must be a GPO Registry.pol file */
return reg_preg_diff_load(fd, callbacks, callback_data);
/**
* The reg_diff_apply functions
*/
-static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
+static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
{
struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *tmp;
error = reg_key_add_abs(ctx, ctx, key_name, 0, NULL, &tmp);
- if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) && !W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error adding new key '%s': %s\n", key_name, win_errstr(error)));
+ if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) &&
+ !W_ERROR_IS_OK(error)) {
+ DEBUG(0, ("Error adding new key '%s': %s\n",
+ key_name, win_errstr(error)));
return error;
}
return WERR_OK;
}
-static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
+static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
{
struct registry_context *ctx = (struct registry_context *)_ctx;
WERROR error;
DEBUG(0, ("Unable to delete key '%s'\n", key_name));
return error;
}
-
+
return WERR_OK;
}
-static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char *value_name, uint32_t value_type, DATA_BLOB value)
+static WERROR reg_diff_apply_set_value(void *_ctx, const char *path,
+ const char *value_name,
+ uint32_t value_type, DATA_BLOB value)
{
struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *tmp;
WERROR error;
-
+
/* Open key */
error = reg_open_key_abs(ctx, ctx, path, &tmp);
}
/* Set value */
- error = reg_val_set(tmp, value_name,
+ error = reg_val_set(tmp, value_name,
value_type, value);
if (!W_ERROR_IS_OK(error)) {
DEBUG(0, ("Error setting value '%s'\n", value_name));
return error;
- }
-
+ }
+
return WERR_OK;
}
-static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const char *value_name)
+static WERROR reg_diff_apply_del_value(void *_ctx, const char *key_name,
+ const char *value_name)
{
struct registry_context *ctx = (struct registry_context *)_ctx;
struct registry_key *tmp;
WERROR error;
-
+
/* Open key */
error = reg_open_key_abs(ctx, ctx, key_name, &tmp);
DEBUG(0, ("Error deleting value '%s'\n", value_name));
return error;
}
-
+
return WERR_OK;
}
return error;
}
- W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key,
- NULL,
- NULL,
- &num_values,
- NULL));
+ W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key,
+ NULL,
+ NULL,
+ &num_values,
+ NULL));
for (i = 0; i < num_values; i++) {
const char *name;
- W_ERROR_NOT_OK_RETURN(reg_key_get_value_by_index(ctx, key, i, &name,
- NULL, NULL));
+ W_ERROR_NOT_OK_RETURN(reg_key_get_value_by_index(ctx, key, i,
+ &name,
+ NULL, NULL));
W_ERROR_NOT_OK_RETURN(reg_del_value(key, name));
}
return WERR_OK;
}
-/**
- * Apply diff to a registry context
+/**
+ * Apply diff to a registry context
*/
-_PUBLIC_ WERROR reg_diff_apply (const char *filename, struct registry_context *ctx)
+_PUBLIC_ WERROR reg_diff_apply(const char *filename,
+ struct registry_context *ctx)
{
struct reg_diff_callbacks callbacks;
-/*
+/*
Unix SMB/CIFS implementation.
Patchfile interface
Copyright (C) Jelmer Vernooij 2006
Copyright (C) Wilco Baan Hofman 2006
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 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.
*/
#ifndef _PATCHFILE_H
-#define _PATCHFILE_H
+#define _PATCHFILE_H
#include "lib/registry/registry.h"
struct reg_diff_callbacks {
WERROR (*add_key) (void *callback_data, const char *key_name);
- WERROR (*set_value) (void *callback_data, const char *key_name,
- const char *value_name, uint32_t value_type, DATA_BLOB value);
- WERROR (*del_value) (void *callback_data, const char *key_name, const char *value_name);
+ WERROR (*set_value) (void *callback_data, const char *key_name,
+ const char *value_name, uint32_t value_type,
+ DATA_BLOB value);
+ WERROR (*del_value) (void *callback_data, const char *key_name,
+ const char *value_name);
WERROR (*del_key) (void *callback_data, const char *key_name);
WERROR (*del_all_values) (void *callback_data, const char *key_name);
WERROR (*done) (void *callback_data);
};
-WERROR reg_diff_apply (const char *filename,
- struct registry_context *ctx);
-
-WERROR reg_generate_diff(struct registry_context *ctx1,
- struct registry_context *ctx2,
- const struct reg_diff_callbacks *callbacks,
- void *callback_data);
-WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
- struct reg_diff_callbacks **callbacks, void **callback_data);
-WERROR reg_generate_diff_key(struct registry_key *oldkey,
- struct registry_key *newkey,
- const char *path,
- const struct reg_diff_callbacks *callbacks,
- void *callback_data);
+WERROR reg_diff_apply (const char *filename,
+ struct registry_context *ctx);
+
+WERROR reg_generate_diff(struct registry_context *ctx1,
+ struct registry_context *ctx2,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data);
+WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
+ struct reg_diff_callbacks **callbacks,
+ void **callback_data);
+WERROR reg_generate_diff_key(struct registry_key *oldkey,
+ struct registry_key *newkey,
+ const char *path,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data);
#endif /* _PATCHFILE_H */
-/*
+/*
Unix SMB/CIFS implementation.
Reading .REG files
-
+
Copyright (C) Jelmer Vernooij 2004-2007
Copyright (C) Wilco Baan Hofman 2006
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.
struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\n[%s]\n", key_name);
-
+
return WERR_OK;
}
struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\n[-%s]\n", key_name);
-
+
return WERR_OK;
}
-static WERROR reg_dotreg_diff_set_value(void *_data, const char *path,
- const char *value_name, uint32_t value_type, DATA_BLOB value)
+static WERROR reg_dotreg_diff_set_value(void *_data, const char *path,
+ const char *value_name,
+ uint32_t value_type, DATA_BLOB value)
{
struct dotreg_data *data = (struct dotreg_data *)_data;
fdprintf(data->fd, "\"%s\"=%s:%s\n",
- value_name, str_regtype(value_type),
+ value_name, str_regtype(value_type),
reg_val_data_string(NULL, value_type, value));
-
+
return WERR_OK;
}
-static WERROR reg_dotreg_diff_del_value(void *_data, const char *path, const char *value_name)
+static WERROR reg_dotreg_diff_del_value(void *_data, const char *path,
+ const char *value_name)
{
struct dotreg_data *data = (struct dotreg_data *)_data;
return WERR_OK;
}
-static WERROR reg_dotreg_diff_del_all_values (void *callback_data, const char *key_name)
+static WERROR reg_dotreg_diff_del_all_values(void *callback_data,
+ const char *key_name)
{
return WERR_NOT_SUPPORTED;
}
/**
* Save registry diff
*/
-_PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
- struct reg_diff_callbacks **callbacks, void **callback_data)
+_PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
+ struct reg_diff_callbacks **callbacks,
+ void **callback_data)
{
struct dotreg_data *data;
(*callbacks)->done = reg_dotreg_diff_done;
return WERR_OK;
-}
+}
/**
* Load diff file
*/
-_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
- const struct reg_diff_callbacks *callbacks, void *callback_data)
+_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data)
{
char *line, *p, *q;
char *curkey = NULL;
/* Ignore comments and empty lines */
if (strlen(line) == 0 || line[0] == ';') {
talloc_free(line);
-
- if (curkey) {
+
+ if (curkey) {
talloc_free(curkey);
}
curkey = NULL;
if (line[1] == '-') {
curkey = talloc_strndup(line, line+2, strlen(line)-3);
- error = callbacks->del_key(callback_data, curkey);
+ error = callbacks->del_key(callback_data,
+ curkey);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0,("Error deleting key %s\n", curkey));
+ DEBUG(0,("Error deleting key %s\n",
+ curkey));
talloc_free(mem_ctx);
return error;
}
/* Delete value */
if (strcmp(p, "-") == 0) {
- error = callbacks->del_value(callback_data, curkey, line);
+ error = callbacks->del_value(callback_data,
+ curkey, line);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error deleting value %s in key %s\n", line, curkey));
+ DEBUG(0, ("Error deleting value %s in key %s\n",
+ line, curkey));
talloc_free(mem_ctx);
return error;
}
talloc_free(line);
continue;
}
-
+
q = strchr_m(p, ':');
if (q) {
- *q = '\0';
+ *q = '\0';
q++;
}
- reg_string_to_val(line, q?p:"REG_SZ", q?q:p, &value_type, &value);
-
- error = callbacks->set_value(callback_data, curkey, line, value_type, value);
+ reg_string_to_val(line, q?p:"REG_SZ", q?q:p,
+ &value_type, &value);
+
+ error = callbacks->set_value(callback_data, curkey, line,
+ value_type, value);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(0, ("Error setting value for %s in %s\n", line, curkey));
+ DEBUG(0, ("Error setting value for %s in %s\n",
+ line, curkey));
talloc_free(mem_ctx);
return error;
}
-/*
+/*
Unix SMB/CIFS implementation.
Reading Registry.pol PReg registry files
-
+
Copyright (C) Wilco Baan Hofman 2006
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 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.
return WERR_OK;
}
-static WERROR reg_preg_diff_set_value(void *_data, const char *key_name, const char *value_name, uint32_t value_type, DATA_BLOB value_data)
+static WERROR reg_preg_diff_set_value(void *_data, const char *key_name,
+ const char *value_name,
+ uint32_t value_type, DATA_BLOB value_data)
{
struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
}
-static WERROR reg_preg_diff_del_value(void *_data, const char *key_name, const char *value_name)
+static WERROR reg_preg_diff_del_value(void *_data, const char *key_name,
+ const char *value_name)
{
struct preg_data *data = (struct preg_data *)_data;
return WERR_OK;
/**
* Save registry diff
*/
-_PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename, struct reg_diff_callbacks **callbacks, void **callback_data)
+_PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
+ struct reg_diff_callbacks **callbacks,
+ void **callback_data)
{
struct preg_data *data;
struct {
char hdr[4];
uint32_t version;
} preg_header;
-
+
data = talloc_zero(ctx, struct preg_data);
*callback_data = data;
}
snprintf(preg_header.hdr, 4, "PReg");
SIVAL(&preg_header, 4, 1);
- write(data->fd, (uint8_t *)&preg_header,8);
+ write(data->fd, (uint8_t *)&preg_header,8);
*callbacks = talloc(ctx, struct reg_diff_callbacks);
-
+
(*callbacks)->add_key = reg_preg_diff_add_key;
(*callbacks)->del_key = reg_preg_diff_del_key;
(*callbacks)->set_value = reg_preg_diff_set_value;
(*callbacks)->del_value = reg_preg_diff_del_value;
(*callbacks)->del_all_values = reg_preg_diff_del_all_values;
(*callbacks)->done = reg_preg_diff_done;
-
+
return WERR_OK;
}
/**
* Load diff file
*/
-_PUBLIC_ WERROR reg_preg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data)
+_PUBLIC_ WERROR reg_preg_diff_load(int fd,
+ const struct reg_diff_callbacks *callbacks,
+ void *callback_data)
{
struct {
char hdr[4];
char *buf_ptr = buf;
TALLOC_CTX *mem_ctx = talloc_init("reg_preg_diff_load");
-
+
/* Read first 8 bytes (the header) */
if (read(fd, &preg_header, 8) != 8) {
DEBUG(0, ("Could not read PReg file: %s\n",
}
if (preg_header.version > 1) {
DEBUG(0, ("Warning: file format version is higher than expected.\n"));
- }
+ }
/* Read the entries */
while(1) {
char *key, *value_name;
uint32_t value_type, length;
DATA_BLOB data;
-
+
if (!W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr))) {
break;
}
close(fd);
return WERR_GENERAL_FAILURE;
}
-
+
/* Get the path */
buf_ptr = buf;
- while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) && *buf_ptr != ';' && buf_ptr-buf < sizeof(buf)) {
+ while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ *buf_ptr != ';' && buf_ptr-buf < sizeof(buf)) {
buf_ptr++;
}
key = talloc_asprintf(mem_ctx, "\\%s", buf);
-
+
/* Get the name */
buf_ptr = buf;
- while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) && *buf_ptr != ';' && buf_ptr-buf < sizeof(buf)) {
+ while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ *buf_ptr != ';' && buf_ptr-buf < sizeof(buf)) {
buf_ptr++;
}
value_name = talloc_strdup(mem_ctx, buf);
}
/* Read past delimiter */
buf_ptr = buf;
- if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) && *buf_ptr == ';') && buf_ptr-buf < sizeof(buf)) {
+ if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ *buf_ptr == ';') && buf_ptr-buf < sizeof(buf)) {
DEBUG(0, ("Error in PReg file.\n"));
close(fd);
return WERR_GENERAL_FAILURE;
}
/* Read past delimiter */
buf_ptr = buf;
- if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) && *buf_ptr == ';') && buf_ptr-buf < sizeof(buf)) {
+ if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ *buf_ptr == ';') && buf_ptr-buf < sizeof(buf)) {
DEBUG(0, ("Error in PReg file.\n"));
close(fd);
return WERR_GENERAL_FAILURE;
- }
+ }
/* Get the data */
buf_ptr = buf;
- if (length < sizeof(buf) && read(fd, buf_ptr, length) != length) {
+ if (length < sizeof(buf) &&
+ read(fd, buf_ptr, length) != length) {
DEBUG(0, ("Error while reading PReg\n"));
close(fd);
return WERR_GENERAL_FAILURE;
}
data = data_blob_talloc(mem_ctx, buf, length);
-
+
/* Check if delimiter is in place (whine if it isn't) */
buf_ptr = buf;
- if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) && *buf_ptr == ']') && buf_ptr-buf < sizeof(buf)) {
- DEBUG(0, ("Warning: Missing ']' in PReg file, expected ']', got '%c' 0x%x.\n",*buf_ptr, *buf_ptr));
+ if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+ *buf_ptr == ']') && buf_ptr-buf < sizeof(buf)) {
+ DEBUG(0, ("Warning: Missing ']' in PReg file, expected ']', got '%c' 0x%x.\n",
+ *buf_ptr, *buf_ptr));
}
if (strcasecmp(value_name, "**DelVals") == 0) {
callbacks->del_all_values(callback_data, key);
} else if (strncasecmp(value_name, "**Del.",6) == 0) {
char *p = value_name+6;
-
+
callbacks->del_value(callback_data, key, p);
} else if (strcasecmp(value_name, "**DeleteValues") == 0) {
char *p, *q;
p = (char *) data.data;
-
+
while ((q = strchr_m(p, ';'))) {
- *q = '\0';
+ *q = '\0';
q++;
callbacks->del_value(callback_data, key, p);
char *p, *q, *full_key;
p = (char *) data.data;
-
+
while ((q = strchr_m(p, ';'))) {
*q = '\0';
q++;
-
- full_key = talloc_asprintf(mem_ctx, "%s\\%s", key, p);
+
+ full_key = talloc_asprintf(mem_ctx, "%s\\%s",
+ key, p);
callbacks->del_key(callback_data, full_key);
talloc_free(full_key);
- p = q;
+ p = q;
}
full_key = talloc_asprintf(mem_ctx, "%s\\%s", key, p);
callbacks->del_key(callback_data, full_key);
talloc_free(full_key);
} else {
callbacks->add_key(callback_data, key);
- callbacks->set_value(callback_data, key, value_name, value_type, data);
+ callbacks->set_value(callback_data, key, value_name,
+ value_type, data);
}
talloc_free(key);
talloc_free(value_name);
talloc_free(data.data);
}
- close(fd);
+ close(fd);
return WERR_OK;
}
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 <http://www.gnu.org/licenses/>. */
-
+
#include "includes.h"
#include "lib/registry/hive.h"
#include "system/filesys.h"
static struct hive_operations reg_backend_regf;
/**
- * There are several places on the web where the REGF format is explained;
+ * There are several places on the web where the REGF format is explained;
*
* TODO: Links
*/
struct regf_key_data {
struct hive_key key;
- struct regf_data *hive;
+ struct regf_data *hive;
uint32_t offset;
struct nk_block *nk;
};
-static struct hbin_block *hbin_by_offset(const struct regf_data *data,
- uint32_t offset, uint32_t *rel_offset)
+static struct hbin_block *hbin_by_offset(const struct regf_data *data,
+ uint32_t offset, uint32_t *rel_offset)
{
int i;
for (i = 0; data->hbins[i]; i++) {
- if (offset >= data->hbins[i]->offset_from_first &&
+ if (offset >= data->hbins[i]->offset_from_first &&
offset < data->hbins[i]->offset_from_first+
data->hbins[i]->offset_to_next) {
if (rel_offset != NULL)
{
uint32_t checksum = 0, x;
int i;
-
+
for (i = 0; i < 0x01FB; i+= 4) {
x = IVAL(buffer, i);
checksum ^= x;
ret.length = (ret.length ^ 0xffffffff) + 1;
ret.length -= 4; /* 4 bytes for the length... */
- ret.data = hbin->data +
+ ret.data = hbin->data +
(offset - hbin->offset_from_first - 0x20) + 4;
-
+
return ret;
}
-static bool hbin_get_tdr (struct regf_data *regf, uint32_t offset,
- TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
+static bool hbin_get_tdr(struct regf_data *regf, uint32_t offset,
+ TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
{
struct tdr_pull pull;
DEBUG(1, ("Unable to get data at 0x%04x\n", offset));
return false;
}
-
+
if (NT_STATUS_IS_ERR(pull_fn(&pull, ctx, p))) {
- DEBUG(1, ("Error parsing record at 0x%04x using tdr\n", offset));
+ DEBUG(1, ("Error parsing record at 0x%04x using tdr\n",
+ offset));
return false;
}
}
/* Allocate some new data */
-static DATA_BLOB hbin_alloc(struct regf_data *data, uint32_t size,
- uint32_t *offset)
+static DATA_BLOB hbin_alloc(struct regf_data *data, uint32_t size,
+ uint32_t *offset)
{
DATA_BLOB ret;
uint32_t rel_offset = -1; /* Relative offset ! */
my_size = -my_size;
} else if (my_size == size) { /* exact match */
rel_offset = j;
- DEBUG(4, ("Found free block of exact size %d in middle of HBIN\n", size));
+ DEBUG(4, ("Found free block of exact size %d in middle of HBIN\n",
+ size));
break;
} else if (my_size > size) { /* data will remain */
rel_offset = j;
/* Split this block and mark the next block as free */
- SIVAL(hbin->data, rel_offset+size, my_size-size);
- DEBUG(4, ("Found free block of size %d (needing %d) in middle of HBIN\n", my_size, size));
+ SIVAL(hbin->data, rel_offset+size, my_size-size);
+ DEBUG(4, ("Found free block of size %d (needing %d) in middle of HBIN\n",
+ my_size, size));
break;
}
}
if (rel_offset != -1)
break;
}
-
- /* No space available in previous hbins,
+
+ /* No space available in previous hbins,
* allocate new one */
- if (data->hbins[i] == NULL) {
- DEBUG(4, ("No space available in other HBINs for block of size %d, allocating new HBIN\n", size));
- data->hbins = talloc_realloc(data, data->hbins, struct hbin_block *, i+2);
+ if (data->hbins[i] == NULL) {
+ DEBUG(4, ("No space available in other HBINs for block of size %d, allocating new HBIN\n",
+ size));
+ data->hbins = talloc_realloc(data, data->hbins,
+ struct hbin_block *, i+2);
hbin = talloc(data->hbins, struct hbin_block);
SMB_ASSERT(hbin != NULL);
return ret;
}
-static uint32_t hbin_store_tdr (struct regf_data *data, tdr_push_fn_t push_fn, void *p)
+static uint32_t hbin_store_tdr(struct regf_data *data,
+ tdr_push_fn_t push_fn, void *p)
{
struct tdr_push *push = talloc_zero(data, struct tdr_push);
uint32_t ret;
-
+
if (NT_STATUS_IS_ERR(push_fn(push, p))) {
DEBUG(0, ("Error during push\n"));
return -1;
{
int32_t size;
uint32_t rel_offset;
- int32_t next_size;
+ int32_t next_size;
struct hbin_block *hbin;
SMB_ASSERT (offset > 0);
-
+
hbin = hbin_by_offset(data, offset, &rel_offset);
if (hbin == NULL)
return;
-
+
/* Get original size */
size = IVALS(hbin->data, rel_offset);
if (size > 0) {
- DEBUG(1, ("Trying to free already freed block at 0x%04x\n", offset));
+ DEBUG(1, ("Trying to free already freed block at 0x%04x\n",
+ offset));
return;
}
/* Mark as unused */
size = -size;
-
+
/* If the next block is free, merge into big free block */
if (rel_offset + size < hbin->offset_to_next) {
next_size = IVALS(hbin->data, rel_offset+size);
/**
* Store a data blob data was already stored, but has changed in size
- * Will try to save it at the current location if possible, otherwise
+ * Will try to save it at the current location if possible, otherwise
* does a free + store */
-static uint32_t hbin_store_resize(struct regf_data *data,
- uint32_t orig_offset, DATA_BLOB blob)
+static uint32_t hbin_store_resize(struct regf_data *data,
+ uint32_t orig_offset, DATA_BLOB blob)
{
uint32_t rel_offset;
- struct hbin_block *hbin = hbin_by_offset(data, orig_offset, &rel_offset);
+ struct hbin_block *hbin = hbin_by_offset(data, orig_offset,
+ &rel_offset);
int32_t my_size;
int32_t orig_size;
int32_t needed_size;
* and free/merge it */
if (orig_size - needed_size > 0x4) {
SIVALS(hbin->data, rel_offset, -needed_size);
- SIVALS(hbin->data, rel_offset + needed_size, needed_size-orig_size);
+ SIVALS(hbin->data, rel_offset + needed_size,
+ needed_size-orig_size);
hbin_free(data, orig_offset + needed_size);
}
return orig_offset;
break;
my_size = IVALS(hbin->data, i);
-
+
if (my_size == 0x0) {
DEBUG(0, ("Invalid zero-length block! File is corrupt.\n"));
break;
if (possible_size >= blob.length) {
SIVAL(hbin->data, rel_offset, -possible_size);
- memcpy(hbin->data + rel_offset + 0x4, blob.data, blob.length);
+ memcpy(hbin->data + rel_offset + 0x4,
+ blob.data, blob.length);
return orig_offset;
}
}
return hbin_store(data, blob);
}
-static uint32_t hbin_store_tdr_resize (struct regf_data *regf, tdr_push_fn_t push_fn,
- uint32_t orig_offset, void *p)
+static uint32_t hbin_store_tdr_resize(struct regf_data *regf,
+ tdr_push_fn_t push_fn,
+ uint32_t orig_offset, void *p)
{
struct tdr_push *push = talloc_zero(regf, struct tdr_push);
uint32_t ret;
-
+
if (NT_STATUS_IS_ERR(push_fn(push, p))) {
DEBUG(0, ("Error during push\n"));
return -1;
return ret;
}
-static uint32_t regf_create_lh_hash(const char *name)
+static uint32_t regf_create_lh_hash(const char *name)
{
char *hash_name;
uint32_t ret = 0;
uint16_t i;
- hash_name = strupper_talloc(NULL, name);
+ hash_name = strupper_talloc(NULL, name);
for (i = 0; *(hash_name + i) != 0; i++) {
ret *= 37;
ret += *(hash_name + i);
return ret;
}
-static WERROR regf_get_info (TALLOC_CTX *mem_ctx,
- const struct hive_key *key,
- const char **classname,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_mod_time)
+static WERROR regf_get_info(TALLOC_CTX *mem_ctx,
+ const struct hive_key *key,
+ const char **classname,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_mod_time)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
if (num_subkeys != NULL)
if (classname != NULL) {
if (private_data->nk->clsname_offset != -1) {
- DATA_BLOB data = hbin_get(private_data->hive,
- private_data->nk->clsname_offset);
- *classname = talloc_strndup(mem_ctx,
- (char*)data.data, private_data->nk->clsname_length);
- } else
+ DATA_BLOB data = hbin_get(private_data->hive,
+ private_data->nk->clsname_offset);
+ *classname = talloc_strndup(mem_ctx,
+ (char*)data.data,
+ private_data->nk->clsname_length);
+ } else
*classname = NULL;
}
/* TODO: Last mod time */
-
+
return WERR_OK;
}
-static struct regf_key_data *regf_get_key(TALLOC_CTX *ctx,
- struct regf_data *regf,
- uint32_t offset)
+static struct regf_key_data *regf_get_key(TALLOC_CTX *ctx,
+ struct regf_data *regf,
+ uint32_t offset)
{
struct nk_block *nk;
struct regf_key_data *ret;
ret->nk = nk;
- if (!hbin_get_tdr(regf, offset, nk, (tdr_pull_fn_t)tdr_pull_nk_block, nk)) {
+ if (!hbin_get_tdr(regf, offset, nk,
+ (tdr_pull_fn_t)tdr_pull_nk_block, nk)) {
DEBUG(0, ("Unable to find HBIN data for offset %d\n", offset));
return NULL;
}
}
-static WERROR regf_get_value(TALLOC_CTX *ctx, const struct hive_key *key,
- int idx, const char **name,
- uint32_t *data_type, DATA_BLOB *data)
+static WERROR regf_get_value(TALLOC_CTX *ctx, const struct hive_key *key,
+ int idx, const char **name,
+ uint32_t *data_type, DATA_BLOB *data)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
struct vk_block *vk;
struct regf_data *regf = private_data->hive;
vk = talloc(NULL, struct vk_block);
W_ERROR_HAVE_NO_MEMORY(vk);
-
- if (!hbin_get_tdr(regf, vk_offset, vk, (tdr_pull_fn_t)tdr_pull_vk_block, vk)) {
+
+ if (!hbin_get_tdr(regf, vk_offset, vk,
+ (tdr_pull_fn_t)tdr_pull_vk_block, vk)) {
DEBUG(0, ("Unable to get VK block at %d\n", vk_offset));
talloc_free(vk);
return WERR_GENERAL_FAILURE;
if (data_type != NULL)
*data_type = vk->data_type;
- if (vk->data_length & 0x80000000) {
+ if (vk->data_length & 0x80000000) {
vk->data_length &=~0x80000000;
data->data = (uint8_t *)&vk->data_offset;
data->length = vk->data_length;
}
talloc_free(vk);
-
+
return WERR_OK;
}
-static WERROR regf_get_value_by_name (TALLOC_CTX *mem_ctx,
- struct hive_key *key, const char *name,
- uint32_t *type, DATA_BLOB *data)
+static WERROR regf_get_value_by_name(TALLOC_CTX *mem_ctx,
+ struct hive_key *key, const char *name,
+ uint32_t *type, DATA_BLOB *data)
{
int i;
const char *vname;
/* FIXME: Do binary search? Is this list sorted at all? */
- for (i = 0; W_ERROR_IS_OK(error = regf_get_value(mem_ctx, key, i,
- &vname, type, data)); i++) {
+ for (i = 0; W_ERROR_IS_OK(error = regf_get_value(mem_ctx, key, i,
+ &vname, type, data));
+ i++) {
if (!strcmp(vname, name))
return WERR_OK;
- }
+ }
if (W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS))
return WERR_NOT_FOUND;
return error;
}
-
-static WERROR regf_get_subkey_by_index (TALLOC_CTX *ctx,
- const struct hive_key *key,
- uint32_t idx, const char **name,
- const char **classname,
- NTTIME *last_mod_time)
+
+static WERROR regf_get_subkey_by_index(TALLOC_CTX *ctx,
+ const struct hive_key *key,
+ uint32_t idx, const char **name,
+ const char **classname,
+ NTTIME *last_mod_time)
{
DATA_BLOB data;
struct regf_key_data *ret;
return WERR_GENERAL_FAILURE;
}
key_off = li.nk_offset[idx];
-
+
} else if (!strncmp((char *)data.data, "lf", 2)) {
struct lf_block lf;
struct tdr_pull pull;
} else if (!strncmp((char *)data.data, "lh", 2)) {
struct lh_block lh;
struct tdr_pull pull;
-
+
DEBUG(10, ("Subkeys in LH list\n"));
ZERO_STRUCT(pull);
pull.data = data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull, nk, &lh))) {
DEBUG(0, ("Error parsing LH list\n"));
return WERR_GENERAL_FAILURE;
}
SMB_ASSERT(!strncmp(lh.header, "lh", 2));
-
+
if (lh.key_count != nk->num_subkeys) {
DEBUG(0, ("Subkey counts don't match\n"));
return WERR_GENERAL_FAILURE;
struct tdr_pull pull;
uint16_t i;
uint16_t sublist_count = 0;
-
+
DEBUG(10, ("Subkeys in RI list\n"));
ZERO_STRUCT(pull);
pull.data = data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_ri_block(&pull, nk, &ri))) {
DEBUG(0, ("Error parsing RI list\n"));
return WERR_GENERAL_FAILURE;
}
SMB_ASSERT(!strncmp(ri.header, "ri", 2));
-
+
for (i = 0; i < ri.key_count; i++) {
DATA_BLOB list_data;
-
+
/* Get sublist data blob */
list_data = hbin_get(private_data->hive, ri.offset[i]);
if (!list_data.data) {
DEBUG(0, ("Error getting RI list."));
return WERR_GENERAL_FAILURE;
}
-
+
ZERO_STRUCT(pull);
pull.data = list_data;
-
+
if (!strncmp((char *)list_data.data, "li", 2)) {
struct li_block li;
DEBUG(10, ("Subkeys in RI->LI list\n"));
- if (NT_STATUS_IS_ERR(tdr_pull_li_block(&pull, nk, &li))) {
+ if (NT_STATUS_IS_ERR(tdr_pull_li_block(&pull,
+ nk,
+ &li))) {
DEBUG(0, ("Error parsing LI list from RI\n"));
return WERR_GENERAL_FAILURE;
}
SMB_ASSERT(!strncmp(li.header, "li", 2));
-
+
/* Advance to next sublist if necessary */
if (idx >= sublist_count + li.key_count) {
sublist_count += li.key_count;
break;
} else if (!strncmp((char *)list_data.data, "lh", 2)) {
struct lh_block lh;
-
+
DEBUG(10, ("Subkeys in RI->LH list\n"));
- if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull, nk, &lh))) {
+ if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull,
+ nk,
+ &lh))) {
DEBUG(0, ("Error parsing LH list from RI\n"));
return WERR_GENERAL_FAILURE;
}
return WERR_GENERAL_FAILURE;
}
-
+
}
-
+
if (idx > sublist_count) {
return WERR_NO_MORE_ITEMS;
}
} else {
- DEBUG(0, ("Unknown type for subkey list (0x%04x): %c%c\n",
+ DEBUG(0, ("Unknown type for subkey list (0x%04x): %c%c\n",
nk->subkeys_offset, data.data[0], data.data[1]));
return WERR_GENERAL_FAILURE;
}
if (classname != NULL) {
if (ret->nk->clsname_offset != -1) {
- DATA_BLOB db = hbin_get(ret->hive,
- ret->nk->clsname_offset);
- *classname = talloc_strndup(ctx,
- (char*)db.data, ret->nk->clsname_length);
- } else
+ DATA_BLOB db = hbin_get(ret->hive,
+ ret->nk->clsname_offset);
+ *classname = talloc_strndup(ctx,
+ (char*)db.data,
+ ret->nk->clsname_length);
+ } else
*classname = NULL;
}
return WERR_OK;
}
-static WERROR regf_match_subkey_by_name(TALLOC_CTX *ctx,
- const struct hive_key *key, uint32_t offset,
- const char *name, uint32_t *ret)
+static WERROR regf_match_subkey_by_name(TALLOC_CTX *ctx,
+ const struct hive_key *key,
+ uint32_t offset,
+ const char *name, uint32_t *ret)
{
DATA_BLOB subkey_data;
struct nk_block subkey;
struct tdr_pull pull;
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
-
+
subkey_data = hbin_get(private_data->hive, offset);
if (!subkey_data.data) {
DEBUG(0, ("Unable to retrieve subkey HBIN\n"));
ZERO_STRUCT(pull);
pull.data = subkey_data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_nk_block(&pull, ctx, &subkey))) {
DEBUG(0, ("Error parsing NK structure.\n"));
return WERR_GENERAL_FAILURE;
}
return WERR_OK;
}
-
-static WERROR regf_get_subkey_by_name(TALLOC_CTX *ctx,
- const struct hive_key *key,
- const char *name,
- struct hive_key **ret)
+
+static WERROR regf_get_subkey_by_name(TALLOC_CTX *ctx,
+ const struct hive_key *key,
+ const char *name,
+ struct hive_key **ret)
{
DATA_BLOB data;
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
struct nk_block *nk = private_data->nk;
uint32_t key_off = 0;
DEBUG(10, ("Subkeys in LI list\n"));
ZERO_STRUCT(pull);
pull.data = data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_li_block(&pull, nk, &li))) {
DEBUG(0, ("Error parsing LI list\n"));
return WERR_GENERAL_FAILURE;
DEBUG(0, ("Subkey counts don't match\n"));
return WERR_GENERAL_FAILURE;
}
-
+
for (i = 0; i < li.key_count; i++) {
- W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key, li.nk_offset[i], name, &key_off));
+ W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
+ li.nk_offset[i],
+ name,
+ &key_off));
if (key_off != 0)
break;
}
DEBUG(10, ("Subkeys in LF list\n"));
ZERO_STRUCT(pull);
pull.data = data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_lf_block(&pull, nk, &lf))) {
DEBUG(0, ("Error parsing LF list\n"));
return WERR_GENERAL_FAILURE;
DEBUG(0, ("Subkey counts don't match\n"));
return WERR_GENERAL_FAILURE;
}
-
+
for (i = 0; i < lf.key_count; i++) {
if (strncmp(lf.hr[i].hash, name, 4)) {
continue;
}
- W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key, lf.hr[i].nk_offset, name, &key_off));
+ W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk,
+ key,
+ lf.hr[i].nk_offset,
+ name,
+ &key_off));
if (key_off != 0)
break;
}
DEBUG(10, ("Subkeys in LH list\n"));
ZERO_STRUCT(pull);
pull.data = data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull, nk, &lh))) {
DEBUG(0, ("Error parsing LH list\n"));
return WERR_GENERAL_FAILURE;
DEBUG(0, ("Subkey counts don't match\n"));
return WERR_GENERAL_FAILURE;
}
-
+
hash = regf_create_lh_hash(name);
for (i = 0; i < lh.key_count; i++) {
if (lh.hr[i].base37 != hash) {
continue;
}
- W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key, lh.hr[i].nk_offset, name, &key_off));
+ W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk,
+ key,
+ lh.hr[i].nk_offset,
+ name,
+ &key_off));
if (key_off != 0)
break;
- }
+ }
if (key_off == 0)
return WERR_NOT_FOUND;
} else if (!strncmp((char *)data.data, "ri", 2)) {
DEBUG(10, ("Subkeys in RI list\n"));
ZERO_STRUCT(pull);
pull.data = data;
-
+
if (NT_STATUS_IS_ERR(tdr_pull_ri_block(&pull, nk, &ri))) {
DEBUG(0, ("Error parsing RI list\n"));
return WERR_GENERAL_FAILURE;
}
SMB_ASSERT(!strncmp(ri.header, "ri", 2));
-
+
for (i = 0; i < ri.key_count; i++) {
DATA_BLOB list_data;
-
+
/* Get sublist data blob */
list_data = hbin_get(private_data->hive, ri.offset[i]);
if (list_data.data == NULL) {
DEBUG(0, ("Error getting RI list."));
return WERR_GENERAL_FAILURE;
}
-
+
ZERO_STRUCT(pull);
pull.data = list_data;
-
+
if (!strncmp((char *)list_data.data, "li", 2)) {
struct li_block li;
-
- if (NT_STATUS_IS_ERR(tdr_pull_li_block(&pull, nk, &li))) {
+
+ if (NT_STATUS_IS_ERR(tdr_pull_li_block(&pull,
+ nk,
+ &li))) {
DEBUG(0, ("Error parsing LI list from RI\n"));
return WERR_GENERAL_FAILURE;
}
SMB_ASSERT(!strncmp(li.header, "li", 2));
-
+
for (j = 0; j < li.key_count; j++) {
- W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
- li.nk_offset[j], name, &key_off));
+ W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
+ li.nk_offset[j],
+ name,
+ &key_off));
if (key_off)
break;
}
} else if (!strncmp((char *)list_data.data, "lh", 2)) {
struct lh_block lh;
uint32_t hash;
-
- if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull, nk, &lh))) {
+
+ if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull,
+ nk,
+ &lh))) {
DEBUG(0, ("Error parsing LH list from RI\n"));
return WERR_GENERAL_FAILURE;
}
if (lh.hr[j].base37 != hash) {
continue;
}
- W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
- lh.hr[j].nk_offset, name, &key_off));
+ W_ERROR_NOT_OK_RETURN(regf_match_subkey_by_name(nk, key,
+ lh.hr[j].nk_offset,
+ name,
+ &key_off));
if (key_off)
break;
}
return WERR_GENERAL_FAILURE;
}
- *ret = (struct hive_key *)regf_get_key (ctx, private_data->hive, key_off);
+ *ret = (struct hive_key *)regf_get_key(ctx, private_data->hive,
+ key_off);
return WERR_OK;
}
-static WERROR regf_set_sec_desc (struct hive_key *key,
- const struct security_descriptor *sec_desc)
+static WERROR regf_set_sec_desc(struct hive_key *key,
+ const struct security_descriptor *sec_desc)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
struct sk_block cur_sk, sk, new_sk;
struct regf_data *regf = private_data->hive;
bool update_cur_sk = false;
/* Get the root nk */
- hbin_get_tdr(regf, regf->header->data_offset, regf,
- (tdr_pull_fn_t) tdr_pull_nk_block, &root);
+ hbin_get_tdr(regf, regf->header->data_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_nk_block, &root);
/* Push the security descriptor to a blob */
- if (NT_STATUS_IS_ERR(ndr_push_struct_blob(&data, regf, sec_desc,
- (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
+ if (NT_STATUS_IS_ERR(ndr_push_struct_blob(&data, regf, sec_desc,
+ (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
DEBUG(0, ("Unable to push security descriptor\n"));
return WERR_GENERAL_FAILURE;
}
- /* Get the current security descriptor for the key */
- if (!hbin_get_tdr(regf, private_data->nk->sk_offset, regf,
- (tdr_pull_fn_t) tdr_pull_sk_block, &cur_sk)) {
+ /* Get the current security descriptor for the key */
+ if (!hbin_get_tdr(regf, private_data->nk->sk_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &cur_sk)) {
DEBUG(0, ("Unable to find security descriptor for current key\n"));
return WERR_BADFILE;
}
/* If there's no change, change nothing. */
- if (memcmp(data.data, cur_sk.sec_desc, MIN(data.length, cur_sk.rec_size)) == 0) {
+ if (memcmp(data.data, cur_sk.sec_desc,
+ MIN(data.length, cur_sk.rec_size)) == 0) {
return WERR_OK;
}
- /* Delete the current sk if only this key is using it */
+ /* Delete the current sk if only this key is using it */
if (cur_sk.ref_cnt == 1) {
- /* Get the previous security descriptor for the key */
- if (!hbin_get_tdr(regf, cur_sk.prev_offset, regf,
- (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
+ /* Get the previous security descriptor for the key */
+ if (!hbin_get_tdr(regf, cur_sk.prev_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
DEBUG(0, ("Unable to find prev security descriptor for current key\n"));
return WERR_BADFILE;
}
/* Change and store the previous security descriptor */
sk.next_offset = cur_sk.next_offset;
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, cur_sk.prev_offset, &sk);
-
- /* Get the next security descriptor for the key */
- if (!hbin_get_tdr(regf, cur_sk.next_offset, regf, (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
+ hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block,
+ cur_sk.prev_offset, &sk);
+
+ /* Get the next security descriptor for the key */
+ if (!hbin_get_tdr(regf, cur_sk.next_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
DEBUG(0, ("Unable to find next security descriptor for current key\n"));
return WERR_BADFILE;
}
/* Change and store the next security descriptor */
sk.prev_offset = cur_sk.prev_offset;
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, cur_sk.next_offset, &sk);
+ hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block,
+ cur_sk.next_offset, &sk);
hbin_free(regf, private_data->nk->sk_offset);
} else {
do {
cur_sk_offset = sk_offset;
- if (!hbin_get_tdr(regf, sk_offset, regf, (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
+ if (!hbin_get_tdr(regf, sk_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
DEBUG(0, ("Unable to find security descriptor\n"));
return WERR_BADFILE;
}
if (memcmp(data.data, sk.sec_desc, MIN(data.length, sk.rec_size)) == 0) {
private_data->nk->sk_offset = sk_offset;
sk.ref_cnt++;
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, sk_offset, &sk);
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block, private_data->offset, private_data->nk);
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ sk_offset, &sk);
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_nk_block,
+ private_data->offset,
+ private_data->nk);
return WERR_OK;
}
sk_offset = sk.next_offset;
} while (sk_offset != root.sk_offset);
-
+
ZERO_STRUCT(new_sk);
new_sk.header = "sk";
new_sk.prev_offset = cur_sk_offset;
new_sk.ref_cnt = 1;
new_sk.rec_size = data.length;
new_sk.sec_desc = data.data;
-
- sk_offset = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_sk_block, &new_sk);
+
+ sk_offset = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ &new_sk);
if (sk_offset == -1) {
DEBUG(0, ("Error storing sk block\n"));
return WERR_GENERAL_FAILURE;
private_data->nk->sk_offset = sk_offset;
if (update_cur_sk) {
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, private_data->nk->sk_offset, &cur_sk);
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ private_data->nk->sk_offset, &cur_sk);
}
- /* Get the previous security descriptor for the key */
- if (!hbin_get_tdr(regf, new_sk.prev_offset, regf, (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
+ /* Get the previous security descriptor for the key */
+ if (!hbin_get_tdr(regf, new_sk.prev_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
DEBUG(0, ("Unable to find security descriptor for previous key\n"));
return WERR_BADFILE;
}
/* Change and store the previous security descriptor */
sk.next_offset = sk_offset;
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, cur_sk.prev_offset, &sk);
-
- /* Get the next security descriptor for the key (always root, as we append) */
- if (!hbin_get_tdr(regf, new_sk.next_offset, regf, (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ cur_sk.prev_offset, &sk);
+
+ /* Get the next security descriptor for the key (always root, as we append) */
+ if (!hbin_get_tdr(regf, new_sk.next_offset, regf,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
DEBUG(0, ("Unable to find security descriptor for current key\n"));
return WERR_BADFILE;
}
/* Change and store the next security descriptor (always root, as we append) */
sk.prev_offset = sk_offset;
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, root.sk_offset, &sk);
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ root.sk_offset, &sk);
/* Store the nk. */
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_sk_block, private_data->offset, private_data->nk);
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_sk_block,
+ private_data->offset, private_data->nk);
return WERR_OK;
}
-static WERROR regf_get_sec_desc(TALLOC_CTX *ctx, const struct hive_key *key,
- struct security_descriptor **sd)
+static WERROR regf_get_sec_desc(TALLOC_CTX *ctx, const struct hive_key *key,
+ struct security_descriptor **sd)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
struct sk_block sk;
struct regf_data *regf = private_data->hive;
DATA_BLOB data;
- if (!hbin_get_tdr(regf, private_data->nk->sk_offset, ctx, (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
+ if (!hbin_get_tdr(regf, private_data->nk->sk_offset, ctx,
+ (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
DEBUG(0, ("Unable to find security descriptor\n"));
return WERR_GENERAL_FAILURE;
}
-
+
if (strcmp(sk.header, "sk") != 0) {
DEBUG(0, ("Expected 'sk', got '%s'\n", sk.header));
return WERR_GENERAL_FAILURE;
data.data = sk.sec_desc;
data.length = sk.rec_size;
- if (NT_STATUS_IS_ERR(ndr_pull_struct_blob(&data, ctx, *sd, (ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
+ if (NT_STATUS_IS_ERR(ndr_pull_struct_blob(&data, ctx, *sd,
+ (ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
DEBUG(0, ("Error parsing security descriptor\n"));
return WERR_GENERAL_FAILURE;
}
return WERR_OK;
}
-static WERROR regf_sl_add_entry(struct regf_data *regf, uint32_t list_offset,
- const char *name, uint32_t key_offset, uint32_t *ret)
+static WERROR regf_sl_add_entry(struct regf_data *regf, uint32_t list_offset,
+ const char *name,
+ uint32_t key_offset, uint32_t *ret)
{
DATA_BLOB data;
/* Create a new key if necessary */
- if (list_offset == -1) {
+ if (list_offset == -1) {
if (regf->header->version.major != 1) {
DEBUG(0, ("Can't store keys in unknown registry format\n"));
return WERR_NOT_SUPPORTED;
}
- if (regf->header->version.minor < 3) {
+ if (regf->header->version.minor < 3) {
/* Store LI */
struct li_block li;
ZERO_STRUCT(li);
li.header = "li";
- li.key_count = 1;
+ li.key_count = 1;
li.nk_offset = talloc_array(regf, uint32_t, 1);
W_ERROR_HAVE_NO_MEMORY(li.nk_offset);
li.nk_offset[0] = key_offset;
- *ret = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_li_block, &li);
+ *ret = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_li_block,
+ &li);
talloc_free(li.nk_offset);
- } else if (regf->header->version.minor == 3 || regf->header->version.minor == 4) {
+ } else if (regf->header->version.minor == 3 ||
+ regf->header->version.minor == 4) {
/* Store LF */
struct lf_block lf;
ZERO_STRUCT(lf);
lf.header = "lf";
lf.key_count = 1;
-
+
lf.hr = talloc_array(regf, struct hash_record, 1);
W_ERROR_HAVE_NO_MEMORY(lf.hr);
lf.hr[0].nk_offset = key_offset;
lf.hr[0].hash = talloc_strndup(lf.hr, name, 4);
W_ERROR_HAVE_NO_MEMORY(lf.hr[0].hash);
- *ret = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_lf_block, &lf);
+ *ret = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_lf_block,
+ &lf);
talloc_free(lf.hr);
} else if (regf->header->version.minor == 5) {
ZERO_STRUCT(lh);
lh.header = "lh";
lh.key_count = 1;
-
+
lh.hr = talloc_array(regf, struct lh_hash, 1);
W_ERROR_HAVE_NO_MEMORY(lh.hr);
lh.hr[0].nk_offset = key_offset;
lh.hr[0].base37 = regf_create_lh_hash(name);
- *ret = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_lh_block, &lh);
+ *ret = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_lh_block,
+ &lh);
talloc_free(lh.hr);
}
return WERR_OK;
- }
-
+ }
+
data = hbin_get(regf, list_offset);
if (!data.data) {
DEBUG(0, ("Unable to find subkey list\n"));
if (!strncmp((char *)data.data, "li", 2)) {
struct tdr_pull pull;
struct li_block li;
-
+
ZERO_STRUCT(pull);
pull.data = data;
DEBUG(0, ("LI header corrupt\n"));
return WERR_BADFILE;
}
-
- li.nk_offset = talloc_realloc(regf, li.nk_offset, uint32_t, li.key_count+1);
+
+ li.nk_offset = talloc_realloc(regf, li.nk_offset,
+ uint32_t, li.key_count+1);
W_ERROR_HAVE_NO_MEMORY(li.nk_offset);
li.nk_offset[li.key_count] = key_offset;
li.key_count++;
- *ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t)tdr_push_li_block, list_offset, &li);
-
+ *ret = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t)tdr_push_li_block,
+ list_offset, &li);
+
talloc_free(li.nk_offset);
} else if (!strncmp((char *)data.data, "lf", 2)) {
struct tdr_pull pull;
return WERR_BADFILE;
}
SMB_ASSERT(!strncmp(lf.header, "lf", 2));
-
- lf.hr = talloc_realloc(regf, lf.hr, struct hash_record, lf.key_count+1);
+
+ lf.hr = talloc_realloc(regf, lf.hr, struct hash_record,
+ lf.key_count+1);
W_ERROR_HAVE_NO_MEMORY(lf.hr);
lf.hr[lf.key_count].nk_offset = key_offset;
lf.hr[lf.key_count].hash = talloc_strndup(lf.hr, name, 4);
W_ERROR_HAVE_NO_MEMORY(lf.hr[lf.key_count].hash);
lf.key_count++;
- *ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t)tdr_push_lf_block, list_offset, &lf);
+ *ret = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t)tdr_push_lf_block,
+ list_offset, &lf);
talloc_free(lf.hr);
} else if (!strncmp((char *)data.data, "lh", 2)) {
return WERR_BADFILE;
}
SMB_ASSERT(!strncmp(lh.header, "lh", 2));
-
- lh.hr = talloc_realloc(regf, lh.hr, struct lh_hash, lh.key_count+1);
+
+ lh.hr = talloc_realloc(regf, lh.hr, struct lh_hash,
+ lh.key_count+1);
W_ERROR_HAVE_NO_MEMORY(lh.hr);
lh.hr[lh.key_count].nk_offset = key_offset;
lh.hr[lh.key_count].base37 = regf_create_lh_hash(name);
lh.key_count++;
- *ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t)tdr_push_lh_block, list_offset, &lh);
+ *ret = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t)tdr_push_lh_block,
+ list_offset, &lh);
talloc_free(lh.hr);
} else if (!strncmp((char *)data.data, "ri", 2)) {
DEBUG(0, ("Cannot add to unknown subkey list\n"));
return WERR_BADFILE;
}
-
+
return WERR_OK;
}
-static WERROR regf_sl_del_entry(struct regf_data *regf, uint32_t list_offset,
- uint32_t key_offset, uint32_t *ret)
+static WERROR regf_sl_del_entry(struct regf_data *regf, uint32_t list_offset,
+ uint32_t key_offset, uint32_t *ret)
{
DATA_BLOB data;
struct tdr_pull pull;
uint16_t i;
bool found_offset = false;
-
+
DEBUG(10, ("Subkeys in LI list\n"));
-
+
ZERO_STRUCT(pull);
- pull.data = data;
-
+ pull.data = data;
+
if (NT_STATUS_IS_ERR(tdr_pull_li_block(&pull, regf, &li))) {
DEBUG(0, ("Error parsing LI list\n"));
return WERR_BADFILE;
}
-
+
SMB_ASSERT(!strncmp(li.header, "li", 2));
for (i = 0; i < li.key_count; i++) {
}
/* Store li block */
- *ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_li_block, list_offset, &li);
+ *ret = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_li_block,
+ list_offset, &li);
} else if (strncmp((char *)data.data, "lf", 2) == 0) {
struct lf_block lf;
struct tdr_pull pull;
uint16_t i;
bool found_offset = false;
-
+
DEBUG(10, ("Subkeys in LF list\n"));
-
+
ZERO_STRUCT(pull);
- pull.data = data;
-
+ pull.data = data;
+
if (NT_STATUS_IS_ERR(tdr_pull_lf_block(&pull, regf, &lf))) {
DEBUG(0, ("Error parsing LF list\n"));
return WERR_BADFILE;
}
-
+
SMB_ASSERT(!strncmp(lf.header, "lf", 2));
for (i = 0; i < lf.key_count; i++) {
return WERR_NOT_FOUND;
}
lf.key_count--;
-
+
/* If the there are no entries left, free the subkey list */
if (lf.key_count == 0) {
hbin_free(regf, list_offset);
}
/* Store lf block */
- *ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_lf_block, list_offset, &lf);
+ *ret = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_lf_block,
+ list_offset, &lf);
} else if (strncmp((char *)data.data, "lh", 2) == 0) {
struct lh_block lh;
struct tdr_pull pull;
uint16_t i;
bool found_offset = false;
-
+
DEBUG(10, ("Subkeys in LH list\n"));
-
+
ZERO_STRUCT(pull);
- pull.data = data;
-
+ pull.data = data;
+
if (NT_STATUS_IS_ERR(tdr_pull_lh_block(&pull, regf, &lh))) {
DEBUG(0, ("Error parsing LF list\n"));
return WERR_BADFILE;
}
-
+
SMB_ASSERT(!strncmp(lh.header, "lh", 2));
for (i = 0; i < lh.key_count; i++) {
return WERR_NOT_FOUND;
}
lh.key_count--;
-
+
/* If the there are no entries left, free the subkey list */
if (lh.key_count == 0) {
hbin_free(regf, list_offset);
}
/* Store lh block */
- *ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_lh_block, list_offset, &lh);
+ *ret = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_lh_block,
+ list_offset, &lh);
} else if (strncmp((char *)data.data, "ri", 2) == 0) {
/* FIXME */
DEBUG(0, ("Sorry, deletion from ri block is not supported yet.\n"));
static WERROR regf_del_value (struct hive_key *key, const char *name)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
struct regf_data *regf = private_data->hive;
struct nk_block *nk = private_data->nk;
((uint32_t *)values.data)[i-1] = ((uint32_t *) values.data)[i];
} else {
vk_offset = IVAL(values.data, i * 4);
- if (!hbin_get_tdr(regf, vk_offset, private_data,
- (tdr_pull_fn_t)tdr_pull_vk_block, &vk)) {
- DEBUG(0, ("Unable to get VK block at %d\n", vk_offset));
+ if (!hbin_get_tdr(regf, vk_offset, private_data,
+ (tdr_pull_fn_t)tdr_pull_vk_block,
+ &vk)) {
+ DEBUG(0, ("Unable to get VK block at %d\n",
+ vk_offset));
return WERR_BADFILE;
- }
+ }
if (strcmp(vk.data_name, name) == 0) {
hbin_free(regf, vk_offset);
found_offset = true;
if (nk->num_values == 0) {
hbin_free(regf, nk->values_offset);
nk->values_offset = -1;
- } else {
- nk->values_offset = hbin_store_resize(regf, nk->values_offset, values);
+ } else {
+ nk->values_offset = hbin_store_resize(regf,
+ nk->values_offset,
+ values);
}
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block, private_data->offset, nk);
+ hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block,
+ private_data->offset, nk);
return regf_save_hbin(private_data->hive);
}
static WERROR regf_del_key(const struct hive_key *parent, const char *name)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)parent;
struct regf_key_data *key;
struct nk_block *parent_nk;
WERROR error;
SMB_ASSERT(private_data);
-
+
parent_nk = private_data->nk;
if (parent_nk->subkeys_offset == -1) {
}
/* Find the key */
- if (!W_ERROR_IS_OK(regf_get_subkey_by_name(parent_nk, parent, name,
- (struct hive_key **)&key))) {
+ if (!W_ERROR_IS_OK(regf_get_subkey_by_name(parent_nk, parent, name,
+ (struct hive_key **)&key))) {
DEBUG(2, ("Key '%s' not found\n", name));
return WERR_NOT_FOUND;
}
-
- if (key->nk->subkeys_offset != -1 ||
+
+ if (key->nk->subkeys_offset != -1 ||
key->nk->values_offset != -1) {
DEBUG(0, ("Key '%s' is not empty.\n", name));
return WERR_FILE_EXISTS;
}
-
+
/* Delete it from the subkey list. */
- error = regf_sl_del_entry(private_data->hive, parent_nk->subkeys_offset,
- key->offset, &parent_nk->subkeys_offset);
+ error = regf_sl_del_entry(private_data->hive, parent_nk->subkeys_offset,
+ key->offset, &parent_nk->subkeys_offset);
if (!W_ERROR_IS_OK(error)) {
DEBUG(0, ("Can't store new subkey list for parent key. Won't delete.\n"));
return error;
/* Re-store parent key */
parent_nk->num_subkeys--;
- hbin_store_tdr_resize(private_data->hive,
- (tdr_push_fn_t) tdr_push_nk_block,
- private_data->offset, parent_nk);
+ hbin_store_tdr_resize(private_data->hive,
+ (tdr_push_fn_t) tdr_push_nk_block,
+ private_data->offset, parent_nk);
if (key->nk->clsname_offset != -1) {
hbin_free(private_data->hive, key->nk->clsname_offset);
return regf_save_hbin(private_data->hive);
}
-static WERROR regf_add_key(TALLOC_CTX *ctx, const struct hive_key *parent,
- const char *name, const char *classname,
- struct security_descriptor *sec_desc,
- struct hive_key **ret)
+static WERROR regf_add_key(TALLOC_CTX *ctx, const struct hive_key *parent,
+ const char *name, const char *classname,
+ struct security_descriptor *sec_desc,
+ struct hive_key **ret)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)parent;
struct nk_block *parent_nk = private_data->nk, nk;
struct nk_block *root;
nk.clsname_offset = -1; /* FIXME: fill in */
nk.clsname_length = 0;
nk.key_name = name;
-
+
/* Get the security descriptor of the root key */
root = talloc_zero(ctx, struct nk_block);
W_ERROR_HAVE_NO_MEMORY(root);
- if (!hbin_get_tdr(regf, regf->header->data_offset, root,
- (tdr_pull_fn_t)tdr_pull_nk_block, root)) {
+ if (!hbin_get_tdr(regf, regf->header->data_offset, root,
+ (tdr_pull_fn_t)tdr_pull_nk_block, root)) {
DEBUG(0, ("Unable to find HBIN data for offset %d\n", offset));
return WERR_GENERAL_FAILURE;
}
nk.sk_offset = root->sk_offset;
talloc_free(root);
-
+
/* Store the new nk key */
offset = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_nk_block, &nk);
-
- error = regf_sl_add_entry(regf, parent_nk->subkeys_offset, name, offset, &parent_nk->subkeys_offset);
+
+ error = regf_sl_add_entry(regf, parent_nk->subkeys_offset, name, offset,
+ &parent_nk->subkeys_offset);
if (!W_ERROR_IS_OK(error)) {
hbin_free(regf, offset);
return error;
}
-
+
parent_nk->num_subkeys++;
/* Since the subkey offset of the parent can change, store it again */
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block,
+ hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block,
nk.parent_offset, parent_nk);
*ret = (struct hive_key *)regf_get_key(ctx, regf, offset);
return regf_save_hbin(private_data->hive);
}
-static WERROR regf_set_value(struct hive_key *key, const char *name,
- uint32_t type, const DATA_BLOB data)
+static WERROR regf_set_value(struct hive_key *key, const char *name,
+ uint32_t type, const DATA_BLOB data)
{
- const struct regf_key_data *private_data =
+ const struct regf_key_data *private_data =
(const struct regf_key_data *)key;
struct regf_data *regf = private_data->hive;
struct nk_block *nk = private_data->nk;
for (i = 0; i < nk->num_values; i++) {
tmp_vk_offset = IVAL(values.data, i * 4);
- if (!hbin_get_tdr(regf, tmp_vk_offset, private_data,
- (tdr_pull_fn_t)tdr_pull_vk_block, &vk)) {
- DEBUG(0, ("Unable to get VK block at %d\n", tmp_vk_offset));
+ if (!hbin_get_tdr(regf, tmp_vk_offset, private_data,
+ (tdr_pull_fn_t)tdr_pull_vk_block,
+ &vk)) {
+ DEBUG(0, ("Unable to get VK block at %d\n",
+ tmp_vk_offset));
return WERR_GENERAL_FAILURE;
}
if (strcmp(vk.data_name, name) == 0) {
}
/* Free data, if any */
if (!(vk.data_length & 0x80000000)) {
- hbin_free(regf, vk.data_offset);
+ hbin_free(regf, vk.data_offset);
}
}
if (old_vk_offset == -1) {
}
if (old_vk_offset == -1) {
/* Store new vk */
- vk_offset = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_vk_block, &vk);
+ vk_offset = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_vk_block,
+ &vk);
} else {
/* Store vk at offset */
- vk_offset = hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_vk_block, old_vk_offset ,&vk);
+ vk_offset = hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_vk_block,
+ old_vk_offset ,&vk);
}
/* Re-allocate the value list */
if (nk->values_offset == -1) {
- nk->values_offset = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_uint32, &vk_offset);
+ nk->values_offset = hbin_store_tdr(regf,
+ (tdr_push_fn_t) tdr_push_uint32,
+ &vk_offset);
nk->num_values = 1;
} else {
DATA_BLOB value_list;
value_list.length = (nk->num_values+1)*4;
- value_list.data = (uint8_t *)talloc_array(private_data, uint32_t, nk->num_values+1);
+ value_list.data = (uint8_t *)talloc_array(private_data,
+ uint32_t,
+ nk->num_values+1);
W_ERROR_HAVE_NO_MEMORY(value_list.data);
memcpy(value_list.data, values.data, nk->num_values * 4);
SIVAL(value_list.data, nk->num_values * 4, vk_offset);
nk->num_values++;
- nk->values_offset = hbin_store_resize(regf, nk->values_offset, value_list);
+ nk->values_offset = hbin_store_resize(regf,
+ nk->values_offset,
+ value_list);
}
-
+
}
- hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block, private_data->offset, nk);
+ hbin_store_tdr_resize(regf,
+ (tdr_push_fn_t) tdr_push_nk_block,
+ private_data->offset, nk);
return regf_save_hbin(private_data->hive);
}
regf->header->chksum = regf_hdr_checksum(push->data.data);
talloc_free(push);
- if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
- (tdr_push_fn_t)tdr_push_regf_hdr, regf->header))) {
+ if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
+ (tdr_push_fn_t)tdr_push_regf_hdr,
+ regf->header))) {
DEBUG(0, ("Error writing registry file header\n"));
return WERR_GENERAL_FAILURE;
}
if (lseek(regf->fd, 0x1000, SEEK_SET) == -1) {
DEBUG(0, ("Error lseeking to 0x1000 in regf file\n"));
return WERR_GENERAL_FAILURE;
- }
+ }
for (i = 0; regf->hbins[i]; i++) {
- if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
- (tdr_push_fn_t)tdr_push_hbin_block,
- regf->hbins[i]))) {
- DEBUG(0, ("Error writing HBIN block\n"));
+ if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
+ (tdr_push_fn_t)tdr_push_hbin_block,
+ regf->hbins[i]))) {
+ DEBUG(0, ("Error writing HBIN block\n"));
return WERR_GENERAL_FAILURE;
}
}
return WERR_OK;
}
-WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, const char *location,
- int minor_version, struct hive_key **key)
+WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, const char *location,
+ int minor_version, struct hive_key **key)
{
struct regf_data *regf;
struct regf_hdr *regf_hdr;
regf_hdr->version.major = 1;
regf_hdr->version.minor = minor_version;
regf_hdr->last_block = 0x1000; /* Block size */
- regf_hdr->description = talloc_strdup(regf_hdr, "registry created by Samba 4");
+ regf_hdr->description = talloc_strdup(regf_hdr,
+ "registry created by Samba 4");
W_ERROR_HAVE_NO_MEMORY(regf_hdr->description);
regf_hdr->chksum = 0;
nk.clsname_offset = -1; /* FIXME: fill in */
nk.clsname_length = 0;
nk.key_name = "";
-
+
nk.sk_offset = -1; /* FIXME: fill in */
-
+
/* Store the new nk key */
- regf->header->data_offset = hbin_store_tdr(regf,
- (tdr_push_fn_t)tdr_push_nk_block, &nk);
-
- *key = (struct hive_key *)regf_get_key(parent_ctx, regf, regf->header->data_offset);
+ regf->header->data_offset = hbin_store_tdr(regf,
+ (tdr_push_fn_t)tdr_push_nk_block,
+ &nk);
+
+ *key = (struct hive_key *)regf_get_key(parent_ctx, regf,
+ regf->header->data_offset);
/* We can drop our own reference now that *key will have created one */
talloc_free(regf);
return WERR_OK;
}
-WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
- const char *location, struct hive_key **key)
+WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
+ const char *location, struct hive_key **key)
{
struct regf_data *regf;
struct regf_hdr *regf_hdr;
if (strcmp(regf_hdr->REGF_ID, "regf") != 0) {
DEBUG(0, ("Unrecognized NT registry header id: %s, %s\n",
- regf_hdr->REGF_ID, location));
+ regf_hdr->REGF_ID, location));
talloc_free(regf);
return WERR_GENERAL_FAILURE;
}
/* Validate the header ... */
if (regf_hdr_checksum(pull.data.data) != regf_hdr->chksum) {
DEBUG(0, ("Registry file checksum error: %s: %d,%d\n",
- location, regf_hdr->chksum,
- regf_hdr_checksum(pull.data.data)));
+ location, regf_hdr->chksum,
+ regf_hdr_checksum(pull.data.data)));
talloc_free(regf);
return WERR_GENERAL_FAILURE;
}
regf->hbins[0] = NULL;
- while (pull.offset < pull.data.length && pull.offset <= regf->header->last_block) {
- struct hbin_block *hbin = talloc(regf->hbins, struct hbin_block);
+ while (pull.offset < pull.data.length &&
+ pull.offset <= regf->header->last_block) {
+ struct hbin_block *hbin = talloc(regf->hbins,
+ struct hbin_block);
W_ERROR_HAVE_NO_MEMORY(hbin);
}
if (strcmp(hbin->HBIN_ID, "hbin") != 0) {
- DEBUG(0, ("[%d] Expected 'hbin', got '%s'\n", i, hbin->HBIN_ID));
+ DEBUG(0, ("[%d] Expected 'hbin', got '%s'\n",
+ i, hbin->HBIN_ID));
talloc_free(regf);
return WERR_FOOBAR;
}
regf->hbins[i] = hbin;
i++;
- regf->hbins = talloc_realloc(regf, regf->hbins, struct hbin_block *, i+2);
+ regf->hbins = talloc_realloc(regf, regf->hbins,
+ struct hbin_block *, i+2);
regf->hbins[i] = NULL;
- }
+ }
DEBUG(1, ("%d HBIN blocks read\n", i));
- *key = (struct hive_key *)regf_get_key(parent_ctx, regf,
- regf->header->data_offset);
+ *key = (struct hive_key *)regf_get_key(parent_ctx, regf,
+ regf->header->data_offset);
/* We can drop our own reference now that *key will have created one */
talloc_free(regf);
-/*
+/*
Unix SMB/CIFS implementation.
Registry interface
Copyright (C) Gerald Carter 2002.
Copyright (C) Jelmer Vernooij 2003-2007.
-
+
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 <http://www.gnu.org/licenses/>.
*/
#ifndef _REGISTRY_H /* _REGISTRY_H */
-#define _REGISTRY_H
+#define _REGISTRY_H
struct registry_context;
#include "libcli/util/ntstatus.h"
/* Handles for the predefined keys */
-#define HKEY_CLASSES_ROOT 0x80000000
-#define HKEY_CURRENT_USER 0x80000001
-#define HKEY_LOCAL_MACHINE 0x80000002
-#define HKEY_USERS 0x80000003
-#define HKEY_PERFORMANCE_DATA 0x80000004
-#define HKEY_CURRENT_CONFIG 0x80000005
-#define HKEY_DYN_DATA 0x80000006
-#define HKEY_PERFORMANCE_TEXT 0x80000050
-#define HKEY_PERFORMANCE_NLSTEXT 0x80000060
+#define HKEY_CLASSES_ROOT 0x80000000
+#define HKEY_CURRENT_USER 0x80000001
+#define HKEY_LOCAL_MACHINE 0x80000002
+#define HKEY_USERS 0x80000003
+#define HKEY_PERFORMANCE_DATA 0x80000004
+#define HKEY_CURRENT_CONFIG 0x80000005
+#define HKEY_DYN_DATA 0x80000006
+#define HKEY_PERFORMANCE_TEXT 0x80000050
+#define HKEY_PERFORMANCE_NLSTEXT 0x80000060
#define HKEY_FIRST HKEY_CLASSES_ROOT
#define HKEY_LAST HKEY_PERFORMANCE_NLSTEXT
struct reg_key_operations;
/* structure to store the registry handles */
-struct registry_key
+struct registry_key
{
struct registry_context *context;
};
#include "lib/registry/patchfile.h"
-struct registry_value
+struct registry_value
{
- const char *name;
- unsigned int data_type;
- DATA_BLOB data;
+ const char *name;
+ unsigned int data_type;
+ DATA_BLOB data;
};
/* FIXME */
const char *name;
WERROR (*get_key_info) (TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char **classname,
- uint32_t *numsubkeys,
- uint32_t *numvalues,
- NTTIME *last_change_time);
+ const struct registry_key *key,
+ const char **classname,
+ uint32_t *numsubkeys,
+ uint32_t *numvalues,
+ NTTIME *last_change_time);
WERROR (*flush_key) (struct registry_key *key);
- WERROR (*get_predefined_key) (const struct registry_context *ctx,
- uint32_t key_id,
- struct registry_key **key);
+ WERROR (*get_predefined_key) (const struct registry_context *ctx,
+ uint32_t key_id,
+ struct registry_key **key);
WERROR (*open_key) (TALLOC_CTX *mem_ctx,
- struct registry_key *parent,
- const char *path,
- struct registry_key **key);
+ struct registry_key *parent,
+ const char *path,
+ struct registry_key **key);
- WERROR (*create_key) (TALLOC_CTX *mem_ctx,
- struct registry_key *parent,
- const char *name,
- const char *key_class,
- struct security_descriptor *security,
- struct registry_key **key);
+ WERROR (*create_key) (TALLOC_CTX *mem_ctx,
+ struct registry_key *parent,
+ const char *name,
+ const char *key_class,
+ struct security_descriptor *security,
+ struct registry_key **key);
WERROR (*delete_key) (struct registry_key *key, const char *name);
WERROR (*delete_value) (struct registry_key *key, const char *name);
WERROR (*enum_key) (TALLOC_CTX *mem_ctx,
- const struct registry_key *key, uint32_t idx,
- const char **name,
- const char **keyclass,
- NTTIME *last_changed_time);
+ const struct registry_key *key, uint32_t idx,
+ const char **name,
+ const char **keyclass,
+ NTTIME *last_changed_time);
WERROR (*enum_value) (TALLOC_CTX *mem_ctx,
- const struct registry_key *key, uint32_t idx,
- const char **name,
- uint32_t *type,
- DATA_BLOB *data);
+ const struct registry_key *key, uint32_t idx,
+ const char **name,
+ uint32_t *type,
+ DATA_BLOB *data);
WERROR (*get_security) (TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- struct security_descriptor **security);
+ const struct registry_key *key,
+ struct security_descriptor **security);
WERROR (*set_security) (struct registry_key *key,
- const struct security_descriptor *security);
+ const struct security_descriptor *security);
WERROR (*load_key) (struct registry_key *key,
- const char *key_name,
- const char *path);
+ const char *key_name,
+ const char *path);
WERROR (*unload_key) (struct registry_key *key, const char *name);
WERROR (*notify_value_change) (struct registry_key *key,
- reg_value_notification_function fn);
+ reg_value_notification_function fn);
WERROR (*get_value) (TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char *name,
- uint32_t *type,
- DATA_BLOB *data);
+ const struct registry_key *key,
+ const char *name,
+ uint32_t *type,
+ DATA_BLOB *data);
WERROR (*set_value) (struct registry_key *key,
- const char *name,
- uint32_t type,
- const DATA_BLOB data);
-};
+ const char *name,
+ uint32_t type,
+ const DATA_BLOB data);
+};
/**
* Handle to a full registry
- * contains zero or more hives
+ * contains zero or more hives
*/
struct registry_context {
const struct registry_operations *ops;
/**
* Open the locally defined registry.
*/
-WERROR reg_open_local (TALLOC_CTX *mem_ctx,
- struct registry_context **ctx,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials);
+WERROR reg_open_local(TALLOC_CTX *mem_ctx,
+ struct registry_context **ctx,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials);
-WERROR reg_open_samba (TALLOC_CTX *mem_ctx,
- struct registry_context **ctx,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials);
+WERROR reg_open_samba(TALLOC_CTX *mem_ctx,
+ struct registry_context **ctx,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials);
/**
* Open the registry on a remote machine.
*/
-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);
+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);
WERROR reg_open_wine(struct registry_context **ctx, const char *path);
const char *reg_get_predef_name(uint32_t hkey);
-WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
- const char *name,
- struct registry_key **key);
-WERROR reg_get_predefined_key(const struct registry_context *ctx,
- uint32_t hkey,
- struct registry_key **key);
-
-WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
- const char *name, struct registry_key **result);
-
-WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx,
- const struct registry_key *key, uint32_t idx,
- const char **name,
- uint32_t *type,
- DATA_BLOB *data);
+WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
+ const char *name,
+ struct registry_key **key);
+WERROR reg_get_predefined_key(const struct registry_context *ctx,
+ uint32_t hkey,
+ struct registry_key **key);
+
+WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
+ const char *name, struct registry_key **result);
+
+WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key, uint32_t idx,
+ const char **name,
+ uint32_t *type,
+ DATA_BLOB *data);
WERROR reg_key_get_info(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char **class_name,
- uint32_t *num_subkeys,
- uint32_t *num_values,
- NTTIME *last_change_time);
-WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- int idx,
- const char **name,
- const char **classname,
- NTTIME *last_mod_time);
-WERROR reg_key_get_subkey_by_name(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char *name,
- struct registry_key **subkey);
-WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- const char *name,
- uint32_t *type,
- DATA_BLOB *data);
+ const struct registry_key *key,
+ const char **class_name,
+ uint32_t *num_subkeys,
+ uint32_t *num_values,
+ NTTIME *last_change_time);
+WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ int idx,
+ const char **name,
+ const char **classname,
+ NTTIME *last_mod_time);
+WERROR reg_key_get_subkey_by_name(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ const char *name,
+ struct registry_key **subkey);
+WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ const char *name,
+ uint32_t *type,
+ DATA_BLOB *data);
WERROR reg_key_del(struct registry_key *parent, const char *name);
-WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
- struct registry_key *parent, const char *name,
- const char *classname,
- struct security_descriptor *desc,
- struct registry_key **newkey);
-WERROR reg_val_set(struct registry_key *key, const char *value,
- uint32_t type, DATA_BLOB data);
-WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key, struct security_descriptor **secdesc);
+WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
+ struct registry_key *parent, const char *name,
+ const char *classname,
+ struct security_descriptor *desc,
+ struct registry_key **newkey);
+WERROR reg_val_set(struct registry_key *key, const char *value,
+ uint32_t type, DATA_BLOB data);
+WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key,
+ struct security_descriptor **secdesc);
WERROR reg_del_value(struct registry_key *key, const char *valname);
WERROR reg_key_flush(struct registry_key *key);
-WERROR reg_create_key (TALLOC_CTX *mem_ctx,
- struct registry_key *parent,
-
- const char *name,
- const char *key_class,
- struct security_descriptor *security,
- struct registry_key **key);
+WERROR reg_create_key(TALLOC_CTX *mem_ctx,
+ struct registry_key *parent,
+ const char *name,
+ const char *key_class,
+ struct security_descriptor *security,
+ struct registry_key **key);
/* Utility functions */
const char *str_regtype(int type);
-char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
- const DATA_BLOB data);
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
+ const DATA_BLOB data);
char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
- uint32_t type, const DATA_BLOB data);
-bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str, const char *data_str, uint32_t *type, DATA_BLOB *data);
-WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle, const char *name, struct registry_key **result);
+ uint32_t type, const DATA_BLOB data);
+bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+ const char *data_str, uint32_t *type, DATA_BLOB *data);
+WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
+ const char *name, struct registry_key **result);
WERROR reg_key_del_abs(struct registry_context *ctx, const char *path);
-WERROR reg_key_add_abs(TALLOC_CTX *mem_ctx, struct registry_context *ctx, const char *path, uint32_t access_mask, struct security_descriptor *sec_desc, struct registry_key **result);
-WERROR reg_load_key(struct registry_context *ctx, struct registry_key *key,
- const char *name, const char *filename);
-
-WERROR reg_mount_hive(struct registry_context *rctx,
- struct hive_key *hive_key,
- uint32_t key_id,
- const char **elements);
+WERROR reg_key_add_abs(TALLOC_CTX *mem_ctx, struct registry_context *ctx,
+ const char *path, uint32_t access_mask,
+ struct security_descriptor *sec_desc,
+ struct registry_key **result);
+WERROR reg_load_key(struct registry_context *ctx, struct registry_key *key,
+ const char *name, const char *filename);
+
+WERROR reg_mount_hive(struct registry_context *rctx,
+ struct hive_key *hive_key,
+ uint32_t key_id,
+ const char **elements);
struct registry_key *reg_import_hive_key(struct registry_context *ctx,
- struct hive_key *hive,
- uint32_t predef_key,
- const char **elements);
-WERROR reg_get_security(TALLOC_CTX *mem_ctx,
- const struct registry_key *key,
- struct security_descriptor **security);
-
-WERROR reg_set_security(struct registry_key *key,
- struct security_descriptor *security);
+ struct hive_key *hive,
+ uint32_t predef_key,
+ const char **elements);
+WERROR reg_get_security(TALLOC_CTX *mem_ctx,
+ const struct registry_key *key,
+ struct security_descriptor **security);
+
+WERROR reg_set_security(struct registry_key *key,
+ struct security_descriptor *security);
#endif /* _REGISTRY_H */
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 <http://www.gnu.org/licenses/>. */
-
+
#include "includes.h"
#include "registry.h"
#include "librpc/gen_ndr/ndr_winreg_c.h"
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 },
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;
#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);
/* 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;
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.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);
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;
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;
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);
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;
}
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);
}
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 */
.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;
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);
-/*
+/*
Unix SMB/CIFS implementation.
Copyright (C) Jelmer Vernooij 2004-2007.
* @brief Samba-specific registry functions
*/
-static WERROR mount_samba_hive(struct registry_context *ctx,
+static WERROR mount_samba_hive(struct registry_context *ctx,
struct auth_session_info *auth_info,
struct cli_credentials *creds,
- const char *name,
+ const char *name,
uint32_t hive_id)
{
WERROR error;
struct hive_key *hive;
const char *location;
- location = talloc_asprintf(ctx, "%s/%s.ldb", lp_private_dir(global_loadparm), name);
-
+ location = talloc_asprintf(ctx, "%s/%s.ldb",
+ lp_private_dir(global_loadparm),
+ name);
error = reg_open_hive(ctx, location, auth_info, creds, &hive);
if (W_ERROR_EQUAL(error, WERR_NOT_FOUND))
- error = reg_open_ldb_file(ctx, location, auth_info, creds, &hive);
+ error = reg_open_ldb_file(ctx, location, auth_info,
+ creds, &hive);
if (!W_ERROR_IS_OK(error))
return error;
}
-_PUBLIC_ WERROR reg_open_samba (TALLOC_CTX *mem_ctx,
- struct registry_context **ctx,
- struct auth_session_info *session_info,
- struct cli_credentials *credentials)
+_PUBLIC_ WERROR reg_open_samba(TALLOC_CTX *mem_ctx,
+ struct registry_context **ctx,
+ struct auth_session_info *session_info,
+ struct cli_credentials *credentials)
{
WERROR result;
return result;
}
- mount_samba_hive(*ctx, session_info, credentials,
- "hklm", HKEY_LOCAL_MACHINE);
+ mount_samba_hive(*ctx, session_info, credentials,
+ "hklm", HKEY_LOCAL_MACHINE);
- mount_samba_hive(*ctx, session_info, credentials,
- "hkcr", HKEY_CLASSES_ROOT);
+ mount_samba_hive(*ctx, session_info, credentials,
+ "hkcr", HKEY_CLASSES_ROOT);
- /* FIXME: Should be mounted from NTUSER.DAT in the home directory of the
+ /* FIXME: Should be mounted from NTUSER.DAT in the home directory of the
* current user */
- mount_samba_hive(*ctx, session_info, credentials,
- "hkcu", HKEY_CURRENT_USER);
+ mount_samba_hive(*ctx, session_info, credentials,
+ "hkcu", HKEY_CURRENT_USER);
- mount_samba_hive(*ctx, session_info, credentials,
- "hku", HKEY_USERS);
+ mount_samba_hive(*ctx, session_info, credentials,
+ "hku", HKEY_USERS);
/* FIXME: Different hive backend for HKEY_CLASSES_ROOT: merged view of HKEY_LOCAL_MACHINE\Software\Classes
* and HKEY_CURRENT_USER\Software\Classes */
/* FIXME: HKEY_LOCAL_MACHINE\Hardware is autogenerated */
/* FIXME: HKEY_LOCAL_MACHINE\Security\SAM is an alias for HKEY_LOCAL_MACHINE\SAM */
-
+
return WERR_OK;
}
-/*
+/*
Unix SMB/CIFS implementation.
Transparent registry backend handling
Copyright (C) Jelmer Vernooij 2003-2007.
{
int i;
for (i = 0; reg_value_types[i].name; i++) {
- if (reg_value_types[i].id == type)
+ if (reg_value_types[i].id == type)
return reg_value_types[i].name;
}
return "Unknown";
}
-_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
+_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
const DATA_BLOB data)
-{
- char *ret = NULL;
-
- if (data.length == 0)
- return talloc_strdup(mem_ctx, "");
-
- switch (type) {
- case REG_EXPAND_SZ:
- case REG_SZ:
- convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX, data.data, data.length,
- (void **)&ret);
- return ret;
-
- case REG_BINARY:
- ret = data_blob_hex_string(mem_ctx, &data);
- return ret;
-
- case REG_DWORD:
- if (*(int *)data.data == 0)
- return talloc_strdup(mem_ctx, "0");
-
- return talloc_asprintf(mem_ctx, "0x%x", *(int *)data.data);
+{
+ char *ret = NULL;
- case REG_MULTI_SZ:
- /* FIXME */
- break;
+ if (data.length == 0)
+ return talloc_strdup(mem_ctx, "");
- default:
- break;
- }
+ switch (type) {
+ case REG_EXPAND_SZ:
+ case REG_SZ:
+ convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
+ data.data, data.length,
+ (void **)&ret);
+ return ret;
+ case REG_BINARY:
+ ret = data_blob_hex_string(mem_ctx, &data);
+ return ret;
+ case REG_DWORD:
+ if (*(int *)data.data == 0)
+ return talloc_strdup(mem_ctx, "0");
+ return talloc_asprintf(mem_ctx, "0x%x",
+ *(int *)data.data);
+ case REG_MULTI_SZ:
+ /* FIXME */
+ break;
+ default:
+ break;
+ }
- return ret;
+ return ret;
}
/** Generate a string that describes a registry value */
-_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
- uint32_t data_type,
- const DATA_BLOB data)
+_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
+ uint32_t data_type,
+ const DATA_BLOB data)
{
- return talloc_asprintf(mem_ctx, "%s = %s : %s", name?name:"<No Name>",
- str_regtype(data_type),
- reg_val_data_string(mem_ctx, data_type, data));
+ return talloc_asprintf(mem_ctx, "%s = %s : %s", name?name:"<No Name>",
+ str_regtype(data_type),
+ reg_val_data_string(mem_ctx, data_type, data));
}
-_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str, const char *data_str, uint32_t *type, DATA_BLOB *data)
+_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+ const char *data_str, uint32_t *type,
+ DATA_BLOB *data)
{
int i;
*type = -1;
}
}
- if (*type == -1)
+ if (*type == -1)
return false;
/* Convert data appropriately */
- switch (*type)
+ switch (*type)
{
case REG_SZ:
case REG_EXPAND_SZ:
- data->length = convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16, data_str, strlen(data_str), (void **)&data->data);
+ data->length = convert_string_talloc(mem_ctx, CH_UNIX, CH_UTF16,
+ data_str, strlen(data_str),
+ (void **)&data->data);
break;
case REG_DWORD: {
case REG_NONE:
ZERO_STRUCTP(data);
break;
-
- case REG_BINARY:
+
+ case REG_BINARY:
*data = strhex_to_data_blob(data_str);
talloc_steal(mem_ctx, data->data);
break;
-
+
default:
/* FIXME */
return false;
}
/** Open a key by name (including the predefined key name!) */
-WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle, const char *name, struct registry_key **result)
+WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
+ const char *name, struct registry_key **result)
{
struct registry_key *predef;
WERROR error;
int predeflength;
char *predefname;
- if (strchr(name, '\\') != NULL)
+ if (strchr(name, '\\') != NULL)
predeflength = strchr(name, '\\')-name;
- else
+ else
predeflength = strlen(name);
predefname = talloc_strndup(mem_ctx, name, predeflength);
}
if (strchr(name, '\\')) {
- return reg_open_key(mem_ctx, predef, strchr(name, '\\')+1, result);
+ return reg_open_key(mem_ctx, predef, strchr(name, '\\')+1,
+ result);
} else {
*result = predef;
return WERR_OK;
}
}
-static WERROR get_abs_parent(TALLOC_CTX *mem_ctx, struct registry_context *ctx,
- const char *path, struct registry_key **parent,
- const char **name)
+static WERROR get_abs_parent(TALLOC_CTX *mem_ctx, struct registry_context *ctx,
+ const char *path, struct registry_key **parent,
+ const char **name)
{
char *parent_name;
WERROR error;
-
+
if (strchr(path, '\\') == NULL) {
return WERR_FOOBAR;
}
-
+
parent_name = talloc_strndup(mem_ctx, path, strrchr(path, '\\')-path);
error = reg_open_key_abs(mem_ctx, ctx, parent_name, parent);
if (!W_ERROR_IS_OK(error)) {
return error;
}
-
+
*name = talloc_strdup(mem_ctx, strrchr(path, '\\')+1);
return WERR_OK;
const char *n;
TALLOC_CTX *mem_ctx = talloc_init("reg_key_del_abs");
WERROR error;
-
+
if (!strchr(path, '\\')) {
return WERR_FOOBAR;
}
-
+
error = get_abs_parent(mem_ctx, ctx, path, &parent, &n);
if (W_ERROR_IS_OK(error)) {
error = reg_key_del(parent, n);
return error;
}
-WERROR reg_key_add_abs(TALLOC_CTX *mem_ctx, struct registry_context *ctx,
- const char *path, uint32_t access_mask,
- struct security_descriptor *sec_desc,
- struct registry_key **result)
+WERROR reg_key_add_abs(TALLOC_CTX *mem_ctx, struct registry_context *ctx,
+ const char *path, uint32_t access_mask,
+ struct security_descriptor *sec_desc,
+ struct registry_key **result)
{
struct registry_key *parent;
const char *n;
WERROR error;
-
+
if (!strchr(path, '\\')) {
return WERR_ALREADY_EXISTS;
}
-
+
error = get_abs_parent(mem_ctx, ctx, path, &parent, &n);
if (!W_ERROR_IS_OK(error)) {
- DEBUG(2, ("Opening parent of %s failed with %s\n", path,
+ DEBUG(2, ("Opening parent of %s failed with %s\n", path,
win_errstr(error)));
return error;
}
-/*
+/*
Unix SMB/CIFS implementation.
Registry interface
Copyright (C) Jelmer Vernooij 2007.
-
+
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 <http://www.gnu.org/licenses/>.
*/
static REG_OPS reg_backend_wine = {
.name = "wine",
.open_hive = wine_open_reg,
-
+
};
NTSTATUS registry_wine_init(void)
git.samba.org / sfrench / samba-autobuild / .git / commitdiff