#include "includes.h"
#include "utils/net.h"
#include "utils/net_registry_util.h"
-
+#include "include/g_lock.h"
+#include "registry/reg_import.h"
/*
*
return ret;
}
+struct net_registry_increment_state {
+ const char *keyname;
+ const char *valuename;
+ uint32_t increment;
+ uint32_t newvalue;
+ WERROR werr;
+};
+
+static void net_registry_increment_fn(void *private_data)
+{
+ struct net_registry_increment_state *state =
+ (struct net_registry_increment_state *)private_data;
+ struct registry_value *value;
+ struct registry_key *key = NULL;
+
+ state->werr = open_key(talloc_tos(), state->keyname,
+ REG_KEY_READ|REG_KEY_WRITE, &key);
+ if (!W_ERROR_IS_OK(state->werr)) {
+ d_fprintf(stderr, "open_key failed: %s\n",
+ win_errstr(state->werr));
+ goto done;
+ }
+
+ state->werr = reg_queryvalue(key, key, state->valuename, &value);
+ if (!W_ERROR_IS_OK(state->werr)) {
+ d_fprintf(stderr, "reg_queryvalue failed: %s\n",
+ win_errstr(state->werr));
+ goto done;
+ }
+
+ if (value->type != REG_DWORD) {
+ d_fprintf(stderr, "value not a DWORD: %s\n",
+ reg_type_lookup(value->type));
+ goto done;
+ }
+
+ value->v.dword += state->increment;
+ state->newvalue = value->v.dword;
+
+ state->werr = reg_setvalue(key, state->valuename, value);
+ if (!W_ERROR_IS_OK(state->werr)) {
+ d_fprintf(stderr, "reg_setvalue failed: %s\n",
+ win_errstr(state->werr));
+ goto done;
+ }
+
+done:
+ TALLOC_FREE(key);
+ return;
+}
+
+static int net_registry_increment(struct net_context *c, int argc,
+ const char **argv)
+{
+ struct net_registry_increment_state state;
+ NTSTATUS status;
+ int ret = -1;
+
+ if (argc < 2 || c->display_usage) {
+ d_fprintf(stderr, "%s\n%s",
+ "Usage:",
+ "net registry increment <key> <valuename> "
+ "[<increment>]\n");
+ goto done;
+ }
+
+ state.keyname = argv[0];
+ state.valuename = argv[1];
+
+ state.increment = 1;
+ if (argc == 3) {
+ state.increment = strtoul(argv[2], NULL, 10);
+ }
+
+ status = g_lock_do("registry_increment_lock", G_LOCK_WRITE,
+ timeval_set(600, 0),
+ net_registry_increment_fn, &state);
+ if (!NT_STATUS_IS_OK(status)) {
+ d_fprintf(stderr, "g_lock_do failed: %s\n",
+ nt_errstr(status));
+ goto done;
+ }
+ if (!W_ERROR_IS_OK(state.werr)) {
+ d_fprintf(stderr, "increment failed: %s\n",
+ win_errstr(state.werr));
+ goto done;
+ }
+
+ d_printf("new value: %u\n", (unsigned)state.newvalue);
+
+ ret = 0;
+
+done:
+ return ret;
+}
+
static int net_registry_deletevalue(struct net_context *c, int argc,
const char **argv)
{
return ret;
}
-static int net_registry_getsd(struct net_context *c, int argc,
- const char **argv)
+static WERROR net_registry_getsd_internal(struct net_context *c,
+ TALLOC_CTX *mem_ctx,
+ const char *keyname,
+ struct security_descriptor **sd)
{
WERROR werr;
- int ret = -1;
struct registry_key *key = NULL;
- struct security_descriptor *secdesc = NULL;
TALLOC_CTX *ctx = talloc_stackframe();
uint32_t access_mask = REG_KEY_READ |
SEC_FLAG_MAXIMUM_ALLOWED |
*/
access_mask = REG_KEY_READ;
+ if (sd == NULL) {
+ d_fprintf(stderr, "internal error: invalid argument\n");
+ werr = WERR_INVALID_PARAM;
+ goto done;
+ }
+
+ if (strlen(keyname) == 0) {
+ d_fprintf(stderr, "error: zero length key name given\n");
+ werr = WERR_INVALID_PARAM;
+ goto done;
+ }
+
+ werr = open_key(ctx, keyname, access_mask, &key);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
+ goto done;
+ }
+
+ werr = reg_getkeysecurity(mem_ctx, key, sd);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "reg_getkeysecurity failed: %s\n",
+ win_errstr(werr));
+ goto done;
+ }
+
+ werr = WERR_OK;
+
+done:
+ TALLOC_FREE(ctx);
+ return werr;
+}
+
+static int net_registry_getsd(struct net_context *c, int argc,
+ const char **argv)
+{
+ WERROR werr;
+ int ret = -1;
+ struct security_descriptor *secdesc = NULL;
+ TALLOC_CTX *ctx = talloc_stackframe();
+
if (argc != 1 || c->display_usage) {
d_printf("Usage: net registry getsd <path>\n");
d_printf("Example: net registry getsd "
"'HKLM\\Software\\Samba'\n");
goto done;
}
- if (strlen(argv[0]) == 0) {
+
+ werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ display_sec_desc(secdesc);
+
+ ret = 0;
+
+done:
+ TALLOC_FREE(ctx);
+ return ret;
+}
+
+static int net_registry_getsd_sddl(struct net_context *c,
+ int argc, const char **argv)
+{
+ WERROR werr;
+ int ret = -1;
+ struct security_descriptor *secdesc = NULL;
+ TALLOC_CTX *ctx = talloc_stackframe();
+
+ if (argc != 1 || c->display_usage) {
+ d_printf("Usage: net registry getsd_sddl <path>\n");
+ d_printf("Example: net registry getsd_sddl 'HKLM\\Software\\Samba'\n");
+ goto done;
+ }
+
+ werr = net_registry_getsd_internal(c, ctx, argv[0], &secdesc);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ d_printf("%s\n", sddl_encode(ctx, secdesc, get_global_sam_sid()));
+
+ ret = 0;
+
+done:
+ TALLOC_FREE(ctx);
+ return ret;
+}
+
+static WERROR net_registry_setsd_internal(struct net_context *c,
+ TALLOC_CTX *mem_ctx,
+ const char *keyname,
+ struct security_descriptor *sd)
+{
+ WERROR werr;
+ struct registry_key *key = NULL;
+ TALLOC_CTX *ctx = talloc_stackframe();
+ uint32_t access_mask = REG_KEY_WRITE |
+ SEC_FLAG_MAXIMUM_ALLOWED |
+ SEC_FLAG_SYSTEM_SECURITY;
+
+ /*
+ * net_rpc_regsitry uses SEC_FLAG_SYSTEM_SECURITY, but access
+ * is denied with these perms right now...
+ */
+ access_mask = REG_KEY_WRITE;
+
+ if (strlen(keyname) == 0) {
d_fprintf(stderr, "error: zero length key name given\n");
+ werr = WERR_INVALID_PARAM;
goto done;
}
- werr = open_key(ctx, argv[0], access_mask, &key);
+ werr = open_key(ctx, keyname, access_mask, &key);
if (!W_ERROR_IS_OK(werr)) {
d_fprintf(stderr, "open_key failed: %s\n", win_errstr(werr));
goto done;
}
- werr = reg_getkeysecurity(ctx, key, &secdesc);
+ werr = reg_setkeysecurity(key, sd);
if (!W_ERROR_IS_OK(werr)) {
- d_fprintf(stderr, "reg_getkeysecurity failed: %s\n",
+ d_fprintf(stderr, "reg_setkeysecurity failed: %s\n",
win_errstr(werr));
goto done;
}
- display_sec_desc(secdesc);
+ werr = WERR_OK;
+
+done:
+ TALLOC_FREE(ctx);
+ return werr;
+}
+
+static int net_registry_setsd_sddl(struct net_context *c,
+ int argc, const char **argv)
+{
+ WERROR werr;
+ int ret = -1;
+ struct security_descriptor *secdesc = NULL;
+ TALLOC_CTX *ctx = talloc_stackframe();
+
+ if (argc != 2 || c->display_usage) {
+ d_printf("Usage: net registry setsd_sddl <path> <security_descriptor>\n");
+ d_printf("Example:\n"
+ "net registry setsd_sddl 'HKLM\\Software\\Samba'\n");
+ goto done;
+ }
+
+ secdesc = sddl_decode(ctx, argv[1], get_global_sam_sid());
+ if (secdesc == NULL) {
+ goto done;
+ }
+
+ werr = net_registry_setsd_internal(c, ctx, argv[0], secdesc);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
ret = 0;
return ret;
}
+/******************************************************************************/
+/**
+ * @defgroup net_registry net registry
+ */
+
+/**
+ * @defgroup net_registry_import Import
+ * @ingroup net_registry
+ * @{
+ */
+
+struct import_ctx {
+ TALLOC_CTX *mem_ctx;
+};
+
+
+static WERROR import_create_key(struct import_ctx* ctx,
+ struct registry_key* parent,
+ const char* name, void** pkey, bool* existing)
+{
+ WERROR werr;
+ void* mem_ctx = talloc_new(ctx->mem_ctx);
+
+ struct registry_key* key = NULL;
+ enum winreg_CreateAction action;
+
+ if (parent == NULL) {
+ char* subkeyname = NULL;
+ werr = open_hive(mem_ctx, name, REG_KEY_WRITE,
+ &parent, &subkeyname);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "open_hive failed: %s\n",
+ win_errstr(werr));
+ goto done;
+ }
+ name = subkeyname;
+ }
+
+ action = REG_ACTION_NONE;
+ werr = reg_createkey(mem_ctx, parent, name, REG_KEY_WRITE,
+ &key, &action);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "reg_createkey failed: %s\n",
+ win_errstr(werr));
+ goto done;
+ }
+
+ if (action == REG_ACTION_NONE) {
+ d_fprintf(stderr, "createkey did nothing -- huh?\n");
+ werr = WERR_FOOBAR;
+ goto done;
+ }
+
+ if (existing != NULL) {
+ *existing = (action == REG_OPENED_EXISTING_KEY);
+ }
+
+ if (pkey!=NULL) {
+ *pkey = talloc_steal(ctx->mem_ctx, key);
+ }
+
+done:
+ talloc_free(mem_ctx);
+ return werr;
+}
+
+static WERROR import_close_key(struct import_ctx* ctx,
+ struct registry_key* key)
+{
+ return WERR_OK;
+}
+
+static WERROR import_delete_key(struct import_ctx* ctx,
+ struct registry_key* parent, const char* name)
+{
+ WERROR werr;
+ void* mem_ctx = talloc_new(talloc_tos());
+
+ if (parent == NULL) {
+ char* subkeyname = NULL;
+ werr = open_hive(mem_ctx, name, REG_KEY_WRITE,
+ &parent, &subkeyname);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "open_hive failed: %s\n",
+ win_errstr(werr));
+ goto done;
+ }
+ name = subkeyname;
+ }
+
+ werr = reg_deletekey_recursive(mem_ctx, parent, name);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "reg_deletekey_recursive %s: %s\n", "failed",
+ win_errstr(werr));
+ goto done;
+ }
+
+done:
+ talloc_free(mem_ctx);
+ return werr;
+}
+
+static WERROR import_create_val (struct import_ctx* ctx,
+ struct registry_key* parent, const char* name,
+ const struct registry_value* value)
+{
+ WERROR werr;
+
+ if (parent == NULL) {
+ return WERR_INVALID_PARAM;
+ }
+
+ werr = reg_setvalue(parent, name, value);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "reg_setvalue failed: %s\n",
+ win_errstr(werr));
+ }
+ return werr;
+}
+
+static WERROR import_delete_val (struct import_ctx* ctx, struct registry_key* parent, const char* name) {
+ WERROR werr;
+
+ if (parent == NULL) {
+ return WERR_INVALID_PARAM;
+ }
+
+ werr = reg_deletevalue(parent, name);
+ if (!W_ERROR_IS_OK(werr)) {
+ d_fprintf(stderr, "reg_deletekey failed: %s\n",
+ win_errstr(werr));
+ }
+
+ return werr;
+}
+
+
+static int net_registry_import(struct net_context *c, int argc,
+ const char **argv)
+{
+ struct import_ctx import_ctx;
+ struct reg_import_callback import_callback = {
+ .openkey = NULL,
+ .closekey = (reg_import_callback_closekey_t)&import_close_key,
+ .createkey = (reg_import_callback_createkey_t)&import_create_key,
+ .deletekey = (reg_import_callback_deletekey_t)&import_delete_key,
+ .deleteval = (reg_import_callback_deleteval_t)&import_delete_val,
+ .setval.registry_value = (reg_import_callback_setval_registry_value_t)
+ &import_create_val,
+ .setval_type = REGISTRY_VALUE,
+ .data = &import_ctx
+ };
+
+ int ret;
+
+ if (argc < 1 || argc > 2 || c->display_usage) {
+ d_printf("%s\n%s",
+ "Usage:",
+ "net registry import <reg> [options]\n");
+ d_printf("%s\n%s",
+ "Example:",
+ "net registry import file.reg enc=CP1252\n");
+ return -1;
+ }
+
+ ZERO_STRUCT(import_ctx);
+ import_ctx.mem_ctx = talloc_stackframe();
+
+ regdb_open();
+ regdb_transaction_start();
+
+ ret = reg_parse_file(argv[0],
+ reg_import_adapter(import_ctx.mem_ctx,
+ import_callback),
+ (argc > 1) ? argv[1] : NULL
+ );
+ if (ret < 0) {
+ d_printf("reg_parse_file failed: transaction canceled\n");
+ regdb_transaction_cancel();
+ } else{
+ regdb_transaction_commit();
+ }
+
+ regdb_close();
+ talloc_free(import_ctx.mem_ctx);
+
+ return ret;
+}
+/**@}*/
+
+/******************************************************************************/
+
int net_registry(struct net_context *c, int argc, const char **argv)
{
int ret = -1;
"net registry setvalue\n"
" Set a new registry value"
},
+ {
+ "increment",
+ net_registry_increment,
+ NET_TRANSPORT_LOCAL,
+ "Increment a DWORD registry value under a lock",
+ "net registry increment\n"
+ " Increment a DWORD registry value under a lock"
+ },
{
"deletevalue",
net_registry_deletevalue,
"net registry getsd\n"
" Get security descriptor"
},
+ {
+ "getsd_sddl",
+ net_registry_getsd_sddl,
+ NET_TRANSPORT_LOCAL,
+ "Get security descriptor in sddl format",
+ "net registry getsd_sddl\n"
+ " Get security descriptor in sddl format"
+ },
+ {
+ "setsd_sddl",
+ net_registry_setsd_sddl,
+ NET_TRANSPORT_LOCAL,
+ "Set security descriptor from sddl format string",
+ "net registry setsd_sddl\n"
+ " Set security descriptor from sddl format string"
+ },
+ {
+ "import",
+ net_registry_import,
+ NET_TRANSPORT_LOCAL,
+ "Import .reg file",
+ "net registry import\n"
+ " Import .reg file"
+ },
{ NULL, NULL, 0, NULL, NULL }
};
git.samba.org / obnox / samba-ctdb.git / blobdiff