2 * Unix SMB/CIFS implementation.
3 * libsmbconf - Samba configuration library, registry backend
4 * Copyright (C) Michael Adam 2008
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include "smbconf_private.h"
23 #define INCLUDES_VALNAME "includes"
25 struct reg_private_data {
27 bool open; /* did _we_ open the registry? */
30 /**********************************************************************
34 **********************************************************************/
37 * a convenience helper to cast the private data structure
39 static struct reg_private_data *rpd(struct smbconf_ctx *ctx)
41 return (struct reg_private_data *)(ctx->data);
45 * check whether a given value name is forbidden in registry (smbconf)
47 static bool smbconf_reg_valname_forbidden(const char *valname)
49 /* hard code the list of forbidden names here for now */
50 const char *forbidden_valnames[] = {
55 "includes", /* this has a special meaning internally */
58 const char **forbidden = NULL;
60 for (forbidden = forbidden_valnames; *forbidden != NULL; forbidden++) {
61 if (strwicmp(valname, *forbidden) == 0) {
68 static bool smbconf_reg_valname_valid(const char *valname)
70 return (!smbconf_reg_valname_forbidden(valname) &&
71 lp_parameter_is_valid(valname));
75 * Open a registry key specified by "path"
77 static WERROR smbconf_reg_open_path(TALLOC_CTX *mem_ctx,
78 struct smbconf_ctx *ctx,
80 uint32 desired_access,
81 struct registry_key **key)
83 WERROR werr = WERR_OK;
86 DEBUG(1, ("Error: configuration is not open!\n"));
87 werr = WERR_INVALID_PARAM;
91 if (rpd(ctx)->token == NULL) {
92 DEBUG(1, ("Error: token missing from smbconf_ctx. "
93 "was smbconf_init() called?\n"));
94 werr = WERR_INVALID_PARAM;
98 werr = ctx->ops->open_conf(ctx);
99 if (!W_ERROR_IS_OK(werr)) {
100 DEBUG(1, ("Error opening the registry.\n"));
105 DEBUG(1, ("Error: NULL path string given\n"));
106 werr = WERR_INVALID_PARAM;
110 werr = reg_open_path(mem_ctx, path, desired_access, rpd(ctx)->token,
113 if (!W_ERROR_IS_OK(werr)) {
114 DEBUG(5, ("Error opening registry path '%s': %s\n",
115 path, win_errstr(werr)));
123 * Open a subkey of the base key (i.e a service)
125 static WERROR smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
126 struct smbconf_ctx *ctx,
127 const char *servicename,
128 uint32 desired_access,
129 struct registry_key **key)
131 WERROR werr = WERR_OK;
134 if (servicename == NULL) {
135 path = talloc_strdup(mem_ctx, ctx->path);
137 path = talloc_asprintf(mem_ctx, "%s\\%s", ctx->path,
145 werr = smbconf_reg_open_path(mem_ctx, ctx, path, desired_access, key);
155 static WERROR smbconf_reg_open_base_key(TALLOC_CTX *mem_ctx,
156 struct smbconf_ctx *ctx,
157 uint32 desired_access,
158 struct registry_key **key)
160 return smbconf_reg_open_path(mem_ctx, ctx, ctx->path, desired_access,
165 * check if a value exists in a given registry key
167 static bool smbconf_value_exists(struct registry_key *key, const char *param)
170 WERROR werr = WERR_OK;
171 TALLOC_CTX *ctx = talloc_stackframe();
172 struct registry_value *value = NULL;
174 werr = reg_queryvalue(ctx, key, param, &value);
175 if (W_ERROR_IS_OK(werr)) {
184 * create a subkey of the base key (i.e. a service...)
186 static WERROR smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
187 struct smbconf_ctx *ctx,
188 const char * subkeyname,
189 struct registry_key **newkey)
191 WERROR werr = WERR_OK;
192 struct registry_key *create_parent = NULL;
193 TALLOC_CTX *create_ctx;
194 enum winreg_CreateAction action = REG_ACTION_NONE;
196 /* create a new talloc ctx for creation. it will hold
197 * the intermediate parent key (SMBCONF) for creation
198 * and will be destroyed when leaving this function... */
199 create_ctx = talloc_stackframe();
201 werr = smbconf_reg_open_base_key(create_ctx, ctx, REG_KEY_WRITE,
203 if (!W_ERROR_IS_OK(werr)) {
207 werr = reg_createkey(mem_ctx, create_parent, subkeyname,
208 REG_KEY_WRITE, newkey, &action);
209 if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
210 DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
211 werr = WERR_FILE_EXISTS;
213 if (!W_ERROR_IS_OK(werr)) {
214 DEBUG(5, ("Error creating key %s: %s\n",
215 subkeyname, win_errstr(werr)));
219 TALLOC_FREE(create_ctx);
224 * add a value to a key.
226 static WERROR smbconf_reg_set_value(struct registry_key *key,
230 struct registry_value val;
231 WERROR werr = WERR_OK;
233 const char *canon_valname;
234 const char *canon_valstr;
236 if (!lp_canonicalize_parameter_with_value(valname, valstr,
240 if (canon_valname == NULL) {
241 DEBUG(5, ("invalid parameter '%s' given\n",
244 DEBUG(5, ("invalid value '%s' given for "
245 "parameter '%s'\n", valstr, valname));
247 werr = WERR_INVALID_PARAM;
251 if (smbconf_reg_valname_forbidden(canon_valname)) {
252 DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
254 werr = WERR_INVALID_PARAM;
258 subkeyname = strrchr_m(key->key->name, '\\');
259 if ((subkeyname == NULL) || (*(subkeyname +1) == '\0')) {
260 DEBUG(5, ("Invalid registry key '%s' given as "
261 "smbconf section.\n", key->key->name));
262 werr = WERR_INVALID_PARAM;
266 if (!strequal(subkeyname, GLOBAL_NAME) &&
267 lp_parameter_is_global(valname))
269 DEBUG(5, ("Global paramter '%s' not allowed in "
270 "service definition ('%s').\n", canon_valname,
272 werr = WERR_INVALID_PARAM;
279 val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
280 val.v.sz.len = strlen(canon_valstr) + 1;
282 werr = reg_setvalue(key, canon_valname, &val);
283 if (!W_ERROR_IS_OK(werr)) {
284 DEBUG(5, ("Error adding value '%s' to "
286 canon_valname, key->key->name, win_errstr(werr)));
293 static WERROR smbconf_reg_set_multi_sz_value(struct registry_key *key,
295 const uint32_t num_strings,
296 const char **strings)
299 struct registry_value *value;
301 TALLOC_CTX *tmp_ctx = talloc_stackframe();
303 if (strings == NULL) {
304 werr = WERR_INVALID_PARAM;
308 value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
310 value->type = REG_MULTI_SZ;
311 value->v.multi_sz.num_strings = num_strings;
312 value->v.multi_sz.strings = TALLOC_ARRAY(tmp_ctx, char *, num_strings);
313 if (value->v.multi_sz.strings == NULL) {
317 for (count = 0; count < num_strings; count++) {
318 value->v.multi_sz.strings[count] =
319 talloc_strdup(value->v.multi_sz.strings,
321 if (value->v.multi_sz.strings[count] == NULL) {
327 werr = reg_setvalue(key, valname, value);
328 if (!W_ERROR_IS_OK(werr)) {
329 DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
330 valname, key->key->name, win_errstr(werr)));
334 TALLOC_FREE(tmp_ctx);
339 * format a registry_value into a string.
341 * This is intended to be used for smbconf registry values,
342 * which are ar stored as REG_SZ values, so the incomplete
343 * handling should be ok.
345 static char *smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
346 struct registry_value *value)
350 /* alternatively, create a new talloc context? */
351 if (mem_ctx == NULL) {
355 switch (value->type) {
357 result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
361 result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
365 for (j = 0; j < value->v.multi_sz.num_strings; j++) {
366 result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
367 result ? result : "" ,
368 value->v.multi_sz.strings[j]);
369 if (result == NULL) {
376 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
377 (int)value->v.binary.length);
380 result = talloc_asprintf(mem_ctx, "<unprintable>");
386 static WERROR smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
387 struct registry_key *key,
388 uint32_t *num_includes,
393 struct registry_value *value = NULL;
394 char **tmp_includes = NULL;
395 TALLOC_CTX *tmp_ctx = talloc_stackframe();
397 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
405 werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
406 if (!W_ERROR_IS_OK(werr)) {
410 if (value->type != REG_MULTI_SZ) {
411 /* wront type -- ignore */
415 for (count = 0; count < value->v.multi_sz.num_strings; count++)
417 werr = smbconf_add_string_to_array(tmp_ctx,
420 value->v.multi_sz.strings[count]);
421 if (!W_ERROR_IS_OK(werr)) {
427 *includes = talloc_move(mem_ctx, &tmp_includes);
428 if (*includes == NULL) {
432 *num_includes = count;
439 TALLOC_FREE(tmp_ctx);
444 * Get the values of a key as a list of value names
445 * and a list of value strings (ordered)
447 static WERROR smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
448 struct registry_key *key,
449 uint32_t *num_values,
451 char ***value_strings)
453 TALLOC_CTX *tmp_ctx = NULL;
454 WERROR werr = WERR_OK;
456 struct registry_value *valvalue = NULL;
457 char *valname = NULL;
458 uint32_t tmp_num_values = 0;
459 char **tmp_valnames = NULL;
460 char **tmp_valstrings = NULL;
461 uint32_t num_includes = 0;
462 char **includes = NULL;
464 if ((num_values == NULL) || (value_names == NULL) ||
465 (value_strings == NULL))
467 werr = WERR_INVALID_PARAM;
471 tmp_ctx = talloc_stackframe();
474 werr = reg_enumvalue(tmp_ctx, key, count, &valname, &valvalue),
480 if (!smbconf_reg_valname_valid(valname)) {
484 werr = smbconf_add_string_to_array(tmp_ctx,
486 tmp_num_values, valname);
487 if (!W_ERROR_IS_OK(werr)) {
491 valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
492 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
493 tmp_num_values, valstring);
494 if (!W_ERROR_IS_OK(werr)) {
499 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
503 /* now add the includes at the end */
504 werr = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
506 if (!W_ERROR_IS_OK(werr)) {
509 for (count = 0; count < num_includes; count++) {
510 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
511 tmp_num_values, "include");
512 if (!W_ERROR_IS_OK(werr)) {
516 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
519 if (!W_ERROR_IS_OK(werr)) {
526 *num_values = tmp_num_values;
527 if (tmp_num_values > 0) {
528 *value_names = talloc_move(mem_ctx, &tmp_valnames);
529 *value_strings = talloc_move(mem_ctx, &tmp_valstrings);
532 *value_strings = NULL;
536 TALLOC_FREE(tmp_ctx);
540 static bool smbconf_reg_key_has_values(struct registry_key *key)
543 uint32_t num_subkeys;
544 uint32_t max_subkeylen;
545 uint32_t max_subkeysize;
547 uint32_t max_valnamelen;
548 uint32_t max_valbufsize;
549 uint32_t secdescsize;
550 NTTIME last_changed_time;
552 werr = reg_queryinfokey(key, &num_subkeys, &max_subkeylen,
553 &max_subkeysize, &num_values, &max_valnamelen,
554 &max_valbufsize, &secdescsize,
556 if (!W_ERROR_IS_OK(werr)) {
560 return (num_values != 0);
564 * delete all values from a key
566 static WERROR smbconf_reg_delete_values(struct registry_key *key)
570 struct registry_value *valvalue;
572 TALLOC_CTX *mem_ctx = talloc_stackframe();
575 werr = reg_enumvalue(mem_ctx, key, count, &valname, &valvalue),
579 werr = reg_deletevalue(key, valname);
580 if (!W_ERROR_IS_OK(werr)) {
584 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
585 DEBUG(1, ("smbconf_reg_delete_values: "
586 "Error enumerating values of %s: %s\n",
595 TALLOC_FREE(mem_ctx);
599 /**********************************************************************
601 * smbconf operations: registry implementations
603 **********************************************************************/
606 * initialize the registry smbconf backend
608 static WERROR smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
610 WERROR werr = WERR_OK;
615 ctx->path = talloc_strdup(ctx, path);
616 if (ctx->path == NULL) {
621 ctx->data = TALLOC_ZERO_P(ctx, struct reg_private_data);
623 werr = ntstatus_to_werror(registry_create_admin_token(ctx,
624 &(rpd(ctx)->token)));
625 if (!W_ERROR_IS_OK(werr)) {
626 DEBUG(1, ("Error creating admin token\n"));
629 rpd(ctx)->open = false;
631 werr = registry_init_smbconf(path);
632 if (!W_ERROR_IS_OK(werr)) {
640 static int smbconf_reg_shutdown(struct smbconf_ctx *ctx)
642 return ctx->ops->close_conf(ctx);
645 static bool smbconf_reg_requires_messaging(struct smbconf_ctx *ctx)
647 #ifdef CLUSTER_SUPPORT
648 if (lp_clustering() && lp_parm_bool(-1, "ctdb", "registry.tdb", true)) {
655 static bool smbconf_reg_is_writeable(struct smbconf_ctx *ctx)
658 * The backend has write support.
660 * TODO: add access checks whether the concrete
661 * config source is really writeable by the calling user.
666 static WERROR smbconf_reg_open(struct smbconf_ctx *ctx)
670 if (rpd(ctx)->open) {
675 if (W_ERROR_IS_OK(werr)) {
676 rpd(ctx)->open = true;
681 static int smbconf_reg_close(struct smbconf_ctx *ctx)
685 if (!rpd(ctx)->open) {
691 rpd(ctx)->open = false;
697 * Get the change sequence number of the given service/parameter.
698 * service and parameter strings may be NULL.
700 static void smbconf_reg_get_csn(struct smbconf_ctx *ctx,
701 struct smbconf_csn *csn,
702 const char *service, const char *param)
708 if (!W_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
712 csn->csn = (uint64_t)regdb_get_seqnum();
716 * Drop the whole configuration (restarting empty) - registry version
718 static WERROR smbconf_reg_drop(struct smbconf_ctx *ctx)
721 WERROR werr = WERR_OK;
722 struct registry_key *parent_key = NULL;
723 struct registry_key *new_key = NULL;
724 TALLOC_CTX* mem_ctx = talloc_stackframe();
725 enum winreg_CreateAction action;
727 path = talloc_strdup(mem_ctx, ctx->path);
732 p = strrchr(path, '\\');
734 werr = smbconf_reg_open_path(mem_ctx, ctx, path, REG_KEY_WRITE,
737 if (!W_ERROR_IS_OK(werr)) {
741 werr = reg_deletekey_recursive(mem_ctx, parent_key, p+1);
743 if (!W_ERROR_IS_OK(werr)) {
747 werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
751 TALLOC_FREE(mem_ctx);
756 * get the list of share names defined in the configuration.
759 static WERROR smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
761 uint32_t *num_shares,
765 uint32_t added_count = 0;
766 TALLOC_CTX *tmp_ctx = NULL;
767 WERROR werr = WERR_OK;
768 struct registry_key *key = NULL;
769 char *subkey_name = NULL;
770 char **tmp_share_names = NULL;
772 if ((num_shares == NULL) || (share_names == NULL)) {
773 werr = WERR_INVALID_PARAM;
777 tmp_ctx = talloc_stackframe();
779 /* if there are values in the base key, return NULL as share name */
780 werr = smbconf_reg_open_base_key(tmp_ctx, ctx,
781 SEC_RIGHTS_ENUM_SUBKEYS, &key);
782 if (!W_ERROR_IS_OK(werr)) {
786 if (smbconf_reg_key_has_values(key)) {
787 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
789 if (!W_ERROR_IS_OK(werr)) {
795 /* make sure "global" is always listed first */
796 if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
797 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
798 added_count, GLOBAL_NAME);
799 if (!W_ERROR_IS_OK(werr)) {
806 werr = reg_enumkey(tmp_ctx, key, count, &subkey_name, NULL),
810 if (strequal(subkey_name, GLOBAL_NAME)) {
814 werr = smbconf_add_string_to_array(tmp_ctx,
818 if (!W_ERROR_IS_OK(werr)) {
823 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
828 *num_shares = added_count;
829 if (added_count > 0) {
830 *share_names = talloc_move(mem_ctx, &tmp_share_names);
836 TALLOC_FREE(tmp_ctx);
841 * check if a share/service of a given name exists - registry version
843 static bool smbconf_reg_share_exists(struct smbconf_ctx *ctx,
844 const char *servicename)
847 WERROR werr = WERR_OK;
848 TALLOC_CTX *mem_ctx = talloc_stackframe();
849 struct registry_key *key = NULL;
851 werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
853 if (W_ERROR_IS_OK(werr)) {
857 TALLOC_FREE(mem_ctx);
862 * Add a service if it does not already exist - registry version
864 static WERROR smbconf_reg_create_share(struct smbconf_ctx *ctx,
865 const char *servicename)
868 TALLOC_CTX *mem_ctx = talloc_stackframe();
869 struct registry_key *key = NULL;
871 if (servicename == NULL) {
872 werr = smbconf_reg_open_base_key(mem_ctx, ctx, REG_KEY_WRITE,
875 werr = smbconf_reg_create_service_key(mem_ctx, ctx,
879 TALLOC_FREE(mem_ctx);
884 * get a definition of a share (service) from configuration.
886 static WERROR smbconf_reg_get_share(struct smbconf_ctx *ctx,
888 const char *servicename,
889 struct smbconf_service **service)
891 WERROR werr = WERR_OK;
892 struct registry_key *key = NULL;
893 struct smbconf_service *tmp_service = NULL;
894 TALLOC_CTX *tmp_ctx = talloc_stackframe();
896 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
898 if (!W_ERROR_IS_OK(werr)) {
902 tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
903 if (tmp_service == NULL) {
908 if (servicename != NULL) {
909 tmp_service->name = talloc_strdup(tmp_service, servicename);
910 if (tmp_service->name == NULL) {
916 werr = smbconf_reg_get_values(tmp_service, key,
917 &(tmp_service->num_params),
918 &(tmp_service->param_names),
919 &(tmp_service->param_values));
921 if (W_ERROR_IS_OK(werr)) {
922 *service = talloc_move(mem_ctx, &tmp_service);
926 TALLOC_FREE(tmp_ctx);
931 * delete a service from configuration
933 static WERROR smbconf_reg_delete_share(struct smbconf_ctx *ctx,
934 const char *servicename)
936 WERROR werr = WERR_OK;
937 struct registry_key *key = NULL;
938 TALLOC_CTX *mem_ctx = talloc_stackframe();
940 werr = smbconf_reg_open_base_key(mem_ctx, ctx, REG_KEY_WRITE, &key);
941 if (!W_ERROR_IS_OK(werr)) {
945 if (servicename != NULL) {
946 werr = reg_deletekey_recursive(key, key, servicename);
948 werr = smbconf_reg_delete_values(key);
952 TALLOC_FREE(mem_ctx);
957 * set a configuration parameter to the value provided.
959 static WERROR smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
965 struct registry_key *key = NULL;
966 TALLOC_CTX *mem_ctx = talloc_stackframe();
968 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
969 REG_KEY_WRITE, &key);
970 if (!W_ERROR_IS_OK(werr)) {
974 werr = smbconf_reg_set_value(key, param, valstr);
977 TALLOC_FREE(mem_ctx);
982 * get the value of a configuration parameter as a string
984 static WERROR smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
990 WERROR werr = WERR_OK;
991 struct registry_key *key = NULL;
992 struct registry_value *value = NULL;
994 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
996 if (!W_ERROR_IS_OK(werr)) {
1000 if (!smbconf_reg_valname_valid(param)) {
1001 werr = WERR_INVALID_PARAM;
1005 if (!smbconf_value_exists(key, param)) {
1006 werr = WERR_INVALID_PARAM;
1010 werr = reg_queryvalue(mem_ctx, key, param, &value);
1011 if (!W_ERROR_IS_OK(werr)) {
1015 *valstr = smbconf_format_registry_value(mem_ctx, value);
1017 if (*valstr == NULL) {
1028 * delete a parameter from configuration
1030 static WERROR smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
1031 const char *service,
1034 struct registry_key *key = NULL;
1035 WERROR werr = WERR_OK;
1036 TALLOC_CTX *mem_ctx = talloc_stackframe();
1038 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
1040 if (!W_ERROR_IS_OK(werr)) {
1044 if (!smbconf_reg_valname_valid(param)) {
1045 werr = WERR_INVALID_PARAM;
1049 if (!smbconf_value_exists(key, param)) {
1050 werr = WERR_INVALID_PARAM;
1054 werr = reg_deletevalue(key, param);
1057 TALLOC_FREE(mem_ctx);
1061 static WERROR smbconf_reg_get_includes(struct smbconf_ctx *ctx,
1062 TALLOC_CTX *mem_ctx,
1063 const char *service,
1064 uint32_t *num_includes,
1068 struct registry_key *key = NULL;
1069 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1071 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1072 REG_KEY_READ, &key);
1073 if (!W_ERROR_IS_OK(werr)) {
1077 werr = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
1081 TALLOC_FREE(tmp_ctx);
1085 static WERROR smbconf_reg_set_includes(struct smbconf_ctx *ctx,
1086 const char *service,
1087 uint32_t num_includes,
1088 const char **includes)
1090 WERROR werr = WERR_OK;
1091 struct registry_key *key = NULL;
1092 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1094 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1096 if (!W_ERROR_IS_OK(werr)) {
1100 if (num_includes == 0) {
1101 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1104 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1106 werr = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
1107 num_includes, includes);
1111 TALLOC_FREE(tmp_ctx);
1115 static WERROR smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
1116 const char *service)
1118 WERROR werr = WERR_OK;
1119 struct registry_key *key = NULL;
1120 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1122 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1124 if (!W_ERROR_IS_OK(werr)) {
1128 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1132 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1136 TALLOC_FREE(tmp_ctx);
1140 struct smbconf_ops smbconf_ops_reg = {
1141 .init = smbconf_reg_init,
1142 .shutdown = smbconf_reg_shutdown,
1143 .requires_messaging = smbconf_reg_requires_messaging,
1144 .is_writeable = smbconf_reg_is_writeable,
1145 .open_conf = smbconf_reg_open,
1146 .close_conf = smbconf_reg_close,
1147 .get_csn = smbconf_reg_get_csn,
1148 .drop = smbconf_reg_drop,
1149 .get_share_names = smbconf_reg_get_share_names,
1150 .share_exists = smbconf_reg_share_exists,
1151 .create_share = smbconf_reg_create_share,
1152 .get_share = smbconf_reg_get_share,
1153 .delete_share = smbconf_reg_delete_share,
1154 .set_parameter = smbconf_reg_set_parameter,
1155 .get_parameter = smbconf_reg_get_parameter,
1156 .delete_parameter = smbconf_reg_delete_parameter,
1157 .get_includes = smbconf_reg_get_includes,
1158 .set_includes = smbconf_reg_set_includes,
1159 .delete_includes = smbconf_reg_delete_includes,
1164 * initialize the smbconf registry backend
1165 * the only function that is exported from this module
1167 WERROR smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
1170 return smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_reg);