source: branches/samba-3.2.x/source/lib/smbconf/smbconf_reg.c

Last change on this file was 235, checked in by Herwig Bauernfeind, 16 years ago

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