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 "lib/smbconf/smbconf_private.h"
23 #include "registry/reg_api.h"
24 #include "registry/reg_backend_db.h"
25 #include "registry/reg_util_token.h"
26 #include "registry/reg_api_util.h"
27 #include "registry/reg_init_smbconf.h"
28 #include "lib/smbconf/smbconf_init.h"
29 #include "lib/smbconf/smbconf_reg.h"
30 #include "../libcli/registry/util_reg.h"
32 #define INCLUDES_VALNAME "includes"
34 struct reg_private_data {
35 struct registry_key *base_key;
36 bool open; /* did _we_ open the registry? */
39 /**********************************************************************
43 **********************************************************************/
46 * a convenience helper to cast the private data structure
48 static struct reg_private_data *rpd(struct smbconf_ctx *ctx)
50 return (struct reg_private_data *)(ctx->data);
54 * check whether a given value name is forbidden in registry (smbconf)
56 static bool smbconf_reg_valname_forbidden(const char *valname)
58 /* hard code the list of forbidden names here for now */
59 const char *forbidden_valnames[] = {
64 "includes", /* this has a special meaning internally */
67 const char **forbidden = NULL;
69 for (forbidden = forbidden_valnames; *forbidden != NULL; forbidden++) {
70 if (strwicmp(valname, *forbidden) == 0) {
77 static bool smbconf_reg_valname_valid(const char *valname)
79 return (!smbconf_reg_valname_forbidden(valname) &&
80 lp_parameter_is_valid(valname));
84 * Open a subkey of the base key (i.e a service)
86 static sbcErr smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
87 struct smbconf_ctx *ctx,
88 const char *servicename,
89 uint32 desired_access,
90 struct registry_key **key)
94 if (servicename == NULL) {
95 *key = rpd(ctx)->base_key;
98 werr = reg_openkey(mem_ctx, rpd(ctx)->base_key, servicename,
100 if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
101 return SBC_ERR_NO_SUCH_SERVICE;
103 if (!W_ERROR_IS_OK(werr)) {
104 return SBC_ERR_NOMEM;
111 * check if a value exists in a given registry key
113 static bool smbconf_value_exists(struct registry_key *key, const char *param)
116 WERROR werr = WERR_OK;
117 TALLOC_CTX *ctx = talloc_stackframe();
118 struct registry_value *value = NULL;
120 werr = reg_queryvalue(ctx, key, param, &value);
121 if (W_ERROR_IS_OK(werr)) {
130 * create a subkey of the base key (i.e. a service...)
132 static sbcErr smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
133 struct smbconf_ctx *ctx,
134 const char * subkeyname,
135 struct registry_key **newkey)
138 sbcErr err = SBC_ERR_OK;
139 TALLOC_CTX *create_ctx;
140 enum winreg_CreateAction action = REG_ACTION_NONE;
142 /* create a new talloc ctx for creation. it will hold
143 * the intermediate parent key (SMBCONF) for creation
144 * and will be destroyed when leaving this function... */
145 create_ctx = talloc_stackframe();
147 werr = reg_createkey(mem_ctx, rpd(ctx)->base_key, subkeyname,
148 REG_KEY_WRITE, newkey, &action);
149 if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
150 DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
151 err = SBC_ERR_FILE_EXISTS;
153 if (!W_ERROR_IS_OK(werr)) {
154 DEBUG(5, ("Error creating key %s: %s\n",
155 subkeyname, win_errstr(werr)));
156 err = SBC_ERR_UNKNOWN_FAILURE;
159 talloc_free(create_ctx);
164 * add a value to a key.
166 static sbcErr smbconf_reg_set_value(struct registry_key *key,
170 struct registry_value val;
171 WERROR werr = WERR_OK;
174 const char *canon_valname;
175 const char *canon_valstr;
177 if (!lp_canonicalize_parameter_with_value(valname, valstr,
181 if (canon_valname == NULL) {
182 DEBUG(5, ("invalid parameter '%s' given\n",
185 DEBUG(5, ("invalid value '%s' given for "
186 "parameter '%s'\n", valstr, valname));
188 err = SBC_ERR_INVALID_PARAM;
192 if (smbconf_reg_valname_forbidden(canon_valname)) {
193 DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
195 err = SBC_ERR_INVALID_PARAM;
199 subkeyname = strrchr_m(key->key->name, '\\');
200 if ((subkeyname == NULL) || (*(subkeyname +1) == '\0')) {
201 DEBUG(5, ("Invalid registry key '%s' given as "
202 "smbconf section.\n", key->key->name));
203 err = SBC_ERR_INVALID_PARAM;
207 if (!strequal(subkeyname, GLOBAL_NAME) &&
208 lp_parameter_is_global(valname))
210 DEBUG(5, ("Global parameter '%s' not allowed in "
211 "service definition ('%s').\n", canon_valname,
213 err = SBC_ERR_INVALID_PARAM;
220 if (!push_reg_sz(talloc_tos(), &val.data, canon_valstr)) {
225 werr = reg_setvalue(key, canon_valname, &val);
226 if (!W_ERROR_IS_OK(werr)) {
227 DEBUG(5, ("Error adding value '%s' to "
229 canon_valname, key->key->name, win_errstr(werr)));
239 static sbcErr smbconf_reg_set_multi_sz_value(struct registry_key *key,
241 const uint32_t num_strings,
242 const char **strings)
245 sbcErr err = SBC_ERR_OK;
246 struct registry_value *value;
248 TALLOC_CTX *tmp_ctx = talloc_stackframe();
251 if (strings == NULL) {
252 err = SBC_ERR_INVALID_PARAM;
256 array = talloc_zero_array(tmp_ctx, const char *, num_strings + 1);
262 value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
268 value->type = REG_MULTI_SZ;
270 for (count = 0; count < num_strings; count++) {
271 array[count] = talloc_strdup(value, strings[count]);
272 if (array[count] == NULL) {
278 if (!push_reg_multi_sz(value, &value->data, array)) {
283 werr = reg_setvalue(key, valname, value);
284 if (!W_ERROR_IS_OK(werr)) {
285 DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
286 valname, key->key->name, win_errstr(werr)));
287 err = SBC_ERR_ACCESS_DENIED;
291 talloc_free(tmp_ctx);
296 * format a registry_value into a string.
298 * This is intended to be used for smbconf registry values,
299 * which are ar stored as REG_SZ values, so the incomplete
300 * handling should be ok.
302 static char *smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
303 struct registry_value *value)
307 /* alternatively, create a new talloc context? */
308 if (mem_ctx == NULL) {
312 switch (value->type) {
314 if (value->data.length >= 4) {
315 uint32_t v = IVAL(value->data.data, 0);
316 result = talloc_asprintf(mem_ctx, "%d", v);
320 case REG_EXPAND_SZ: {
322 if (!pull_reg_sz(mem_ctx, &value->data, &s)) {
325 result = talloc_strdup(mem_ctx, s);
330 const char **a = NULL;
331 if (!pull_reg_multi_sz(mem_ctx, &value->data, &a)) {
334 for (j = 0; a[j] != NULL; j++) {
335 result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
336 result ? result : "" ,
338 if (result == NULL) {
345 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
346 (int)value->data.length);
349 result = talloc_asprintf(mem_ctx, "<unprintable>");
355 static sbcErr smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
356 struct registry_key *key,
357 uint32_t *num_includes,
363 struct registry_value *value = NULL;
364 char **tmp_includes = NULL;
365 const char **array = NULL;
366 TALLOC_CTX *tmp_ctx = talloc_stackframe();
368 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
376 werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
377 if (!W_ERROR_IS_OK(werr)) {
378 err = SBC_ERR_ACCESS_DENIED;
382 if (value->type != REG_MULTI_SZ) {
383 /* wrong type -- ignore */
388 if (!pull_reg_multi_sz(tmp_ctx, &value->data, &array)) {
393 for (count = 0; array[count] != NULL; count++) {
394 err = smbconf_add_string_to_array(tmp_ctx,
398 if (!SBC_ERROR_IS_OK(err)) {
404 *includes = talloc_move(mem_ctx, &tmp_includes);
405 if (*includes == NULL) {
409 *num_includes = count;
417 talloc_free(tmp_ctx);
422 * Get the values of a key as a list of value names
423 * and a list of value strings (ordered)
425 static sbcErr smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
426 struct registry_key *key,
427 uint32_t *num_values,
429 char ***value_strings)
431 TALLOC_CTX *tmp_ctx = NULL;
432 WERROR werr = WERR_OK;
435 struct registry_value *valvalue = NULL;
436 char *valname = NULL;
437 uint32_t tmp_num_values = 0;
438 char **tmp_valnames = NULL;
439 char **tmp_valstrings = NULL;
440 uint32_t num_includes = 0;
441 char **includes = NULL;
443 if ((num_values == NULL) || (value_names == NULL) ||
444 (value_strings == NULL))
446 err = SBC_ERR_INVALID_PARAM;
450 tmp_ctx = talloc_stackframe();
453 werr = reg_enumvalue(tmp_ctx, key, count, &valname, &valvalue),
459 if (!smbconf_reg_valname_valid(valname)) {
463 err = smbconf_add_string_to_array(tmp_ctx,
465 tmp_num_values, valname);
466 if (!SBC_ERROR_IS_OK(err)) {
470 valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
471 err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
472 tmp_num_values, valstring);
473 if (!SBC_ERROR_IS_OK(err)) {
478 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
483 /* now add the includes at the end */
484 err = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
486 if (!SBC_ERROR_IS_OK(err)) {
490 for (count = 0; count < num_includes; count++) {
491 err = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
492 tmp_num_values, "include");
493 if (!SBC_ERROR_IS_OK(err)) {
497 err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
500 if (!SBC_ERROR_IS_OK(err)) {
507 *num_values = tmp_num_values;
508 if (tmp_num_values > 0) {
509 *value_names = talloc_move(mem_ctx, &tmp_valnames);
510 *value_strings = talloc_move(mem_ctx, &tmp_valstrings);
513 *value_strings = NULL;
517 talloc_free(tmp_ctx);
521 static bool smbconf_reg_key_has_values(struct registry_key *key)
524 uint32_t num_subkeys;
525 uint32_t max_subkeylen;
526 uint32_t max_subkeysize;
528 uint32_t max_valnamelen;
529 uint32_t max_valbufsize;
530 uint32_t secdescsize;
531 NTTIME last_changed_time;
533 werr = reg_queryinfokey(key, &num_subkeys, &max_subkeylen,
534 &max_subkeysize, &num_values, &max_valnamelen,
535 &max_valbufsize, &secdescsize,
537 if (!W_ERROR_IS_OK(werr)) {
541 return (num_values != 0);
545 * delete all values from a key
547 static sbcErr smbconf_reg_delete_values(struct registry_key *key)
552 struct registry_value *valvalue;
554 TALLOC_CTX *mem_ctx = talloc_stackframe();
557 werr = reg_enumvalue(mem_ctx, key, count, &valname, &valvalue),
561 werr = reg_deletevalue(key, valname);
562 if (!W_ERROR_IS_OK(werr)) {
563 err = SBC_ERR_ACCESS_DENIED;
567 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
568 DEBUG(1, ("smbconf_reg_delete_values: "
569 "Error enumerating values of %s: %s\n",
572 err = SBC_ERR_ACCESS_DENIED;
579 talloc_free(mem_ctx);
583 /**********************************************************************
585 * smbconf operations: registry implementations
587 **********************************************************************/
590 * initialize the registry smbconf backend
592 static sbcErr smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
594 WERROR werr = WERR_OK;
596 struct security_token *token;
601 ctx->path = talloc_strdup(ctx, path);
602 if (ctx->path == NULL) {
607 ctx->data = TALLOC_ZERO_P(ctx, struct reg_private_data);
609 werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
610 if (!W_ERROR_IS_OK(werr)) {
611 DEBUG(1, ("Error creating admin token\n"));
612 err = SBC_ERR_UNKNOWN_FAILURE;
615 rpd(ctx)->open = false;
617 werr = registry_init_smbconf(path);
618 if (!W_ERROR_IS_OK(werr)) {
619 err = SBC_ERR_BADFILE;
623 err = ctx->ops->open_conf(ctx);
624 if (!SBC_ERROR_IS_OK(err)) {
625 DEBUG(1, ("Error opening the registry.\n"));
629 werr = reg_open_path(ctx, ctx->path,
630 KEY_ENUMERATE_SUB_KEYS | REG_KEY_WRITE,
631 token, &rpd(ctx)->base_key);
632 if (!W_ERROR_IS_OK(werr)) {
633 err = SBC_ERR_UNKNOWN_FAILURE;
641 static int smbconf_reg_shutdown(struct smbconf_ctx *ctx)
643 return ctx->ops->close_conf(ctx);
646 static bool smbconf_reg_requires_messaging(struct smbconf_ctx *ctx)
648 #ifdef CLUSTER_SUPPORT
649 if (lp_clustering() && lp_parm_bool(-1, "ctdb", "registry.tdb", true)) {
656 static bool smbconf_reg_is_writeable(struct smbconf_ctx *ctx)
659 * The backend has write support.
661 * TODO: add access checks whether the concrete
662 * config source is really writeable by the calling user.
667 static sbcErr smbconf_reg_open(struct smbconf_ctx *ctx)
671 if (rpd(ctx)->open) {
676 if (!W_ERROR_IS_OK(werr)) {
677 return SBC_ERR_BADFILE;
680 rpd(ctx)->open = true;
684 static int smbconf_reg_close(struct smbconf_ctx *ctx)
688 if (!rpd(ctx)->open) {
694 rpd(ctx)->open = false;
700 * Get the change sequence number of the given service/parameter.
701 * service and parameter strings may be NULL.
703 static void smbconf_reg_get_csn(struct smbconf_ctx *ctx,
704 struct smbconf_csn *csn,
705 const char *service, const char *param)
711 if (!SBC_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
715 csn->csn = (uint64_t)regdb_get_seqnum();
719 * Drop the whole configuration (restarting empty) - registry version
721 static sbcErr smbconf_reg_drop(struct smbconf_ctx *ctx)
724 WERROR werr = WERR_OK;
725 sbcErr err = SBC_ERR_OK;
726 struct registry_key *parent_key = NULL;
727 struct registry_key *new_key = NULL;
728 TALLOC_CTX* mem_ctx = talloc_stackframe();
729 enum winreg_CreateAction action;
730 struct security_token *token;
732 werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
733 if (!W_ERROR_IS_OK(werr)) {
734 DEBUG(1, ("Error creating admin token\n"));
735 err = SBC_ERR_UNKNOWN_FAILURE;
739 path = talloc_strdup(mem_ctx, ctx->path);
744 p = strrchr(path, '\\');
746 err = SBC_ERR_INVALID_PARAM;
750 werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token,
752 if (!W_ERROR_IS_OK(werr)) {
753 err = SBC_ERR_IO_FAILURE;
757 werr = reg_deletekey_recursive(parent_key, p+1);
758 if (!W_ERROR_IS_OK(werr)) {
759 err = SBC_ERR_IO_FAILURE;
763 werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
765 if (!W_ERROR_IS_OK(werr)) {
766 err = SBC_ERR_IO_FAILURE;
771 talloc_free(mem_ctx);
776 * get the list of share names defined in the configuration.
779 static sbcErr smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
781 uint32_t *num_shares,
785 uint32_t added_count = 0;
786 TALLOC_CTX *tmp_ctx = NULL;
788 sbcErr err = SBC_ERR_OK;
789 char *subkey_name = NULL;
790 char **tmp_share_names = NULL;
792 if ((num_shares == NULL) || (share_names == NULL)) {
793 return SBC_ERR_INVALID_PARAM;
796 tmp_ctx = talloc_stackframe();
798 /* if there are values in the base key, return NULL as share name */
800 if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
801 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
803 if (!SBC_ERROR_IS_OK(err)) {
809 /* make sure "global" is always listed first */
810 if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
811 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
812 added_count, GLOBAL_NAME);
813 if (!SBC_ERROR_IS_OK(err)) {
820 werr = reg_enumkey(tmp_ctx, rpd(ctx)->base_key, count,
825 if (strequal(subkey_name, GLOBAL_NAME)) {
829 err = smbconf_add_string_to_array(tmp_ctx,
833 if (!SBC_ERROR_IS_OK(err)) {
838 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
839 err = SBC_ERR_NO_MORE_ITEMS;
844 *num_shares = added_count;
845 if (added_count > 0) {
846 *share_names = talloc_move(mem_ctx, &tmp_share_names);
852 talloc_free(tmp_ctx);
857 * check if a share/service of a given name exists - registry version
859 static bool smbconf_reg_share_exists(struct smbconf_ctx *ctx,
860 const char *servicename)
864 TALLOC_CTX *mem_ctx = talloc_stackframe();
865 struct registry_key *key = NULL;
867 err = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
869 if (SBC_ERROR_IS_OK(err)) {
873 talloc_free(mem_ctx);
878 * Add a service if it does not already exist - registry version
880 static sbcErr smbconf_reg_create_share(struct smbconf_ctx *ctx,
881 const char *servicename)
884 struct registry_key *key = NULL;
886 if (servicename == NULL) {
890 err = smbconf_reg_create_service_key(talloc_tos(), ctx,
898 * get a definition of a share (service) from configuration.
900 static sbcErr smbconf_reg_get_share(struct smbconf_ctx *ctx,
902 const char *servicename,
903 struct smbconf_service **service)
906 struct registry_key *key = NULL;
907 struct smbconf_service *tmp_service = NULL;
908 TALLOC_CTX *tmp_ctx = talloc_stackframe();
910 err = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
912 if (!SBC_ERROR_IS_OK(err)) {
916 tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
917 if (tmp_service == NULL) {
922 if (servicename != NULL) {
923 tmp_service->name = talloc_strdup(tmp_service, servicename);
924 if (tmp_service->name == NULL) {
930 err = smbconf_reg_get_values(tmp_service, key,
931 &(tmp_service->num_params),
932 &(tmp_service->param_names),
933 &(tmp_service->param_values));
934 if (SBC_ERROR_IS_OK(err)) {
935 *service = talloc_move(mem_ctx, &tmp_service);
939 talloc_free(tmp_ctx);
944 * delete a service from configuration
946 static sbcErr smbconf_reg_delete_share(struct smbconf_ctx *ctx,
947 const char *servicename)
950 sbcErr err = SBC_ERR_OK;
951 TALLOC_CTX *mem_ctx = talloc_stackframe();
953 if (servicename != NULL) {
954 werr = reg_deletekey_recursive(rpd(ctx)->base_key, servicename);
955 if (!W_ERROR_IS_OK(werr)) {
956 err = SBC_ERR_ACCESS_DENIED;
959 err = smbconf_reg_delete_values(rpd(ctx)->base_key);
962 talloc_free(mem_ctx);
967 * set a configuration parameter to the value provided.
969 static sbcErr smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
975 struct registry_key *key = NULL;
976 TALLOC_CTX *mem_ctx = talloc_stackframe();
978 err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
979 REG_KEY_WRITE, &key);
980 if (!SBC_ERROR_IS_OK(err)) {
984 err = smbconf_reg_set_value(key, param, valstr);
987 talloc_free(mem_ctx);
992 * get the value of a configuration parameter as a string
994 static sbcErr smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
1000 WERROR werr = WERR_OK;
1002 struct registry_key *key = NULL;
1003 struct registry_value *value = NULL;
1005 err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
1006 REG_KEY_READ, &key);
1007 if (!SBC_ERROR_IS_OK(err)) {
1011 if (!smbconf_reg_valname_valid(param)) {
1012 err = SBC_ERR_INVALID_PARAM;
1016 if (!smbconf_value_exists(key, param)) {
1017 err = SBC_ERR_INVALID_PARAM;
1021 werr = reg_queryvalue(mem_ctx, key, param, &value);
1022 if (!W_ERROR_IS_OK(werr)) {
1023 err = SBC_ERR_NOMEM;
1027 *valstr = smbconf_format_registry_value(mem_ctx, value);
1028 if (*valstr == NULL) {
1029 err = SBC_ERR_NOMEM;
1039 * delete a parameter from configuration
1041 static sbcErr smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
1042 const char *service,
1045 struct registry_key *key = NULL;
1048 TALLOC_CTX *mem_ctx = talloc_stackframe();
1050 err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
1052 if (!SBC_ERROR_IS_OK(err)) {
1056 if (!smbconf_reg_valname_valid(param)) {
1057 err = SBC_ERR_INVALID_PARAM;
1061 if (!smbconf_value_exists(key, param)) {
1066 werr = reg_deletevalue(key, param);
1067 if (!W_ERROR_IS_OK(werr)) {
1068 err = SBC_ERR_ACCESS_DENIED;
1072 talloc_free(mem_ctx);
1076 static sbcErr smbconf_reg_get_includes(struct smbconf_ctx *ctx,
1077 TALLOC_CTX *mem_ctx,
1078 const char *service,
1079 uint32_t *num_includes,
1083 struct registry_key *key = NULL;
1084 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1086 err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1087 REG_KEY_READ, &key);
1088 if (!SBC_ERROR_IS_OK(err)) {
1092 err = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
1094 if (!SBC_ERROR_IS_OK(err)) {
1099 talloc_free(tmp_ctx);
1103 static sbcErr smbconf_reg_set_includes(struct smbconf_ctx *ctx,
1104 const char *service,
1105 uint32_t num_includes,
1106 const char **includes)
1108 WERROR werr = WERR_OK;
1110 struct registry_key *key = NULL;
1111 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1113 err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1115 if (!SBC_ERROR_IS_OK(err)) {
1119 if (num_includes == 0) {
1120 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1124 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1125 if (!W_ERROR_IS_OK(werr)) {
1126 err = SBC_ERR_ACCESS_DENIED;
1130 err = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
1131 num_includes, includes);
1135 talloc_free(tmp_ctx);
1139 static sbcErr smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
1140 const char *service)
1144 struct registry_key *key = NULL;
1145 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1147 err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1149 if (!SBC_ERROR_IS_OK(err)) {
1153 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1158 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1159 if (!W_ERROR_IS_OK(werr)) {
1160 err = SBC_ERR_ACCESS_DENIED;
1166 talloc_free(tmp_ctx);
1170 static WERROR smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
1172 return regdb_transaction_start();
1175 static WERROR smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
1177 return regdb_transaction_commit();
1180 static WERROR smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
1182 return regdb_transaction_cancel();
1185 struct smbconf_ops smbconf_ops_reg = {
1186 .init = smbconf_reg_init,
1187 .shutdown = smbconf_reg_shutdown,
1188 .requires_messaging = smbconf_reg_requires_messaging,
1189 .is_writeable = smbconf_reg_is_writeable,
1190 .open_conf = smbconf_reg_open,
1191 .close_conf = smbconf_reg_close,
1192 .get_csn = smbconf_reg_get_csn,
1193 .drop = smbconf_reg_drop,
1194 .get_share_names = smbconf_reg_get_share_names,
1195 .share_exists = smbconf_reg_share_exists,
1196 .create_share = smbconf_reg_create_share,
1197 .get_share = smbconf_reg_get_share,
1198 .delete_share = smbconf_reg_delete_share,
1199 .set_parameter = smbconf_reg_set_parameter,
1200 .get_parameter = smbconf_reg_get_parameter,
1201 .delete_parameter = smbconf_reg_delete_parameter,
1202 .get_includes = smbconf_reg_get_includes,
1203 .set_includes = smbconf_reg_set_includes,
1204 .delete_includes = smbconf_reg_delete_includes,
1205 .transaction_start = smbconf_reg_transaction_start,
1206 .transaction_commit = smbconf_reg_transaction_commit,
1207 .transaction_cancel = smbconf_reg_transaction_cancel,
1212 * initialize the smbconf registry backend
1213 * the only function that is exported from this module
1215 sbcErr smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
1218 return smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_reg);