?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3/smbconf_reg: Fix typo.
[Samba/gebeck_regimport.git] / source3 / lib / smbconf / smbconf_reg.c
blob0ecac97575e4c89b3ea5784c95531ce3ff88b247
1 /*
2 * Unix SMB/CIFS implementation.
3 * libsmbconf - Samba configuration library, registry backend
4 * Copyright (C) Michael Adam 2008
5 *
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.
10 *
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.
15 *
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/>.
18 */
19
20 #include "includes.h"
21 #include "lib/smbconf/smbconf_private.h"
22
23 #define INCLUDES_VALNAME "includes"
24
25 struct reg_private_data {
26 struct registry_key *base_key;
27 bool open; /* did _we_ open the registry? */
28 };
29
30 /**********************************************************************
31 *
32 * helper functions
33 *
34 **********************************************************************/
35
36 /**
37 * a convenience helper to cast the private data structure
38 */
39 static struct reg_private_data *rpd(struct smbconf_ctx *ctx)
40 {
41 return (struct reg_private_data *)(ctx->data);
42 }
43
44 /*
45 * check whether a given value name is forbidden in registry (smbconf)
46 */
47 static bool smbconf_reg_valname_forbidden(const char *valname)
48 {
49 /* hard code the list of forbidden names here for now */
50 const char *forbidden_valnames[] = {
51 "lock directory",
52 "lock dir",
53 "config backend",
54 "include",
55 "includes", /* this has a special meaning internally */
56 NULL
57 };
58 const char **forbidden = NULL;
59
60 for (forbidden = forbidden_valnames; *forbidden != NULL; forbidden++) {
61 if (strwicmp(valname, *forbidden) == 0) {
62 return true;
63 }
64 }
65 return false;
66 }
67
68 static bool smbconf_reg_valname_valid(const char *valname)
69 {
70 return (!smbconf_reg_valname_forbidden(valname) &&
71 lp_parameter_is_valid(valname));
72 }
73
74 /**
75 * Open a subkey of the base key (i.e a service)
76 */
77 static WERROR smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
78 struct smbconf_ctx *ctx,
79 const char *servicename,
80 uint32 desired_access,
81 struct registry_key **key)
82 {
83 WERROR werr;
84
85 if (servicename == NULL) {
86 *key = rpd(ctx)->base_key;
87 return WERR_OK;
88 }
89 werr = reg_openkey(mem_ctx, rpd(ctx)->base_key, servicename,
90 desired_access, key);
91
92 if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
93 werr = WERR_NO_SUCH_SERVICE;
94 }
95
96 return werr;
97 }
98
99 /**
100 * check if a value exists in a given registry key
101 */
102 static bool smbconf_value_exists(struct registry_key *key, const char *param)
103 {
104 bool ret = false;
105 WERROR werr = WERR_OK;
106 TALLOC_CTX *ctx = talloc_stackframe();
107 struct registry_value *value = NULL;
108
109 werr = reg_queryvalue(ctx, key, param, &value);
110 if (W_ERROR_IS_OK(werr)) {
111 ret = true;
112 }
113
114 talloc_free(ctx);
115 return ret;
116 }
117
118 /**
119 * create a subkey of the base key (i.e. a service...)
120 */
121 static WERROR smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
122 struct smbconf_ctx *ctx,
123 const char * subkeyname,
124 struct registry_key **newkey)
125 {
126 WERROR werr = WERR_OK;
127 TALLOC_CTX *create_ctx;
128 enum winreg_CreateAction action = REG_ACTION_NONE;
129
130 /* create a new talloc ctx for creation. it will hold
131 * the intermediate parent key (SMBCONF) for creation
132 * and will be destroyed when leaving this function... */
133 create_ctx = talloc_stackframe();
134
135 werr = reg_createkey(mem_ctx, rpd(ctx)->base_key, subkeyname,
136 REG_KEY_WRITE, newkey, &action);
137 if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
138 DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
139 werr = WERR_FILE_EXISTS;
140 }
141 if (!W_ERROR_IS_OK(werr)) {
142 DEBUG(5, ("Error creating key %s: %s\n",
143 subkeyname, win_errstr(werr)));
144 }
145
146 talloc_free(create_ctx);
147 return werr;
148 }
149
150 /**
151 * add a value to a key.
152 */
153 static WERROR smbconf_reg_set_value(struct registry_key *key,
154 const char *valname,
155 const char *valstr)
156 {
157 struct registry_value val;
158 WERROR werr = WERR_OK;
159 char *subkeyname;
160 const char *canon_valname;
161 const char *canon_valstr;
162
163 if (!lp_canonicalize_parameter_with_value(valname, valstr,
164 &canon_valname,
165 &canon_valstr))
166 {
167 if (canon_valname == NULL) {
168 DEBUG(5, ("invalid parameter '%s' given\n",
169 valname));
170 } else {
171 DEBUG(5, ("invalid value '%s' given for "
172 "parameter '%s'\n", valstr, valname));
173 }
174 werr = WERR_INVALID_PARAM;
175 goto done;
176 }
177
178 if (smbconf_reg_valname_forbidden(canon_valname)) {
179 DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
180 canon_valname));
181 werr = WERR_INVALID_PARAM;
182 goto done;
183 }
184
185 subkeyname = strrchr_m(key->key->name, '\\');
186 if ((subkeyname == NULL) || (*(subkeyname +1) == '\0')) {
187 DEBUG(5, ("Invalid registry key '%s' given as "
188 "smbconf section.\n", key->key->name));
189 werr = WERR_INVALID_PARAM;
190 goto done;
191 }
192 subkeyname++;
193 if (!strequal(subkeyname, GLOBAL_NAME) &&
194 lp_parameter_is_global(valname))
195 {
196 DEBUG(5, ("Global parameter '%s' not allowed in "
197 "service definition ('%s').\n", canon_valname,
198 subkeyname));
199 werr = WERR_INVALID_PARAM;
200 goto done;
201 }
202
203 ZERO_STRUCT(val);
204
205 val.type = REG_SZ;
206 val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
207 val.v.sz.len = strlen(canon_valstr) + 1;
208
209 werr = reg_setvalue(key, canon_valname, &val);
210 if (!W_ERROR_IS_OK(werr)) {
211 DEBUG(5, ("Error adding value '%s' to "
212 "key '%s': %s\n",
213 canon_valname, key->key->name, win_errstr(werr)));
214 }
215
216 done:
217 return werr;
218 }
219
220 static WERROR smbconf_reg_set_multi_sz_value(struct registry_key *key,
221 const char *valname,
222 const uint32_t num_strings,
223 const char **strings)
224 {
225 WERROR werr;
226 struct registry_value *value;
227 uint32_t count;
228 TALLOC_CTX *tmp_ctx = talloc_stackframe();
229
230 if (strings == NULL) {
231 werr = WERR_INVALID_PARAM;
232 goto done;
233 }
234
235 value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
236
237 value->type = REG_MULTI_SZ;
238 value->v.multi_sz.num_strings = num_strings;
239 value->v.multi_sz.strings = TALLOC_ARRAY(tmp_ctx, char *, num_strings);
240 if (value->v.multi_sz.strings == NULL) {
241 werr = WERR_NOMEM;
242 goto done;
243 }
244 for (count = 0; count < num_strings; count++) {
245 value->v.multi_sz.strings[count] =
246 talloc_strdup(value->v.multi_sz.strings,
247 strings[count]);
248 if (value->v.multi_sz.strings[count] == NULL) {
249 werr = WERR_NOMEM;
250 goto done;
251 }
252 }
253
254 werr = reg_setvalue(key, valname, value);
255 if (!W_ERROR_IS_OK(werr)) {
256 DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
257 valname, key->key->name, win_errstr(werr)));
258 }
259
260 done:
261 talloc_free(tmp_ctx);
262 return werr;
263 }
264
265 /**
266 * format a registry_value into a string.
267 *
268 * This is intended to be used for smbconf registry values,
269 * which are ar stored as REG_SZ values, so the incomplete
270 * handling should be ok.
271 */
272 static char *smbconf_format_registry_value(TALLOC_CTX *mem_ctx,
273 struct registry_value *value)
274 {
275 char *result = NULL;
276
277 /* alternatively, create a new talloc context? */
278 if (mem_ctx == NULL) {
279 return result;
280 }
281
282 switch (value->type) {
283 case REG_DWORD:
284 result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
285 break;
286 case REG_SZ:
287 case REG_EXPAND_SZ:
288 result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
289 break;
290 case REG_MULTI_SZ: {
291 uint32 j;
292 for (j = 0; j < value->v.multi_sz.num_strings; j++) {
293 result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
294 result ? result : "" ,
295 value->v.multi_sz.strings[j]);
296 if (result == NULL) {
297 break;
298 }
299 }
300 break;
301 }
302 case REG_BINARY:
303 result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
304 (int)value->v.binary.length);
305 break;
306 default:
307 result = talloc_asprintf(mem_ctx, "<unprintable>");
308 break;
309 }
310 return result;
311 }
312
313 static WERROR smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
314 struct registry_key *key,
315 uint32_t *num_includes,
316 char ***includes)
317 {
318 WERROR werr;
319 uint32_t count;
320 struct registry_value *value = NULL;
321 char **tmp_includes = NULL;
322 TALLOC_CTX *tmp_ctx = talloc_stackframe();
323
324 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
325 /* no includes */
326 *num_includes = 0;
327 *includes = NULL;
328 werr = WERR_OK;
329 goto done;
330 }
331
332 werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
333 if (!W_ERROR_IS_OK(werr)) {
334 goto done;
335 }
336
337 if (value->type != REG_MULTI_SZ) {
338 /* wront type -- ignore */
339 goto done;
340 }
341
342 for (count = 0; count < value->v.multi_sz.num_strings; count++)
343 {
344 werr = smbconf_add_string_to_array(tmp_ctx,
345 &tmp_includes,
346 count,
347 value->v.multi_sz.strings[count]);
348 if (!W_ERROR_IS_OK(werr)) {
349 goto done;
350 }
351 }
352
353 if (count > 0) {
354 *includes = talloc_move(mem_ctx, &tmp_includes);
355 if (*includes == NULL) {
356 werr = WERR_NOMEM;
357 goto done;
358 }
359 *num_includes = count;
360 } else {
361 *num_includes = 0;
362 *includes = NULL;
363 }
364
365 done:
366 talloc_free(tmp_ctx);
367 return werr;
368 }
369
370 /**
371 * Get the values of a key as a list of value names
372 * and a list of value strings (ordered)
373 */
374 static WERROR smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
375 struct registry_key *key,
376 uint32_t *num_values,
377 char ***value_names,
378 char ***value_strings)
379 {
380 TALLOC_CTX *tmp_ctx = NULL;
381 WERROR werr = WERR_OK;
382 uint32_t count;
383 struct registry_value *valvalue = NULL;
384 char *valname = NULL;
385 uint32_t tmp_num_values = 0;
386 char **tmp_valnames = NULL;
387 char **tmp_valstrings = NULL;
388 uint32_t num_includes = 0;
389 char **includes = NULL;
390
391 if ((num_values == NULL) || (value_names == NULL) ||
392 (value_strings == NULL))
393 {
394 werr = WERR_INVALID_PARAM;
395 goto done;
396 }
397
398 tmp_ctx = talloc_stackframe();
399
400 for (count = 0;
401 werr = reg_enumvalue(tmp_ctx, key, count, &valname, &valvalue),
402 W_ERROR_IS_OK(werr);
403 count++)
404 {
405 char *valstring;
406
407 if (!smbconf_reg_valname_valid(valname)) {
408 continue;
409 }
410
411 werr = smbconf_add_string_to_array(tmp_ctx,
412 &tmp_valnames,
413 tmp_num_values, valname);
414 if (!W_ERROR_IS_OK(werr)) {
415 goto done;
416 }
417
418 valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
419 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
420 tmp_num_values, valstring);
421 if (!W_ERROR_IS_OK(werr)) {
422 goto done;
423 }
424 tmp_num_values++;
425 }
426 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
427 goto done;
428 }
429
430 /* now add the includes at the end */
431 werr = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
432 &includes);
433 if (!W_ERROR_IS_OK(werr)) {
434 goto done;
435 }
436 for (count = 0; count < num_includes; count++) {
437 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
438 tmp_num_values, "include");
439 if (!W_ERROR_IS_OK(werr)) {
440 goto done;
441 }
442
443 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
444 tmp_num_values,
445 includes[count]);
446 if (!W_ERROR_IS_OK(werr)) {
447 goto done;
448 }
449
450 tmp_num_values++;
451 }
452
453 *num_values = tmp_num_values;
454 if (tmp_num_values > 0) {
455 *value_names = talloc_move(mem_ctx, &tmp_valnames);
456 *value_strings = talloc_move(mem_ctx, &tmp_valstrings);
457 } else {
458 *value_names = NULL;
459 *value_strings = NULL;
460 }
461
462 done:
463 talloc_free(tmp_ctx);
464 return werr;
465 }
466
467 static bool smbconf_reg_key_has_values(struct registry_key *key)
468 {
469 WERROR werr;
470 uint32_t num_subkeys;
471 uint32_t max_subkeylen;
472 uint32_t max_subkeysize;
473 uint32_t num_values;
474 uint32_t max_valnamelen;
475 uint32_t max_valbufsize;
476 uint32_t secdescsize;
477 NTTIME last_changed_time;
478
479 werr = reg_queryinfokey(key, &num_subkeys, &max_subkeylen,
480 &max_subkeysize, &num_values, &max_valnamelen,
481 &max_valbufsize, &secdescsize,
482 &last_changed_time);
483 if (!W_ERROR_IS_OK(werr)) {
484 return false;
485 }
486
487 return (num_values != 0);
488 }
489
490 /**
491 * delete all values from a key
492 */
493 static WERROR smbconf_reg_delete_values(struct registry_key *key)
494 {
495 WERROR werr;
496 char *valname;
497 struct registry_value *valvalue;
498 uint32_t count;
499 TALLOC_CTX *mem_ctx = talloc_stackframe();
500
501 for (count = 0;
502 werr = reg_enumvalue(mem_ctx, key, count, &valname, &valvalue),
503 W_ERROR_IS_OK(werr);
504 count++)
505 {
506 werr = reg_deletevalue(key, valname);
507 if (!W_ERROR_IS_OK(werr)) {
508 goto done;
509 }
510 }
511 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
512 DEBUG(1, ("smbconf_reg_delete_values: "
513 "Error enumerating values of %s: %s\n",
514 key->key->name,
515 win_errstr(werr)));
516 goto done;
517 }
518
519 werr = WERR_OK;
520
521 done:
522 talloc_free(mem_ctx);
523 return werr;
524 }
525
526 /**********************************************************************
527 *
528 * smbconf operations: registry implementations
529 *
530 **********************************************************************/
531
532 /**
533 * initialize the registry smbconf backend
534 */
535 static WERROR smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
536 {
537 WERROR werr = WERR_OK;
538 struct nt_user_token *token;
539
540 if (path == NULL) {
541 path = KEY_SMBCONF;
542 }
543 ctx->path = talloc_strdup(ctx, path);
544 if (ctx->path == NULL) {
545 werr = WERR_NOMEM;
546 goto done;
547 }
548
549 ctx->data = TALLOC_ZERO_P(ctx, struct reg_private_data);
550
551 werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
552 if (!W_ERROR_IS_OK(werr)) {
553 DEBUG(1, ("Error creating admin token\n"));
554 goto done;
555 }
556 rpd(ctx)->open = false;
557
558 werr = registry_init_smbconf(path);
559 if (!W_ERROR_IS_OK(werr)) {
560 goto done;
561 }
562
563 werr = ctx->ops->open_conf(ctx);
564 if (!W_ERROR_IS_OK(werr)) {
565 DEBUG(1, ("Error opening the registry.\n"));
566 goto done;
567 }
568
569 werr = reg_open_path(ctx, ctx->path,
570 SEC_RIGHTS_ENUM_SUBKEYS | REG_KEY_WRITE,
571 token, &rpd(ctx)->base_key);
572 if (!W_ERROR_IS_OK(werr)) {
573 goto done;
574 }
575
576 done:
577 return werr;
578 }
579
580 static int smbconf_reg_shutdown(struct smbconf_ctx *ctx)
581 {
582 return ctx->ops->close_conf(ctx);
583 }
584
585 static bool smbconf_reg_requires_messaging(struct smbconf_ctx *ctx)
586 {
587 #ifdef CLUSTER_SUPPORT
588 if (lp_clustering() && lp_parm_bool(-1, "ctdb", "registry.tdb", true)) {
589 return true;
590 }
591 #endif
592 return false;
593 }
594
595 static bool smbconf_reg_is_writeable(struct smbconf_ctx *ctx)
596 {
597 /*
598 * The backend has write support.
599 *
600 * TODO: add access checks whether the concrete
601 * config source is really writeable by the calling user.
602 */
603 return true;
604 }
605
606 static WERROR smbconf_reg_open(struct smbconf_ctx *ctx)
607 {
608 WERROR werr;
609
610 if (rpd(ctx)->open) {
611 return WERR_OK;
612 }
613
614 werr = regdb_open();
615 if (W_ERROR_IS_OK(werr)) {
616 rpd(ctx)->open = true;
617 }
618 return werr;
619 }
620
621 static int smbconf_reg_close(struct smbconf_ctx *ctx)
622 {
623 int ret;
624
625 if (!rpd(ctx)->open) {
626 return 0;
627 }
628
629 ret = regdb_close();
630 if (ret == 0) {
631 rpd(ctx)->open = false;
632 }
633 return ret;
634 }
635
636 /**
637 * Get the change sequence number of the given service/parameter.
638 * service and parameter strings may be NULL.
639 */
640 static void smbconf_reg_get_csn(struct smbconf_ctx *ctx,
641 struct smbconf_csn *csn,
642 const char *service, const char *param)
643 {
644 if (csn == NULL) {
645 return;
646 }
647
648 if (!W_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
649 return;
650 }
651
652 csn->csn = (uint64_t)regdb_get_seqnum();
653 }
654
655 /**
656 * Drop the whole configuration (restarting empty) - registry version
657 */
658 static WERROR smbconf_reg_drop(struct smbconf_ctx *ctx)
659 {
660 char *path, *p;
661 WERROR werr = WERR_OK;
662 struct registry_key *parent_key = NULL;
663 struct registry_key *new_key = NULL;
664 TALLOC_CTX* mem_ctx = talloc_stackframe();
665 enum winreg_CreateAction action;
666 struct nt_user_token *token;
667
668 werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
669 if (!W_ERROR_IS_OK(werr)) {
670 DEBUG(1, ("Error creating admin token\n"));
671 goto done;
672 }
673
674 path = talloc_strdup(mem_ctx, ctx->path);
675 if (path == NULL) {
676 werr = WERR_NOMEM;
677 goto done;
678 }
679 p = strrchr(path, '\\');
680 *p = '\0';
681 werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token,
682 &parent_key);
683
684 if (!W_ERROR_IS_OK(werr)) {
685 goto done;
686 }
687
688 werr = reg_deletekey_recursive(mem_ctx, parent_key, p+1);
689
690 if (!W_ERROR_IS_OK(werr)) {
691 goto done;
692 }
693
694 werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
695 &new_key, &action);
696
697 done:
698 talloc_free(mem_ctx);
699 return werr;
700 }
701
702 /**
703 * get the list of share names defined in the configuration.
704 * registry version.
705 */
706 static WERROR smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
707 TALLOC_CTX *mem_ctx,
708 uint32_t *num_shares,
709 char ***share_names)
710 {
711 uint32_t count;
712 uint32_t added_count = 0;
713 TALLOC_CTX *tmp_ctx = NULL;
714 WERROR werr = WERR_OK;
715 char *subkey_name = NULL;
716 char **tmp_share_names = NULL;
717
718 if ((num_shares == NULL) || (share_names == NULL)) {
719 werr = WERR_INVALID_PARAM;
720 goto done;
721 }
722
723 tmp_ctx = talloc_stackframe();
724
725 /* if there are values in the base key, return NULL as share name */
726
727 if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
728 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
729 0, NULL);
730 if (!W_ERROR_IS_OK(werr)) {
731 goto done;
732 }
733 added_count++;
734 }
735
736 /* make sure "global" is always listed first */
737 if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
738 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
739 added_count, GLOBAL_NAME);
740 if (!W_ERROR_IS_OK(werr)) {
741 goto done;
742 }
743 added_count++;
744 }
745
746 for (count = 0;
747 werr = reg_enumkey(tmp_ctx, rpd(ctx)->base_key, count,
748 &subkey_name, NULL),
749 W_ERROR_IS_OK(werr);
750 count++)
751 {
752 if (strequal(subkey_name, GLOBAL_NAME)) {
753 continue;
754 }
755
756 werr = smbconf_add_string_to_array(tmp_ctx,
757 &tmp_share_names,
758 added_count,
759 subkey_name);
760 if (!W_ERROR_IS_OK(werr)) {
761 goto done;
762 }
763 added_count++;
764 }
765 if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
766 goto done;
767 }
768 werr = WERR_OK;
769
770 *num_shares = added_count;
771 if (added_count > 0) {
772 *share_names = talloc_move(mem_ctx, &tmp_share_names);
773 } else {
774 *share_names = NULL;
775 }
776
777 done:
778 talloc_free(tmp_ctx);
779 return werr;
780 }
781
782 /**
783 * check if a share/service of a given name exists - registry version
784 */
785 static bool smbconf_reg_share_exists(struct smbconf_ctx *ctx,
786 const char *servicename)
787 {
788 bool ret = false;
789 WERROR werr = WERR_OK;
790 TALLOC_CTX *mem_ctx = talloc_stackframe();
791 struct registry_key *key = NULL;
792
793 werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
794 REG_KEY_READ, &key);
795 if (W_ERROR_IS_OK(werr)) {
796 ret = true;
797 }
798
799 talloc_free(mem_ctx);
800 return ret;
801 }
802
803 /**
804 * Add a service if it does not already exist - registry version
805 */
806 static WERROR smbconf_reg_create_share(struct smbconf_ctx *ctx,
807 const char *servicename)
808 {
809 WERROR werr;
810 struct registry_key *key = NULL;
811
812 if (servicename == NULL) {
813 return WERR_OK;
814 }
815
816 werr = smbconf_reg_create_service_key(talloc_tos(), ctx,
817 servicename, &key);
818
819 talloc_free(key);
820 return werr;
821 }
822
823 /**
824 * get a definition of a share (service) from configuration.
825 */
826 static WERROR smbconf_reg_get_share(struct smbconf_ctx *ctx,
827 TALLOC_CTX *mem_ctx,
828 const char *servicename,
829 struct smbconf_service **service)
830 {
831 WERROR werr = WERR_OK;
832 struct registry_key *key = NULL;
833 struct smbconf_service *tmp_service = NULL;
834 TALLOC_CTX *tmp_ctx = talloc_stackframe();
835
836 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
837 REG_KEY_READ, &key);
838 if (!W_ERROR_IS_OK(werr)) {
839 goto done;
840 }
841
842 tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
843 if (tmp_service == NULL) {
844 werr = WERR_NOMEM;
845 goto done;
846 }
847
848 if (servicename != NULL) {
849 tmp_service->name = talloc_strdup(tmp_service, servicename);
850 if (tmp_service->name == NULL) {
851 werr = WERR_NOMEM;
852 goto done;
853 }
854 }
855
856 werr = smbconf_reg_get_values(tmp_service, key,
857 &(tmp_service->num_params),
858 &(tmp_service->param_names),
859 &(tmp_service->param_values));
860
861 if (W_ERROR_IS_OK(werr)) {
862 *service = talloc_move(mem_ctx, &tmp_service);
863 }
864
865 done:
866 talloc_free(tmp_ctx);
867 return werr;
868 }
869
870 /**
871 * delete a service from configuration
872 */
873 static WERROR smbconf_reg_delete_share(struct smbconf_ctx *ctx,
874 const char *servicename)
875 {
876 WERROR werr = WERR_OK;
877 TALLOC_CTX *mem_ctx = talloc_stackframe();
878
879 if (servicename != NULL) {
880 werr = reg_deletekey_recursive(mem_ctx, rpd(ctx)->base_key,
881 servicename);
882 } else {
883 werr = smbconf_reg_delete_values(rpd(ctx)->base_key);
884 }
885
886 talloc_free(mem_ctx);
887 return werr;
888 }
889
890 /**
891 * set a configuration parameter to the value provided.
892 */
893 static WERROR smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
894 const char *service,
895 const char *param,
896 const char *valstr)
897 {
898 WERROR werr;
899 struct registry_key *key = NULL;
900 TALLOC_CTX *mem_ctx = talloc_stackframe();
901
902 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
903 REG_KEY_WRITE, &key);
904 if (!W_ERROR_IS_OK(werr)) {
905 goto done;
906 }
907
908 werr = smbconf_reg_set_value(key, param, valstr);
909
910 done:
911 talloc_free(mem_ctx);
912 return werr;
913 }
914
915 /**
916 * get the value of a configuration parameter as a string
917 */
918 static WERROR smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
919 TALLOC_CTX *mem_ctx,
920 const char *service,
921 const char *param,
922 char **valstr)
923 {
924 WERROR werr = WERR_OK;
925 struct registry_key *key = NULL;
926 struct registry_value *value = NULL;
927
928 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
929 REG_KEY_READ, &key);
930 if (!W_ERROR_IS_OK(werr)) {
931 goto done;
932 }
933
934 if (!smbconf_reg_valname_valid(param)) {
935 werr = WERR_INVALID_PARAM;
936 goto done;
937 }
938
939 if (!smbconf_value_exists(key, param)) {
940 werr = WERR_INVALID_PARAM;
941 goto done;
942 }
943
944 werr = reg_queryvalue(mem_ctx, key, param, &value);
945 if (!W_ERROR_IS_OK(werr)) {
946 goto done;
947 }
948
949 *valstr = smbconf_format_registry_value(mem_ctx, value);
950
951 if (*valstr == NULL) {
952 werr = WERR_NOMEM;
953 }
954
955 done:
956 talloc_free(key);
957 talloc_free(value);
958 return werr;
959 }
960
961 /**
962 * delete a parameter from configuration
963 */
964 static WERROR smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
965 const char *service,
966 const char *param)
967 {
968 struct registry_key *key = NULL;
969 WERROR werr = WERR_OK;
970 TALLOC_CTX *mem_ctx = talloc_stackframe();
971
972 werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
973 REG_KEY_ALL, &key);
974 if (!W_ERROR_IS_OK(werr)) {
975 goto done;
976 }
977
978 if (!smbconf_reg_valname_valid(param)) {
979 werr = WERR_INVALID_PARAM;
980 goto done;
981 }
982
983 if (!smbconf_value_exists(key, param)) {
984 werr = WERR_INVALID_PARAM;
985 goto done;
986 }
987
988 werr = reg_deletevalue(key, param);
989
990 done:
991 talloc_free(mem_ctx);
992 return werr;
993 }
994
995 static WERROR smbconf_reg_get_includes(struct smbconf_ctx *ctx,
996 TALLOC_CTX *mem_ctx,
997 const char *service,
998 uint32_t *num_includes,
999 char ***includes)
1000 {
1001 WERROR werr;
1002 struct registry_key *key = NULL;
1003 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1004
1005 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1006 REG_KEY_READ, &key);
1007 if (!W_ERROR_IS_OK(werr)) {
1008 goto done;
1009 }
1010
1011 werr = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
1012 includes);
1013
1014 done:
1015 talloc_free(tmp_ctx);
1016 return werr;
1017 }
1018
1019 static WERROR smbconf_reg_set_includes(struct smbconf_ctx *ctx,
1020 const char *service,
1021 uint32_t num_includes,
1022 const char **includes)
1023 {
1024 WERROR werr = WERR_OK;
1025 struct registry_key *key = NULL;
1026 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1027
1028 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1029 REG_KEY_ALL, &key);
1030 if (!W_ERROR_IS_OK(werr)) {
1031 goto done;
1032 }
1033
1034 if (num_includes == 0) {
1035 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1036 goto done;
1037 }
1038 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1039 } else {
1040 werr = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
1041 num_includes, includes);
1042 }
1043
1044 done:
1045 talloc_free(tmp_ctx);
1046 return werr;
1047 }
1048
1049 static WERROR smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
1050 const char *service)
1051 {
1052 WERROR werr = WERR_OK;
1053 struct registry_key *key = NULL;
1054 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1055
1056 werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
1057 REG_KEY_ALL, &key);
1058 if (!W_ERROR_IS_OK(werr)) {
1059 goto done;
1060 }
1061
1062 if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
1063 goto done;
1064 }
1065
1066 werr = reg_deletevalue(key, INCLUDES_VALNAME);
1067
1068
1069 done:
1070 talloc_free(tmp_ctx);
1071 return werr;
1072 }
1073
1074 static WERROR smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
1075 {
1076 return regdb_transaction_start();
1077 }
1078
1079 static WERROR smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
1080 {
1081 return regdb_transaction_commit();
1082 }
1083
1084 static WERROR smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
1085 {
1086 return regdb_transaction_cancel();
1087 }
1088
1089 struct smbconf_ops smbconf_ops_reg = {
1090 .init = smbconf_reg_init,
1091 .shutdown = smbconf_reg_shutdown,
1092 .requires_messaging = smbconf_reg_requires_messaging,
1093 .is_writeable = smbconf_reg_is_writeable,
1094 .open_conf = smbconf_reg_open,
1095 .close_conf = smbconf_reg_close,
1096 .get_csn = smbconf_reg_get_csn,
1097 .drop = smbconf_reg_drop,
1098 .get_share_names = smbconf_reg_get_share_names,
1099 .share_exists = smbconf_reg_share_exists,
1100 .create_share = smbconf_reg_create_share,
1101 .get_share = smbconf_reg_get_share,
1102 .delete_share = smbconf_reg_delete_share,
1103 .set_parameter = smbconf_reg_set_parameter,
1104 .get_parameter = smbconf_reg_get_parameter,
1105 .delete_parameter = smbconf_reg_delete_parameter,
1106 .get_includes = smbconf_reg_get_includes,
1107 .set_includes = smbconf_reg_set_includes,
1108 .delete_includes = smbconf_reg_delete_includes,
1109 .transaction_start = smbconf_reg_transaction_start,
1110 .transaction_commit = smbconf_reg_transaction_commit,
1111 .transaction_cancel = smbconf_reg_transaction_cancel,
1112 };
1113
1114
1115 /**
1116 * initialize the smbconf registry backend
1117 * the only function that is exported from this module
1118 */
1119 WERROR smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
1120 const char *path)
1121 {
1122 return smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_reg);
1123 }
reg import