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