*/
#include "includes.h"
-#include "smbconf_private.h"
+#include "lib/smbconf/smbconf_private.h"
+#define INCLUDES_VALNAME "includes"
+
+struct reg_private_data {
+ struct registry_key *base_key;
+ bool open; /* did _we_ open the registry? */
+};
/**********************************************************************
*
**********************************************************************/
/**
- * Open a registry key specified by "path"
+ * a convenience helper to cast the private data structure
*/
-static WERROR smbconf_reg_open_path(TALLOC_CTX *mem_ctx,
- struct smbconf_ctx *ctx,
- const char *path,
- uint32 desired_access,
- struct registry_key **key)
+static struct reg_private_data *rpd(struct smbconf_ctx *ctx)
{
- WERROR werr = WERR_OK;
-
- if (ctx == NULL) {
- DEBUG(1, ("Error: configuration is not open!\n"));
- werr = WERR_INVALID_PARAM;
- goto done;
- }
-
- if (ctx->token == NULL) {
- DEBUG(1, ("Error: token missing from smbconf_ctx. "
- "was smbconf_init() called?\n"));
- werr = WERR_INVALID_PARAM;
- goto done;
- }
-
- if (path == NULL) {
- DEBUG(1, ("Error: NULL path string given\n"));
- werr = WERR_INVALID_PARAM;
- goto done;
- }
-
- werr = reg_open_path(mem_ctx, path, desired_access, ctx->token, key);
+ return (struct reg_private_data *)(ctx->data);
+}
- if (!W_ERROR_IS_OK(werr)) {
- DEBUG(1, ("Error opening registry path '%s': %s\n",
- path, dos_errstr(werr)));
+/*
+ * check whether a given value name is forbidden in registry (smbconf)
+ */
+static bool smbconf_reg_valname_forbidden(const char *valname)
+{
+ /* hard code the list of forbidden names here for now */
+ const char *forbidden_valnames[] = {
+ "lock directory",
+ "lock dir",
+ "config backend",
+ "include",
+ "includes", /* this has a special meaning internally */
+ NULL
+ };
+ const char **forbidden = NULL;
+
+ for (forbidden = forbidden_valnames; *forbidden != NULL; forbidden++) {
+ if (strwicmp(valname, *forbidden) == 0) {
+ return true;
+ }
}
+ return false;
+}
-done:
- return werr;
+static bool smbconf_reg_valname_valid(const char *valname)
+{
+ return (!smbconf_reg_valname_forbidden(valname) &&
+ lp_parameter_is_valid(valname));
}
/**
uint32 desired_access,
struct registry_key **key)
{
- WERROR werr = WERR_OK;
- char *path = NULL;
-
if (servicename == NULL) {
- DEBUG(3, ("Error: NULL servicename given.\n"));
- werr = WERR_INVALID_PARAM;
- goto done;
+ *key = rpd(ctx)->base_key;
+ return WERR_OK;
}
-
- path = talloc_asprintf(mem_ctx, "%s\\%s", ctx->path, servicename);
- if (path == NULL) {
- werr = WERR_NOMEM;
- goto done;
- }
-
- werr = smbconf_reg_open_path(mem_ctx, ctx, path, desired_access, key);
-
-done:
- TALLOC_FREE(path);
- return werr;
-}
-
-/**
- * open the base key
- */
-static WERROR smbconf_reg_open_base_key(TALLOC_CTX *mem_ctx,
- struct smbconf_ctx *ctx,
- uint32 desired_access,
- struct registry_key **key)
-{
- return smbconf_reg_open_path(mem_ctx, ctx, ctx->path, desired_access,
- key);
+ return reg_openkey(mem_ctx, rpd(ctx)->base_key, servicename,
+ desired_access, key);
}
/**
ret = true;
}
- TALLOC_FREE(ctx);
+ talloc_free(ctx);
return ret;
}
struct registry_key **newkey)
{
WERROR werr = WERR_OK;
- struct registry_key *create_parent = NULL;
TALLOC_CTX *create_ctx;
enum winreg_CreateAction action = REG_ACTION_NONE;
/* create a new talloc ctx for creation. it will hold
* the intermediate parent key (SMBCONF) for creation
* and will be destroyed when leaving this function... */
- if (!(create_ctx = talloc_stackframe())) {
- werr = WERR_NOMEM;
- goto done;
- }
-
- werr = smbconf_reg_open_base_key(create_ctx, ctx, REG_KEY_WRITE,
- &create_parent);
- if (!W_ERROR_IS_OK(werr)) {
- goto done;
- }
+ create_ctx = talloc_stackframe();
- werr = reg_createkey(mem_ctx, create_parent, subkeyname,
+ werr = reg_createkey(mem_ctx, rpd(ctx)->base_key, subkeyname,
REG_KEY_WRITE, newkey, &action);
if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
- werr = WERR_ALREADY_EXISTS;
+ werr = WERR_FILE_EXISTS;
}
if (!W_ERROR_IS_OK(werr)) {
DEBUG(5, ("Error creating key %s: %s\n",
- subkeyname, dos_errstr(werr)));
+ subkeyname, win_errstr(werr)));
}
-done:
- TALLOC_FREE(create_ctx);
+ talloc_free(create_ctx);
return werr;
}
goto done;
}
- ZERO_STRUCT(val);
-
- val.type = REG_SZ;
- val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
- val.v.sz.len = strlen(canon_valstr) + 1;
-
- if (registry_smbconf_valname_forbidden(canon_valname)) {
+ if (smbconf_reg_valname_forbidden(canon_valname)) {
DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
canon_valname));
werr = WERR_INVALID_PARAM;
goto done;
}
+ ZERO_STRUCT(val);
+
+ val.type = REG_SZ;
+ val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
+ val.v.sz.len = strlen(canon_valstr) + 1;
+
werr = reg_setvalue(key, canon_valname, &val);
if (!W_ERROR_IS_OK(werr)) {
DEBUG(5, ("Error adding value '%s' to "
"key '%s': %s\n",
- canon_valname, key->key->name, dos_errstr(werr)));
+ canon_valname, key->key->name, win_errstr(werr)));
+ }
+
+done:
+ return werr;
+}
+
+static WERROR smbconf_reg_set_multi_sz_value(struct registry_key *key,
+ const char *valname,
+ const uint32_t num_strings,
+ const char **strings)
+{
+ WERROR werr;
+ struct registry_value *value;
+ uint32_t count;
+ TALLOC_CTX *tmp_ctx = talloc_stackframe();
+
+ if (strings == NULL) {
+ werr = WERR_INVALID_PARAM;
+ goto done;
+ }
+
+ value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
+
+ value->type = REG_MULTI_SZ;
+ value->v.multi_sz.num_strings = num_strings;
+ value->v.multi_sz.strings = TALLOC_ARRAY(tmp_ctx, char *, num_strings);
+ if (value->v.multi_sz.strings == NULL) {
+ werr = WERR_NOMEM;
+ goto done;
+ }
+ for (count = 0; count < num_strings; count++) {
+ value->v.multi_sz.strings[count] =
+ talloc_strdup(value->v.multi_sz.strings,
+ strings[count]);
+ if (value->v.multi_sz.strings[count] == NULL) {
+ werr = WERR_NOMEM;
+ goto done;
+ }
+ }
+
+ werr = reg_setvalue(key, valname, value);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
+ valname, key->key->name, win_errstr(werr)));
}
done:
+ talloc_free(tmp_ctx);
return werr;
}
result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
break;
case REG_MULTI_SZ: {
- uint32 j;
- for (j = 0; j < value->v.multi_sz.num_strings; j++) {
- result = talloc_asprintf(mem_ctx, "%s \"%s\" ",
- result,
+ uint32 j;
+ for (j = 0; j < value->v.multi_sz.num_strings; j++) {
+ result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
+ result ? result : "" ,
value->v.multi_sz.strings[j]);
if (result == NULL) {
break;
}
- }
- break;
- }
+ }
+ break;
+ }
case REG_BINARY:
- result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
+ result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
(int)value->v.binary.length);
- break;
- default:
- result = talloc_asprintf(mem_ctx, "<unprintable>");
- break;
- }
+ break;
+ default:
+ result = talloc_asprintf(mem_ctx, "<unprintable>");
+ break;
+ }
return result;
}
+static WERROR smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
+ struct registry_key *key,
+ uint32_t *num_includes,
+ char ***includes)
+{
+ WERROR werr;
+ uint32_t count;
+ struct registry_value *value = NULL;
+ char **tmp_includes = NULL;
+ TALLOC_CTX *tmp_ctx = talloc_stackframe();
+
+ if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
+ /* no includes */
+ *num_includes = 0;
+ *includes = NULL;
+ werr = WERR_OK;
+ goto done;
+ }
+
+ werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ if (value->type != REG_MULTI_SZ) {
+ /* wront type -- ignore */
+ goto done;
+ }
+
+ for (count = 0; count < value->v.multi_sz.num_strings; count++)
+ {
+ werr = smbconf_add_string_to_array(tmp_ctx,
+ &tmp_includes,
+ count,
+ value->v.multi_sz.strings[count]);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+ }
+
+ if (count > 0) {
+ *includes = talloc_move(mem_ctx, &tmp_includes);
+ if (*includes == NULL) {
+ werr = WERR_NOMEM;
+ goto done;
+ }
+ *num_includes = count;
+ } else {
+ *num_includes = 0;
+ *includes = NULL;
+ }
+
+done:
+ talloc_free(tmp_ctx);
+ return werr;
+}
+
/**
* Get the values of a key as a list of value names
* and a list of value strings (ordered)
uint32_t count;
struct registry_value *valvalue = NULL;
char *valname = NULL;
+ uint32_t tmp_num_values = 0;
char **tmp_valnames = NULL;
char **tmp_valstrings = NULL;
+ uint32_t num_includes = 0;
+ char **includes = NULL;
if ((num_values == NULL) || (value_names == NULL) ||
(value_strings == NULL))
}
tmp_ctx = talloc_stackframe();
- if (tmp_ctx == NULL) {
- werr = WERR_NOMEM;
- goto done;
- }
for (count = 0;
- W_ERROR_IS_OK(werr = reg_enumvalue(tmp_ctx, key, count, &valname,
- &valvalue));
+ werr = reg_enumvalue(tmp_ctx, key, count, &valname, &valvalue),
+ W_ERROR_IS_OK(werr);
count++)
{
char *valstring;
+ if (!smbconf_reg_valname_valid(valname)) {
+ continue;
+ }
+
werr = smbconf_add_string_to_array(tmp_ctx,
&tmp_valnames,
- count, valname);
+ tmp_num_values, valname);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
- count, valstring);
+ tmp_num_values, valstring);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
+ tmp_num_values++;
}
if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
goto done;
}
- werr = WERR_OK;
+ /* now add the includes at the end */
+ werr = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
+ &includes);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+ for (count = 0; count < num_includes; count++) {
+ werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
+ tmp_num_values, "include");
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
- *num_values = count;
- if (count > 0) {
+ werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
+ tmp_num_values,
+ includes[count]);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ tmp_num_values++;
+ }
+
+ *num_values = tmp_num_values;
+ if (tmp_num_values > 0) {
*value_names = talloc_move(mem_ctx, &tmp_valnames);
*value_strings = talloc_move(mem_ctx, &tmp_valstrings);
} else {
}
done:
- TALLOC_FREE(tmp_ctx);
+ talloc_free(tmp_ctx);
+ return werr;
+}
+
+static bool smbconf_reg_key_has_values(struct registry_key *key)
+{
+ WERROR werr;
+ uint32_t num_subkeys;
+ uint32_t max_subkeylen;
+ uint32_t max_subkeysize;
+ uint32_t num_values;
+ uint32_t max_valnamelen;
+ uint32_t max_valbufsize;
+ uint32_t secdescsize;
+ NTTIME last_changed_time;
+
+ werr = reg_queryinfokey(key, &num_subkeys, &max_subkeylen,
+ &max_subkeysize, &num_values, &max_valnamelen,
+ &max_valbufsize, &secdescsize,
+ &last_changed_time);
+ if (!W_ERROR_IS_OK(werr)) {
+ return false;
+ }
+
+ return (num_values != 0);
+}
+
+/**
+ * delete all values from a key
+ */
+static WERROR smbconf_reg_delete_values(struct registry_key *key)
+{
+ WERROR werr;
+ char *valname;
+ struct registry_value *valvalue;
+ uint32_t count;
+ TALLOC_CTX *mem_ctx = talloc_stackframe();
+
+ for (count = 0;
+ werr = reg_enumvalue(mem_ctx, key, count, &valname, &valvalue),
+ W_ERROR_IS_OK(werr);
+ count++)
+ {
+ werr = reg_deletevalue(key, valname);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+ }
+ if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
+ DEBUG(1, ("smbconf_reg_delete_values: "
+ "Error enumerating values of %s: %s\n",
+ key->key->name,
+ win_errstr(werr)));
+ goto done;
+ }
+
+ werr = WERR_OK;
+
+done:
+ talloc_free(mem_ctx);
return werr;
}
static WERROR smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
{
WERROR werr = WERR_OK;
+ struct nt_user_token *token;
if (path == NULL) {
path = KEY_SMBCONF;
goto done;
}
- if (!registry_init_smbconf()) {
- werr = WERR_REG_IO_FAILURE;
+ ctx->data = TALLOC_ZERO_P(ctx, struct reg_private_data);
+
+ werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(1, ("Error creating admin token\n"));
goto done;
}
+ rpd(ctx)->open = false;
- werr = ntstatus_to_werror(registry_create_admin_token(ctx,
- &(ctx->token)));
+ werr = registry_init_smbconf(path);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ werr = ctx->ops->open_conf(ctx);
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(1, ("Error opening the registry.\n"));
+ goto done;
+ }
+
+ werr = reg_open_path(ctx, ctx->path,
+ SEC_RIGHTS_ENUM_SUBKEYS | REG_KEY_WRITE,
+ token, &rpd(ctx)->base_key);
if (!W_ERROR_IS_OK(werr)) {
- DEBUG(1, ("Error creating admin token\n"));
goto done;
}
static int smbconf_reg_shutdown(struct smbconf_ctx *ctx)
{
- return regdb_close();
+ return ctx->ops->close_conf(ctx);
+}
+
+static bool smbconf_reg_requires_messaging(struct smbconf_ctx *ctx)
+{
+#ifdef CLUSTER_SUPPORT
+ if (lp_clustering() && lp_parm_bool(-1, "ctdb", "registry.tdb", true)) {
+ return true;
+ }
+#endif
+ return false;
+}
+
+static bool smbconf_reg_is_writeable(struct smbconf_ctx *ctx)
+{
+ /*
+ * The backend has write support.
+ *
+ * TODO: add access checks whether the concrete
+ * config source is really writeable by the calling user.
+ */
+ return true;
}
static WERROR smbconf_reg_open(struct smbconf_ctx *ctx)
{
- return regdb_open();
+ WERROR werr;
+
+ if (rpd(ctx)->open) {
+ return WERR_OK;
+ }
+
+ werr = regdb_open();
+ if (W_ERROR_IS_OK(werr)) {
+ rpd(ctx)->open = true;
+ }
+ return werr;
}
static int smbconf_reg_close(struct smbconf_ctx *ctx)
{
- return regdb_close();
+ int ret;
+
+ if (!rpd(ctx)->open) {
+ return 0;
+ }
+
+ ret = regdb_close();
+ if (ret == 0) {
+ rpd(ctx)->open = false;
+ }
+ return ret;
}
/**
if (csn == NULL) {
return;
}
+
+ if (!W_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
+ return;
+ }
+
csn->csn = (uint64_t)regdb_get_seqnum();
}
struct registry_key *new_key = NULL;
TALLOC_CTX* mem_ctx = talloc_stackframe();
enum winreg_CreateAction action;
+ struct nt_user_token *token;
+
+ werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
+ if (!W_ERROR_IS_OK(werr)) {
+ DEBUG(1, ("Error creating admin token\n"));
+ goto done;
+ }
path = talloc_strdup(mem_ctx, ctx->path);
if (path == NULL) {
}
p = strrchr(path, '\\');
*p = '\0';
- werr = smbconf_reg_open_path(mem_ctx, ctx, path, REG_KEY_WRITE,
- &parent_key);
+ werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token,
+ &parent_key);
if (!W_ERROR_IS_OK(werr)) {
goto done;
&new_key, &action);
done:
- TALLOC_FREE(mem_ctx);
+ talloc_free(mem_ctx);
return werr;
}
uint32_t added_count = 0;
TALLOC_CTX *tmp_ctx = NULL;
WERROR werr = WERR_OK;
- struct registry_key *key = NULL;
char *subkey_name = NULL;
char **tmp_share_names = NULL;
}
tmp_ctx = talloc_stackframe();
- if (tmp_ctx == NULL) {
- werr = WERR_NOMEM;
- goto done;
+
+ /* if there are values in the base key, return NULL as share name */
+
+ if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
+ werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
+ 0, NULL);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+ added_count++;
}
/* make sure "global" is always listed first */
if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
- 0, GLOBAL_NAME);
+ added_count, GLOBAL_NAME);
if (!W_ERROR_IS_OK(werr)) {
goto done;
}
added_count++;
}
- werr = smbconf_reg_open_base_key(tmp_ctx, ctx,
- SEC_RIGHTS_ENUM_SUBKEYS, &key);
- if (!W_ERROR_IS_OK(werr)) {
- goto done;
- }
-
for (count = 0;
- W_ERROR_IS_OK(werr = reg_enumkey(tmp_ctx, key, count,
- &subkey_name, NULL));
+ werr = reg_enumkey(tmp_ctx, rpd(ctx)->base_key, count,
+ &subkey_name, NULL),
+ W_ERROR_IS_OK(werr);
count++)
{
if (strequal(subkey_name, GLOBAL_NAME)) {
}
done:
- TALLOC_FREE(tmp_ctx);
+ talloc_free(tmp_ctx);
return werr;
}
ret = true;
}
- TALLOC_FREE(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
const char *servicename)
{
WERROR werr;
- TALLOC_CTX *mem_ctx = talloc_stackframe();
struct registry_key *key = NULL;
- werr = smbconf_reg_create_service_key(mem_ctx, ctx, servicename, &key);
+ if (servicename == NULL) {
+ return WERR_OK;
+ }
- TALLOC_FREE(mem_ctx);
+ werr = smbconf_reg_create_service_key(talloc_tos(), ctx,
+ servicename, &key);
+
+ talloc_free(key);
return werr;
}
static WERROR smbconf_reg_get_share(struct smbconf_ctx *ctx,
TALLOC_CTX *mem_ctx,
const char *servicename,
- uint32_t *num_params,
- char ***param_names, char ***param_values)
+ struct smbconf_service **service)
{
WERROR werr = WERR_OK;
struct registry_key *key = NULL;
+ struct smbconf_service *tmp_service = NULL;
+ TALLOC_CTX *tmp_ctx = talloc_stackframe();
- werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
+ werr = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
REG_KEY_READ, &key);
if (!W_ERROR_IS_OK(werr)) {
+ if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
+ werr = WERR_NO_SUCH_SERVICE;
+ }
+ goto done;
+ }
+
+ tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
+ if (tmp_service == NULL) {
+ werr = WERR_NOMEM;
goto done;
}
- werr = smbconf_reg_get_values(mem_ctx, key, num_params,
- param_names, param_values);
+ if (servicename != NULL) {
+ tmp_service->name = talloc_strdup(tmp_service, servicename);
+ if (tmp_service->name == NULL) {
+ werr = WERR_NOMEM;
+ goto done;
+ }
+ }
+
+ werr = smbconf_reg_get_values(tmp_service, key,
+ &(tmp_service->num_params),
+ &(tmp_service->param_names),
+ &(tmp_service->param_values));
+
+ if (W_ERROR_IS_OK(werr)) {
+ *service = talloc_move(mem_ctx, &tmp_service);
+ }
done:
- TALLOC_FREE(key);
+ talloc_free(tmp_ctx);
return werr;
}
const char *servicename)
{
WERROR werr = WERR_OK;
- struct registry_key *key = NULL;
TALLOC_CTX *mem_ctx = talloc_stackframe();
- werr = smbconf_reg_open_base_key(mem_ctx, ctx, REG_KEY_WRITE, &key);
- if (!W_ERROR_IS_OK(werr)) {
- goto done;
+ if (servicename != NULL) {
+ werr = reg_deletekey_recursive(mem_ctx, rpd(ctx)->base_key,
+ servicename);
+ } else {
+ werr = smbconf_reg_delete_values(rpd(ctx)->base_key);
}
- werr = reg_deletekey_recursive(key, key, servicename);
-
-done:
- TALLOC_FREE(mem_ctx);
+ talloc_free(mem_ctx);
return werr;
}
werr = smbconf_reg_set_value(key, param, valstr);
done:
- TALLOC_FREE(mem_ctx);
+ talloc_free(mem_ctx);
return werr;
}
goto done;
}
+ if (!smbconf_reg_valname_valid(param)) {
+ werr = WERR_INVALID_PARAM;
+ goto done;
+ }
+
if (!smbconf_value_exists(key, param)) {
werr = WERR_INVALID_PARAM;
goto done;
}
done:
- TALLOC_FREE(key);
- TALLOC_FREE(value);
+ talloc_free(key);
+ talloc_free(value);
return werr;
}
goto done;
}
+ if (!smbconf_reg_valname_valid(param)) {
+ werr = WERR_INVALID_PARAM;
+ goto done;
+ }
+
if (!smbconf_value_exists(key, param)) {
werr = WERR_INVALID_PARAM;
goto done;
werr = reg_deletevalue(key, param);
done:
- TALLOC_FREE(mem_ctx);
+ talloc_free(mem_ctx);
+ return werr;
+}
+
+static WERROR smbconf_reg_get_includes(struct smbconf_ctx *ctx,
+ TALLOC_CTX *mem_ctx,
+ const char *service,
+ uint32_t *num_includes,
+ char ***includes)
+{
+ WERROR werr;
+ struct registry_key *key = NULL;
+ TALLOC_CTX *tmp_ctx = talloc_stackframe();
+
+ werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
+ REG_KEY_READ, &key);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ werr = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
+ includes);
+
+done:
+ talloc_free(tmp_ctx);
+ return werr;
+}
+
+static WERROR smbconf_reg_set_includes(struct smbconf_ctx *ctx,
+ const char *service,
+ uint32_t num_includes,
+ const char **includes)
+{
+ WERROR werr = WERR_OK;
+ struct registry_key *key = NULL;
+ TALLOC_CTX *tmp_ctx = talloc_stackframe();
+
+ werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
+ REG_KEY_ALL, &key);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ if (num_includes == 0) {
+ if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
+ goto done;
+ }
+ werr = reg_deletevalue(key, INCLUDES_VALNAME);
+ } else {
+ werr = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
+ num_includes, includes);
+ }
+
+done:
+ talloc_free(tmp_ctx);
+ return werr;
+}
+
+static WERROR smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
+ const char *service)
+{
+ WERROR werr = WERR_OK;
+ struct registry_key *key = NULL;
+ TALLOC_CTX *tmp_ctx = talloc_stackframe();
+
+ werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
+ REG_KEY_ALL, &key);
+ if (!W_ERROR_IS_OK(werr)) {
+ goto done;
+ }
+
+ if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
+ goto done;
+ }
+
+ werr = reg_deletevalue(key, INCLUDES_VALNAME);
+
+
+done:
+ talloc_free(tmp_ctx);
return werr;
}
struct smbconf_ops smbconf_ops_reg = {
.init = smbconf_reg_init,
.shutdown = smbconf_reg_shutdown,
+ .requires_messaging = smbconf_reg_requires_messaging,
+ .is_writeable = smbconf_reg_is_writeable,
.open_conf = smbconf_reg_open,
.close_conf = smbconf_reg_close,
.get_csn = smbconf_reg_get_csn,
.delete_share = smbconf_reg_delete_share,
.set_parameter = smbconf_reg_set_parameter,
.get_parameter = smbconf_reg_get_parameter,
- .delete_parameter = smbconf_reg_delete_parameter
+ .delete_parameter = smbconf_reg_delete_parameter,
+ .get_includes = smbconf_reg_get_includes,
+ .set_includes = smbconf_reg_set_includes,
+ .delete_includes = smbconf_reg_delete_includes,
};
WERROR smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
const char *path)
{
- return smbconf_init(mem_ctx, conf_ctx, path, &smbconf_ops_reg);
+ return smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_reg);
}
git.samba.org / ira / wip.git / blobdiff