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 parameter name is valid in the
55 * smbconf registry backend.
57 bool smbconf_reg_parameter_is_valid(const char *param_name)
59 /* hard code the list of forbidden names here for now */
60 const char *forbidden_names[] = {
67 * "includes" has a special meaning internally.
68 * It is currently not necessary to list it here since it is
69 * not a valid parameter. But for clarity and safety, we keep
75 const char **forbidden = NULL;
77 if (!lp_parameter_is_valid(param_name)) {
81 for (forbidden = forbidden_names; *forbidden != NULL; forbidden++) {
82 if (strwicmp(param_name, *forbidden) == 0) {
91 * Open a subkey of the base key (i.e a service)
93 static sbcErr smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
94 struct smbconf_ctx *ctx,
95 const char *servicename,
96 uint32 desired_access,
97 struct registry_key **key)
101 if (servicename == NULL) {
102 *key = rpd(ctx)->base_key;
105 werr = reg_openkey(mem_ctx, rpd(ctx)->base_key, servicename,
106 desired_access, key);
107 if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
108 return SBC_ERR_NO_SUCH_SERVICE;
110 if (!W_ERROR_IS_OK(werr)) {
111 return SBC_ERR_NOMEM;
118 * check if a value exists in a given registry key
120 static bool smbconf_value_exists(struct registry_key *key, const char *param)
123 WERROR werr = WERR_OK;
124 TALLOC_CTX *ctx = talloc_stackframe();
125 struct registry_value *value = NULL;
127 werr = reg_queryvalue(ctx, key, param, &value);
128 if (W_ERROR_IS_OK(werr)) {
137 * create a subkey of the base key (i.e. a service...)
139 static sbcErr smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
140 struct smbconf_ctx *ctx,
141 const char * subkeyname,
142 struct registry_key **newkey)
145 sbcErr err = SBC_ERR_OK;
146 TALLOC_CTX *create_ctx;
147 enum winreg_CreateAction action = REG_ACTION_NONE;
149 /* create a new talloc ctx for creation. it will hold
150 * the intermediate parent key (SMBCONF) for creation
151 * and will be destroyed when leaving this function... */
152 create_ctx = talloc_stackframe();
154 werr = reg_createkey(mem_ctx, rpd(ctx)->base_key, subkeyname,
155 REG_KEY_WRITE, newkey, &action);
156 if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
157 DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
158 err = SBC_ERR_FILE_EXISTS;
160 if (!W_ERROR_IS_OK(werr)) {
161 DEBUG(5, ("Error creating key %s: %s\n",
162 subkeyname, win_errstr(werr)));
163 err = SBC_ERR_UNKNOWN_FAILURE;
166 talloc_free(create_ctx);
171 * add a value to a key.
173 static sbcErr smbconf_reg_set_value(struct registry_key *key,
177 struct registry_value val;
178 WERROR werr = WERR_OK;
181 const char *canon_valname;
182 const char *canon_valstr;
184 if (!lp_parameter_is_valid(valname)) {
185 DEBUG(5, ("Invalid parameter '%s' given.\n", valname));
186 err = SBC_ERR_INVALID_PARAM;
190 if (!smbconf_reg_parameter_is_valid(valname)) {
191 DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
193 err = SBC_ERR_INVALID_PARAM;
197 subkeyname = strrchr_m(key->key->name, '\\');
198 if ((subkeyname == NULL) || (*(subkeyname +1) == '\0')) {
199 DEBUG(5, ("Invalid registry key '%s' given as "
200 "smbconf section.\n", key->key->name));
201 err = SBC_ERR_INVALID_PARAM;
205 if (!strequal(subkeyname, GLOBAL_NAME) &&
206 lp_parameter_is_global(valname))
208 DEBUG(5, ("Global parameter '%s' not allowed in "
209 "service definition ('%s').\n", valname,
211 err = SBC_ERR_INVALID_PARAM;
215 if (!lp_canonicalize_parameter_with_value(valname, valstr,
220 * We already know the parameter name is valid.
221 * So the value must be invalid.
223 DEBUG(5, ("invalid value '%s' given for parameter '%s'\n",
225 err = SBC_ERR_INVALID_PARAM;
232 if (!push_reg_sz(talloc_tos(), &val.data, canon_valstr)) {
237 werr = reg_setvalue(key, canon_valname, &val);
238 if (!W_ERROR_IS_OK(werr)) {
239 DEBUG(5, ("Error adding value '%s' to "
241 canon_valname, key->key->name, win_errstr(werr)));
251 static sbcErr smbconf_reg_set_multi_sz_value(struct registry_key *key,
253 const uint32_t num_strings,
254 const char **strings)
257 sbcErr err = SBC_ERR_OK;
258 struct registry_value *value;
260 TALLOC_CTX *tmp_ctx = talloc_stackframe();
263 if (strings == NULL) {
264 err = SBC_ERR_INVALID_PARAM;
268 array = talloc_zero_array(tmp_ctx, const char *, num_strings + 1);
274 value = talloc_zero(tmp_ctx, struct registry_value);
280 value->type = REG_MULTI_SZ;
282 for (count = 0; count < num_strings; count++) {
283 array[count] = talloc_strdup(value, strings[count]);
284 if (array[count] == NULL) {
290 if (!push_reg_multi_sz(value, &value->data, array)) {
295 werr = reg_setvalue(key, valname, value);
296 if (!W_ERROR_IS_OK(werr)) {
297 DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
298 valname, key->key->name, win_errstr(werr)));
299 err = SBC_ERR_ACCESS_DENIED;
303 talloc_free(tmp_ctx);
308 * format a registry_value into a string.
310 * This is intended to be used for smbconf registry values,
311 * which are ar stored as REG_SZ values, so the incomplete
312 * handling should be ok.
314 static char *smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
315 struct registry_value *value)
319 /* alternatively, create a new talloc context? */
320 if (mem_ctx == NULL) {
324 switch (value->type) {
326 if (value->data.length >= 4) {
327 uint32_t v = IVAL(value->data.data, 0);
328 result = talloc_asprintf(mem_ctx, "%d", v);
332 case REG_EXPAND_SZ: {
334 if (!pull_reg_sz(mem_ctx, &value->data, &s)) {
337 result = talloc_strdup(mem_ctx, s);
342 const char **a = NULL;
343 if (!pull_reg_multi_sz(mem_ctx, &value->data, &a)) {
346 for (j = 0; a[j] != NULL; j++) {
347 result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
348 result ? result : "" ,
350 if (result == NULL) {
357 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
358 (int)value->data.length);
361 result = talloc_asprintf(mem_ctx, "<unprintable>");
367 static sbcErr smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
368 struct registry_key *key,
369 uint32_t *num_includes,
375 struct registry_value *value = NULL;
376 char **tmp_includes = NULL;
377 const char **array = NULL;
378 TALLOC_CTX *tmp_ctx = talloc_stackframe();
380 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
388 werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
389 if (!W_ERROR_IS_OK(werr)) {
390 err = SBC_ERR_ACCESS_DENIED;
394 if (value->type != REG_MULTI_SZ) {
395 /* wrong type -- ignore */
400 if (!pull_reg_multi_sz(tmp_ctx, &value->data, &array)) {
405 for (count = 0; array[count] != NULL; count++) {
406 err = smbconf_add_string_to_array(tmp_ctx,
410 if (!SBC_ERROR_IS_OK(err)) {
416 *includes = talloc_move(mem_ctx, &tmp_includes);
417 if (*includes == NULL) {
421 *num_includes = count;
429 talloc_free(tmp_ctx);
434 * Get the values of a key as a list of value names
435 * and a list of value strings (ordered)
437 static sbcErr smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
438 struct registry_key *key,
439 uint32_t *num_values,
441 char ***value_strings)
443 TALLOC_CTX *tmp_ctx = NULL;
444 WERROR werr = WERR_OK;
447 struct registry_value *valvalue = NULL;
448 char *valname = NULL;
449 uint32_t tmp_num_values = 0;
450 char **tmp_valnames = NULL;
451 char **tmp_valstrings = NULL;
452 uint32_t num_includes = 0;
453 char **includes = NULL;
455 if ((num_values == NULL) || (value_names == NULL) ||
456 (value_strings == NULL))
458 err = SBC_ERR_INVALID_PARAM;
462 tmp_ctx = talloc_stackframe();
465 werr = reg_enumvalue(tmp_ctx, key, count, &valname, &valvalue),
471 if (!smbconf_reg_parameter_is_valid(valname)) {
475 err = smbconf_add_string_to_array(tmp_ctx,
477 tmp_num_values, valname);
478 if (!SBC_ERROR_IS_OK(err)) {
482 valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
483 err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
484 tmp_num_values, valstring);
485 if (!SBC_ERROR_IS_OK(err)) {
490 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
495 /* now add the includes at the end */
496 err = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
498 if (!SBC_ERROR_IS_OK(err)) {
502 for (count = 0; count < num_includes; count++) {
503 err = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
504 tmp_num_values, "include");
505 if (!SBC_ERROR_IS_OK(err)) {
509 err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
512 if (!SBC_ERROR_IS_OK(err)) {
519 *num_values = tmp_num_values;
520 if (tmp_num_values > 0) {
521 *value_names = talloc_move(mem_ctx, &tmp_valnames);
522 *value_strings = talloc_move(mem_ctx, &tmp_valstrings);
525 *value_strings = NULL;
529 talloc_free(tmp_ctx);
533 static bool smbconf_reg_key_has_values(struct registry_key *key)
536 uint32_t num_subkeys;
537 uint32_t max_subkeylen;
538 uint32_t max_subkeysize;
540 uint32_t max_valnamelen;
541 uint32_t max_valbufsize;
542 uint32_t secdescsize;
543 NTTIME last_changed_time;
545 werr = reg_queryinfokey(key, &num_subkeys, &max_subkeylen,
546 &max_subkeysize, &num_values, &max_valnamelen,
547 &max_valbufsize, &secdescsize,
549 if (!W_ERROR_IS_OK(werr)) {
553 return (num_values != 0);
557 * delete all values from a key
559 static sbcErr smbconf_reg_delete_values(struct registry_key *key)
564 struct registry_value *valvalue;
566 TALLOC_CTX *mem_ctx = talloc_stackframe();
569 werr = reg_enumvalue(mem_ctx, key, count, &valname, &valvalue),
573 werr = reg_deletevalue(key, valname);
574 if (!W_ERROR_IS_OK(werr)) {
575 err = SBC_ERR_ACCESS_DENIED;
579 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
580 DEBUG(1, ("smbconf_reg_delete_values: "
581 "Error enumerating values of %s: %s\n",
584 err = SBC_ERR_ACCESS_DENIED;
591 talloc_free(mem_ctx);
595 /**********************************************************************
597 * smbconf operations: registry implementations
599 **********************************************************************/
602 * initialize the registry smbconf backend
604 static sbcErr smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
606 WERROR werr = WERR_OK;
608 struct security_token *token;
613 ctx->path = talloc_strdup(ctx, path);
614 if (ctx->path == NULL) {
619 ctx->data = talloc_zero(ctx, struct reg_private_data);
621 werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
622 if (!W_ERROR_IS_OK(werr)) {
623 DEBUG(1, ("Error creating admin token\n"));
624 err = SBC_ERR_UNKNOWN_FAILURE;
627 rpd(ctx)->open = false;
629 werr = registry_init_smbconf(path);
630 if (!W_ERROR_IS_OK(werr)) {
631 err = SBC_ERR_BADFILE;
635 err = ctx->ops->open_conf(ctx);
636 if (!SBC_ERROR_IS_OK(err)) {
637 DEBUG(1, ("Error opening the registry.\n"));
641 werr = reg_open_path(ctx, ctx->path,
642 KEY_ENUMERATE_SUB_KEYS | REG_KEY_WRITE,
643 token, &rpd(ctx)->base_key);
644 if (!W_ERROR_IS_OK(werr)) {
645 err = SBC_ERR_UNKNOWN_FAILURE;
653 static int smbconf_reg_shutdown(struct smbconf_ctx *ctx)
655 return ctx->ops->close_conf(ctx);
658 static bool smbconf_reg_requires_messaging(struct smbconf_ctx *ctx)
660 #ifdef CLUSTER_SUPPORT
661 if (lp_clustering() && lp_parm_bool(-1, "ctdb", "registry.tdb", true)) {
668 static bool smbconf_reg_is_writeable(struct smbconf_ctx *ctx)
671 * The backend has write support.
673 * TODO: add access checks whether the concrete
674 * config source is really writeable by the calling user.
679 static sbcErr smbconf_reg_open(struct smbconf_ctx *ctx)
683 if (rpd(ctx)->open) {
688 if (!W_ERROR_IS_OK(werr)) {
689 return SBC_ERR_BADFILE;
692 rpd(ctx)->open = true;
696 static int smbconf_reg_close(struct smbconf_ctx *ctx)
700 if (!rpd(ctx)->open) {
706 rpd(ctx)->open = false;
712 * Get the change sequence number of the given service/parameter.
713 * service and parameter strings may be NULL.
715 static void smbconf_reg_get_csn(struct smbconf_ctx *ctx,
716 struct smbconf_csn *csn,
717 const char *service, const char *param)
723 if (!SBC_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
727 csn->csn = (uint64_t)regdb_get_seqnum();
731 * Drop the whole configuration (restarting empty) - registry version
733 static sbcErr smbconf_reg_drop(struct smbconf_ctx *ctx)
736 WERROR werr = WERR_OK;
737 sbcErr err = SBC_ERR_OK;
738 struct registry_key *parent_key = NULL;
739 struct registry_key *new_key = NULL;
740 TALLOC_CTX* mem_ctx = talloc_stackframe();
741 enum winreg_CreateAction action;
742 struct security_token *token;
744 werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
745 if (!W_ERROR_IS_OK(werr)) {
746 DEBUG(1, ("Error creating admin token\n"));
747 err = SBC_ERR_UNKNOWN_FAILURE;
751 path = talloc_strdup(mem_ctx, ctx->path);
756 p = strrchr(path, '\\');
758 err = SBC_ERR_INVALID_PARAM;
762 werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token,
764 if (!W_ERROR_IS_OK(werr)) {
765 err = SBC_ERR_IO_FAILURE;
769 werr = reg_deletesubkeys_recursive(parent_key, p+1);
770 if (!W_ERROR_IS_OK(werr)) {
771 err = SBC_ERR_IO_FAILURE;
775 werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
777 if (!W_ERROR_IS_OK(werr)) {
778 err = SBC_ERR_IO_FAILURE;
783 talloc_free(mem_ctx);
788 * get the list of share names defined in the configuration.
791 static sbcErr smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
793 uint32_t *num_shares,
797 uint32_t added_count = 0;
798 TALLOC_CTX *tmp_ctx = NULL;
800 sbcErr err = SBC_ERR_OK;
801 char *subkey_name = NULL;
802 char **tmp_share_names = NULL;
804 if ((num_shares == NULL) || (share_names == NULL)) {
805 return SBC_ERR_INVALID_PARAM;
808 tmp_ctx = talloc_stackframe();
810 /* if there are values in the base key, return NULL as share name */
812 if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
813 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
815 if (!SBC_ERROR_IS_OK(err)) {
821 /* make sure "global" is always listed first */
822 if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
823 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
824 added_count, GLOBAL_NAME);
825 if (!SBC_ERROR_IS_OK(err)) {
832 werr = reg_enumkey(tmp_ctx, rpd(ctx)->base_key, count,
837 if (strequal(subkey_name, GLOBAL_NAME)) {
841 err = smbconf_add_string_to_array(tmp_ctx,
845 if (!SBC_ERROR_IS_OK(err)) {
850 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
851 err = SBC_ERR_NO_MORE_ITEMS;
856 *num_shares = added_count;
857 if (added_count > 0) {
858 *share_names = talloc_move(mem_ctx, &tmp_share_names);
864 talloc_free(tmp_ctx);
869 * check if a share/service of a given name exists - registry version
871 static bool smbconf_reg_share_exists(struct smbconf_ctx *ctx,
872 const char *servicename)
876 TALLOC_CTX *mem_ctx = talloc_stackframe();
877 struct registry_key *key = NULL;
879 err = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
881 if (SBC_ERROR_IS_OK(err)) {
885 talloc_free(mem_ctx);
890 * Add a service if it does not already exist - registry version
892 static sbcErr smbconf_reg_create_share(struct smbconf_ctx *ctx,
893 const char *servicename)
896 struct registry_key *key = NULL;
898 if (servicename == NULL) {
902 err = smbconf_reg_create_service_key(talloc_tos(), ctx,
910 * get a definition of a share (service) from configuration.
912 static sbcErr smbconf_reg_get_share(struct smbconf_ctx *ctx,
914 const char *servicename,
915 struct smbconf_service **service)
918 struct registry_key *key = NULL;
919 struct smbconf_service *tmp_service = NULL;
920 TALLOC_CTX *tmp_ctx = talloc_stackframe();
922 err = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
924 if (!SBC_ERROR_IS_OK(err)) {
928 tmp_service = talloc_zero(tmp_ctx, struct smbconf_service);
929 if (tmp_service == NULL) {
934 if (servicename != NULL) {
935 tmp_service->name = talloc_strdup(tmp_service, servicename);
936 if (tmp_service->name == NULL) {
942 err = smbconf_reg_get_values(tmp_service, key,
943 &(tmp_service->num_params),
944 &(tmp_service->param_names),
945 &(tmp_service->param_values));
946 if (SBC_ERROR_IS_OK(err)) {
947 *service = talloc_move(mem_ctx, &tmp_service);
951 talloc_free(tmp_ctx);
956 * delete a service from configuration
958 static sbcErr smbconf_reg_delete_share(struct smbconf_ctx *ctx,
959 const char *servicename)
962 sbcErr err = SBC_ERR_OK;
963 TALLOC_CTX *mem_ctx = talloc_stackframe();
965 if (servicename != NULL) {
966 werr = reg_deletekey_recursive(rpd(ctx)->base_key, servicename);
967 if (!W_ERROR_IS_OK(werr)) {
968 err = SBC_ERR_ACCESS_DENIED;
971 err = smbconf_reg_delete_values(rpd(ctx)->base_key);
974 talloc_free(mem_ctx);
979 * set a configuration parameter to the value provided.
981 static sbcErr smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
987 struct registry_key *key = NULL;
988 TALLOC_CTX *mem_ctx = talloc_stackframe();
990 err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
991 REG_KEY_WRITE, &key);
992 if (!SBC_ERROR_IS_OK(err)) {
996 err = smbconf_reg_set_value(key, param, valstr);
999 talloc_free(mem_ctx);
1004 * get the value of a configuration parameter as a string
1006 static sbcErr smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
1007 TALLOC_CTX *mem_ctx,
1008 const char *service,
1012 WERROR werr = WERR_OK;
1014 struct registry_key *key = NULL;
1015 struct registry_value *value = NULL;
1017 err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
1018 REG_KEY_READ, &key);
1019 if (!SBC_ERROR_IS_OK(err)) {
1023 if (!smbconf_reg_parameter_is_valid(param)) {
1024 err = SBC_ERR_INVALID_PARAM;
1028 if (!smbconf_value_exists(key, param)) {
1029 err = SBC_ERR_INVALID_PARAM;
1033 werr = reg_queryvalue(mem_ctx, key, param, &value);
1034 if (!W_ERROR_IS_OK(werr)) {
1035 err = SBC_ERR_NOMEM;
1039 *valstr = smbconf_format_registry_value(mem_ctx, value);
1040 if (*valstr == NULL) {
1041 err = SBC_ERR_NOMEM;
1051 * delete a parameter from configuration
1053 static sbcErr smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
1054 const char *service,
1057 struct registry_key *key = NULL;
1060 TALLOC_CTX *mem_ctx = talloc_stackframe();
1062 err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
1064 if (!SBC_ERROR_IS_OK(err)) {
1068 if (!smbconf_reg_parameter_is_valid(param)) {
1069 err = SBC_ERR_INVALID_PARAM;
1073 if (!smbconf_value_exists(key, param)) {
1078 werr = reg_deletevalue(key, param);
1079 if (!W_ERROR_IS_OK(werr)) {
1080 err = SBC_ERR_ACCESS_DENIED;
1084 talloc_free(mem_ctx);
1088 static sbcErr smbconf_reg_get_includes(struct smbconf_ctx *ctx,
1089 TALLOC_CTX *mem_ctx,
1090 const char *service,
1091 uint32_t *num_includes,
1095 struct registry_key *key = NULL;
1096 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1098 err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1099 REG_KEY_READ, &key);
1100 if (!SBC_ERROR_IS_OK(err)) {
1104 err = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
1106 if (!SBC_ERROR_IS_OK(err)) {
1111 talloc_free(tmp_ctx);
1115 static sbcErr smbconf_reg_set_includes(struct smbconf_ctx *ctx,
1116 const char *service,
1117 uint32_t num_includes,
1118 const char **includes)
1120 WERROR werr = WERR_OK;
1122 struct registry_key *key = NULL;
1123 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1125 err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1127 if (!SBC_ERROR_IS_OK(err)) {
1131 if (num_includes == 0) {
1132 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1136 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1137 if (!W_ERROR_IS_OK(werr)) {
1138 err = SBC_ERR_ACCESS_DENIED;
1142 err = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
1143 num_includes, includes);
1147 talloc_free(tmp_ctx);
1151 static sbcErr smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
1152 const char *service)
1156 struct registry_key *key = NULL;
1157 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1159 err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1161 if (!SBC_ERROR_IS_OK(err)) {
1165 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1170 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1171 if (!W_ERROR_IS_OK(werr)) {
1172 err = SBC_ERR_ACCESS_DENIED;
1178 talloc_free(tmp_ctx);
1182 static sbcErr smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
1186 werr = regdb_transaction_start();
1187 if (!W_ERROR_IS_OK(werr)) {
1188 return SBC_ERR_IO_FAILURE;
1194 static sbcErr smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
1198 werr = regdb_transaction_commit();
1199 if (!W_ERROR_IS_OK(werr)) {
1200 return SBC_ERR_IO_FAILURE;
1206 static sbcErr smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
1210 werr = regdb_transaction_cancel();
1211 if (!W_ERROR_IS_OK(werr)) {
1212 return SBC_ERR_IO_FAILURE;
1218 struct smbconf_ops smbconf_ops_reg = {
1219 .init = smbconf_reg_init,
1220 .shutdown = smbconf_reg_shutdown,
1221 .requires_messaging = smbconf_reg_requires_messaging,
1222 .is_writeable = smbconf_reg_is_writeable,
1223 .open_conf = smbconf_reg_open,
1224 .close_conf = smbconf_reg_close,
1225 .get_csn = smbconf_reg_get_csn,
1226 .drop = smbconf_reg_drop,
1227 .get_share_names = smbconf_reg_get_share_names,
1228 .share_exists = smbconf_reg_share_exists,
1229 .create_share = smbconf_reg_create_share,
1230 .get_share = smbconf_reg_get_share,
1231 .delete_share = smbconf_reg_delete_share,
1232 .set_parameter = smbconf_reg_set_parameter,
1233 .get_parameter = smbconf_reg_get_parameter,
1234 .delete_parameter = smbconf_reg_delete_parameter,
1235 .get_includes = smbconf_reg_get_includes,
1236 .set_includes = smbconf_reg_set_includes,
1237 .delete_includes = smbconf_reg_delete_includes,
1238 .transaction_start = smbconf_reg_transaction_start,
1239 .transaction_commit = smbconf_reg_transaction_commit,
1240 .transaction_cancel = smbconf_reg_transaction_cancel,
1245 * initialize the smbconf registry backend
1246 * the only function that is exported from this module
1248 sbcErr smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
1251 return smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_reg);