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