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